G__Proof.cxx

Go to the documentation of this file.
00001 //
00002 // File generated by core/utils/src/rootcint_tmp at Wed Apr 20 13:47:08 2011
00003 
00004 // Do NOT change. Changes will be lost next time file is generated
00005 //
00006 
00007 #define R__DICTIONARY_FILENAME proofdIproofdIsrcdIG__Proof
00008 #include "RConfig.h" //rootcint 4834
00009 #if !defined(R__ACCESS_IN_SYMBOL)
00010 //Break the privacy of classes -- Disabled for the moment
00011 #define private public
00012 #define protected public
00013 #endif
00014 
00015 // Since CINT ignores the std namespace, we need to do so in this file.
00016 namespace std {} using namespace std;
00017 #include "G__Proof.h"
00018 
00019 #include "TCollectionProxyInfo.h"
00020 #include "TClass.h"
00021 #include "TBuffer.h"
00022 #include "TMemberInspector.h"
00023 #include "TError.h"
00024 
00025 #ifndef G__ROOT
00026 #define G__ROOT
00027 #endif
00028 
00029 #include "RtypesImp.h"
00030 #include "TIsAProxy.h"
00031 
00032 // START OF SHADOWS
00033 
00034 namespace ROOT {
00035    namespace Shadow {
00036       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00037       typedef pair< ::TDSetElement*, ::TString > pairlETDSetElementmUcOTStringgR;
00038       #else
00039       class pairlETDSetElementmUcOTStringgR  {
00040          public:
00041          //friend XX;
00042          ::TDSetElement* first; //
00043          ::TString second; //
00044       };
00045       #endif
00046 
00047    } // of namespace Shadow
00048 } // of namespace ROOT
00049 // END OF SHADOWS
00050 
00051 namespace ROOT {
00052    void TCondorSlave_ShowMembers(void *obj, TMemberInspector &R__insp);
00053    static void *new_TCondorSlave(void *p = 0);
00054    static void *newArray_TCondorSlave(Long_t size, void *p);
00055    static void delete_TCondorSlave(void *p);
00056    static void deleteArray_TCondorSlave(void *p);
00057    static void destruct_TCondorSlave(void *p);
00058 
00059    // Function generating the singleton type initializer
00060    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TCondorSlave*)
00061    {
00062       ::TCondorSlave *ptr = 0;
00063       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TCondorSlave >(0);
00064       static ::ROOT::TGenericClassInfo 
00065          instance("TCondorSlave", ::TCondorSlave::Class_Version(), "include/TCondor.h", 38,
00066                   typeid(::TCondorSlave), DefineBehavior(ptr, ptr),
00067                   &::TCondorSlave::Dictionary, isa_proxy, 4,
00068                   sizeof(::TCondorSlave) );
00069       instance.SetNew(&new_TCondorSlave);
00070       instance.SetNewArray(&newArray_TCondorSlave);
00071       instance.SetDelete(&delete_TCondorSlave);
00072       instance.SetDeleteArray(&deleteArray_TCondorSlave);
00073       instance.SetDestructor(&destruct_TCondorSlave);
00074       return &instance;
00075    }
00076    TGenericClassInfo *GenerateInitInstance(const ::TCondorSlave*)
00077    {
00078       return GenerateInitInstanceLocal((::TCondorSlave*)0);
00079    }
00080    // Static variable to force the class initialization
00081    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TCondorSlave*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00082 } // end of namespace ROOT
00083 
00084 namespace ROOT {
00085    void TCondor_ShowMembers(void *obj, TMemberInspector &R__insp);
00086    static void *new_TCondor(void *p = 0);
00087    static void *newArray_TCondor(Long_t size, void *p);
00088    static void delete_TCondor(void *p);
00089    static void deleteArray_TCondor(void *p);
00090    static void destruct_TCondor(void *p);
00091 
00092    // Function generating the singleton type initializer
00093    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TCondor*)
00094    {
00095       ::TCondor *ptr = 0;
00096       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TCondor >(0);
00097       static ::ROOT::TGenericClassInfo 
00098          instance("TCondor", ::TCondor::Class_Version(), "include/TCondor.h", 56,
00099                   typeid(::TCondor), DefineBehavior(ptr, ptr),
00100                   &::TCondor::Dictionary, isa_proxy, 4,
00101                   sizeof(::TCondor) );
00102       instance.SetNew(&new_TCondor);
00103       instance.SetNewArray(&newArray_TCondor);
00104       instance.SetDelete(&delete_TCondor);
00105       instance.SetDeleteArray(&deleteArray_TCondor);
00106       instance.SetDestructor(&destruct_TCondor);
00107       return &instance;
00108    }
00109    TGenericClassInfo *GenerateInitInstance(const ::TCondor*)
00110    {
00111       return GenerateInitInstanceLocal((::TCondor*)0);
00112    }
00113    // Static variable to force the class initialization
00114    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TCondor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00115 } // end of namespace ROOT
00116 
00117 namespace ROOT {
00118    void TDataSetManager_ShowMembers(void *obj, TMemberInspector &R__insp);
00119    static void *new_TDataSetManager(void *p = 0);
00120    static void *newArray_TDataSetManager(Long_t size, void *p);
00121    static void delete_TDataSetManager(void *p);
00122    static void deleteArray_TDataSetManager(void *p);
00123    static void destruct_TDataSetManager(void *p);
00124    static void streamer_TDataSetManager(TBuffer &buf, void *obj);
00125 
00126    // Function generating the singleton type initializer
00127    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDataSetManager*)
00128    {
00129       ::TDataSetManager *ptr = 0;
00130       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDataSetManager >(0);
00131       static ::ROOT::TGenericClassInfo 
00132          instance("TDataSetManager", ::TDataSetManager::Class_Version(), "include/TDataSetManager.h", 46,
00133                   typeid(::TDataSetManager), DefineBehavior(ptr, ptr),
00134                   &::TDataSetManager::Dictionary, isa_proxy, 0,
00135                   sizeof(::TDataSetManager) );
00136       instance.SetNew(&new_TDataSetManager);
00137       instance.SetNewArray(&newArray_TDataSetManager);
00138       instance.SetDelete(&delete_TDataSetManager);
00139       instance.SetDeleteArray(&deleteArray_TDataSetManager);
00140       instance.SetDestructor(&destruct_TDataSetManager);
00141       instance.SetStreamerFunc(&streamer_TDataSetManager);
00142       return &instance;
00143    }
00144    TGenericClassInfo *GenerateInitInstance(const ::TDataSetManager*)
00145    {
00146       return GenerateInitInstanceLocal((::TDataSetManager*)0);
00147    }
00148    // Static variable to force the class initialization
00149    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDataSetManager*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00150 } // end of namespace ROOT
00151 
00152 namespace ROOT {
00153    void TDataSetManagerFile_ShowMembers(void *obj, TMemberInspector &R__insp);
00154    static void *new_TDataSetManagerFile(void *p = 0);
00155    static void *newArray_TDataSetManagerFile(Long_t size, void *p);
00156    static void delete_TDataSetManagerFile(void *p);
00157    static void deleteArray_TDataSetManagerFile(void *p);
00158    static void destruct_TDataSetManagerFile(void *p);
00159    static void streamer_TDataSetManagerFile(TBuffer &buf, void *obj);
00160 
00161    // Function generating the singleton type initializer
00162    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDataSetManagerFile*)
00163    {
00164       ::TDataSetManagerFile *ptr = 0;
00165       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDataSetManagerFile >(0);
00166       static ::ROOT::TGenericClassInfo 
00167          instance("TDataSetManagerFile", ::TDataSetManagerFile::Class_Version(), "include/TDataSetManagerFile.h", 32,
00168                   typeid(::TDataSetManagerFile), DefineBehavior(ptr, ptr),
00169                   &::TDataSetManagerFile::Dictionary, isa_proxy, 0,
00170                   sizeof(::TDataSetManagerFile) );
00171       instance.SetNew(&new_TDataSetManagerFile);
00172       instance.SetNewArray(&newArray_TDataSetManagerFile);
00173       instance.SetDelete(&delete_TDataSetManagerFile);
00174       instance.SetDeleteArray(&deleteArray_TDataSetManagerFile);
00175       instance.SetDestructor(&destruct_TDataSetManagerFile);
00176       instance.SetStreamerFunc(&streamer_TDataSetManagerFile);
00177       return &instance;
00178    }
00179    TGenericClassInfo *GenerateInitInstance(const ::TDataSetManagerFile*)
00180    {
00181       return GenerateInitInstanceLocal((::TDataSetManagerFile*)0);
00182    }
00183    // Static variable to force the class initialization
00184    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDataSetManagerFile*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00185 } // end of namespace ROOT
00186 
00187 namespace ROOT {
00188    void TDSet_ShowMembers(void *obj, TMemberInspector &R__insp);
00189    static void *new_TDSet(void *p = 0);
00190    static void *newArray_TDSet(Long_t size, void *p);
00191    static void delete_TDSet(void *p);
00192    static void deleteArray_TDSet(void *p);
00193    static void destruct_TDSet(void *p);
00194    static void streamer_TDSet(TBuffer &buf, void *obj);
00195 
00196    // Function generating the singleton type initializer
00197    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDSet*)
00198    {
00199       ::TDSet *ptr = 0;
00200       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDSet >(0);
00201       static ::ROOT::TGenericClassInfo 
00202          instance("TDSet", ::TDSet::Class_Version(), "include/TDSet.h", 148,
00203                   typeid(::TDSet), DefineBehavior(ptr, ptr),
00204                   &::TDSet::Dictionary, isa_proxy, 1,
00205                   sizeof(::TDSet) );
00206       instance.SetNew(&new_TDSet);
00207       instance.SetNewArray(&newArray_TDSet);
00208       instance.SetDelete(&delete_TDSet);
00209       instance.SetDeleteArray(&deleteArray_TDSet);
00210       instance.SetDestructor(&destruct_TDSet);
00211       instance.SetStreamerFunc(&streamer_TDSet);
00212       return &instance;
00213    }
00214    TGenericClassInfo *GenerateInitInstance(const ::TDSet*)
00215    {
00216       return GenerateInitInstanceLocal((::TDSet*)0);
00217    }
00218    // Static variable to force the class initialization
00219    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDSet*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00220 } // end of namespace ROOT
00221 
00222 namespace ROOT {
00223    void TProof_ShowMembers(void *obj, TMemberInspector &R__insp);
00224    static void delete_TProof(void *p);
00225    static void deleteArray_TProof(void *p);
00226    static void destruct_TProof(void *p);
00227    static void streamer_TProof(TBuffer &buf, void *obj);
00228 
00229    // Function generating the singleton type initializer
00230    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProof*)
00231    {
00232       ::TProof *ptr = 0;
00233       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProof >(0);
00234       static ::ROOT::TGenericClassInfo 
00235          instance("TProof", ::TProof::Class_Version(), "include/TProof.h", 321,
00236                   typeid(::TProof), DefineBehavior(ptr, ptr),
00237                   &::TProof::Dictionary, isa_proxy, 0,
00238                   sizeof(::TProof) );
00239       instance.SetDelete(&delete_TProof);
00240       instance.SetDeleteArray(&deleteArray_TProof);
00241       instance.SetDestructor(&destruct_TProof);
00242       instance.SetStreamerFunc(&streamer_TProof);
00243       return &instance;
00244    }
00245    TGenericClassInfo *GenerateInitInstance(const ::TProof*)
00246    {
00247       return GenerateInitInstanceLocal((::TProof*)0);
00248    }
00249    // Static variable to force the class initialization
00250    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProof*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00251 } // end of namespace ROOT
00252 
00253 namespace ROOT {
00254    void TProofChain_ShowMembers(void *obj, TMemberInspector &R__insp);
00255    static void *new_TProofChain(void *p = 0);
00256    static void *newArray_TProofChain(Long_t size, void *p);
00257    static void delete_TProofChain(void *p);
00258    static void deleteArray_TProofChain(void *p);
00259    static void destruct_TProofChain(void *p);
00260    static void directoryAutoAdd_TProofChain(void *p, TDirectory *dir);
00261 
00262    // Function generating the singleton type initializer
00263    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofChain*)
00264    {
00265       ::TProofChain *ptr = 0;
00266       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofChain >(0);
00267       static ::ROOT::TGenericClassInfo 
00268          instance("TProofChain", ::TProofChain::Class_Version(), "include/TProofChain.h", 34,
00269                   typeid(::TProofChain), DefineBehavior(ptr, ptr),
00270                   &::TProofChain::Dictionary, isa_proxy, 4,
00271                   sizeof(::TProofChain) );
00272       instance.SetNew(&new_TProofChain);
00273       instance.SetNewArray(&newArray_TProofChain);
00274       instance.SetDelete(&delete_TProofChain);
00275       instance.SetDeleteArray(&deleteArray_TProofChain);
00276       instance.SetDestructor(&destruct_TProofChain);
00277       instance.SetDirectoryAutoAdd(&directoryAutoAdd_TProofChain);
00278       return &instance;
00279    }
00280    TGenericClassInfo *GenerateInitInstance(const ::TProofChain*)
00281    {
00282       return GenerateInitInstanceLocal((::TProofChain*)0);
00283    }
00284    // Static variable to force the class initialization
00285    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofChain*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00286 } // end of namespace ROOT
00287 
00288 namespace ROOT {
00289    void TDSetElement_ShowMembers(void *obj, TMemberInspector &R__insp);
00290    static void *new_TDSetElement(void *p = 0);
00291    static void *newArray_TDSetElement(Long_t size, void *p);
00292    static void delete_TDSetElement(void *p);
00293    static void deleteArray_TDSetElement(void *p);
00294    static void destruct_TDSetElement(void *p);
00295    static void streamer_TDSetElement(TBuffer &buf, void *obj);
00296 
00297    // Function generating the singleton type initializer
00298    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDSetElement*)
00299    {
00300       ::TDSetElement *ptr = 0;
00301       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDSetElement >(0);
00302       static ::ROOT::TGenericClassInfo 
00303          instance("TDSetElement", ::TDSetElement::Class_Version(), "include/TDSet.h", 67,
00304                   typeid(::TDSetElement), DefineBehavior(ptr, ptr),
00305                   &::TDSetElement::Dictionary, isa_proxy, 1,
00306                   sizeof(::TDSetElement) );
00307       instance.SetNew(&new_TDSetElement);
00308       instance.SetNewArray(&newArray_TDSetElement);
00309       instance.SetDelete(&delete_TDSetElement);
00310       instance.SetDeleteArray(&deleteArray_TDSetElement);
00311       instance.SetDestructor(&destruct_TDSetElement);
00312       instance.SetStreamerFunc(&streamer_TDSetElement);
00313       return &instance;
00314    }
00315    TGenericClassInfo *GenerateInitInstance(const ::TDSetElement*)
00316    {
00317       return GenerateInitInstanceLocal((::TDSetElement*)0);
00318    }
00319    // Static variable to force the class initialization
00320    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDSetElement*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00321 } // end of namespace ROOT
00322 
00323 namespace ROOT {
00324    void pairlETDSetElementmUcOTStringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
00325    static void pairlETDSetElementmUcOTStringgR_Dictionary();
00326    static void *new_pairlETDSetElementmUcOTStringgR(void *p = 0);
00327    static void *newArray_pairlETDSetElementmUcOTStringgR(Long_t size, void *p);
00328    static void delete_pairlETDSetElementmUcOTStringgR(void *p);
00329    static void deleteArray_pairlETDSetElementmUcOTStringgR(void *p);
00330    static void destruct_pairlETDSetElementmUcOTStringgR(void *p);
00331 
00332    // Function generating the singleton type initializer
00333    static TGenericClassInfo *GenerateInitInstanceLocal(const pair<TDSetElement*,TString>*)
00334    {
00335       // Make sure the shadow class has the right sizeof
00336       pair<TDSetElement*,TString> *ptr = 0;
00337       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(pair<TDSetElement*,TString>),0);
00338       static ::ROOT::TGenericClassInfo 
00339          instance("pair<TDSetElement*,TString>", "prec_stl/utility", 17,
00340                   typeid(pair<TDSetElement*,TString>), DefineBehavior(ptr, ptr),
00341                   &pairlETDSetElementmUcOTStringgR_ShowMembers, &pairlETDSetElementmUcOTStringgR_Dictionary, isa_proxy, 0,
00342                   sizeof(pair<TDSetElement*,TString>) );
00343       instance.SetNew(&new_pairlETDSetElementmUcOTStringgR);
00344       instance.SetNewArray(&newArray_pairlETDSetElementmUcOTStringgR);
00345       instance.SetDelete(&delete_pairlETDSetElementmUcOTStringgR);
00346       instance.SetDeleteArray(&deleteArray_pairlETDSetElementmUcOTStringgR);
00347       instance.SetDestructor(&destruct_pairlETDSetElementmUcOTStringgR);
00348       return &instance;
00349    }
00350    TGenericClassInfo *GenerateInitInstance(const pair<TDSetElement*,TString>*)
00351    {
00352       return GenerateInitInstanceLocal((pair<TDSetElement*,TString>*)0);
00353    }
00354    // Static variable to force the class initialization
00355    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const pair<TDSetElement*,TString>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00356 
00357    // Dictionary for non-ClassDef classes
00358    static void pairlETDSetElementmUcOTStringgR_Dictionary() {
00359       ::ROOT::GenerateInitInstanceLocal((const pair<TDSetElement*,TString>*)0x0)->GetClass();
00360    }
00361 
00362 } // end of namespace ROOT
00363 
00364 namespace ROOT {
00365    void TProofServ_ShowMembers(void *obj, TMemberInspector &R__insp);
00366    static void delete_TProofServ(void *p);
00367    static void deleteArray_TProofServ(void *p);
00368    static void destruct_TProofServ(void *p);
00369    static void streamer_TProofServ(TBuffer &buf, void *obj);
00370 
00371    // Function generating the singleton type initializer
00372    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofServ*)
00373    {
00374       ::TProofServ *ptr = 0;
00375       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofServ >(0);
00376       static ::ROOT::TGenericClassInfo 
00377          instance("TProofServ", ::TProofServ::Class_Version(), "include/TProofServ.h", 73,
00378                   typeid(::TProofServ), DefineBehavior(ptr, ptr),
00379                   &::TProofServ::Dictionary, isa_proxy, 0,
00380                   sizeof(::TProofServ) );
00381       instance.SetDelete(&delete_TProofServ);
00382       instance.SetDeleteArray(&deleteArray_TProofServ);
00383       instance.SetDestructor(&destruct_TProofServ);
00384       instance.SetStreamerFunc(&streamer_TProofServ);
00385       return &instance;
00386    }
00387    TGenericClassInfo *GenerateInitInstance(const ::TProofServ*)
00388    {
00389       return GenerateInitInstanceLocal((::TProofServ*)0);
00390    }
00391    // Static variable to force the class initialization
00392    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofServ*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00393 } // end of namespace ROOT
00394 
00395 namespace ROOT {
00396    void TDSetProxy_ShowMembers(void *obj, TMemberInspector &R__insp);
00397    static void *new_TDSetProxy(void *p = 0);
00398    static void *newArray_TDSetProxy(Long_t size, void *p);
00399    static void delete_TDSetProxy(void *p);
00400    static void deleteArray_TDSetProxy(void *p);
00401    static void destruct_TDSetProxy(void *p);
00402 
00403    // Function generating the singleton type initializer
00404    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDSetProxy*)
00405    {
00406       ::TDSetProxy *ptr = 0;
00407       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDSetProxy >(0);
00408       static ::ROOT::TGenericClassInfo 
00409          instance("TDSetProxy", ::TDSetProxy::Class_Version(), "include/TDSetProxy.h", 31,
00410                   typeid(::TDSetProxy), DefineBehavior(ptr, ptr),
00411                   &::TDSetProxy::Dictionary, isa_proxy, 4,
00412                   sizeof(::TDSetProxy) );
00413       instance.SetNew(&new_TDSetProxy);
00414       instance.SetNewArray(&newArray_TDSetProxy);
00415       instance.SetDelete(&delete_TDSetProxy);
00416       instance.SetDeleteArray(&deleteArray_TDSetProxy);
00417       instance.SetDestructor(&destruct_TDSetProxy);
00418       return &instance;
00419    }
00420    TGenericClassInfo *GenerateInitInstance(const ::TDSetProxy*)
00421    {
00422       return GenerateInitInstanceLocal((::TDSetProxy*)0);
00423    }
00424    // Static variable to force the class initialization
00425    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDSetProxy*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00426 } // end of namespace ROOT
00427 
00428 namespace ROOT {
00429    void TProofDesc_ShowMembers(void *obj, TMemberInspector &R__insp);
00430    static void *new_TProofDesc(void *p = 0);
00431    static void *newArray_TProofDesc(Long_t size, void *p);
00432    static void delete_TProofDesc(void *p);
00433    static void deleteArray_TProofDesc(void *p);
00434    static void destruct_TProofDesc(void *p);
00435    static void streamer_TProofDesc(TBuffer &buf, void *obj);
00436 
00437    // Function generating the singleton type initializer
00438    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofDesc*)
00439    {
00440       ::TProofDesc *ptr = 0;
00441       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofDesc >(0);
00442       static ::ROOT::TGenericClassInfo 
00443          instance("TProofDesc", ::TProofDesc::Class_Version(), "include/TProofMgr.h", 135,
00444                   typeid(::TProofDesc), DefineBehavior(ptr, ptr),
00445                   &::TProofDesc::Dictionary, isa_proxy, 0,
00446                   sizeof(::TProofDesc) );
00447       instance.SetNew(&new_TProofDesc);
00448       instance.SetNewArray(&newArray_TProofDesc);
00449       instance.SetDelete(&delete_TProofDesc);
00450       instance.SetDeleteArray(&deleteArray_TProofDesc);
00451       instance.SetDestructor(&destruct_TProofDesc);
00452       instance.SetStreamerFunc(&streamer_TProofDesc);
00453       return &instance;
00454    }
00455    TGenericClassInfo *GenerateInitInstance(const ::TProofDesc*)
00456    {
00457       return GenerateInitInstanceLocal((::TProofDesc*)0);
00458    }
00459    // Static variable to force the class initialization
00460    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofDesc*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00461 } // end of namespace ROOT
00462 
00463 namespace ROOT {
00464    void TProofLog_ShowMembers(void *obj, TMemberInspector &R__insp);
00465    static void delete_TProofLog(void *p);
00466    static void deleteArray_TProofLog(void *p);
00467    static void destruct_TProofLog(void *p);
00468    static void streamer_TProofLog(TBuffer &buf, void *obj);
00469 
00470    // Function generating the singleton type initializer
00471    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofLog*)
00472    {
00473       ::TProofLog *ptr = 0;
00474       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofLog >(0);
00475       static ::ROOT::TGenericClassInfo 
00476          instance("TProofLog", ::TProofLog::Class_Version(), "include/TProofLog.h", 38,
00477                   typeid(::TProofLog), DefineBehavior(ptr, ptr),
00478                   &::TProofLog::Dictionary, isa_proxy, 0,
00479                   sizeof(::TProofLog) );
00480       instance.SetDelete(&delete_TProofLog);
00481       instance.SetDeleteArray(&deleteArray_TProofLog);
00482       instance.SetDestructor(&destruct_TProofLog);
00483       instance.SetStreamerFunc(&streamer_TProofLog);
00484       return &instance;
00485    }
00486    TGenericClassInfo *GenerateInitInstance(const ::TProofLog*)
00487    {
00488       return GenerateInitInstanceLocal((::TProofLog*)0);
00489    }
00490    // Static variable to force the class initialization
00491    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofLog*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00492 } // end of namespace ROOT
00493 
00494 namespace ROOT {
00495    void TProofMgr_ShowMembers(void *obj, TMemberInspector &R__insp);
00496    static void delete_TProofMgr(void *p);
00497    static void deleteArray_TProofMgr(void *p);
00498    static void destruct_TProofMgr(void *p);
00499    static void streamer_TProofMgr(TBuffer &buf, void *obj);
00500 
00501    // Function generating the singleton type initializer
00502    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofMgr*)
00503    {
00504       ::TProofMgr *ptr = 0;
00505       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofMgr >(0);
00506       static ::ROOT::TGenericClassInfo 
00507          instance("TProofMgr", ::TProofMgr::Class_Version(), "include/TProofMgr.h", 47,
00508                   typeid(::TProofMgr), DefineBehavior(ptr, ptr),
00509                   &::TProofMgr::Dictionary, isa_proxy, 0,
00510                   sizeof(::TProofMgr) );
00511       instance.SetDelete(&delete_TProofMgr);
00512       instance.SetDeleteArray(&deleteArray_TProofMgr);
00513       instance.SetDestructor(&destruct_TProofMgr);
00514       instance.SetStreamerFunc(&streamer_TProofMgr);
00515       return &instance;
00516    }
00517    TGenericClassInfo *GenerateInitInstance(const ::TProofMgr*)
00518    {
00519       return GenerateInitInstanceLocal((::TProofMgr*)0);
00520    }
00521    // Static variable to force the class initialization
00522    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofMgr*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00523 } // end of namespace ROOT
00524 
00525 namespace ROOT {
00526    void TProofDebug_ShowMembers(void *obj, TMemberInspector &R__insp);
00527    static void TProofDebug_Dictionary();
00528    static void *new_TProofDebug(void *p = 0);
00529    static void *newArray_TProofDebug(Long_t size, void *p);
00530    static void delete_TProofDebug(void *p);
00531    static void deleteArray_TProofDebug(void *p);
00532    static void destruct_TProofDebug(void *p);
00533 
00534    // Function generating the singleton type initializer
00535    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofDebug*)
00536    {
00537       ::TProofDebug *ptr = 0;
00538       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TProofDebug),0);
00539       static ::ROOT::TGenericClassInfo 
00540          instance("TProofDebug", "include/TProofDebug.h", 28,
00541                   typeid(::TProofDebug), DefineBehavior(ptr, ptr),
00542                   0, &TProofDebug_Dictionary, isa_proxy, 0,
00543                   sizeof(::TProofDebug) );
00544       instance.SetNew(&new_TProofDebug);
00545       instance.SetNewArray(&newArray_TProofDebug);
00546       instance.SetDelete(&delete_TProofDebug);
00547       instance.SetDeleteArray(&deleteArray_TProofDebug);
00548       instance.SetDestructor(&destruct_TProofDebug);
00549       return &instance;
00550    }
00551    TGenericClassInfo *GenerateInitInstance(const ::TProofDebug*)
00552    {
00553       return GenerateInitInstanceLocal((::TProofDebug*)0);
00554    }
00555    // Static variable to force the class initialization
00556    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofDebug*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00557 
00558    // Dictionary for non-ClassDef classes
00559    static void TProofDebug_Dictionary() {
00560       ::ROOT::GenerateInitInstanceLocal((const ::TProofDebug*)0x0)->GetClass();
00561    }
00562 
00563 } // end of namespace ROOT
00564 
00565 namespace ROOT {
00566    void TVirtualProofPlayer_ShowMembers(void *obj, TMemberInspector &R__insp);
00567    static void delete_TVirtualProofPlayer(void *p);
00568    static void deleteArray_TVirtualProofPlayer(void *p);
00569    static void destruct_TVirtualProofPlayer(void *p);
00570 
00571    // Function generating the singleton type initializer
00572    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TVirtualProofPlayer*)
00573    {
00574       ::TVirtualProofPlayer *ptr = 0;
00575       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TVirtualProofPlayer >(0);
00576       static ::ROOT::TGenericClassInfo 
00577          instance("TVirtualProofPlayer", ::TVirtualProofPlayer::Class_Version(), "include/TVirtualProofPlayer.h", 47,
00578                   typeid(::TVirtualProofPlayer), DefineBehavior(ptr, ptr),
00579                   &::TVirtualProofPlayer::Dictionary, isa_proxy, 4,
00580                   sizeof(::TVirtualProofPlayer) );
00581       instance.SetDelete(&delete_TVirtualProofPlayer);
00582       instance.SetDeleteArray(&deleteArray_TVirtualProofPlayer);
00583       instance.SetDestructor(&destruct_TVirtualProofPlayer);
00584       return &instance;
00585    }
00586    TGenericClassInfo *GenerateInitInstance(const ::TVirtualProofPlayer*)
00587    {
00588       return GenerateInitInstanceLocal((::TVirtualProofPlayer*)0);
00589    }
00590    // Static variable to force the class initialization
00591    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TVirtualProofPlayer*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00592 } // end of namespace ROOT
00593 
00594 namespace ROOT {
00595    void TSlave_ShowMembers(void *obj, TMemberInspector &R__insp);
00596    static void delete_TSlave(void *p);
00597    static void deleteArray_TSlave(void *p);
00598    static void destruct_TSlave(void *p);
00599    static void streamer_TSlave(TBuffer &buf, void *obj);
00600 
00601    // Function generating the singleton type initializer
00602    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSlave*)
00603    {
00604       ::TSlave *ptr = 0;
00605       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSlave >(0);
00606       static ::ROOT::TGenericClassInfo 
00607          instance("TSlave", ::TSlave::Class_Version(), "include/TSlave.h", 50,
00608                   typeid(::TSlave), DefineBehavior(ptr, ptr),
00609                   &::TSlave::Dictionary, isa_proxy, 0,
00610                   sizeof(::TSlave) );
00611       instance.SetDelete(&delete_TSlave);
00612       instance.SetDeleteArray(&deleteArray_TSlave);
00613       instance.SetDestructor(&destruct_TSlave);
00614       instance.SetStreamerFunc(&streamer_TSlave);
00615       return &instance;
00616    }
00617    TGenericClassInfo *GenerateInitInstance(const ::TSlave*)
00618    {
00619       return GenerateInitInstanceLocal((::TSlave*)0);
00620    }
00621    // Static variable to force the class initialization
00622    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSlave*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00623 } // end of namespace ROOT
00624 
00625 namespace ROOT {
00626    void TProofProgressInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
00627    static void *new_TProofProgressInfo(void *p = 0);
00628    static void *newArray_TProofProgressInfo(Long_t size, void *p);
00629    static void delete_TProofProgressInfo(void *p);
00630    static void deleteArray_TProofProgressInfo(void *p);
00631    static void destruct_TProofProgressInfo(void *p);
00632    static void streamer_TProofProgressInfo(TBuffer &buf, void *obj);
00633 
00634    // Function generating the singleton type initializer
00635    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofProgressInfo*)
00636    {
00637       ::TProofProgressInfo *ptr = 0;
00638       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofProgressInfo >(0);
00639       static ::ROOT::TGenericClassInfo 
00640          instance("TProofProgressInfo", ::TProofProgressInfo::Class_Version(), "include/TProof.h", 172,
00641                   typeid(::TProofProgressInfo), DefineBehavior(ptr, ptr),
00642                   &::TProofProgressInfo::Dictionary, isa_proxy, 0,
00643                   sizeof(::TProofProgressInfo) );
00644       instance.SetNew(&new_TProofProgressInfo);
00645       instance.SetNewArray(&newArray_TProofProgressInfo);
00646       instance.SetDelete(&delete_TProofProgressInfo);
00647       instance.SetDeleteArray(&deleteArray_TProofProgressInfo);
00648       instance.SetDestructor(&destruct_TProofProgressInfo);
00649       instance.SetStreamerFunc(&streamer_TProofProgressInfo);
00650       return &instance;
00651    }
00652    TGenericClassInfo *GenerateInitInstance(const ::TProofProgressInfo*)
00653    {
00654       return GenerateInitInstanceLocal((::TProofProgressInfo*)0);
00655    }
00656    // Static variable to force the class initialization
00657    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofProgressInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00658 } // end of namespace ROOT
00659 
00660 namespace ROOT {
00661    void TSlaveInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
00662    static void *new_TSlaveInfo(void *p = 0);
00663    static void *newArray_TSlaveInfo(Long_t size, void *p);
00664    static void delete_TSlaveInfo(void *p);
00665    static void deleteArray_TSlaveInfo(void *p);
00666    static void destruct_TSlaveInfo(void *p);
00667 
00668    // Function generating the singleton type initializer
00669    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSlaveInfo*)
00670    {
00671       ::TSlaveInfo *ptr = 0;
00672       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSlaveInfo >(0);
00673       static ::ROOT::TGenericClassInfo 
00674          instance("TSlaveInfo", ::TSlaveInfo::Class_Version(), "include/TProof.h", 223,
00675                   typeid(::TSlaveInfo), DefineBehavior(ptr, ptr),
00676                   &::TSlaveInfo::Dictionary, isa_proxy, 4,
00677                   sizeof(::TSlaveInfo) );
00678       instance.SetNew(&new_TSlaveInfo);
00679       instance.SetNewArray(&newArray_TSlaveInfo);
00680       instance.SetDelete(&delete_TSlaveInfo);
00681       instance.SetDeleteArray(&deleteArray_TSlaveInfo);
00682       instance.SetDestructor(&destruct_TSlaveInfo);
00683       return &instance;
00684    }
00685    TGenericClassInfo *GenerateInitInstance(const ::TSlaveInfo*)
00686    {
00687       return GenerateInitInstanceLocal((::TSlaveInfo*)0);
00688    }
00689    // Static variable to force the class initialization
00690    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSlaveInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00691 } // end of namespace ROOT
00692 
00693 namespace ROOT {
00694    void TMergerInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
00695    static void delete_TMergerInfo(void *p);
00696    static void deleteArray_TMergerInfo(void *p);
00697    static void destruct_TMergerInfo(void *p);
00698    static void streamer_TMergerInfo(TBuffer &buf, void *obj);
00699 
00700    // Function generating the singleton type initializer
00701    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMergerInfo*)
00702    {
00703       ::TMergerInfo *ptr = 0;
00704       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMergerInfo >(0);
00705       static ::ROOT::TGenericClassInfo 
00706          instance("TMergerInfo", ::TMergerInfo::Class_Version(), "include/TProof.h", 256,
00707                   typeid(::TMergerInfo), DefineBehavior(ptr, ptr),
00708                   &::TMergerInfo::Dictionary, isa_proxy, 0,
00709                   sizeof(::TMergerInfo) );
00710       instance.SetDelete(&delete_TMergerInfo);
00711       instance.SetDeleteArray(&deleteArray_TMergerInfo);
00712       instance.SetDestructor(&destruct_TMergerInfo);
00713       instance.SetStreamerFunc(&streamer_TMergerInfo);
00714       return &instance;
00715    }
00716    TGenericClassInfo *GenerateInitInstance(const ::TMergerInfo*)
00717    {
00718       return GenerateInitInstanceLocal((::TMergerInfo*)0);
00719    }
00720    // Static variable to force the class initialization
00721    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMergerInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00722 } // end of namespace ROOT
00723 
00724 namespace ROOT {
00725    void TProofLite_ShowMembers(void *obj, TMemberInspector &R__insp);
00726    static void delete_TProofLite(void *p);
00727    static void deleteArray_TProofLite(void *p);
00728    static void destruct_TProofLite(void *p);
00729    static void streamer_TProofLite(TBuffer &buf, void *obj);
00730 
00731    // Function generating the singleton type initializer
00732    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofLite*)
00733    {
00734       ::TProofLite *ptr = 0;
00735       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofLite >(0);
00736       static ::ROOT::TGenericClassInfo 
00737          instance("TProofLite", ::TProofLite::Class_Version(), "include/TProofLite.h", 41,
00738                   typeid(::TProofLite), DefineBehavior(ptr, ptr),
00739                   &::TProofLite::Dictionary, isa_proxy, 0,
00740                   sizeof(::TProofLite) );
00741       instance.SetDelete(&delete_TProofLite);
00742       instance.SetDeleteArray(&deleteArray_TProofLite);
00743       instance.SetDestructor(&destruct_TProofLite);
00744       instance.SetStreamerFunc(&streamer_TProofLite);
00745       return &instance;
00746    }
00747    TGenericClassInfo *GenerateInitInstance(const ::TProofLite*)
00748    {
00749       return GenerateInitInstanceLocal((::TProofLite*)0);
00750    }
00751    // Static variable to force the class initialization
00752    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofLite*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00753 } // end of namespace ROOT
00754 
00755 namespace ROOT {
00756    void TSlaveLite_ShowMembers(void *obj, TMemberInspector &R__insp);
00757    static void delete_TSlaveLite(void *p);
00758    static void deleteArray_TSlaveLite(void *p);
00759    static void destruct_TSlaveLite(void *p);
00760    static void streamer_TSlaveLite(TBuffer &buf, void *obj);
00761 
00762    // Function generating the singleton type initializer
00763    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSlaveLite*)
00764    {
00765       ::TSlaveLite *ptr = 0;
00766       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSlaveLite >(0);
00767       static ::ROOT::TGenericClassInfo 
00768          instance("TSlaveLite", ::TSlaveLite::Class_Version(), "include/TSlaveLite.h", 33,
00769                   typeid(::TSlaveLite), DefineBehavior(ptr, ptr),
00770                   &::TSlaveLite::Dictionary, isa_proxy, 0,
00771                   sizeof(::TSlaveLite) );
00772       instance.SetDelete(&delete_TSlaveLite);
00773       instance.SetDeleteArray(&deleteArray_TSlaveLite);
00774       instance.SetDestructor(&destruct_TSlaveLite);
00775       instance.SetStreamerFunc(&streamer_TSlaveLite);
00776       return &instance;
00777    }
00778    TGenericClassInfo *GenerateInitInstance(const ::TSlaveLite*)
00779    {
00780       return GenerateInitInstanceLocal((::TSlaveLite*)0);
00781    }
00782    // Static variable to force the class initialization
00783    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSlaveLite*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00784 } // end of namespace ROOT
00785 
00786 namespace ROOT {
00787    void TProofCondor_ShowMembers(void *obj, TMemberInspector &R__insp);
00788    static void delete_TProofCondor(void *p);
00789    static void deleteArray_TProofCondor(void *p);
00790    static void destruct_TProofCondor(void *p);
00791    static void streamer_TProofCondor(TBuffer &buf, void *obj);
00792 
00793    // Function generating the singleton type initializer
00794    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofCondor*)
00795    {
00796       ::TProofCondor *ptr = 0;
00797       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofCondor >(0);
00798       static ::ROOT::TGenericClassInfo 
00799          instance("TProofCondor", ::TProofCondor::Class_Version(), "include/TProofCondor.h", 37,
00800                   typeid(::TProofCondor), DefineBehavior(ptr, ptr),
00801                   &::TProofCondor::Dictionary, isa_proxy, 0,
00802                   sizeof(::TProofCondor) );
00803       instance.SetDelete(&delete_TProofCondor);
00804       instance.SetDeleteArray(&deleteArray_TProofCondor);
00805       instance.SetDestructor(&destruct_TProofCondor);
00806       instance.SetStreamerFunc(&streamer_TProofCondor);
00807       return &instance;
00808    }
00809    TGenericClassInfo *GenerateInitInstance(const ::TProofCondor*)
00810    {
00811       return GenerateInitInstanceLocal((::TProofCondor*)0);
00812    }
00813    // Static variable to force the class initialization
00814    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofCondor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00815 } // end of namespace ROOT
00816 
00817 namespace ROOT {
00818    void TQueryResultManager_ShowMembers(void *obj, TMemberInspector &R__insp);
00819    static void delete_TQueryResultManager(void *p);
00820    static void deleteArray_TQueryResultManager(void *p);
00821    static void destruct_TQueryResultManager(void *p);
00822 
00823    // Function generating the singleton type initializer
00824    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TQueryResultManager*)
00825    {
00826       ::TQueryResultManager *ptr = 0;
00827       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TQueryResultManager >(0);
00828       static ::ROOT::TGenericClassInfo 
00829          instance("TQueryResultManager", ::TQueryResultManager::Class_Version(), "include/TQueryResultManager.h", 41,
00830                   typeid(::TQueryResultManager), DefineBehavior(ptr, ptr),
00831                   &::TQueryResultManager::Dictionary, isa_proxy, 4,
00832                   sizeof(::TQueryResultManager) );
00833       instance.SetDelete(&delete_TQueryResultManager);
00834       instance.SetDeleteArray(&deleteArray_TQueryResultManager);
00835       instance.SetDestructor(&destruct_TQueryResultManager);
00836       return &instance;
00837    }
00838    TGenericClassInfo *GenerateInitInstance(const ::TQueryResultManager*)
00839    {
00840       return GenerateInitInstanceLocal((::TQueryResultManager*)0);
00841    }
00842    // Static variable to force the class initialization
00843    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TQueryResultManager*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00844 } // end of namespace ROOT
00845 
00846 namespace ROOT {
00847    void TProofQueryResult_ShowMembers(void *obj, TMemberInspector &R__insp);
00848    static void *new_TProofQueryResult(void *p = 0);
00849    static void *newArray_TProofQueryResult(Long_t size, void *p);
00850    static void delete_TProofQueryResult(void *p);
00851    static void deleteArray_TProofQueryResult(void *p);
00852    static void destruct_TProofQueryResult(void *p);
00853 
00854    // Function generating the singleton type initializer
00855    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofQueryResult*)
00856    {
00857       ::TProofQueryResult *ptr = 0;
00858       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofQueryResult >(0);
00859       static ::ROOT::TGenericClassInfo 
00860          instance("TProofQueryResult", ::TProofQueryResult::Class_Version(), "include/TProofQueryResult.h", 30,
00861                   typeid(::TProofQueryResult), DefineBehavior(ptr, ptr),
00862                   &::TProofQueryResult::Dictionary, isa_proxy, 4,
00863                   sizeof(::TProofQueryResult) );
00864       instance.SetNew(&new_TProofQueryResult);
00865       instance.SetNewArray(&newArray_TProofQueryResult);
00866       instance.SetDelete(&delete_TProofQueryResult);
00867       instance.SetDeleteArray(&deleteArray_TProofQueryResult);
00868       instance.SetDestructor(&destruct_TProofQueryResult);
00869       return &instance;
00870    }
00871    TGenericClassInfo *GenerateInitInstance(const ::TProofQueryResult*)
00872    {
00873       return GenerateInitInstanceLocal((::TProofQueryResult*)0);
00874    }
00875    // Static variable to force the class initialization
00876    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofQueryResult*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00877 } // end of namespace ROOT
00878 
00879 namespace ROOT {
00880    void TProofLogElem_ShowMembers(void *obj, TMemberInspector &R__insp);
00881    static void delete_TProofLogElem(void *p);
00882    static void deleteArray_TProofLogElem(void *p);
00883    static void destruct_TProofLogElem(void *p);
00884    static void streamer_TProofLogElem(TBuffer &buf, void *obj);
00885 
00886    // Function generating the singleton type initializer
00887    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofLogElem*)
00888    {
00889       ::TProofLogElem *ptr = 0;
00890       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofLogElem >(0);
00891       static ::ROOT::TGenericClassInfo 
00892          instance("TProofLogElem", ::TProofLogElem::Class_Version(), "include/TProofLog.h", 85,
00893                   typeid(::TProofLogElem), DefineBehavior(ptr, ptr),
00894                   &::TProofLogElem::Dictionary, isa_proxy, 0,
00895                   sizeof(::TProofLogElem) );
00896       instance.SetDelete(&delete_TProofLogElem);
00897       instance.SetDeleteArray(&deleteArray_TProofLogElem);
00898       instance.SetDestructor(&destruct_TProofLogElem);
00899       instance.SetStreamerFunc(&streamer_TProofLogElem);
00900       return &instance;
00901    }
00902    TGenericClassInfo *GenerateInitInstance(const ::TProofLogElem*)
00903    {
00904       return GenerateInitInstanceLocal((::TProofLogElem*)0);
00905    }
00906    // Static variable to force the class initialization
00907    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofLogElem*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00908 } // end of namespace ROOT
00909 
00910 namespace ROOT {
00911    void TProofMgrLite_ShowMembers(void *obj, TMemberInspector &R__insp);
00912    static void delete_TProofMgrLite(void *p);
00913    static void deleteArray_TProofMgrLite(void *p);
00914    static void destruct_TProofMgrLite(void *p);
00915    static void streamer_TProofMgrLite(TBuffer &buf, void *obj);
00916 
00917    // Function generating the singleton type initializer
00918    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofMgrLite*)
00919    {
00920       ::TProofMgrLite *ptr = 0;
00921       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofMgrLite >(0);
00922       static ::ROOT::TGenericClassInfo 
00923          instance("TProofMgrLite", ::TProofMgrLite::Class_Version(), "include/TProofMgrLite.h", 31,
00924                   typeid(::TProofMgrLite), DefineBehavior(ptr, ptr),
00925                   &::TProofMgrLite::Dictionary, isa_proxy, 0,
00926                   sizeof(::TProofMgrLite) );
00927       instance.SetDelete(&delete_TProofMgrLite);
00928       instance.SetDeleteArray(&deleteArray_TProofMgrLite);
00929       instance.SetDestructor(&destruct_TProofMgrLite);
00930       instance.SetStreamerFunc(&streamer_TProofMgrLite);
00931       return &instance;
00932    }
00933    TGenericClassInfo *GenerateInitInstance(const ::TProofMgrLite*)
00934    {
00935       return GenerateInitInstanceLocal((::TProofMgrLite*)0);
00936    }
00937    // Static variable to force the class initialization
00938    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofMgrLite*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00939 } // end of namespace ROOT
00940 
00941 namespace ROOT {
00942    void TProofResourcesStatic_ShowMembers(void *obj, TMemberInspector &R__insp);
00943    static void *new_TProofResourcesStatic(void *p = 0);
00944    static void *newArray_TProofResourcesStatic(Long_t size, void *p);
00945    static void delete_TProofResourcesStatic(void *p);
00946    static void deleteArray_TProofResourcesStatic(void *p);
00947    static void destruct_TProofResourcesStatic(void *p);
00948    static void streamer_TProofResourcesStatic(TBuffer &buf, void *obj);
00949 
00950    // Function generating the singleton type initializer
00951    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofResourcesStatic*)
00952    {
00953       ::TProofResourcesStatic *ptr = 0;
00954       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofResourcesStatic >(0);
00955       static ::ROOT::TGenericClassInfo 
00956          instance("TProofResourcesStatic", ::TProofResourcesStatic::Class_Version(), "include/TProofResourcesStatic.h", 41,
00957                   typeid(::TProofResourcesStatic), DefineBehavior(ptr, ptr),
00958                   &::TProofResourcesStatic::Dictionary, isa_proxy, 0,
00959                   sizeof(::TProofResourcesStatic) );
00960       instance.SetNew(&new_TProofResourcesStatic);
00961       instance.SetNewArray(&newArray_TProofResourcesStatic);
00962       instance.SetDelete(&delete_TProofResourcesStatic);
00963       instance.SetDeleteArray(&deleteArray_TProofResourcesStatic);
00964       instance.SetDestructor(&destruct_TProofResourcesStatic);
00965       instance.SetStreamerFunc(&streamer_TProofResourcesStatic);
00966       return &instance;
00967    }
00968    TGenericClassInfo *GenerateInitInstance(const ::TProofResourcesStatic*)
00969    {
00970       return GenerateInitInstanceLocal((::TProofResourcesStatic*)0);
00971    }
00972    // Static variable to force the class initialization
00973    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofResourcesStatic*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00974 } // end of namespace ROOT
00975 
00976 namespace ROOT {
00977    void TProofNodeInfo_ShowMembers(void *obj, TMemberInspector &R__insp);
00978    static void *new_TProofNodeInfo(void *p = 0);
00979    static void *newArray_TProofNodeInfo(Long_t size, void *p);
00980    static void delete_TProofNodeInfo(void *p);
00981    static void deleteArray_TProofNodeInfo(void *p);
00982    static void destruct_TProofNodeInfo(void *p);
00983    static void streamer_TProofNodeInfo(TBuffer &buf, void *obj);
00984 
00985    // Function generating the singleton type initializer
00986    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofNodeInfo*)
00987    {
00988       ::TProofNodeInfo *ptr = 0;
00989       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofNodeInfo >(0);
00990       static ::ROOT::TGenericClassInfo 
00991          instance("TProofNodeInfo", ::TProofNodeInfo::Class_Version(), "include/TProofNodeInfo.h", 36,
00992                   typeid(::TProofNodeInfo), DefineBehavior(ptr, ptr),
00993                   &::TProofNodeInfo::Dictionary, isa_proxy, 0,
00994                   sizeof(::TProofNodeInfo) );
00995       instance.SetNew(&new_TProofNodeInfo);
00996       instance.SetNewArray(&newArray_TProofNodeInfo);
00997       instance.SetDelete(&delete_TProofNodeInfo);
00998       instance.SetDeleteArray(&deleteArray_TProofNodeInfo);
00999       instance.SetDestructor(&destruct_TProofNodeInfo);
01000       instance.SetStreamerFunc(&streamer_TProofNodeInfo);
01001       return &instance;
01002    }
01003    TGenericClassInfo *GenerateInitInstance(const ::TProofNodeInfo*)
01004    {
01005       return GenerateInitInstanceLocal((::TProofNodeInfo*)0);
01006    }
01007    // Static variable to force the class initialization
01008    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofNodeInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01009 } // end of namespace ROOT
01010 
01011 namespace ROOT {
01012    void TProofProgressStatus_ShowMembers(void *obj, TMemberInspector &R__insp);
01013    static void *new_TProofProgressStatus(void *p = 0);
01014    static void *newArray_TProofProgressStatus(Long_t size, void *p);
01015    static void delete_TProofProgressStatus(void *p);
01016    static void deleteArray_TProofProgressStatus(void *p);
01017    static void destruct_TProofProgressStatus(void *p);
01018    static void streamer_TProofProgressStatus(TBuffer &buf, void *obj);
01019 
01020    // Function generating the singleton type initializer
01021    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofProgressStatus*)
01022    {
01023       ::TProofProgressStatus *ptr = 0;
01024       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofProgressStatus >(0);
01025       static ::ROOT::TGenericClassInfo 
01026          instance("TProofProgressStatus", ::TProofProgressStatus::Class_Version(), "include/TProofProgressStatus.h", 27,
01027                   typeid(::TProofProgressStatus), DefineBehavior(ptr, ptr),
01028                   &::TProofProgressStatus::Dictionary, isa_proxy, 0,
01029                   sizeof(::TProofProgressStatus) );
01030       instance.SetNew(&new_TProofProgressStatus);
01031       instance.SetNewArray(&newArray_TProofProgressStatus);
01032       instance.SetDelete(&delete_TProofProgressStatus);
01033       instance.SetDeleteArray(&deleteArray_TProofProgressStatus);
01034       instance.SetDestructor(&destruct_TProofProgressStatus);
01035       instance.SetStreamerFunc(&streamer_TProofProgressStatus);
01036       return &instance;
01037    }
01038    TGenericClassInfo *GenerateInitInstance(const ::TProofProgressStatus*)
01039    {
01040       return GenerateInitInstanceLocal((::TProofProgressStatus*)0);
01041    }
01042    // Static variable to force the class initialization
01043    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofProgressStatus*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01044 } // end of namespace ROOT
01045 
01046 namespace ROOT {
01047    void TProofResources_ShowMembers(void *obj, TMemberInspector &R__insp);
01048    static void delete_TProofResources(void *p);
01049    static void deleteArray_TProofResources(void *p);
01050    static void destruct_TProofResources(void *p);
01051    static void streamer_TProofResources(TBuffer &buf, void *obj);
01052 
01053    // Function generating the singleton type initializer
01054    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofResources*)
01055    {
01056       ::TProofResources *ptr = 0;
01057       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofResources >(0);
01058       static ::ROOT::TGenericClassInfo 
01059          instance("TProofResources", ::TProofResources::Class_Version(), "include/TProofResources.h", 36,
01060                   typeid(::TProofResources), DefineBehavior(ptr, ptr),
01061                   &::TProofResources::Dictionary, isa_proxy, 0,
01062                   sizeof(::TProofResources) );
01063       instance.SetDelete(&delete_TProofResources);
01064       instance.SetDeleteArray(&deleteArray_TProofResources);
01065       instance.SetDestructor(&destruct_TProofResources);
01066       instance.SetStreamerFunc(&streamer_TProofResources);
01067       return &instance;
01068    }
01069    TGenericClassInfo *GenerateInitInstance(const ::TProofResources*)
01070    {
01071       return GenerateInitInstanceLocal((::TProofResources*)0);
01072    }
01073    // Static variable to force the class initialization
01074    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofResources*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01075 } // end of namespace ROOT
01076 
01077 namespace ROOT {
01078    void TProofServLite_ShowMembers(void *obj, TMemberInspector &R__insp);
01079    static void delete_TProofServLite(void *p);
01080    static void deleteArray_TProofServLite(void *p);
01081    static void destruct_TProofServLite(void *p);
01082    static void streamer_TProofServLite(TBuffer &buf, void *obj);
01083 
01084    // Function generating the singleton type initializer
01085    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofServLite*)
01086    {
01087       ::TProofServLite *ptr = 0;
01088       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofServLite >(0);
01089       static ::ROOT::TGenericClassInfo 
01090          instance("TProofServLite", ::TProofServLite::Class_Version(), "include/TProofServLite.h", 32,
01091                   typeid(::TProofServLite), DefineBehavior(ptr, ptr),
01092                   &::TProofServLite::Dictionary, isa_proxy, 0,
01093                   sizeof(::TProofServLite) );
01094       instance.SetDelete(&delete_TProofServLite);
01095       instance.SetDeleteArray(&deleteArray_TProofServLite);
01096       instance.SetDestructor(&destruct_TProofServLite);
01097       instance.SetStreamerFunc(&streamer_TProofServLite);
01098       return &instance;
01099    }
01100    TGenericClassInfo *GenerateInitInstance(const ::TProofServLite*)
01101    {
01102       return GenerateInitInstanceLocal((::TProofServLite*)0);
01103    }
01104    // Static variable to force the class initialization
01105    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofServLite*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01106 } // end of namespace ROOT
01107 
01108 namespace ROOT {
01109    void TProofSuperMaster_ShowMembers(void *obj, TMemberInspector &R__insp);
01110    static void delete_TProofSuperMaster(void *p);
01111    static void deleteArray_TProofSuperMaster(void *p);
01112    static void destruct_TProofSuperMaster(void *p);
01113    static void streamer_TProofSuperMaster(TBuffer &buf, void *obj);
01114 
01115    // Function generating the singleton type initializer
01116    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofSuperMaster*)
01117    {
01118       ::TProofSuperMaster *ptr = 0;
01119       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofSuperMaster >(0);
01120       static ::ROOT::TGenericClassInfo 
01121          instance("TProofSuperMaster", ::TProofSuperMaster::Class_Version(), "include/TProofSuperMaster.h", 37,
01122                   typeid(::TProofSuperMaster), DefineBehavior(ptr, ptr),
01123                   &::TProofSuperMaster::Dictionary, isa_proxy, 0,
01124                   sizeof(::TProofSuperMaster) );
01125       instance.SetDelete(&delete_TProofSuperMaster);
01126       instance.SetDeleteArray(&deleteArray_TProofSuperMaster);
01127       instance.SetDestructor(&destruct_TProofSuperMaster);
01128       instance.SetStreamerFunc(&streamer_TProofSuperMaster);
01129       return &instance;
01130    }
01131    TGenericClassInfo *GenerateInitInstance(const ::TProofSuperMaster*)
01132    {
01133       return GenerateInitInstanceLocal((::TProofSuperMaster*)0);
01134    }
01135    // Static variable to force the class initialization
01136    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofSuperMaster*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01137 } // end of namespace ROOT
01138 
01139 //______________________________________________________________________________
01140 TClass *TCondorSlave::fgIsA = 0;  // static to hold class pointer
01141 
01142 //______________________________________________________________________________
01143 const char *TCondorSlave::Class_Name()
01144 {
01145    return "TCondorSlave";
01146 }
01147 
01148 //______________________________________________________________________________
01149 const char *TCondorSlave::ImplFileName()
01150 {
01151    return ::ROOT::GenerateInitInstanceLocal((const ::TCondorSlave*)0x0)->GetImplFileName();
01152 }
01153 
01154 //______________________________________________________________________________
01155 int TCondorSlave::ImplFileLine()
01156 {
01157    return ::ROOT::GenerateInitInstanceLocal((const ::TCondorSlave*)0x0)->GetImplFileLine();
01158 }
01159 
01160 //______________________________________________________________________________
01161 void TCondorSlave::Dictionary()
01162 {
01163    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TCondorSlave*)0x0)->GetClass();
01164 }
01165 
01166 //______________________________________________________________________________
01167 TClass *TCondorSlave::Class()
01168 {
01169    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TCondorSlave*)0x0)->GetClass();
01170    return fgIsA;
01171 }
01172 
01173 //______________________________________________________________________________
01174 TClass *TCondor::fgIsA = 0;  // static to hold class pointer
01175 
01176 //______________________________________________________________________________
01177 const char *TCondor::Class_Name()
01178 {
01179    return "TCondor";
01180 }
01181 
01182 //______________________________________________________________________________
01183 const char *TCondor::ImplFileName()
01184 {
01185    return ::ROOT::GenerateInitInstanceLocal((const ::TCondor*)0x0)->GetImplFileName();
01186 }
01187 
01188 //______________________________________________________________________________
01189 int TCondor::ImplFileLine()
01190 {
01191    return ::ROOT::GenerateInitInstanceLocal((const ::TCondor*)0x0)->GetImplFileLine();
01192 }
01193 
01194 //______________________________________________________________________________
01195 void TCondor::Dictionary()
01196 {
01197    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TCondor*)0x0)->GetClass();
01198 }
01199 
01200 //______________________________________________________________________________
01201 TClass *TCondor::Class()
01202 {
01203    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TCondor*)0x0)->GetClass();
01204    return fgIsA;
01205 }
01206 
01207 //______________________________________________________________________________
01208 TClass *TDataSetManager::fgIsA = 0;  // static to hold class pointer
01209 
01210 //______________________________________________________________________________
01211 const char *TDataSetManager::Class_Name()
01212 {
01213    return "TDataSetManager";
01214 }
01215 
01216 //______________________________________________________________________________
01217 const char *TDataSetManager::ImplFileName()
01218 {
01219    return ::ROOT::GenerateInitInstanceLocal((const ::TDataSetManager*)0x0)->GetImplFileName();
01220 }
01221 
01222 //______________________________________________________________________________
01223 int TDataSetManager::ImplFileLine()
01224 {
01225    return ::ROOT::GenerateInitInstanceLocal((const ::TDataSetManager*)0x0)->GetImplFileLine();
01226 }
01227 
01228 //______________________________________________________________________________
01229 void TDataSetManager::Dictionary()
01230 {
01231    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDataSetManager*)0x0)->GetClass();
01232 }
01233 
01234 //______________________________________________________________________________
01235 TClass *TDataSetManager::Class()
01236 {
01237    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDataSetManager*)0x0)->GetClass();
01238    return fgIsA;
01239 }
01240 
01241 //______________________________________________________________________________
01242 TClass *TDataSetManagerFile::fgIsA = 0;  // static to hold class pointer
01243 
01244 //______________________________________________________________________________
01245 const char *TDataSetManagerFile::Class_Name()
01246 {
01247    return "TDataSetManagerFile";
01248 }
01249 
01250 //______________________________________________________________________________
01251 const char *TDataSetManagerFile::ImplFileName()
01252 {
01253    return ::ROOT::GenerateInitInstanceLocal((const ::TDataSetManagerFile*)0x0)->GetImplFileName();
01254 }
01255 
01256 //______________________________________________________________________________
01257 int TDataSetManagerFile::ImplFileLine()
01258 {
01259    return ::ROOT::GenerateInitInstanceLocal((const ::TDataSetManagerFile*)0x0)->GetImplFileLine();
01260 }
01261 
01262 //______________________________________________________________________________
01263 void TDataSetManagerFile::Dictionary()
01264 {
01265    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDataSetManagerFile*)0x0)->GetClass();
01266 }
01267 
01268 //______________________________________________________________________________
01269 TClass *TDataSetManagerFile::Class()
01270 {
01271    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDataSetManagerFile*)0x0)->GetClass();
01272    return fgIsA;
01273 }
01274 
01275 //______________________________________________________________________________
01276 TClass *TDSet::fgIsA = 0;  // static to hold class pointer
01277 
01278 //______________________________________________________________________________
01279 const char *TDSet::Class_Name()
01280 {
01281    return "TDSet";
01282 }
01283 
01284 //______________________________________________________________________________
01285 const char *TDSet::ImplFileName()
01286 {
01287    return ::ROOT::GenerateInitInstanceLocal((const ::TDSet*)0x0)->GetImplFileName();
01288 }
01289 
01290 //______________________________________________________________________________
01291 int TDSet::ImplFileLine()
01292 {
01293    return ::ROOT::GenerateInitInstanceLocal((const ::TDSet*)0x0)->GetImplFileLine();
01294 }
01295 
01296 //______________________________________________________________________________
01297 void TDSet::Dictionary()
01298 {
01299    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDSet*)0x0)->GetClass();
01300 }
01301 
01302 //______________________________________________________________________________
01303 TClass *TDSet::Class()
01304 {
01305    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDSet*)0x0)->GetClass();
01306    return fgIsA;
01307 }
01308 
01309 //______________________________________________________________________________
01310 TClass *TProof::fgIsA = 0;  // static to hold class pointer
01311 
01312 //______________________________________________________________________________
01313 const char *TProof::Class_Name()
01314 {
01315    return "TProof";
01316 }
01317 
01318 //______________________________________________________________________________
01319 const char *TProof::ImplFileName()
01320 {
01321    return ::ROOT::GenerateInitInstanceLocal((const ::TProof*)0x0)->GetImplFileName();
01322 }
01323 
01324 //______________________________________________________________________________
01325 int TProof::ImplFileLine()
01326 {
01327    return ::ROOT::GenerateInitInstanceLocal((const ::TProof*)0x0)->GetImplFileLine();
01328 }
01329 
01330 //______________________________________________________________________________
01331 void TProof::Dictionary()
01332 {
01333    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProof*)0x0)->GetClass();
01334 }
01335 
01336 //______________________________________________________________________________
01337 TClass *TProof::Class()
01338 {
01339    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProof*)0x0)->GetClass();
01340    return fgIsA;
01341 }
01342 
01343 //______________________________________________________________________________
01344 TClass *TProofChain::fgIsA = 0;  // static to hold class pointer
01345 
01346 //______________________________________________________________________________
01347 const char *TProofChain::Class_Name()
01348 {
01349    return "TProofChain";
01350 }
01351 
01352 //______________________________________________________________________________
01353 const char *TProofChain::ImplFileName()
01354 {
01355    return ::ROOT::GenerateInitInstanceLocal((const ::TProofChain*)0x0)->GetImplFileName();
01356 }
01357 
01358 //______________________________________________________________________________
01359 int TProofChain::ImplFileLine()
01360 {
01361    return ::ROOT::GenerateInitInstanceLocal((const ::TProofChain*)0x0)->GetImplFileLine();
01362 }
01363 
01364 //______________________________________________________________________________
01365 void TProofChain::Dictionary()
01366 {
01367    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofChain*)0x0)->GetClass();
01368 }
01369 
01370 //______________________________________________________________________________
01371 TClass *TProofChain::Class()
01372 {
01373    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofChain*)0x0)->GetClass();
01374    return fgIsA;
01375 }
01376 
01377 //______________________________________________________________________________
01378 TClass *TDSetElement::fgIsA = 0;  // static to hold class pointer
01379 
01380 //______________________________________________________________________________
01381 const char *TDSetElement::Class_Name()
01382 {
01383    return "TDSetElement";
01384 }
01385 
01386 //______________________________________________________________________________
01387 const char *TDSetElement::ImplFileName()
01388 {
01389    return ::ROOT::GenerateInitInstanceLocal((const ::TDSetElement*)0x0)->GetImplFileName();
01390 }
01391 
01392 //______________________________________________________________________________
01393 int TDSetElement::ImplFileLine()
01394 {
01395    return ::ROOT::GenerateInitInstanceLocal((const ::TDSetElement*)0x0)->GetImplFileLine();
01396 }
01397 
01398 //______________________________________________________________________________
01399 void TDSetElement::Dictionary()
01400 {
01401    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDSetElement*)0x0)->GetClass();
01402 }
01403 
01404 //______________________________________________________________________________
01405 TClass *TDSetElement::Class()
01406 {
01407    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDSetElement*)0x0)->GetClass();
01408    return fgIsA;
01409 }
01410 
01411 //______________________________________________________________________________
01412 TClass *TProofServ::fgIsA = 0;  // static to hold class pointer
01413 
01414 //______________________________________________________________________________
01415 const char *TProofServ::Class_Name()
01416 {
01417    return "TProofServ";
01418 }
01419 
01420 //______________________________________________________________________________
01421 const char *TProofServ::ImplFileName()
01422 {
01423    return ::ROOT::GenerateInitInstanceLocal((const ::TProofServ*)0x0)->GetImplFileName();
01424 }
01425 
01426 //______________________________________________________________________________
01427 int TProofServ::ImplFileLine()
01428 {
01429    return ::ROOT::GenerateInitInstanceLocal((const ::TProofServ*)0x0)->GetImplFileLine();
01430 }
01431 
01432 //______________________________________________________________________________
01433 void TProofServ::Dictionary()
01434 {
01435    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofServ*)0x0)->GetClass();
01436 }
01437 
01438 //______________________________________________________________________________
01439 TClass *TProofServ::Class()
01440 {
01441    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofServ*)0x0)->GetClass();
01442    return fgIsA;
01443 }
01444 
01445 //______________________________________________________________________________
01446 TClass *TDSetProxy::fgIsA = 0;  // static to hold class pointer
01447 
01448 //______________________________________________________________________________
01449 const char *TDSetProxy::Class_Name()
01450 {
01451    return "TDSetProxy";
01452 }
01453 
01454 //______________________________________________________________________________
01455 const char *TDSetProxy::ImplFileName()
01456 {
01457    return ::ROOT::GenerateInitInstanceLocal((const ::TDSetProxy*)0x0)->GetImplFileName();
01458 }
01459 
01460 //______________________________________________________________________________
01461 int TDSetProxy::ImplFileLine()
01462 {
01463    return ::ROOT::GenerateInitInstanceLocal((const ::TDSetProxy*)0x0)->GetImplFileLine();
01464 }
01465 
01466 //______________________________________________________________________________
01467 void TDSetProxy::Dictionary()
01468 {
01469    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDSetProxy*)0x0)->GetClass();
01470 }
01471 
01472 //______________________________________________________________________________
01473 TClass *TDSetProxy::Class()
01474 {
01475    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDSetProxy*)0x0)->GetClass();
01476    return fgIsA;
01477 }
01478 
01479 //______________________________________________________________________________
01480 TClass *TProofDesc::fgIsA = 0;  // static to hold class pointer
01481 
01482 //______________________________________________________________________________
01483 const char *TProofDesc::Class_Name()
01484 {
01485    return "TProofDesc";
01486 }
01487 
01488 //______________________________________________________________________________
01489 const char *TProofDesc::ImplFileName()
01490 {
01491    return ::ROOT::GenerateInitInstanceLocal((const ::TProofDesc*)0x0)->GetImplFileName();
01492 }
01493 
01494 //______________________________________________________________________________
01495 int TProofDesc::ImplFileLine()
01496 {
01497    return ::ROOT::GenerateInitInstanceLocal((const ::TProofDesc*)0x0)->GetImplFileLine();
01498 }
01499 
01500 //______________________________________________________________________________
01501 void TProofDesc::Dictionary()
01502 {
01503    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofDesc*)0x0)->GetClass();
01504 }
01505 
01506 //______________________________________________________________________________
01507 TClass *TProofDesc::Class()
01508 {
01509    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofDesc*)0x0)->GetClass();
01510    return fgIsA;
01511 }
01512 
01513 //______________________________________________________________________________
01514 TClass *TProofLog::fgIsA = 0;  // static to hold class pointer
01515 
01516 //______________________________________________________________________________
01517 const char *TProofLog::Class_Name()
01518 {
01519    return "TProofLog";
01520 }
01521 
01522 //______________________________________________________________________________
01523 const char *TProofLog::ImplFileName()
01524 {
01525    return ::ROOT::GenerateInitInstanceLocal((const ::TProofLog*)0x0)->GetImplFileName();
01526 }
01527 
01528 //______________________________________________________________________________
01529 int TProofLog::ImplFileLine()
01530 {
01531    return ::ROOT::GenerateInitInstanceLocal((const ::TProofLog*)0x0)->GetImplFileLine();
01532 }
01533 
01534 //______________________________________________________________________________
01535 void TProofLog::Dictionary()
01536 {
01537    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofLog*)0x0)->GetClass();
01538 }
01539 
01540 //______________________________________________________________________________
01541 TClass *TProofLog::Class()
01542 {
01543    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofLog*)0x0)->GetClass();
01544    return fgIsA;
01545 }
01546 
01547 //______________________________________________________________________________
01548 TClass *TProofMgr::fgIsA = 0;  // static to hold class pointer
01549 
01550 //______________________________________________________________________________
01551 const char *TProofMgr::Class_Name()
01552 {
01553    return "TProofMgr";
01554 }
01555 
01556 //______________________________________________________________________________
01557 const char *TProofMgr::ImplFileName()
01558 {
01559    return ::ROOT::GenerateInitInstanceLocal((const ::TProofMgr*)0x0)->GetImplFileName();
01560 }
01561 
01562 //______________________________________________________________________________
01563 int TProofMgr::ImplFileLine()
01564 {
01565    return ::ROOT::GenerateInitInstanceLocal((const ::TProofMgr*)0x0)->GetImplFileLine();
01566 }
01567 
01568 //______________________________________________________________________________
01569 void TProofMgr::Dictionary()
01570 {
01571    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofMgr*)0x0)->GetClass();
01572 }
01573 
01574 //______________________________________________________________________________
01575 TClass *TProofMgr::Class()
01576 {
01577    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofMgr*)0x0)->GetClass();
01578    return fgIsA;
01579 }
01580 
01581 //______________________________________________________________________________
01582 TClass *TVirtualProofPlayer::fgIsA = 0;  // static to hold class pointer
01583 
01584 //______________________________________________________________________________
01585 const char *TVirtualProofPlayer::Class_Name()
01586 {
01587    return "TVirtualProofPlayer";
01588 }
01589 
01590 //______________________________________________________________________________
01591 const char *TVirtualProofPlayer::ImplFileName()
01592 {
01593    return ::ROOT::GenerateInitInstanceLocal((const ::TVirtualProofPlayer*)0x0)->GetImplFileName();
01594 }
01595 
01596 //______________________________________________________________________________
01597 int TVirtualProofPlayer::ImplFileLine()
01598 {
01599    return ::ROOT::GenerateInitInstanceLocal((const ::TVirtualProofPlayer*)0x0)->GetImplFileLine();
01600 }
01601 
01602 //______________________________________________________________________________
01603 void TVirtualProofPlayer::Dictionary()
01604 {
01605    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TVirtualProofPlayer*)0x0)->GetClass();
01606 }
01607 
01608 //______________________________________________________________________________
01609 TClass *TVirtualProofPlayer::Class()
01610 {
01611    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TVirtualProofPlayer*)0x0)->GetClass();
01612    return fgIsA;
01613 }
01614 
01615 //______________________________________________________________________________
01616 TClass *TSlave::fgIsA = 0;  // static to hold class pointer
01617 
01618 //______________________________________________________________________________
01619 const char *TSlave::Class_Name()
01620 {
01621    return "TSlave";
01622 }
01623 
01624 //______________________________________________________________________________
01625 const char *TSlave::ImplFileName()
01626 {
01627    return ::ROOT::GenerateInitInstanceLocal((const ::TSlave*)0x0)->GetImplFileName();
01628 }
01629 
01630 //______________________________________________________________________________
01631 int TSlave::ImplFileLine()
01632 {
01633    return ::ROOT::GenerateInitInstanceLocal((const ::TSlave*)0x0)->GetImplFileLine();
01634 }
01635 
01636 //______________________________________________________________________________
01637 void TSlave::Dictionary()
01638 {
01639    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSlave*)0x0)->GetClass();
01640 }
01641 
01642 //______________________________________________________________________________
01643 TClass *TSlave::Class()
01644 {
01645    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSlave*)0x0)->GetClass();
01646    return fgIsA;
01647 }
01648 
01649 //______________________________________________________________________________
01650 TClass *TProofProgressInfo::fgIsA = 0;  // static to hold class pointer
01651 
01652 //______________________________________________________________________________
01653 const char *TProofProgressInfo::Class_Name()
01654 {
01655    return "TProofProgressInfo";
01656 }
01657 
01658 //______________________________________________________________________________
01659 const char *TProofProgressInfo::ImplFileName()
01660 {
01661    return ::ROOT::GenerateInitInstanceLocal((const ::TProofProgressInfo*)0x0)->GetImplFileName();
01662 }
01663 
01664 //______________________________________________________________________________
01665 int TProofProgressInfo::ImplFileLine()
01666 {
01667    return ::ROOT::GenerateInitInstanceLocal((const ::TProofProgressInfo*)0x0)->GetImplFileLine();
01668 }
01669 
01670 //______________________________________________________________________________
01671 void TProofProgressInfo::Dictionary()
01672 {
01673    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofProgressInfo*)0x0)->GetClass();
01674 }
01675 
01676 //______________________________________________________________________________
01677 TClass *TProofProgressInfo::Class()
01678 {
01679    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofProgressInfo*)0x0)->GetClass();
01680    return fgIsA;
01681 }
01682 
01683 //______________________________________________________________________________
01684 TClass *TSlaveInfo::fgIsA = 0;  // static to hold class pointer
01685 
01686 //______________________________________________________________________________
01687 const char *TSlaveInfo::Class_Name()
01688 {
01689    return "TSlaveInfo";
01690 }
01691 
01692 //______________________________________________________________________________
01693 const char *TSlaveInfo::ImplFileName()
01694 {
01695    return ::ROOT::GenerateInitInstanceLocal((const ::TSlaveInfo*)0x0)->GetImplFileName();
01696 }
01697 
01698 //______________________________________________________________________________
01699 int TSlaveInfo::ImplFileLine()
01700 {
01701    return ::ROOT::GenerateInitInstanceLocal((const ::TSlaveInfo*)0x0)->GetImplFileLine();
01702 }
01703 
01704 //______________________________________________________________________________
01705 void TSlaveInfo::Dictionary()
01706 {
01707    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSlaveInfo*)0x0)->GetClass();
01708 }
01709 
01710 //______________________________________________________________________________
01711 TClass *TSlaveInfo::Class()
01712 {
01713    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSlaveInfo*)0x0)->GetClass();
01714    return fgIsA;
01715 }
01716 
01717 //______________________________________________________________________________
01718 TClass *TMergerInfo::fgIsA = 0;  // static to hold class pointer
01719 
01720 //______________________________________________________________________________
01721 const char *TMergerInfo::Class_Name()
01722 {
01723    return "TMergerInfo";
01724 }
01725 
01726 //______________________________________________________________________________
01727 const char *TMergerInfo::ImplFileName()
01728 {
01729    return ::ROOT::GenerateInitInstanceLocal((const ::TMergerInfo*)0x0)->GetImplFileName();
01730 }
01731 
01732 //______________________________________________________________________________
01733 int TMergerInfo::ImplFileLine()
01734 {
01735    return ::ROOT::GenerateInitInstanceLocal((const ::TMergerInfo*)0x0)->GetImplFileLine();
01736 }
01737 
01738 //______________________________________________________________________________
01739 void TMergerInfo::Dictionary()
01740 {
01741    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMergerInfo*)0x0)->GetClass();
01742 }
01743 
01744 //______________________________________________________________________________
01745 TClass *TMergerInfo::Class()
01746 {
01747    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMergerInfo*)0x0)->GetClass();
01748    return fgIsA;
01749 }
01750 
01751 //______________________________________________________________________________
01752 TClass *TProofLite::fgIsA = 0;  // static to hold class pointer
01753 
01754 //______________________________________________________________________________
01755 const char *TProofLite::Class_Name()
01756 {
01757    return "TProofLite";
01758 }
01759 
01760 //______________________________________________________________________________
01761 const char *TProofLite::ImplFileName()
01762 {
01763    return ::ROOT::GenerateInitInstanceLocal((const ::TProofLite*)0x0)->GetImplFileName();
01764 }
01765 
01766 //______________________________________________________________________________
01767 int TProofLite::ImplFileLine()
01768 {
01769    return ::ROOT::GenerateInitInstanceLocal((const ::TProofLite*)0x0)->GetImplFileLine();
01770 }
01771 
01772 //______________________________________________________________________________
01773 void TProofLite::Dictionary()
01774 {
01775    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofLite*)0x0)->GetClass();
01776 }
01777 
01778 //______________________________________________________________________________
01779 TClass *TProofLite::Class()
01780 {
01781    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofLite*)0x0)->GetClass();
01782    return fgIsA;
01783 }
01784 
01785 //______________________________________________________________________________
01786 TClass *TSlaveLite::fgIsA = 0;  // static to hold class pointer
01787 
01788 //______________________________________________________________________________
01789 const char *TSlaveLite::Class_Name()
01790 {
01791    return "TSlaveLite";
01792 }
01793 
01794 //______________________________________________________________________________
01795 const char *TSlaveLite::ImplFileName()
01796 {
01797    return ::ROOT::GenerateInitInstanceLocal((const ::TSlaveLite*)0x0)->GetImplFileName();
01798 }
01799 
01800 //______________________________________________________________________________
01801 int TSlaveLite::ImplFileLine()
01802 {
01803    return ::ROOT::GenerateInitInstanceLocal((const ::TSlaveLite*)0x0)->GetImplFileLine();
01804 }
01805 
01806 //______________________________________________________________________________
01807 void TSlaveLite::Dictionary()
01808 {
01809    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSlaveLite*)0x0)->GetClass();
01810 }
01811 
01812 //______________________________________________________________________________
01813 TClass *TSlaveLite::Class()
01814 {
01815    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TSlaveLite*)0x0)->GetClass();
01816    return fgIsA;
01817 }
01818 
01819 //______________________________________________________________________________
01820 TClass *TProofCondor::fgIsA = 0;  // static to hold class pointer
01821 
01822 //______________________________________________________________________________
01823 const char *TProofCondor::Class_Name()
01824 {
01825    return "TProofCondor";
01826 }
01827 
01828 //______________________________________________________________________________
01829 const char *TProofCondor::ImplFileName()
01830 {
01831    return ::ROOT::GenerateInitInstanceLocal((const ::TProofCondor*)0x0)->GetImplFileName();
01832 }
01833 
01834 //______________________________________________________________________________
01835 int TProofCondor::ImplFileLine()
01836 {
01837    return ::ROOT::GenerateInitInstanceLocal((const ::TProofCondor*)0x0)->GetImplFileLine();
01838 }
01839 
01840 //______________________________________________________________________________
01841 void TProofCondor::Dictionary()
01842 {
01843    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofCondor*)0x0)->GetClass();
01844 }
01845 
01846 //______________________________________________________________________________
01847 TClass *TProofCondor::Class()
01848 {
01849    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofCondor*)0x0)->GetClass();
01850    return fgIsA;
01851 }
01852 
01853 //______________________________________________________________________________
01854 TClass *TQueryResultManager::fgIsA = 0;  // static to hold class pointer
01855 
01856 //______________________________________________________________________________
01857 const char *TQueryResultManager::Class_Name()
01858 {
01859    return "TQueryResultManager";
01860 }
01861 
01862 //______________________________________________________________________________
01863 const char *TQueryResultManager::ImplFileName()
01864 {
01865    return ::ROOT::GenerateInitInstanceLocal((const ::TQueryResultManager*)0x0)->GetImplFileName();
01866 }
01867 
01868 //______________________________________________________________________________
01869 int TQueryResultManager::ImplFileLine()
01870 {
01871    return ::ROOT::GenerateInitInstanceLocal((const ::TQueryResultManager*)0x0)->GetImplFileLine();
01872 }
01873 
01874 //______________________________________________________________________________
01875 void TQueryResultManager::Dictionary()
01876 {
01877    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TQueryResultManager*)0x0)->GetClass();
01878 }
01879 
01880 //______________________________________________________________________________
01881 TClass *TQueryResultManager::Class()
01882 {
01883    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TQueryResultManager*)0x0)->GetClass();
01884    return fgIsA;
01885 }
01886 
01887 //______________________________________________________________________________
01888 TClass *TProofQueryResult::fgIsA = 0;  // static to hold class pointer
01889 
01890 //______________________________________________________________________________
01891 const char *TProofQueryResult::Class_Name()
01892 {
01893    return "TProofQueryResult";
01894 }
01895 
01896 //______________________________________________________________________________
01897 const char *TProofQueryResult::ImplFileName()
01898 {
01899    return ::ROOT::GenerateInitInstanceLocal((const ::TProofQueryResult*)0x0)->GetImplFileName();
01900 }
01901 
01902 //______________________________________________________________________________
01903 int TProofQueryResult::ImplFileLine()
01904 {
01905    return ::ROOT::GenerateInitInstanceLocal((const ::TProofQueryResult*)0x0)->GetImplFileLine();
01906 }
01907 
01908 //______________________________________________________________________________
01909 void TProofQueryResult::Dictionary()
01910 {
01911    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofQueryResult*)0x0)->GetClass();
01912 }
01913 
01914 //______________________________________________________________________________
01915 TClass *TProofQueryResult::Class()
01916 {
01917    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofQueryResult*)0x0)->GetClass();
01918    return fgIsA;
01919 }
01920 
01921 //______________________________________________________________________________
01922 TClass *TProofLogElem::fgIsA = 0;  // static to hold class pointer
01923 
01924 //______________________________________________________________________________
01925 const char *TProofLogElem::Class_Name()
01926 {
01927    return "TProofLogElem";
01928 }
01929 
01930 //______________________________________________________________________________
01931 const char *TProofLogElem::ImplFileName()
01932 {
01933    return ::ROOT::GenerateInitInstanceLocal((const ::TProofLogElem*)0x0)->GetImplFileName();
01934 }
01935 
01936 //______________________________________________________________________________
01937 int TProofLogElem::ImplFileLine()
01938 {
01939    return ::ROOT::GenerateInitInstanceLocal((const ::TProofLogElem*)0x0)->GetImplFileLine();
01940 }
01941 
01942 //______________________________________________________________________________
01943 void TProofLogElem::Dictionary()
01944 {
01945    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofLogElem*)0x0)->GetClass();
01946 }
01947 
01948 //______________________________________________________________________________
01949 TClass *TProofLogElem::Class()
01950 {
01951    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofLogElem*)0x0)->GetClass();
01952    return fgIsA;
01953 }
01954 
01955 //______________________________________________________________________________
01956 TClass *TProofMgrLite::fgIsA = 0;  // static to hold class pointer
01957 
01958 //______________________________________________________________________________
01959 const char *TProofMgrLite::Class_Name()
01960 {
01961    return "TProofMgrLite";
01962 }
01963 
01964 //______________________________________________________________________________
01965 const char *TProofMgrLite::ImplFileName()
01966 {
01967    return ::ROOT::GenerateInitInstanceLocal((const ::TProofMgrLite*)0x0)->GetImplFileName();
01968 }
01969 
01970 //______________________________________________________________________________
01971 int TProofMgrLite::ImplFileLine()
01972 {
01973    return ::ROOT::GenerateInitInstanceLocal((const ::TProofMgrLite*)0x0)->GetImplFileLine();
01974 }
01975 
01976 //______________________________________________________________________________
01977 void TProofMgrLite::Dictionary()
01978 {
01979    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofMgrLite*)0x0)->GetClass();
01980 }
01981 
01982 //______________________________________________________________________________
01983 TClass *TProofMgrLite::Class()
01984 {
01985    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofMgrLite*)0x0)->GetClass();
01986    return fgIsA;
01987 }
01988 
01989 //______________________________________________________________________________
01990 TClass *TProofResourcesStatic::fgIsA = 0;  // static to hold class pointer
01991 
01992 //______________________________________________________________________________
01993 const char *TProofResourcesStatic::Class_Name()
01994 {
01995    return "TProofResourcesStatic";
01996 }
01997 
01998 //______________________________________________________________________________
01999 const char *TProofResourcesStatic::ImplFileName()
02000 {
02001    return ::ROOT::GenerateInitInstanceLocal((const ::TProofResourcesStatic*)0x0)->GetImplFileName();
02002 }
02003 
02004 //______________________________________________________________________________
02005 int TProofResourcesStatic::ImplFileLine()
02006 {
02007    return ::ROOT::GenerateInitInstanceLocal((const ::TProofResourcesStatic*)0x0)->GetImplFileLine();
02008 }
02009 
02010 //______________________________________________________________________________
02011 void TProofResourcesStatic::Dictionary()
02012 {
02013    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofResourcesStatic*)0x0)->GetClass();
02014 }
02015 
02016 //______________________________________________________________________________
02017 TClass *TProofResourcesStatic::Class()
02018 {
02019    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofResourcesStatic*)0x0)->GetClass();
02020    return fgIsA;
02021 }
02022 
02023 //______________________________________________________________________________
02024 TClass *TProofNodeInfo::fgIsA = 0;  // static to hold class pointer
02025 
02026 //______________________________________________________________________________
02027 const char *TProofNodeInfo::Class_Name()
02028 {
02029    return "TProofNodeInfo";
02030 }
02031 
02032 //______________________________________________________________________________
02033 const char *TProofNodeInfo::ImplFileName()
02034 {
02035    return ::ROOT::GenerateInitInstanceLocal((const ::TProofNodeInfo*)0x0)->GetImplFileName();
02036 }
02037 
02038 //______________________________________________________________________________
02039 int TProofNodeInfo::ImplFileLine()
02040 {
02041    return ::ROOT::GenerateInitInstanceLocal((const ::TProofNodeInfo*)0x0)->GetImplFileLine();
02042 }
02043 
02044 //______________________________________________________________________________
02045 void TProofNodeInfo::Dictionary()
02046 {
02047    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofNodeInfo*)0x0)->GetClass();
02048 }
02049 
02050 //______________________________________________________________________________
02051 TClass *TProofNodeInfo::Class()
02052 {
02053    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofNodeInfo*)0x0)->GetClass();
02054    return fgIsA;
02055 }
02056 
02057 //______________________________________________________________________________
02058 TClass *TProofProgressStatus::fgIsA = 0;  // static to hold class pointer
02059 
02060 //______________________________________________________________________________
02061 const char *TProofProgressStatus::Class_Name()
02062 {
02063    return "TProofProgressStatus";
02064 }
02065 
02066 //______________________________________________________________________________
02067 const char *TProofProgressStatus::ImplFileName()
02068 {
02069    return ::ROOT::GenerateInitInstanceLocal((const ::TProofProgressStatus*)0x0)->GetImplFileName();
02070 }
02071 
02072 //______________________________________________________________________________
02073 int TProofProgressStatus::ImplFileLine()
02074 {
02075    return ::ROOT::GenerateInitInstanceLocal((const ::TProofProgressStatus*)0x0)->GetImplFileLine();
02076 }
02077 
02078 //______________________________________________________________________________
02079 void TProofProgressStatus::Dictionary()
02080 {
02081    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofProgressStatus*)0x0)->GetClass();
02082 }
02083 
02084 //______________________________________________________________________________
02085 TClass *TProofProgressStatus::Class()
02086 {
02087    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofProgressStatus*)0x0)->GetClass();
02088    return fgIsA;
02089 }
02090 
02091 //______________________________________________________________________________
02092 TClass *TProofResources::fgIsA = 0;  // static to hold class pointer
02093 
02094 //______________________________________________________________________________
02095 const char *TProofResources::Class_Name()
02096 {
02097    return "TProofResources";
02098 }
02099 
02100 //______________________________________________________________________________
02101 const char *TProofResources::ImplFileName()
02102 {
02103    return ::ROOT::GenerateInitInstanceLocal((const ::TProofResources*)0x0)->GetImplFileName();
02104 }
02105 
02106 //______________________________________________________________________________
02107 int TProofResources::ImplFileLine()
02108 {
02109    return ::ROOT::GenerateInitInstanceLocal((const ::TProofResources*)0x0)->GetImplFileLine();
02110 }
02111 
02112 //______________________________________________________________________________
02113 void TProofResources::Dictionary()
02114 {
02115    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofResources*)0x0)->GetClass();
02116 }
02117 
02118 //______________________________________________________________________________
02119 TClass *TProofResources::Class()
02120 {
02121    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofResources*)0x0)->GetClass();
02122    return fgIsA;
02123 }
02124 
02125 //______________________________________________________________________________
02126 TClass *TProofServLite::fgIsA = 0;  // static to hold class pointer
02127 
02128 //______________________________________________________________________________
02129 const char *TProofServLite::Class_Name()
02130 {
02131    return "TProofServLite";
02132 }
02133 
02134 //______________________________________________________________________________
02135 const char *TProofServLite::ImplFileName()
02136 {
02137    return ::ROOT::GenerateInitInstanceLocal((const ::TProofServLite*)0x0)->GetImplFileName();
02138 }
02139 
02140 //______________________________________________________________________________
02141 int TProofServLite::ImplFileLine()
02142 {
02143    return ::ROOT::GenerateInitInstanceLocal((const ::TProofServLite*)0x0)->GetImplFileLine();
02144 }
02145 
02146 //______________________________________________________________________________
02147 void TProofServLite::Dictionary()
02148 {
02149    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofServLite*)0x0)->GetClass();
02150 }
02151 
02152 //______________________________________________________________________________
02153 TClass *TProofServLite::Class()
02154 {
02155    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofServLite*)0x0)->GetClass();
02156    return fgIsA;
02157 }
02158 
02159 //______________________________________________________________________________
02160 TClass *TProofSuperMaster::fgIsA = 0;  // static to hold class pointer
02161 
02162 //______________________________________________________________________________
02163 const char *TProofSuperMaster::Class_Name()
02164 {
02165    return "TProofSuperMaster";
02166 }
02167 
02168 //______________________________________________________________________________
02169 const char *TProofSuperMaster::ImplFileName()
02170 {
02171    return ::ROOT::GenerateInitInstanceLocal((const ::TProofSuperMaster*)0x0)->GetImplFileName();
02172 }
02173 
02174 //______________________________________________________________________________
02175 int TProofSuperMaster::ImplFileLine()
02176 {
02177    return ::ROOT::GenerateInitInstanceLocal((const ::TProofSuperMaster*)0x0)->GetImplFileLine();
02178 }
02179 
02180 //______________________________________________________________________________
02181 void TProofSuperMaster::Dictionary()
02182 {
02183    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofSuperMaster*)0x0)->GetClass();
02184 }
02185 
02186 //______________________________________________________________________________
02187 TClass *TProofSuperMaster::Class()
02188 {
02189    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofSuperMaster*)0x0)->GetClass();
02190    return fgIsA;
02191 }
02192 
02193 //______________________________________________________________________________
02194 void TDSet::ShowMembers(TMemberInspector &R__insp)
02195 {
02196       // Inspect the data members of an object of class TDSet.
02197       TClass *R__cl = ::TDSet::IsA();
02198       if (R__cl || R__insp.IsA()) { }
02199       R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsTree", &fIsTree);
02200       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEntryList", &fEntryList);
02201       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProofChain", &fProofChain);
02202       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDir", &fDir);
02203       R__insp.InspectMember(fDir, "fDir.");
02204       R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
02205       R__insp.InspectMember(fType, "fType.");
02206       R__insp.Inspect(R__cl, R__insp.GetParent(), "fObjName", &fObjName);
02207       R__insp.InspectMember(fObjName, "fObjName.");
02208       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElements", &fElements);
02209       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIterator", &fIterator);
02210       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrent", &fCurrent);
02211       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSrvMaps", &fSrvMaps);
02212       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSrvMapsIter", &fSrvMapsIter);
02213       TNamed::ShowMembers(R__insp);
02214 }
02215 
02216 namespace ROOT {
02217    // Wrappers around operator new
02218    static void *new_TDSet(void *p) {
02219       return  p ? new(p) ::TDSet : new ::TDSet;
02220    }
02221    static void *newArray_TDSet(Long_t nElements, void *p) {
02222       return p ? new(p) ::TDSet[nElements] : new ::TDSet[nElements];
02223    }
02224    // Wrapper around operator delete
02225    static void delete_TDSet(void *p) {
02226       delete ((::TDSet*)p);
02227    }
02228    static void deleteArray_TDSet(void *p) {
02229       delete [] ((::TDSet*)p);
02230    }
02231    static void destruct_TDSet(void *p) {
02232       typedef ::TDSet current_t;
02233       ((current_t*)p)->~current_t();
02234    }
02235    // Wrapper around a custom streamer member function.
02236    static void streamer_TDSet(TBuffer &buf, void *obj) {
02237       ((::TDSet*)obj)->::TDSet::Streamer(buf);
02238    }
02239 } // end of namespace ROOT for class ::TDSet
02240 
02241 //______________________________________________________________________________
02242 void TDSetElement::ShowMembers(TMemberInspector &R__insp)
02243 {
02244       // Inspect the data members of an object of class TDSetElement.
02245       TClass *R__cl = ::TDSetElement::IsA();
02246       if (R__cl || R__insp.IsA()) { }
02247       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDirectory", &fDirectory);
02248       R__insp.InspectMember(fDirectory, "fDirectory.");
02249       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFirst", &fFirst);
02250       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNum", &fNum);
02251       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMsd", &fMsd);
02252       R__insp.InspectMember(fMsd, "fMsd.");
02253       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTDSetOffset", &fTDSetOffset);
02254       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEntryList", &fEntryList);
02255       R__insp.Inspect(R__cl, R__insp.GetParent(), "fValid", &fValid);
02256       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntries", &fEntries);
02257       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFriends", &fFriends);
02258       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataSet", &fDataSet);
02259       R__insp.InspectMember(fDataSet, "fDataSet.");
02260       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAssocObjList", &fAssocObjList);
02261       TNamed::ShowMembers(R__insp);
02262 }
02263 
02264 namespace ROOT {
02265    // Wrappers around operator new
02266    static void *new_TDSetElement(void *p) {
02267       return  p ? new(p) ::TDSetElement : new ::TDSetElement;
02268    }
02269    static void *newArray_TDSetElement(Long_t nElements, void *p) {
02270       return p ? new(p) ::TDSetElement[nElements] : new ::TDSetElement[nElements];
02271    }
02272    // Wrapper around operator delete
02273    static void delete_TDSetElement(void *p) {
02274       delete ((::TDSetElement*)p);
02275    }
02276    static void deleteArray_TDSetElement(void *p) {
02277       delete [] ((::TDSetElement*)p);
02278    }
02279    static void destruct_TDSetElement(void *p) {
02280       typedef ::TDSetElement current_t;
02281       ((current_t*)p)->~current_t();
02282    }
02283    // Wrapper around a custom streamer member function.
02284    static void streamer_TDSetElement(TBuffer &buf, void *obj) {
02285       ((::TDSetElement*)obj)->::TDSetElement::Streamer(buf);
02286    }
02287 } // end of namespace ROOT for class ::TDSetElement
02288 
02289 //______________________________________________________________________________
02290 void TProofChain::Streamer(TBuffer &R__b)
02291 {
02292    // Stream an object of class TProofChain.
02293 
02294    if (R__b.IsReading()) {
02295       R__b.ReadClassBuffer(TProofChain::Class(),this);
02296    } else {
02297       R__b.WriteClassBuffer(TProofChain::Class(),this);
02298    }
02299 }
02300 
02301 //______________________________________________________________________________
02302 void TProofChain::ShowMembers(TMemberInspector &R__insp)
02303 {
02304       // Inspect the data members of an object of class TProofChain.
02305       TClass *R__cl = ::TProofChain::IsA();
02306       if (R__cl || R__insp.IsA()) { }
02307       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fChain", &fChain);
02308       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSet", &fSet);
02309       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDrawFeedback", &fDrawFeedback);
02310       TChain::ShowMembers(R__insp);
02311 }
02312 
02313 namespace ROOT {
02314    // Wrappers around operator new
02315    static void *new_TProofChain(void *p) {
02316       return  p ? new(p) ::TProofChain : new ::TProofChain;
02317    }
02318    static void *newArray_TProofChain(Long_t nElements, void *p) {
02319       return p ? new(p) ::TProofChain[nElements] : new ::TProofChain[nElements];
02320    }
02321    // Wrapper around operator delete
02322    static void delete_TProofChain(void *p) {
02323       delete ((::TProofChain*)p);
02324    }
02325    static void deleteArray_TProofChain(void *p) {
02326       delete [] ((::TProofChain*)p);
02327    }
02328    static void destruct_TProofChain(void *p) {
02329       typedef ::TProofChain current_t;
02330       ((current_t*)p)->~current_t();
02331    }
02332    // Wrapper around the directory auto add.
02333    static void directoryAutoAdd_TProofChain(void *p, TDirectory *dir) {
02334       ((::TProofChain*)p)->DirectoryAutoAdd(dir);
02335    }
02336 } // end of namespace ROOT for class ::TProofChain
02337 
02338 //______________________________________________________________________________
02339 void TProofMgr::Streamer(TBuffer &R__b)
02340 {
02341    // Stream an object of class TProofMgr.
02342 
02343    TNamed::Streamer(R__b);
02344 }
02345 
02346 //______________________________________________________________________________
02347 void TProofMgr::ShowMembers(TMemberInspector &R__insp)
02348 {
02349       // Inspect the data members of an object of class TProofMgr.
02350       TClass *R__cl = ::TProofMgr::IsA();
02351       if (R__cl || R__insp.IsA()) { }
02352       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRemoteProtocol", &fRemoteProtocol);
02353       R__insp.Inspect(R__cl, R__insp.GetParent(), "fServType", &fServType);
02354       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSessions", &fSessions);
02355       R__insp.Inspect(R__cl, R__insp.GetParent(), "fUrl", &fUrl);
02356       R__insp.InspectMember(fUrl, "fUrl.");
02357       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIntHandler", &fIntHandler);
02358       TNamed::ShowMembers(R__insp);
02359 }
02360 
02361 namespace ROOT {
02362    // Wrapper around operator delete
02363    static void delete_TProofMgr(void *p) {
02364       delete ((::TProofMgr*)p);
02365    }
02366    static void deleteArray_TProofMgr(void *p) {
02367       delete [] ((::TProofMgr*)p);
02368    }
02369    static void destruct_TProofMgr(void *p) {
02370       typedef ::TProofMgr current_t;
02371       ((current_t*)p)->~current_t();
02372    }
02373    // Wrapper around a custom streamer member function.
02374    static void streamer_TProofMgr(TBuffer &buf, void *obj) {
02375       ((::TProofMgr*)obj)->::TProofMgr::Streamer(buf);
02376    }
02377 } // end of namespace ROOT for class ::TProofMgr
02378 
02379 //______________________________________________________________________________
02380 void TProofMgrLite::Streamer(TBuffer &R__b)
02381 {
02382    // Stream an object of class TProofMgrLite.
02383 
02384    TProofMgr::Streamer(R__b);
02385 }
02386 
02387 //______________________________________________________________________________
02388 void TProofMgrLite::ShowMembers(TMemberInspector &R__insp)
02389 {
02390       // Inspect the data members of an object of class TProofMgrLite.
02391       TClass *R__cl = ::TProofMgrLite::IsA();
02392       if (R__cl || R__insp.IsA()) { }
02393       TProofMgr::ShowMembers(R__insp);
02394 }
02395 
02396 namespace ROOT {
02397    // Wrapper around operator delete
02398    static void delete_TProofMgrLite(void *p) {
02399       delete ((::TProofMgrLite*)p);
02400    }
02401    static void deleteArray_TProofMgrLite(void *p) {
02402       delete [] ((::TProofMgrLite*)p);
02403    }
02404    static void destruct_TProofMgrLite(void *p) {
02405       typedef ::TProofMgrLite current_t;
02406       ((current_t*)p)->~current_t();
02407    }
02408    // Wrapper around a custom streamer member function.
02409    static void streamer_TProofMgrLite(TBuffer &buf, void *obj) {
02410       ((::TProofMgrLite*)obj)->::TProofMgrLite::Streamer(buf);
02411    }
02412 } // end of namespace ROOT for class ::TProofMgrLite
02413 
02414 //______________________________________________________________________________
02415 void TProofDesc::Streamer(TBuffer &R__b)
02416 {
02417    // Stream an object of class TProofDesc.
02418 
02419    UInt_t R__s, R__c;
02420    if (R__b.IsReading()) {
02421       Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
02422       TNamed::Streamer(R__b);
02423       R__b >> fLocalId;
02424       R__b >> fStatus;
02425       R__b >> fProof;
02426       R__b >> fRemoteId;
02427       fUrl.Streamer(R__b);
02428       R__b.CheckByteCount(R__s, R__c, TProofDesc::IsA());
02429    } else {
02430       R__c = R__b.WriteVersion(TProofDesc::IsA(), kTRUE);
02431       TNamed::Streamer(R__b);
02432       R__b << fLocalId;
02433       R__b << fStatus;
02434       R__b << fProof;
02435       R__b << fRemoteId;
02436       fUrl.Streamer(R__b);
02437       R__b.SetByteCount(R__c, kTRUE);
02438    }
02439 }
02440 
02441 //______________________________________________________________________________
02442 void TProofDesc::ShowMembers(TMemberInspector &R__insp)
02443 {
02444       // Inspect the data members of an object of class TProofDesc.
02445       TClass *R__cl = ::TProofDesc::IsA();
02446       if (R__cl || R__insp.IsA()) { }
02447       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLocalId", &fLocalId);
02448       R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &fStatus);
02449       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProof", &fProof);
02450       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRemoteId", &fRemoteId);
02451       R__insp.Inspect(R__cl, R__insp.GetParent(), "fUrl", &fUrl);
02452       R__insp.InspectMember(fUrl, "fUrl.");
02453       TNamed::ShowMembers(R__insp);
02454 }
02455 
02456 namespace ROOT {
02457    // Wrappers around operator new
02458    static void *new_TProofDesc(void *p) {
02459       return  p ? new(p) ::TProofDesc : new ::TProofDesc;
02460    }
02461    static void *newArray_TProofDesc(Long_t nElements, void *p) {
02462       return p ? new(p) ::TProofDesc[nElements] : new ::TProofDesc[nElements];
02463    }
02464    // Wrapper around operator delete
02465    static void delete_TProofDesc(void *p) {
02466       delete ((::TProofDesc*)p);
02467    }
02468    static void deleteArray_TProofDesc(void *p) {
02469       delete [] ((::TProofDesc*)p);
02470    }
02471    static void destruct_TProofDesc(void *p) {
02472       typedef ::TProofDesc current_t;
02473       ((current_t*)p)->~current_t();
02474    }
02475    // Wrapper around a custom streamer member function.
02476    static void streamer_TProofDesc(TBuffer &buf, void *obj) {
02477       ((::TProofDesc*)obj)->::TProofDesc::Streamer(buf);
02478    }
02479 } // end of namespace ROOT for class ::TProofDesc
02480 
02481 //______________________________________________________________________________
02482 void TProof::Streamer(TBuffer &R__b)
02483 {
02484    // Stream an object of class TProof.
02485 
02486    TNamed::Streamer(R__b);
02487    TQObject::Streamer(R__b);
02488 }
02489 
02490 //______________________________________________________________________________
02491 void TProof::ShowMembers(TMemberInspector &R__insp)
02492 {
02493       // Inspect the data members of an object of class TProof.
02494       TClass *R__cl = ::TProof::IsA();
02495       if (R__cl || R__insp.IsA()) { }
02496       R__insp.Inspect(R__cl, R__insp.GetParent(), "fValid", &fValid);
02497       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaster", &fMaster);
02498       R__insp.InspectMember(fMaster, "fMaster.");
02499       R__insp.Inspect(R__cl, R__insp.GetParent(), "fWorkDir", &fWorkDir);
02500       R__insp.InspectMember(fWorkDir, "fWorkDir.");
02501       R__insp.Inspect(R__cl, R__insp.GetParent(), "fGroup", &fGroup);
02502       R__insp.InspectMember(fGroup, "fGroup.");
02503       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLogLevel", &fLogLevel);
02504       R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &fStatus);
02505       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCheckFileStatus", &fCheckFileStatus);
02506       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRecvMessages", &fRecvMessages);
02507       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSlaveInfo", &fSlaveInfo);
02508       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSendGroupView", &fSendGroupView);
02509       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fActiveSlaves", &fActiveSlaves);
02510       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInactiveSlaves", &fInactiveSlaves);
02511       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUniqueSlaves", &fUniqueSlaves);
02512       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAllUniqueSlaves", &fAllUniqueSlaves);
02513       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNonUniqueMasters", &fNonUniqueMasters);
02514       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fActiveMonitor", &fActiveMonitor);
02515       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUniqueMonitor", &fUniqueMonitor);
02516       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAllUniqueMonitor", &fAllUniqueMonitor);
02517       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrentMonitor", &fCurrentMonitor);
02518       R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytesRead", &fBytesRead);
02519       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRealTime", &fRealTime);
02520       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCpuTime", &fCpuTime);
02521       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIntHandler", &fIntHandler);
02522       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProgressDialog", &fProgressDialog);
02523       R__insp.Inspect(R__cl, R__insp.GetParent(), "fProgressDialogStarted", &fProgressDialogStarted);
02524       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPlayer", &fPlayer);
02525       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFeedback", &fFeedback);
02526       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fChains", &fChains);
02527       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFileMap", (void*)&fFileMap);
02528       R__insp.InspectMember("TProof::FileMap_t", (void*)&fFileMap, "fFileMap.", false);
02529       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDSet", &fDSet);
02530       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNotIdle", &fNotIdle);
02531       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSync", &fSync);
02532       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRunStatus", &fRunStatus);
02533       R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsWaiting", &fIsWaiting);
02534       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRedirLog", &fRedirLog);
02535       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLogFileName", &fLogFileName);
02536       R__insp.InspectMember(fLogFileName, "fLogFileName.");
02537       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogFileW", &fLogFileW);
02538       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogFileR", &fLogFileR);
02539       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLogToWindowOnly", &fLogToWindowOnly);
02540       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMergePrg", (void*)&fMergePrg);
02541       R__insp.InspectMember("TProofMergePrg", (void*)&fMergePrg, "fMergePrg.", false);
02542       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWaitingSlaves", &fWaitingSlaves);
02543       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fQueries", &fQueries);
02544       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOtherQueries", &fOtherQueries);
02545       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawQueries", &fDrawQueries);
02546       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxDrawQueries", &fMaxDrawQueries);
02547       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSeqNum", &fSeqNum);
02548       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSessionID", &fSessionID);
02549       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEndMaster", &fEndMaster);
02550       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPackageDir", &fPackageDir);
02551       R__insp.InspectMember(fPackageDir, "fPackageDir.");
02552       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGlobalPackageDirList", &fGlobalPackageDirList);
02553       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPackageLock", &fPackageLock);
02554       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEnabledPackagesOnClient", &fEnabledPackagesOnClient);
02555       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInputData", &fInputData);
02556       R__insp.Inspect(R__cl, R__insp.GetParent(), "fInputDataFile", &fInputDataFile);
02557       R__insp.InspectMember(fInputDataFile, "fInputDataFile.");
02558       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPrintProgress", &fPrintProgress);
02559       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCloseMutex", &fCloseMutex);
02560       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLoadedMacros", &fLoadedMacros);
02561       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMergersSet", &fMergersSet);
02562       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMergersCount", &fMergersCount);
02563       R__insp.Inspect(R__cl, R__insp.GetParent(), "fWorkersToMerge", &fWorkersToMerge);
02564       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastAssignedMerger", &fLastAssignedMerger);
02565       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMergers", &fMergers);
02566       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFinalizationRunning", &fFinalizationRunning);
02567       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRedirectNext", &fRedirectNext);
02568       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMasterServ", &fMasterServ);
02569       R__insp.Inspect(R__cl, R__insp.GetParent(), "fUrl", &fUrl);
02570       R__insp.InspectMember(fUrl, "fUrl.");
02571       R__insp.Inspect(R__cl, R__insp.GetParent(), "fConfFile", &fConfFile);
02572       R__insp.InspectMember(fConfFile, "fConfFile.");
02573       R__insp.Inspect(R__cl, R__insp.GetParent(), "fConfDir", &fConfDir);
02574       R__insp.InspectMember(fConfDir, "fConfDir.");
02575       R__insp.Inspect(R__cl, R__insp.GetParent(), "fImage", &fImage);
02576       R__insp.InspectMember(fImage, "fImage.");
02577       R__insp.Inspect(R__cl, R__insp.GetParent(), "fProtocol", &fProtocol);
02578       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSlaves", &fSlaves);
02579       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBadSlaves", &fBadSlaves);
02580       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAllMonitor", &fAllMonitor);
02581       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataReady", &fDataReady);
02582       R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytesReady", &fBytesReady);
02583       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotalBytes", &fTotalBytes);
02584       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAvailablePackages", &fAvailablePackages);
02585       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEnabledPackages", &fEnabledPackages);
02586       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRunningDSets", &fRunningDSets);
02587       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCollectTimeout", &fCollectTimeout);
02588       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataPoolUrl", &fDataPoolUrl);
02589       R__insp.InspectMember(fDataPoolUrl, "fDataPoolUrl.");
02590       R__insp.Inspect(R__cl, R__insp.GetParent(), "fServType", &fServType);
02591       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fManager", &fManager);
02592       R__insp.Inspect(R__cl, R__insp.GetParent(), "fQueryMode", &fQueryMode);
02593       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDynamicStartup", &fDynamicStartup);
02594       TNamed::ShowMembers(R__insp);
02595       TQObject::ShowMembers(R__insp);
02596 }
02597 
02598 namespace ROOT {
02599    // Wrapper around operator delete
02600    static void delete_TProof(void *p) {
02601       delete ((::TProof*)p);
02602    }
02603    static void deleteArray_TProof(void *p) {
02604       delete [] ((::TProof*)p);
02605    }
02606    static void destruct_TProof(void *p) {
02607       typedef ::TProof current_t;
02608       ((current_t*)p)->~current_t();
02609    }
02610    // Wrapper around a custom streamer member function.
02611    static void streamer_TProof(TBuffer &buf, void *obj) {
02612       ((::TProof*)obj)->::TProof::Streamer(buf);
02613    }
02614 } // end of namespace ROOT for class ::TProof
02615 
02616 //______________________________________________________________________________
02617 void TProofCondor::Streamer(TBuffer &R__b)
02618 {
02619    // Stream an object of class TProofCondor.
02620 
02621    TProof::Streamer(R__b);
02622 }
02623 
02624 //______________________________________________________________________________
02625 void TProofCondor::ShowMembers(TMemberInspector &R__insp)
02626 {
02627       // Inspect the data members of an object of class TProofCondor.
02628       TClass *R__cl = ::TProofCondor::IsA();
02629       if (R__cl || R__insp.IsA()) { }
02630       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCondor", &fCondor);
02631       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTimer", &fTimer);
02632       TProof::ShowMembers(R__insp);
02633 }
02634 
02635 namespace ROOT {
02636    // Wrapper around operator delete
02637    static void delete_TProofCondor(void *p) {
02638       delete ((::TProofCondor*)p);
02639    }
02640    static void deleteArray_TProofCondor(void *p) {
02641       delete [] ((::TProofCondor*)p);
02642    }
02643    static void destruct_TProofCondor(void *p) {
02644       typedef ::TProofCondor current_t;
02645       ((current_t*)p)->~current_t();
02646    }
02647    // Wrapper around a custom streamer member function.
02648    static void streamer_TProofCondor(TBuffer &buf, void *obj) {
02649       ((::TProofCondor*)obj)->::TProofCondor::Streamer(buf);
02650    }
02651 } // end of namespace ROOT for class ::TProofCondor
02652 
02653 //______________________________________________________________________________
02654 void TProofLite::Streamer(TBuffer &R__b)
02655 {
02656    // Stream an object of class TProofLite.
02657 
02658    TProof::Streamer(R__b);
02659 }
02660 
02661 //______________________________________________________________________________
02662 void TProofLite::ShowMembers(TMemberInspector &R__insp)
02663 {
02664       // Inspect the data members of an object of class TProofLite.
02665       TClass *R__cl = ::TProofLite::IsA();
02666       if (R__cl || R__insp.IsA()) { }
02667       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNWorkers", &fNWorkers);
02668       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSandbox", &fSandbox);
02669       R__insp.InspectMember(fSandbox, "fSandbox.");
02670       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCacheDir", &fCacheDir);
02671       R__insp.InspectMember(fCacheDir, "fCacheDir.");
02672       R__insp.Inspect(R__cl, R__insp.GetParent(), "fQueryDir", &fQueryDir);
02673       R__insp.InspectMember(fQueryDir, "fQueryDir.");
02674       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataSetDir", &fDataSetDir);
02675       R__insp.InspectMember(fDataSetDir, "fDataSetDir.");
02676       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSockPath", &fSockPath);
02677       R__insp.InspectMember(fSockPath, "fSockPath.");
02678       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fServSock", &fServSock);
02679       R__insp.Inspect(R__cl, R__insp.GetParent(), "fForkStartup", &fForkStartup);
02680       R__insp.Inspect(R__cl, R__insp.GetParent(), "fVarExp", &fVarExp);
02681       R__insp.InspectMember(fVarExp, "fVarExp.");
02682       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelection", &fSelection);
02683       R__insp.InspectMember(fSelection, "fSelection.");
02684       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCacheLock", &fCacheLock);
02685       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fQueryLock", &fQueryLock);
02686       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fQMgr", &fQMgr);
02687       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataSetManager", &fDataSetManager);
02688       TProof::ShowMembers(R__insp);
02689 }
02690 
02691 namespace ROOT {
02692    // Wrapper around operator delete
02693    static void delete_TProofLite(void *p) {
02694       delete ((::TProofLite*)p);
02695    }
02696    static void deleteArray_TProofLite(void *p) {
02697       delete [] ((::TProofLite*)p);
02698    }
02699    static void destruct_TProofLite(void *p) {
02700       typedef ::TProofLite current_t;
02701       ((current_t*)p)->~current_t();
02702    }
02703    // Wrapper around a custom streamer member function.
02704    static void streamer_TProofLite(TBuffer &buf, void *obj) {
02705       ((::TProofLite*)obj)->::TProofLite::Streamer(buf);
02706    }
02707 } // end of namespace ROOT for class ::TProofLite
02708 
02709 //______________________________________________________________________________
02710 void TProofSuperMaster::Streamer(TBuffer &R__b)
02711 {
02712    // Stream an object of class TProofSuperMaster.
02713 
02714    TProof::Streamer(R__b);
02715 }
02716 
02717 //______________________________________________________________________________
02718 void TProofSuperMaster::ShowMembers(TMemberInspector &R__insp)
02719 {
02720       // Inspect the data members of an object of class TProofSuperMaster.
02721       TClass *R__cl = ::TProofSuperMaster::IsA();
02722       if (R__cl || R__insp.IsA()) { }
02723       TProof::ShowMembers(R__insp);
02724 }
02725 
02726 namespace ROOT {
02727    // Wrapper around operator delete
02728    static void delete_TProofSuperMaster(void *p) {
02729       delete ((::TProofSuperMaster*)p);
02730    }
02731    static void deleteArray_TProofSuperMaster(void *p) {
02732       delete [] ((::TProofSuperMaster*)p);
02733    }
02734    static void destruct_TProofSuperMaster(void *p) {
02735       typedef ::TProofSuperMaster current_t;
02736       ((current_t*)p)->~current_t();
02737    }
02738    // Wrapper around a custom streamer member function.
02739    static void streamer_TProofSuperMaster(TBuffer &buf, void *obj) {
02740       ((::TProofSuperMaster*)obj)->::TProofSuperMaster::Streamer(buf);
02741    }
02742 } // end of namespace ROOT for class ::TProofSuperMaster
02743 
02744 //______________________________________________________________________________
02745 void TSlaveInfo::Streamer(TBuffer &R__b)
02746 {
02747    // Stream an object of class TSlaveInfo.
02748 
02749    if (R__b.IsReading()) {
02750       R__b.ReadClassBuffer(TSlaveInfo::Class(),this);
02751    } else {
02752       R__b.WriteClassBuffer(TSlaveInfo::Class(),this);
02753    }
02754 }
02755 
02756 //______________________________________________________________________________
02757 void TSlaveInfo::ShowMembers(TMemberInspector &R__insp)
02758 {
02759       // Inspect the data members of an object of class TSlaveInfo.
02760       TClass *R__cl = ::TSlaveInfo::IsA();
02761       if (R__cl || R__insp.IsA()) { }
02762       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrdinal", &fOrdinal);
02763       R__insp.InspectMember(fOrdinal, "fOrdinal.");
02764       R__insp.Inspect(R__cl, R__insp.GetParent(), "fHostName", &fHostName);
02765       R__insp.InspectMember(fHostName, "fHostName.");
02766       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMsd", &fMsd);
02767       R__insp.InspectMember(fMsd, "fMsd.");
02768       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataDir", &fDataDir);
02769       R__insp.InspectMember(fDataDir, "fDataDir.");
02770       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPerfIndex", &fPerfIndex);
02771       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSysInfo", &fSysInfo);
02772       R__insp.InspectMember(fSysInfo, "fSysInfo.");
02773       R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &fStatus);
02774       TObject::ShowMembers(R__insp);
02775 }
02776 
02777 namespace ROOT {
02778    // Wrappers around operator new
02779    static void *new_TSlaveInfo(void *p) {
02780       return  p ? new(p) ::TSlaveInfo : new ::TSlaveInfo;
02781    }
02782    static void *newArray_TSlaveInfo(Long_t nElements, void *p) {
02783       return p ? new(p) ::TSlaveInfo[nElements] : new ::TSlaveInfo[nElements];
02784    }
02785    // Wrapper around operator delete
02786    static void delete_TSlaveInfo(void *p) {
02787       delete ((::TSlaveInfo*)p);
02788    }
02789    static void deleteArray_TSlaveInfo(void *p) {
02790       delete [] ((::TSlaveInfo*)p);
02791    }
02792    static void destruct_TSlaveInfo(void *p) {
02793       typedef ::TSlaveInfo current_t;
02794       ((current_t*)p)->~current_t();
02795    }
02796 } // end of namespace ROOT for class ::TSlaveInfo
02797 
02798 //______________________________________________________________________________
02799 void TProofServ::Streamer(TBuffer &R__b)
02800 {
02801    // Stream an object of class TProofServ.
02802 
02803    TApplication::Streamer(R__b);
02804 }
02805 
02806 //______________________________________________________________________________
02807 void TProofServ::ShowMembers(TMemberInspector &R__insp)
02808 {
02809       // Inspect the data members of an object of class TProofServ.
02810       TClass *R__cl = ::TProofServ::IsA();
02811       if (R__cl || R__insp.IsA()) { }
02812       R__insp.Inspect(R__cl, R__insp.GetParent(), "fService", &fService);
02813       R__insp.InspectMember(fService, "fService.");
02814       R__insp.Inspect(R__cl, R__insp.GetParent(), "fUser", &fUser);
02815       R__insp.InspectMember(fUser, "fUser.");
02816       R__insp.Inspect(R__cl, R__insp.GetParent(), "fGroup", &fGroup);
02817       R__insp.InspectMember(fGroup, "fGroup.");
02818       R__insp.Inspect(R__cl, R__insp.GetParent(), "fConfDir", &fConfDir);
02819       R__insp.InspectMember(fConfDir, "fConfDir.");
02820       R__insp.Inspect(R__cl, R__insp.GetParent(), "fConfFile", &fConfFile);
02821       R__insp.InspectMember(fConfFile, "fConfFile.");
02822       R__insp.Inspect(R__cl, R__insp.GetParent(), "fWorkDir", &fWorkDir);
02823       R__insp.InspectMember(fWorkDir, "fWorkDir.");
02824       R__insp.Inspect(R__cl, R__insp.GetParent(), "fImage", &fImage);
02825       R__insp.InspectMember(fImage, "fImage.");
02826       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSessionTag", &fSessionTag);
02827       R__insp.InspectMember(fSessionTag, "fSessionTag.");
02828       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTopSessionTag", &fTopSessionTag);
02829       R__insp.InspectMember(fTopSessionTag, "fTopSessionTag.");
02830       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSessionDir", &fSessionDir);
02831       R__insp.InspectMember(fSessionDir, "fSessionDir.");
02832       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPackageDir", &fPackageDir);
02833       R__insp.InspectMember(fPackageDir, "fPackageDir.");
02834       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGlobalPackageDirList", &fGlobalPackageDirList);
02835       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCacheDir", &fCacheDir);
02836       R__insp.InspectMember(fCacheDir, "fCacheDir.");
02837       R__insp.Inspect(R__cl, R__insp.GetParent(), "fQueryDir", &fQueryDir);
02838       R__insp.InspectMember(fQueryDir, "fQueryDir.");
02839       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataSetDir", &fDataSetDir);
02840       R__insp.InspectMember(fDataSetDir, "fDataSetDir.");
02841       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataDir", &fDataDir);
02842       R__insp.InspectMember(fDataDir, "fDataDir.");
02843       R__insp.Inspect(R__cl, R__insp.GetParent(), "fAdminPath", &fAdminPath);
02844       R__insp.InspectMember(fAdminPath, "fAdminPath.");
02845       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPackageLock", &fPackageLock);
02846       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCacheLock", &fCacheLock);
02847       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fQueryLock", &fQueryLock);
02848       R__insp.Inspect(R__cl, R__insp.GetParent(), "fArchivePath", &fArchivePath);
02849       R__insp.InspectMember(fArchivePath, "fArchivePath.");
02850       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSocket", &fSocket);
02851       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProof", &fProof);
02852       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPlayer", &fPlayer);
02853       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogFile", &fLogFile);
02854       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLogFileDes", &fLogFileDes);
02855       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEnabledPackages", &fEnabledPackages);
02856       R__insp.Inspect(R__cl, R__insp.GetParent(), "fProtocol", &fProtocol);
02857       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrdinal", &fOrdinal);
02858       R__insp.InspectMember(fOrdinal, "fOrdinal.");
02859       R__insp.Inspect(R__cl, R__insp.GetParent(), "fGroupId", &fGroupId);
02860       R__insp.Inspect(R__cl, R__insp.GetParent(), "fGroupSize", &fGroupSize);
02861       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLogLevel", &fLogLevel);
02862       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNcmd", &fNcmd);
02863       R__insp.Inspect(R__cl, R__insp.GetParent(), "fGroupPriority", &fGroupPriority);
02864       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEndMaster", &fEndMaster);
02865       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMasterServ", &fMasterServ);
02866       R__insp.Inspect(R__cl, R__insp.GetParent(), "fInterrupt", &fInterrupt);
02867       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRealTime", &fRealTime);
02868       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCpuTime", &fCpuTime);
02869       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLatency", &fLatency);
02870       R__insp.InspectMember(fLatency, "fLatency.");
02871       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCompute", &fCompute);
02872       R__insp.InspectMember(fCompute, "fCompute.");
02873       R__insp.Inspect(R__cl, R__insp.GetParent(), "fQuerySeqNum", &fQuerySeqNum);
02874       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotSessions", &fTotSessions);
02875       R__insp.Inspect(R__cl, R__insp.GetParent(), "fActSessions", &fActSessions);
02876       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEffSessions", &fEffSessions);
02877       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInputHandler", &fInputHandler);
02878       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fQMgr", &fQMgr);
02879       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWaitingQueries", &fWaitingQueries);
02880       R__insp.Inspect(R__cl, R__insp.GetParent(), "fIdle", &fIdle);
02881       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fQMtx", &fQMtx);
02882       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fQueuedMsg", &fQueuedMsg);
02883       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPrefix", &fPrefix);
02884       R__insp.InspectMember(fPrefix, "fPrefix.");
02885       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRealTimeLog", &fRealTimeLog);
02886       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShutdownTimer", &fShutdownTimer);
02887       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fReaperTimer", &fReaperTimer);
02888       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIdleTOTimer", &fIdleTOTimer);
02889       R__insp.Inspect(R__cl, R__insp.GetParent(), "fInflateFactor", &fInflateFactor);
02890       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCompressMsg", &fCompressMsg);
02891       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataSetManager", &fDataSetManager);
02892       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSendLogToMaster", &fSendLogToMaster);
02893       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMergingSocket", &fMergingSocket);
02894       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMergingMonitor", &fMergingMonitor);
02895       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMergedWorkers", &fMergedWorkers);
02896       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxQueries", &fMaxQueries);
02897       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxBoxSize", &fMaxBoxSize);
02898       R__insp.Inspect(R__cl, R__insp.GetParent(), "fHWMBoxSize", &fHWMBoxSize);
02899       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMsgSizeHWM", &fMsgSizeHWM);
02900       TApplication::ShowMembers(R__insp);
02901 }
02902 
02903 namespace ROOT {
02904    // Wrapper around operator delete
02905    static void delete_TProofServ(void *p) {
02906       delete ((::TProofServ*)p);
02907    }
02908    static void deleteArray_TProofServ(void *p) {
02909       delete [] ((::TProofServ*)p);
02910    }
02911    static void destruct_TProofServ(void *p) {
02912       typedef ::TProofServ current_t;
02913       ((current_t*)p)->~current_t();
02914    }
02915    // Wrapper around a custom streamer member function.
02916    static void streamer_TProofServ(TBuffer &buf, void *obj) {
02917       ((::TProofServ*)obj)->::TProofServ::Streamer(buf);
02918    }
02919 } // end of namespace ROOT for class ::TProofServ
02920 
02921 //______________________________________________________________________________
02922 void TProofServLite::Streamer(TBuffer &R__b)
02923 {
02924    // Stream an object of class TProofServLite.
02925 
02926    TProofServ::Streamer(R__b);
02927 }
02928 
02929 //______________________________________________________________________________
02930 void TProofServLite::ShowMembers(TMemberInspector &R__insp)
02931 {
02932       // Inspect the data members of an object of class TProofServLite.
02933       TClass *R__cl = ::TProofServLite::IsA();
02934       if (R__cl || R__insp.IsA()) { }
02935       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInterruptHandler", &fInterruptHandler);
02936       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSockPath", &fSockPath);
02937       R__insp.InspectMember(fSockPath, "fSockPath.");
02938       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTerminated", &fTerminated);
02939       TProofServ::ShowMembers(R__insp);
02940 }
02941 
02942 namespace ROOT {
02943    // Wrapper around operator delete
02944    static void delete_TProofServLite(void *p) {
02945       delete ((::TProofServLite*)p);
02946    }
02947    static void deleteArray_TProofServLite(void *p) {
02948       delete [] ((::TProofServLite*)p);
02949    }
02950    static void destruct_TProofServLite(void *p) {
02951       typedef ::TProofServLite current_t;
02952       ((current_t*)p)->~current_t();
02953    }
02954    // Wrapper around a custom streamer member function.
02955    static void streamer_TProofServLite(TBuffer &buf, void *obj) {
02956       ((::TProofServLite*)obj)->::TProofServLite::Streamer(buf);
02957    }
02958 } // end of namespace ROOT for class ::TProofServLite
02959 
02960 namespace ROOT {
02961    // Wrappers around operator new
02962    static void *new_TProofDebug(void *p) {
02963       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TProofDebug : new ::TProofDebug;
02964    }
02965    static void *newArray_TProofDebug(Long_t nElements, void *p) {
02966       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TProofDebug[nElements] : new ::TProofDebug[nElements];
02967    }
02968    // Wrapper around operator delete
02969    static void delete_TProofDebug(void *p) {
02970       delete ((::TProofDebug*)p);
02971    }
02972    static void deleteArray_TProofDebug(void *p) {
02973       delete [] ((::TProofDebug*)p);
02974    }
02975    static void destruct_TProofDebug(void *p) {
02976       typedef ::TProofDebug current_t;
02977       ((current_t*)p)->~current_t();
02978    }
02979 } // end of namespace ROOT for class ::TProofDebug
02980 
02981 //______________________________________________________________________________
02982 void TProofLog::Streamer(TBuffer &R__b)
02983 {
02984    // Stream an object of class TProofLog.
02985 
02986    TNamed::Streamer(R__b);
02987    TQObject::Streamer(R__b);
02988 }
02989 
02990 //______________________________________________________________________________
02991 void TProofLog::ShowMembers(TMemberInspector &R__insp)
02992 {
02993       // Inspect the data members of an object of class TProofLog.
02994       TClass *R__cl = ::TProofLog::IsA();
02995       if (R__cl || R__insp.IsA()) { }
02996       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMgr", &fMgr);
02997       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFILE", &fFILE);
02998       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElem", &fElem);
02999       R__insp.Inspect(R__cl, R__insp.GetParent(), "fStartTime", &fStartTime);
03000       R__insp.InspectMember(fStartTime, "fStartTime.");
03001       TNamed::ShowMembers(R__insp);
03002       TQObject::ShowMembers(R__insp);
03003 }
03004 
03005 namespace ROOT {
03006    // Wrapper around operator delete
03007    static void delete_TProofLog(void *p) {
03008       delete ((::TProofLog*)p);
03009    }
03010    static void deleteArray_TProofLog(void *p) {
03011       delete [] ((::TProofLog*)p);
03012    }
03013    static void destruct_TProofLog(void *p) {
03014       typedef ::TProofLog current_t;
03015       ((current_t*)p)->~current_t();
03016    }
03017    // Wrapper around a custom streamer member function.
03018    static void streamer_TProofLog(TBuffer &buf, void *obj) {
03019       ((::TProofLog*)obj)->::TProofLog::Streamer(buf);
03020    }
03021 } // end of namespace ROOT for class ::TProofLog
03022 
03023 //______________________________________________________________________________
03024 void TProofLogElem::Streamer(TBuffer &R__b)
03025 {
03026    // Stream an object of class TProofLogElem.
03027 
03028    TNamed::Streamer(R__b);
03029 }
03030 
03031 //______________________________________________________________________________
03032 void TProofLogElem::ShowMembers(TMemberInspector &R__insp)
03033 {
03034       // Inspect the data members of an object of class TProofLogElem.
03035       TClass *R__cl = ::TProofLogElem::IsA();
03036       if (R__cl || R__insp.IsA()) { }
03037       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
03038       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMacro", &fMacro);
03039       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSize", &fSize);
03040       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrom", &fFrom);
03041       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTo", &fTo);
03042       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRole", &fRole);
03043       R__insp.InspectMember(fRole, "fRole.");
03044       TNamed::ShowMembers(R__insp);
03045 }
03046 
03047 namespace ROOT {
03048    // Wrapper around operator delete
03049    static void delete_TProofLogElem(void *p) {
03050       delete ((::TProofLogElem*)p);
03051    }
03052    static void deleteArray_TProofLogElem(void *p) {
03053       delete [] ((::TProofLogElem*)p);
03054    }
03055    static void destruct_TProofLogElem(void *p) {
03056       typedef ::TProofLogElem current_t;
03057       ((current_t*)p)->~current_t();
03058    }
03059    // Wrapper around a custom streamer member function.
03060    static void streamer_TProofLogElem(TBuffer &buf, void *obj) {
03061       ((::TProofLogElem*)obj)->::TProofLogElem::Streamer(buf);
03062    }
03063 } // end of namespace ROOT for class ::TProofLogElem
03064 
03065 //______________________________________________________________________________
03066 void TSlave::Streamer(TBuffer &R__b)
03067 {
03068    // Stream an object of class TSlave.
03069 
03070    TObject::Streamer(R__b);
03071 }
03072 
03073 //______________________________________________________________________________
03074 void TSlave::ShowMembers(TMemberInspector &R__insp)
03075 {
03076       // Inspect the data members of an object of class TSlave.
03077       TClass *R__cl = ::TSlave::IsA();
03078       if (R__cl || R__insp.IsA()) { }
03079       R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", &fName);
03080       R__insp.InspectMember(fName, "fName.");
03081       R__insp.Inspect(R__cl, R__insp.GetParent(), "fImage", &fImage);
03082       R__insp.InspectMember(fImage, "fImage.");
03083       R__insp.Inspect(R__cl, R__insp.GetParent(), "fProofWorkDir", &fProofWorkDir);
03084       R__insp.InspectMember(fProofWorkDir, "fProofWorkDir.");
03085       R__insp.Inspect(R__cl, R__insp.GetParent(), "fWorkDir", &fWorkDir);
03086       R__insp.InspectMember(fWorkDir, "fWorkDir.");
03087       R__insp.Inspect(R__cl, R__insp.GetParent(), "fUser", &fUser);
03088       R__insp.InspectMember(fUser, "fUser.");
03089       R__insp.Inspect(R__cl, R__insp.GetParent(), "fGroup", &fGroup);
03090       R__insp.InspectMember(fGroup, "fGroup.");
03091       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPort", &fPort);
03092       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrdinal", &fOrdinal);
03093       R__insp.InspectMember(fOrdinal, "fOrdinal.");
03094       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPerfIdx", &fPerfIdx);
03095       R__insp.Inspect(R__cl, R__insp.GetParent(), "fProtocol", &fProtocol);
03096       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSocket", &fSocket);
03097       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProof", &fProof);
03098       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInput", &fInput);
03099       R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytesRead", &fBytesRead);
03100       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRealTime", &fRealTime);
03101       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCpuTime", &fCpuTime);
03102       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveType", &fSlaveType);
03103       R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &fStatus);
03104       R__insp.Inspect(R__cl, R__insp.GetParent(), "fParallel", &fParallel);
03105       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMsd", &fMsd);
03106       R__insp.InspectMember(fMsd, "fMsd.");
03107       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSessionTag", &fSessionTag);
03108       R__insp.InspectMember(fSessionTag, "fSessionTag.");
03109       R__insp.Inspect(R__cl, R__insp.GetParent(), "fROOTVers", &fROOTVers);
03110       R__insp.InspectMember(fROOTVers, "fROOTVers.");
03111       R__insp.Inspect(R__cl, R__insp.GetParent(), "fArchComp", &fArchComp);
03112       R__insp.InspectMember(fArchComp, "fArchComp.");
03113       TObject::ShowMembers(R__insp);
03114 }
03115 
03116 namespace ROOT {
03117    // Wrapper around operator delete
03118    static void delete_TSlave(void *p) {
03119       delete ((::TSlave*)p);
03120    }
03121    static void deleteArray_TSlave(void *p) {
03122       delete [] ((::TSlave*)p);
03123    }
03124    static void destruct_TSlave(void *p) {
03125       typedef ::TSlave current_t;
03126       ((current_t*)p)->~current_t();
03127    }
03128    // Wrapper around a custom streamer member function.
03129    static void streamer_TSlave(TBuffer &buf, void *obj) {
03130       ((::TSlave*)obj)->::TSlave::Streamer(buf);
03131    }
03132 } // end of namespace ROOT for class ::TSlave
03133 
03134 //______________________________________________________________________________
03135 void TSlaveLite::Streamer(TBuffer &R__b)
03136 {
03137    // Stream an object of class TSlaveLite.
03138 
03139    TSlave::Streamer(R__b);
03140 }
03141 
03142 //______________________________________________________________________________
03143 void TSlaveLite::ShowMembers(TMemberInspector &R__insp)
03144 {
03145       // Inspect the data members of an object of class TSlaveLite.
03146       TClass *R__cl = ::TSlaveLite::IsA();
03147       if (R__cl || R__insp.IsA()) { }
03148       R__insp.Inspect(R__cl, R__insp.GetParent(), "fValid", &fValid);
03149       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIntHandler", &fIntHandler);
03150       TSlave::ShowMembers(R__insp);
03151 }
03152 
03153 namespace ROOT {
03154    // Wrapper around operator delete
03155    static void delete_TSlaveLite(void *p) {
03156       delete ((::TSlaveLite*)p);
03157    }
03158    static void deleteArray_TSlaveLite(void *p) {
03159       delete [] ((::TSlaveLite*)p);
03160    }
03161    static void destruct_TSlaveLite(void *p) {
03162       typedef ::TSlaveLite current_t;
03163       ((current_t*)p)->~current_t();
03164    }
03165    // Wrapper around a custom streamer member function.
03166    static void streamer_TSlaveLite(TBuffer &buf, void *obj) {
03167       ((::TSlaveLite*)obj)->::TSlaveLite::Streamer(buf);
03168    }
03169 } // end of namespace ROOT for class ::TSlaveLite
03170 
03171 //______________________________________________________________________________
03172 void TVirtualProofPlayer::Streamer(TBuffer &R__b)
03173 {
03174    // Stream an object of class TVirtualProofPlayer.
03175 
03176    if (R__b.IsReading()) {
03177       R__b.ReadClassBuffer(TVirtualProofPlayer::Class(),this);
03178    } else {
03179       R__b.WriteClassBuffer(TVirtualProofPlayer::Class(),this);
03180    }
03181 }
03182 
03183 //______________________________________________________________________________
03184 void TVirtualProofPlayer::ShowMembers(TMemberInspector &R__insp)
03185 {
03186       // Inspect the data members of an object of class TVirtualProofPlayer.
03187       TClass *R__cl = ::TVirtualProofPlayer::IsA();
03188       if (R__cl || R__insp.IsA()) { }
03189       TObject::ShowMembers(R__insp);
03190       TQObject::ShowMembers(R__insp);
03191 }
03192 
03193 namespace ROOT {
03194    // Wrapper around operator delete
03195    static void delete_TVirtualProofPlayer(void *p) {
03196       delete ((::TVirtualProofPlayer*)p);
03197    }
03198    static void deleteArray_TVirtualProofPlayer(void *p) {
03199       delete [] ((::TVirtualProofPlayer*)p);
03200    }
03201    static void destruct_TVirtualProofPlayer(void *p) {
03202       typedef ::TVirtualProofPlayer current_t;
03203       ((current_t*)p)->~current_t();
03204    }
03205 } // end of namespace ROOT for class ::TVirtualProofPlayer
03206 
03207 //______________________________________________________________________________
03208 void TProofQueryResult::Streamer(TBuffer &R__b)
03209 {
03210    // Stream an object of class TProofQueryResult.
03211 
03212    if (R__b.IsReading()) {
03213       R__b.ReadClassBuffer(TProofQueryResult::Class(),this);
03214    } else {
03215       R__b.WriteClassBuffer(TProofQueryResult::Class(),this);
03216    }
03217 }
03218 
03219 //______________________________________________________________________________
03220 void TProofQueryResult::ShowMembers(TMemberInspector &R__insp)
03221 {
03222       // Inspect the data members of an object of class TProofQueryResult.
03223       TClass *R__cl = ::TProofQueryResult::IsA();
03224       if (R__cl || R__insp.IsA()) { }
03225       R__insp.Inspect(R__cl, R__insp.GetParent(), "fStartLog", &fStartLog);
03226       TQueryResult::ShowMembers(R__insp);
03227 }
03228 
03229 namespace ROOT {
03230    // Wrappers around operator new
03231    static void *new_TProofQueryResult(void *p) {
03232       return  p ? new(p) ::TProofQueryResult : new ::TProofQueryResult;
03233    }
03234    static void *newArray_TProofQueryResult(Long_t nElements, void *p) {
03235       return p ? new(p) ::TProofQueryResult[nElements] : new ::TProofQueryResult[nElements];
03236    }
03237    // Wrapper around operator delete
03238    static void delete_TProofQueryResult(void *p) {
03239       delete ((::TProofQueryResult*)p);
03240    }
03241    static void deleteArray_TProofQueryResult(void *p) {
03242       delete [] ((::TProofQueryResult*)p);
03243    }
03244    static void destruct_TProofQueryResult(void *p) {
03245       typedef ::TProofQueryResult current_t;
03246       ((current_t*)p)->~current_t();
03247    }
03248 } // end of namespace ROOT for class ::TProofQueryResult
03249 
03250 //______________________________________________________________________________
03251 void TQueryResultManager::Streamer(TBuffer &R__b)
03252 {
03253    // Stream an object of class TQueryResultManager.
03254 
03255    if (R__b.IsReading()) {
03256       R__b.ReadClassBuffer(TQueryResultManager::Class(),this);
03257    } else {
03258       R__b.WriteClassBuffer(TQueryResultManager::Class(),this);
03259    }
03260 }
03261 
03262 //______________________________________________________________________________
03263 void TQueryResultManager::ShowMembers(TMemberInspector &R__insp)
03264 {
03265       // Inspect the data members of an object of class TQueryResultManager.
03266       TClass *R__cl = ::TQueryResultManager::IsA();
03267       if (R__cl || R__insp.IsA()) { }
03268       R__insp.Inspect(R__cl, R__insp.GetParent(), "fQueryDir", &fQueryDir);
03269       R__insp.InspectMember(fQueryDir, "fQueryDir.");
03270       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSessionTag", &fSessionTag);
03271       R__insp.InspectMember(fSessionTag, "fSessionTag.");
03272       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSessionDir", &fSessionDir);
03273       R__insp.InspectMember(fSessionDir, "fSessionDir.");
03274       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSeqNum", &fSeqNum);
03275       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawQueries", &fDrawQueries);
03276       R__insp.Inspect(R__cl, R__insp.GetParent(), "fKeptQueries", &fKeptQueries);
03277       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fQueries", &fQueries);
03278       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPreviousQueries", &fPreviousQueries);
03279       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLock", &fLock);
03280       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogFile", &fLogFile);
03281       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCompute", &fCompute);
03282       R__insp.InspectMember(fCompute, "fCompute.");
03283       TObject::ShowMembers(R__insp);
03284 }
03285 
03286 namespace ROOT {
03287    // Wrapper around operator delete
03288    static void delete_TQueryResultManager(void *p) {
03289       delete ((::TQueryResultManager*)p);
03290    }
03291    static void deleteArray_TQueryResultManager(void *p) {
03292       delete [] ((::TQueryResultManager*)p);
03293    }
03294    static void destruct_TQueryResultManager(void *p) {
03295       typedef ::TQueryResultManager current_t;
03296       ((current_t*)p)->~current_t();
03297    }
03298 } // end of namespace ROOT for class ::TQueryResultManager
03299 
03300 //______________________________________________________________________________
03301 void TDSetProxy::Streamer(TBuffer &R__b)
03302 {
03303    // Stream an object of class TDSetProxy.
03304 
03305    if (R__b.IsReading()) {
03306       R__b.ReadClassBuffer(TDSetProxy::Class(),this);
03307    } else {
03308       R__b.WriteClassBuffer(TDSetProxy::Class(),this);
03309    }
03310 }
03311 
03312 //______________________________________________________________________________
03313 void TDSetProxy::ShowMembers(TMemberInspector &R__insp)
03314 {
03315       // Inspect the data members of an object of class TDSetProxy.
03316       TClass *R__cl = ::TDSetProxy::IsA();
03317       if (R__cl || R__insp.IsA()) { }
03318       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fServ", &fServ);
03319       TDSet::ShowMembers(R__insp);
03320 }
03321 
03322 namespace ROOT {
03323    // Wrappers around operator new
03324    static void *new_TDSetProxy(void *p) {
03325       return  p ? new(p) ::TDSetProxy : new ::TDSetProxy;
03326    }
03327    static void *newArray_TDSetProxy(Long_t nElements, void *p) {
03328       return p ? new(p) ::TDSetProxy[nElements] : new ::TDSetProxy[nElements];
03329    }
03330    // Wrapper around operator delete
03331    static void delete_TDSetProxy(void *p) {
03332       delete ((::TDSetProxy*)p);
03333    }
03334    static void deleteArray_TDSetProxy(void *p) {
03335       delete [] ((::TDSetProxy*)p);
03336    }
03337    static void destruct_TDSetProxy(void *p) {
03338       typedef ::TDSetProxy current_t;
03339       ((current_t*)p)->~current_t();
03340    }
03341 } // end of namespace ROOT for class ::TDSetProxy
03342 
03343 //______________________________________________________________________________
03344 void TCondor::Streamer(TBuffer &R__b)
03345 {
03346    // Stream an object of class TCondor.
03347 
03348    if (R__b.IsReading()) {
03349       R__b.ReadClassBuffer(TCondor::Class(),this);
03350    } else {
03351       R__b.WriteClassBuffer(TCondor::Class(),this);
03352    }
03353 }
03354 
03355 //______________________________________________________________________________
03356 void TCondor::ShowMembers(TMemberInspector &R__insp)
03357 {
03358       // Inspect the data members of an object of class TCondor.
03359       TClass *R__cl = ::TCondor::IsA();
03360       if (R__cl || R__insp.IsA()) { }
03361       R__insp.Inspect(R__cl, R__insp.GetParent(), "fValid", &fValid);
03362       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPool", &fPool);
03363       R__insp.InspectMember(fPool, "fPool.");
03364       R__insp.Inspect(R__cl, R__insp.GetParent(), "fState", &fState);
03365       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClaims", &fClaims);
03366       TObject::ShowMembers(R__insp);
03367 }
03368 
03369 namespace ROOT {
03370    // Wrappers around operator new
03371    static void *new_TCondor(void *p) {
03372       return  p ? new(p) ::TCondor : new ::TCondor;
03373    }
03374    static void *newArray_TCondor(Long_t nElements, void *p) {
03375       return p ? new(p) ::TCondor[nElements] : new ::TCondor[nElements];
03376    }
03377    // Wrapper around operator delete
03378    static void delete_TCondor(void *p) {
03379       delete ((::TCondor*)p);
03380    }
03381    static void deleteArray_TCondor(void *p) {
03382       delete [] ((::TCondor*)p);
03383    }
03384    static void destruct_TCondor(void *p) {
03385       typedef ::TCondor current_t;
03386       ((current_t*)p)->~current_t();
03387    }
03388 } // end of namespace ROOT for class ::TCondor
03389 
03390 //______________________________________________________________________________
03391 void TCondorSlave::Streamer(TBuffer &R__b)
03392 {
03393    // Stream an object of class TCondorSlave.
03394 
03395    if (R__b.IsReading()) {
03396       R__b.ReadClassBuffer(TCondorSlave::Class(),this);
03397    } else {
03398       R__b.WriteClassBuffer(TCondorSlave::Class(),this);
03399    }
03400 }
03401 
03402 //______________________________________________________________________________
03403 void TCondorSlave::ShowMembers(TMemberInspector &R__insp)
03404 {
03405       // Inspect the data members of an object of class TCondorSlave.
03406       TClass *R__cl = ::TCondorSlave::IsA();
03407       if (R__cl || R__insp.IsA()) { }
03408       R__insp.Inspect(R__cl, R__insp.GetParent(), "fHostname", &fHostname);
03409       R__insp.InspectMember(fHostname, "fHostname.");
03410       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPort", &fPort);
03411       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPerfIdx", &fPerfIdx);
03412       R__insp.Inspect(R__cl, R__insp.GetParent(), "fImage", &fImage);
03413       R__insp.InspectMember(fImage, "fImage.");
03414       R__insp.Inspect(R__cl, R__insp.GetParent(), "fClaimID", &fClaimID);
03415       R__insp.InspectMember(fClaimID, "fClaimID.");
03416       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrdinal", &fOrdinal);
03417       R__insp.InspectMember(fOrdinal, "fOrdinal.");
03418       R__insp.Inspect(R__cl, R__insp.GetParent(), "fWorkDir", &fWorkDir);
03419       R__insp.InspectMember(fWorkDir, "fWorkDir.");
03420       TObject::ShowMembers(R__insp);
03421 }
03422 
03423 namespace ROOT {
03424    // Wrappers around operator new
03425    static void *new_TCondorSlave(void *p) {
03426       return  p ? new(p) ::TCondorSlave : new ::TCondorSlave;
03427    }
03428    static void *newArray_TCondorSlave(Long_t nElements, void *p) {
03429       return p ? new(p) ::TCondorSlave[nElements] : new ::TCondorSlave[nElements];
03430    }
03431    // Wrapper around operator delete
03432    static void delete_TCondorSlave(void *p) {
03433       delete ((::TCondorSlave*)p);
03434    }
03435    static void deleteArray_TCondorSlave(void *p) {
03436       delete [] ((::TCondorSlave*)p);
03437    }
03438    static void destruct_TCondorSlave(void *p) {
03439       typedef ::TCondorSlave current_t;
03440       ((current_t*)p)->~current_t();
03441    }
03442 } // end of namespace ROOT for class ::TCondorSlave
03443 
03444 //______________________________________________________________________________
03445 void TProofNodeInfo::Streamer(TBuffer &R__b)
03446 {
03447    // Stream an object of class TProofNodeInfo.
03448 
03449    UInt_t R__s, R__c;
03450    if (R__b.IsReading()) {
03451       Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
03452       TObject::Streamer(R__b);
03453       void *ptr_fNodeType = (void*)&fNodeType;
03454       R__b >> *reinterpret_cast<Int_t*>(ptr_fNodeType);
03455       fNodeName.Streamer(R__b);
03456       fWorkDir.Streamer(R__b);
03457       fOrdinal.Streamer(R__b);
03458       fImage.Streamer(R__b);
03459       fId.Streamer(R__b);
03460       fConfig.Streamer(R__b);
03461       fMsd.Streamer(R__b);
03462       R__b >> fPort;
03463       R__b >> fPerfIndex;
03464       R__b.CheckByteCount(R__s, R__c, TProofNodeInfo::IsA());
03465    } else {
03466       R__c = R__b.WriteVersion(TProofNodeInfo::IsA(), kTRUE);
03467       TObject::Streamer(R__b);
03468       R__b << (Int_t)fNodeType;
03469       fNodeName.Streamer(R__b);
03470       fWorkDir.Streamer(R__b);
03471       fOrdinal.Streamer(R__b);
03472       fImage.Streamer(R__b);
03473       fId.Streamer(R__b);
03474       fConfig.Streamer(R__b);
03475       fMsd.Streamer(R__b);
03476       R__b << fPort;
03477       R__b << fPerfIndex;
03478       R__b.SetByteCount(R__c, kTRUE);
03479    }
03480 }
03481 
03482 //______________________________________________________________________________
03483 void TProofNodeInfo::ShowMembers(TMemberInspector &R__insp)
03484 {
03485       // Inspect the data members of an object of class TProofNodeInfo.
03486       TClass *R__cl = ::TProofNodeInfo::IsA();
03487       if (R__cl || R__insp.IsA()) { }
03488       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNodeType", &fNodeType);
03489       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNodeName", &fNodeName);
03490       R__insp.InspectMember(fNodeName, "fNodeName.");
03491       R__insp.Inspect(R__cl, R__insp.GetParent(), "fWorkDir", &fWorkDir);
03492       R__insp.InspectMember(fWorkDir, "fWorkDir.");
03493       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrdinal", &fOrdinal);
03494       R__insp.InspectMember(fOrdinal, "fOrdinal.");
03495       R__insp.Inspect(R__cl, R__insp.GetParent(), "fImage", &fImage);
03496       R__insp.InspectMember(fImage, "fImage.");
03497       R__insp.Inspect(R__cl, R__insp.GetParent(), "fId", &fId);
03498       R__insp.InspectMember(fId, "fId.");
03499       R__insp.Inspect(R__cl, R__insp.GetParent(), "fConfig", &fConfig);
03500       R__insp.InspectMember(fConfig, "fConfig.");
03501       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMsd", &fMsd);
03502       R__insp.InspectMember(fMsd, "fMsd.");
03503       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPort", &fPort);
03504       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPerfIndex", &fPerfIndex);
03505       TObject::ShowMembers(R__insp);
03506 }
03507 
03508 namespace ROOT {
03509    // Wrappers around operator new
03510    static void *new_TProofNodeInfo(void *p) {
03511       return  p ? new(p) ::TProofNodeInfo : new ::TProofNodeInfo;
03512    }
03513    static void *newArray_TProofNodeInfo(Long_t nElements, void *p) {
03514       return p ? new(p) ::TProofNodeInfo[nElements] : new ::TProofNodeInfo[nElements];
03515    }
03516    // Wrapper around operator delete
03517    static void delete_TProofNodeInfo(void *p) {
03518       delete ((::TProofNodeInfo*)p);
03519    }
03520    static void deleteArray_TProofNodeInfo(void *p) {
03521       delete [] ((::TProofNodeInfo*)p);
03522    }
03523    static void destruct_TProofNodeInfo(void *p) {
03524       typedef ::TProofNodeInfo current_t;
03525       ((current_t*)p)->~current_t();
03526    }
03527    // Wrapper around a custom streamer member function.
03528    static void streamer_TProofNodeInfo(TBuffer &buf, void *obj) {
03529       ((::TProofNodeInfo*)obj)->::TProofNodeInfo::Streamer(buf);
03530    }
03531 } // end of namespace ROOT for class ::TProofNodeInfo
03532 
03533 //______________________________________________________________________________
03534 void TProofResources::Streamer(TBuffer &R__b)
03535 {
03536    // Stream an object of class TProofResources.
03537 
03538    TObject::Streamer(R__b);
03539 }
03540 
03541 //______________________________________________________________________________
03542 void TProofResources::ShowMembers(TMemberInspector &R__insp)
03543 {
03544       // Inspect the data members of an object of class TProofResources.
03545       TClass *R__cl = ::TProofResources::IsA();
03546       if (R__cl || R__insp.IsA()) { }
03547       R__insp.Inspect(R__cl, R__insp.GetParent(), "fValid", &fValid);
03548       TObject::ShowMembers(R__insp);
03549 }
03550 
03551 namespace ROOT {
03552    // Wrapper around operator delete
03553    static void delete_TProofResources(void *p) {
03554       delete ((::TProofResources*)p);
03555    }
03556    static void deleteArray_TProofResources(void *p) {
03557       delete [] ((::TProofResources*)p);
03558    }
03559    static void destruct_TProofResources(void *p) {
03560       typedef ::TProofResources current_t;
03561       ((current_t*)p)->~current_t();
03562    }
03563    // Wrapper around a custom streamer member function.
03564    static void streamer_TProofResources(TBuffer &buf, void *obj) {
03565       ((::TProofResources*)obj)->::TProofResources::Streamer(buf);
03566    }
03567 } // end of namespace ROOT for class ::TProofResources
03568 
03569 //______________________________________________________________________________
03570 void TProofResourcesStatic::Streamer(TBuffer &R__b)
03571 {
03572    // Stream an object of class TProofResourcesStatic.
03573 
03574    TProofResources::Streamer(R__b);
03575 }
03576 
03577 //______________________________________________________________________________
03578 void TProofResourcesStatic::ShowMembers(TMemberInspector &R__insp)
03579 {
03580       // Inspect the data members of an object of class TProofResourcesStatic.
03581       TClass *R__cl = ::TProofResourcesStatic::IsA();
03582       if (R__cl || R__insp.IsA()) { }
03583       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaster", &fMaster);
03584       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSubmasterList", &fSubmasterList);
03585       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWorkerList", &fWorkerList);
03586       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFoundMaster", &fFoundMaster);
03587       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFileName", &fFileName);
03588       R__insp.InspectMember(fFileName, "fFileName.");
03589       TProofResources::ShowMembers(R__insp);
03590 }
03591 
03592 namespace ROOT {
03593    // Wrappers around operator new
03594    static void *new_TProofResourcesStatic(void *p) {
03595       return  p ? new(p) ::TProofResourcesStatic : new ::TProofResourcesStatic;
03596    }
03597    static void *newArray_TProofResourcesStatic(Long_t nElements, void *p) {
03598       return p ? new(p) ::TProofResourcesStatic[nElements] : new ::TProofResourcesStatic[nElements];
03599    }
03600    // Wrapper around operator delete
03601    static void delete_TProofResourcesStatic(void *p) {
03602       delete ((::TProofResourcesStatic*)p);
03603    }
03604    static void deleteArray_TProofResourcesStatic(void *p) {
03605       delete [] ((::TProofResourcesStatic*)p);
03606    }
03607    static void destruct_TProofResourcesStatic(void *p) {
03608       typedef ::TProofResourcesStatic current_t;
03609       ((current_t*)p)->~current_t();
03610    }
03611    // Wrapper around a custom streamer member function.
03612    static void streamer_TProofResourcesStatic(TBuffer &buf, void *obj) {
03613       ((::TProofResourcesStatic*)obj)->::TProofResourcesStatic::Streamer(buf);
03614    }
03615 } // end of namespace ROOT for class ::TProofResourcesStatic
03616 
03617 //______________________________________________________________________________
03618 void TProofProgressStatus::Streamer(TBuffer &R__b)
03619 {
03620    // Stream an object of class TProofProgressStatus.
03621 
03622    UInt_t R__s, R__c;
03623    if (R__b.IsReading()) {
03624       Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
03625       TObject::Streamer(R__b);
03626       R__b >> fLastEntries;
03627       R__b >> fEntries;
03628       R__b >> fBytesRead;
03629       R__b >> fReadCalls;
03630       R__b >> fLearnTime;
03631       R__b >> fLastProcTime;
03632       R__b >> fProcTime;
03633       R__b >> fCPUTime;
03634       R__b >> fLastUpdate;
03635       R__b.CheckByteCount(R__s, R__c, TProofProgressStatus::IsA());
03636    } else {
03637       R__c = R__b.WriteVersion(TProofProgressStatus::IsA(), kTRUE);
03638       TObject::Streamer(R__b);
03639       R__b << fLastEntries;
03640       R__b << fEntries;
03641       R__b << fBytesRead;
03642       R__b << fReadCalls;
03643       R__b << fLearnTime;
03644       R__b << fLastProcTime;
03645       R__b << fProcTime;
03646       R__b << fCPUTime;
03647       R__b << fLastUpdate;
03648       R__b.SetByteCount(R__c, kTRUE);
03649    }
03650 }
03651 
03652 //______________________________________________________________________________
03653 void TProofProgressStatus::ShowMembers(TMemberInspector &R__insp)
03654 {
03655       // Inspect the data members of an object of class TProofProgressStatus.
03656       TClass *R__cl = ::TProofProgressStatus::IsA();
03657       if (R__cl || R__insp.IsA()) { }
03658       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastEntries", &fLastEntries);
03659       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntries", &fEntries);
03660       R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytesRead", &fBytesRead);
03661       R__insp.Inspect(R__cl, R__insp.GetParent(), "fReadCalls", &fReadCalls);
03662       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLearnTime", &fLearnTime);
03663       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastProcTime", &fLastProcTime);
03664       R__insp.Inspect(R__cl, R__insp.GetParent(), "fProcTime", &fProcTime);
03665       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCPUTime", &fCPUTime);
03666       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastUpdate", &fLastUpdate);
03667       TObject::ShowMembers(R__insp);
03668 }
03669 
03670 namespace ROOT {
03671    // Wrappers around operator new
03672    static void *new_TProofProgressStatus(void *p) {
03673       return  p ? new(p) ::TProofProgressStatus : new ::TProofProgressStatus;
03674    }
03675    static void *newArray_TProofProgressStatus(Long_t nElements, void *p) {
03676       return p ? new(p) ::TProofProgressStatus[nElements] : new ::TProofProgressStatus[nElements];
03677    }
03678    // Wrapper around operator delete
03679    static void delete_TProofProgressStatus(void *p) {
03680       delete ((::TProofProgressStatus*)p);
03681    }
03682    static void deleteArray_TProofProgressStatus(void *p) {
03683       delete [] ((::TProofProgressStatus*)p);
03684    }
03685    static void destruct_TProofProgressStatus(void *p) {
03686       typedef ::TProofProgressStatus current_t;
03687       ((current_t*)p)->~current_t();
03688    }
03689    // Wrapper around a custom streamer member function.
03690    static void streamer_TProofProgressStatus(TBuffer &buf, void *obj) {
03691       ((::TProofProgressStatus*)obj)->::TProofProgressStatus::Streamer(buf);
03692    }
03693 } // end of namespace ROOT for class ::TProofProgressStatus
03694 
03695 //______________________________________________________________________________
03696 void TMergerInfo::Streamer(TBuffer &R__b)
03697 {
03698    // Stream an object of class TMergerInfo.
03699 
03700    TObject::Streamer(R__b);
03701 }
03702 
03703 //______________________________________________________________________________
03704 void TMergerInfo::ShowMembers(TMemberInspector &R__insp)
03705 {
03706       // Inspect the data members of an object of class TMergerInfo.
03707       TClass *R__cl = ::TMergerInfo::IsA();
03708       if (R__cl || R__insp.IsA()) { }
03709       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMerger", &fMerger);
03710       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPort", &fPort);
03711       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMergedObjects", &fMergedObjects);
03712       R__insp.Inspect(R__cl, R__insp.GetParent(), "fWorkersToMerge", &fWorkersToMerge);
03713       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMergedWorkers", &fMergedWorkers);
03714       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWorkers", &fWorkers);
03715       R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsActive", &fIsActive);
03716       TObject::ShowMembers(R__insp);
03717 }
03718 
03719 namespace ROOT {
03720    // Wrapper around operator delete
03721    static void delete_TMergerInfo(void *p) {
03722       delete ((::TMergerInfo*)p);
03723    }
03724    static void deleteArray_TMergerInfo(void *p) {
03725       delete [] ((::TMergerInfo*)p);
03726    }
03727    static void destruct_TMergerInfo(void *p) {
03728       typedef ::TMergerInfo current_t;
03729       ((current_t*)p)->~current_t();
03730    }
03731    // Wrapper around a custom streamer member function.
03732    static void streamer_TMergerInfo(TBuffer &buf, void *obj) {
03733       ((::TMergerInfo*)obj)->::TMergerInfo::Streamer(buf);
03734    }
03735 } // end of namespace ROOT for class ::TMergerInfo
03736 
03737 //______________________________________________________________________________
03738 void TProofProgressInfo::Streamer(TBuffer &R__b)
03739 {
03740    // Stream an object of class TProofProgressInfo.
03741 
03742    UInt_t R__s, R__c;
03743    if (R__b.IsReading()) {
03744       Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
03745       TObject::Streamer(R__b);
03746       R__b >> fTotal;
03747       R__b >> fProcessed;
03748       R__b >> fBytesRead;
03749       R__b >> fInitTime;
03750       R__b >> fProcTime;
03751       R__b >> fEvtRateI;
03752       R__b >> fMBRateI;
03753       R__b >> fActWorkers;
03754       R__b >> fTotSessions;
03755       R__b >> fEffSessions;
03756       R__b.CheckByteCount(R__s, R__c, TProofProgressInfo::IsA());
03757    } else {
03758       R__c = R__b.WriteVersion(TProofProgressInfo::IsA(), kTRUE);
03759       TObject::Streamer(R__b);
03760       R__b << fTotal;
03761       R__b << fProcessed;
03762       R__b << fBytesRead;
03763       R__b << fInitTime;
03764       R__b << fProcTime;
03765       R__b << fEvtRateI;
03766       R__b << fMBRateI;
03767       R__b << fActWorkers;
03768       R__b << fTotSessions;
03769       R__b << fEffSessions;
03770       R__b.SetByteCount(R__c, kTRUE);
03771    }
03772 }
03773 
03774 //______________________________________________________________________________
03775 void TProofProgressInfo::ShowMembers(TMemberInspector &R__insp)
03776 {
03777       // Inspect the data members of an object of class TProofProgressInfo.
03778       TClass *R__cl = ::TProofProgressInfo::IsA();
03779       if (R__cl || R__insp.IsA()) { }
03780       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotal", &fTotal);
03781       R__insp.Inspect(R__cl, R__insp.GetParent(), "fProcessed", &fProcessed);
03782       R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytesRead", &fBytesRead);
03783       R__insp.Inspect(R__cl, R__insp.GetParent(), "fInitTime", &fInitTime);
03784       R__insp.Inspect(R__cl, R__insp.GetParent(), "fProcTime", &fProcTime);
03785       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvtRateI", &fEvtRateI);
03786       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMBRateI", &fMBRateI);
03787       R__insp.Inspect(R__cl, R__insp.GetParent(), "fActWorkers", &fActWorkers);
03788       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotSessions", &fTotSessions);
03789       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEffSessions", &fEffSessions);
03790       TObject::ShowMembers(R__insp);
03791 }
03792 
03793 namespace ROOT {
03794    // Wrappers around operator new
03795    static void *new_TProofProgressInfo(void *p) {
03796       return  p ? new(p) ::TProofProgressInfo : new ::TProofProgressInfo;
03797    }
03798    static void *newArray_TProofProgressInfo(Long_t nElements, void *p) {
03799       return p ? new(p) ::TProofProgressInfo[nElements] : new ::TProofProgressInfo[nElements];
03800    }
03801    // Wrapper around operator delete
03802    static void delete_TProofProgressInfo(void *p) {
03803       delete ((::TProofProgressInfo*)p);
03804    }
03805    static void deleteArray_TProofProgressInfo(void *p) {
03806       delete [] ((::TProofProgressInfo*)p);
03807    }
03808    static void destruct_TProofProgressInfo(void *p) {
03809       typedef ::TProofProgressInfo current_t;
03810       ((current_t*)p)->~current_t();
03811    }
03812    // Wrapper around a custom streamer member function.
03813    static void streamer_TProofProgressInfo(TBuffer &buf, void *obj) {
03814       ((::TProofProgressInfo*)obj)->::TProofProgressInfo::Streamer(buf);
03815    }
03816 } // end of namespace ROOT for class ::TProofProgressInfo
03817 
03818 //______________________________________________________________________________
03819 void TDataSetManager::Streamer(TBuffer &R__b)
03820 {
03821    // Stream an object of class TDataSetManager.
03822 
03823    TObject::Streamer(R__b);
03824 }
03825 
03826 //______________________________________________________________________________
03827 void TDataSetManager::ShowMembers(TMemberInspector &R__insp)
03828 {
03829       // Inspect the data members of an object of class TDataSetManager.
03830       TClass *R__cl = ::TDataSetManager::IsA();
03831       if (R__cl || R__insp.IsA()) { }
03832       R__insp.Inspect(R__cl, R__insp.GetParent(), "fGroup", &fGroup);
03833       R__insp.InspectMember(fGroup, "fGroup.");
03834       R__insp.Inspect(R__cl, R__insp.GetParent(), "fUser", &fUser);
03835       R__insp.InspectMember(fUser, "fUser.");
03836       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCommonUser", &fCommonUser);
03837       R__insp.InspectMember(fCommonUser, "fCommonUser.");
03838       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCommonGroup", &fCommonGroup);
03839       R__insp.InspectMember(fCommonGroup, "fCommonGroup.");
03840       R__insp.Inspect(R__cl, R__insp.GetParent(), "fBase", &fBase);
03841       R__insp.InspectMember(fBase, "fBase.");
03842       R__insp.Inspect(R__cl, R__insp.GetParent(), "fGroupQuota", &fGroupQuota);
03843       R__insp.InspectMember(fGroupQuota, "fGroupQuota.");
03844       R__insp.Inspect(R__cl, R__insp.GetParent(), "fGroupUsed", &fGroupUsed);
03845       R__insp.InspectMember(fGroupUsed, "fGroupUsed.");
03846       R__insp.Inspect(R__cl, R__insp.GetParent(), "fUserUsed", &fUserUsed);
03847       R__insp.InspectMember(fUserUsed, "fUserUsed.");
03848       R__insp.Inspect(R__cl, R__insp.GetParent(), "fAvgFileSize", &fAvgFileSize);
03849       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTouchedFiles", &fNTouchedFiles);
03850       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNOpenedFiles", &fNOpenedFiles);
03851       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNDisappearedFiles", &fNDisappearedFiles);
03852       R__insp.Inspect(R__cl, R__insp.GetParent(), "fGroupConfigFile", &fGroupConfigFile);
03853       R__insp.InspectMember(fGroupConfigFile, "fGroupConfigFile.");
03854       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMTimeGroupConfig", &fMTimeGroupConfig);
03855       TObject::ShowMembers(R__insp);
03856 }
03857 
03858 namespace ROOT {
03859    // Wrappers around operator new
03860    static void *new_TDataSetManager(void *p) {
03861       return  p ? new(p) ::TDataSetManager : new ::TDataSetManager;
03862    }
03863    static void *newArray_TDataSetManager(Long_t nElements, void *p) {
03864       return p ? new(p) ::TDataSetManager[nElements] : new ::TDataSetManager[nElements];
03865    }
03866    // Wrapper around operator delete
03867    static void delete_TDataSetManager(void *p) {
03868       delete ((::TDataSetManager*)p);
03869    }
03870    static void deleteArray_TDataSetManager(void *p) {
03871       delete [] ((::TDataSetManager*)p);
03872    }
03873    static void destruct_TDataSetManager(void *p) {
03874       typedef ::TDataSetManager current_t;
03875       ((current_t*)p)->~current_t();
03876    }
03877    // Wrapper around a custom streamer member function.
03878    static void streamer_TDataSetManager(TBuffer &buf, void *obj) {
03879       ((::TDataSetManager*)obj)->::TDataSetManager::Streamer(buf);
03880    }
03881 } // end of namespace ROOT for class ::TDataSetManager
03882 
03883 //______________________________________________________________________________
03884 void TDataSetManagerFile::Streamer(TBuffer &R__b)
03885 {
03886    // Stream an object of class TDataSetManagerFile.
03887 
03888    TDataSetManager::Streamer(R__b);
03889 }
03890 
03891 //______________________________________________________________________________
03892 void TDataSetManagerFile::ShowMembers(TMemberInspector &R__insp)
03893 {
03894       // Inspect the data members of an object of class TDataSetManagerFile.
03895       TClass *R__cl = ::TDataSetManagerFile::IsA();
03896       if (R__cl || R__insp.IsA()) { }
03897       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataSetDir", &fDataSetDir);
03898       R__insp.InspectMember(fDataSetDir, "fDataSetDir.");
03899       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMSSUrl", &fMSSUrl);
03900       R__insp.InspectMember(fMSSUrl, "fMSSUrl.");
03901       R__insp.Inspect(R__cl, R__insp.GetParent(), "fStageOpts", &fStageOpts);
03902       R__insp.InspectMember(fStageOpts, "fStageOpts.");
03903       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataSetLockFile", &fDataSetLockFile);
03904       R__insp.InspectMember(fDataSetLockFile, "fDataSetLockFile.");
03905       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLockFileTimeLimit", &fLockFileTimeLimit);
03906       R__insp.Inspect(R__cl, R__insp.GetParent(), "fListFile", &fListFile);
03907       R__insp.InspectMember(fListFile, "fListFile.");
03908       R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsRemote", &fIsRemote);
03909       R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseCache", &fUseCache);
03910       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLocalCacheDir", &fLocalCacheDir);
03911       R__insp.InspectMember(fLocalCacheDir, "fLocalCacheDir.");
03912       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCacheUpdatePeriod", &fCacheUpdatePeriod);
03913       TDataSetManager::ShowMembers(R__insp);
03914 }
03915 
03916 namespace ROOT {
03917    // Wrappers around operator new
03918    static void *new_TDataSetManagerFile(void *p) {
03919       return  p ? new(p) ::TDataSetManagerFile : new ::TDataSetManagerFile;
03920    }
03921    static void *newArray_TDataSetManagerFile(Long_t nElements, void *p) {
03922       return p ? new(p) ::TDataSetManagerFile[nElements] : new ::TDataSetManagerFile[nElements];
03923    }
03924    // Wrapper around operator delete
03925    static void delete_TDataSetManagerFile(void *p) {
03926       delete ((::TDataSetManagerFile*)p);
03927    }
03928    static void deleteArray_TDataSetManagerFile(void *p) {
03929       delete [] ((::TDataSetManagerFile*)p);
03930    }
03931    static void destruct_TDataSetManagerFile(void *p) {
03932       typedef ::TDataSetManagerFile current_t;
03933       ((current_t*)p)->~current_t();
03934    }
03935    // Wrapper around a custom streamer member function.
03936    static void streamer_TDataSetManagerFile(TBuffer &buf, void *obj) {
03937       ((::TDataSetManagerFile*)obj)->::TDataSetManagerFile::Streamer(buf);
03938    }
03939 } // end of namespace ROOT for class ::TDataSetManagerFile
03940 
03941 //______________________________________________________________________________
03942 namespace ROOT {
03943    void pairlETDSetElementmUcOTStringgR_ShowMembers(void *obj, TMemberInspector &R__insp)
03944    {
03945       // Inspect the data members of an object of class pair<TDSetElement*,TString>.
03946       typedef ::ROOT::Shadow::pairlETDSetElementmUcOTStringgR ShadowClass;
03947       ShadowClass *sobj = (ShadowClass*)obj;
03948       if (sobj) { } // Dummy usage just in case there is no datamember.
03949 
03950       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const pair<TDSetElement*,TString>*)0x0)->GetClass();
03951       if (R__cl || R__insp.IsA()) { }
03952       R__insp.Inspect(R__cl, R__insp.GetParent(), "*first", &sobj->first);
03953       R__insp.Inspect(R__cl, R__insp.GetParent(), "second", &sobj->second);
03954       R__insp.InspectMember(sobj->second, "second.");
03955    }
03956 
03957 }
03958 
03959 namespace ROOT {
03960    // Wrappers around operator new
03961    static void *new_pairlETDSetElementmUcOTStringgR(void *p) {
03962       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) pair<TDSetElement*,TString> : new pair<TDSetElement*,TString>;
03963    }
03964    static void *newArray_pairlETDSetElementmUcOTStringgR(Long_t nElements, void *p) {
03965       return p ? ::new((::ROOT::TOperatorNewHelper*)p) pair<TDSetElement*,TString>[nElements] : new pair<TDSetElement*,TString>[nElements];
03966    }
03967    // Wrapper around operator delete
03968    static void delete_pairlETDSetElementmUcOTStringgR(void *p) {
03969       delete ((pair<TDSetElement*,TString>*)p);
03970    }
03971    static void deleteArray_pairlETDSetElementmUcOTStringgR(void *p) {
03972       delete [] ((pair<TDSetElement*,TString>*)p);
03973    }
03974    static void destruct_pairlETDSetElementmUcOTStringgR(void *p) {
03975       typedef pair<TDSetElement*,TString> current_t;
03976       ((current_t*)p)->~current_t();
03977    }
03978 } // end of namespace ROOT for class pair<TDSetElement*,TString>
03979 
03980 namespace ROOT {
03981    void listlEpairlETDSetElementmUcOTStringgRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
03982    static void listlEpairlETDSetElementmUcOTStringgRsPgR_Dictionary();
03983    static void *new_listlEpairlETDSetElementmUcOTStringgRsPgR(void *p = 0);
03984    static void *newArray_listlEpairlETDSetElementmUcOTStringgRsPgR(Long_t size, void *p);
03985    static void delete_listlEpairlETDSetElementmUcOTStringgRsPgR(void *p);
03986    static void deleteArray_listlEpairlETDSetElementmUcOTStringgRsPgR(void *p);
03987    static void destruct_listlEpairlETDSetElementmUcOTStringgRsPgR(void *p);
03988 
03989    // Function generating the singleton type initializer
03990    static TGenericClassInfo *GenerateInitInstanceLocal(const list<pair<TDSetElement*,TString> >*)
03991    {
03992       list<pair<TDSetElement*,TString> > *ptr = 0;
03993       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(list<pair<TDSetElement*,TString> >),0);
03994       static ::ROOT::TGenericClassInfo 
03995          instance("list<pair<TDSetElement*,TString> >", -2, "prec_stl/list", 44,
03996                   typeid(list<pair<TDSetElement*,TString> >), DefineBehavior(ptr, ptr),
03997                   0, &listlEpairlETDSetElementmUcOTStringgRsPgR_Dictionary, isa_proxy, 0,
03998                   sizeof(list<pair<TDSetElement*,TString> >) );
03999       instance.SetNew(&new_listlEpairlETDSetElementmUcOTStringgRsPgR);
04000       instance.SetNewArray(&newArray_listlEpairlETDSetElementmUcOTStringgRsPgR);
04001       instance.SetDelete(&delete_listlEpairlETDSetElementmUcOTStringgRsPgR);
04002       instance.SetDeleteArray(&deleteArray_listlEpairlETDSetElementmUcOTStringgRsPgR);
04003       instance.SetDestructor(&destruct_listlEpairlETDSetElementmUcOTStringgRsPgR);
04004       instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< list<pair<TDSetElement*,TString> > >()));
04005       return &instance;
04006    }
04007    // Static variable to force the class initialization
04008    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const list<pair<TDSetElement*,TString> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));
04009 
04010    // Dictionary for non-ClassDef classes
04011    static void listlEpairlETDSetElementmUcOTStringgRsPgR_Dictionary() {
04012       ::ROOT::GenerateInitInstanceLocal((const list<pair<TDSetElement*,TString> >*)0x0)->GetClass();
04013    }
04014 
04015 } // end of namespace ROOT
04016 
04017 namespace ROOT {
04018    // Wrappers around operator new
04019    static void *new_listlEpairlETDSetElementmUcOTStringgRsPgR(void *p) {
04020       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) list<pair<TDSetElement*,TString> > : new list<pair<TDSetElement*,TString> >;
04021    }
04022    static void *newArray_listlEpairlETDSetElementmUcOTStringgRsPgR(Long_t nElements, void *p) {
04023       return p ? ::new((::ROOT::TOperatorNewHelper*)p) list<pair<TDSetElement*,TString> >[nElements] : new list<pair<TDSetElement*,TString> >[nElements];
04024    }
04025    // Wrapper around operator delete
04026    static void delete_listlEpairlETDSetElementmUcOTStringgRsPgR(void *p) {
04027       delete ((list<pair<TDSetElement*,TString> >*)p);
04028    }
04029    static void deleteArray_listlEpairlETDSetElementmUcOTStringgRsPgR(void *p) {
04030       delete [] ((list<pair<TDSetElement*,TString> >*)p);
04031    }
04032    static void destruct_listlEpairlETDSetElementmUcOTStringgRsPgR(void *p) {
04033       typedef list<pair<TDSetElement*,TString> > current_t;
04034       ((current_t*)p)->~current_t();
04035    }
04036 } // end of namespace ROOT for class list<pair<TDSetElement*,TString> >
04037 
04038 /********************************************************
04039 * proof/proof/src/G__Proof.cxx
04040 * CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED
04041 *          FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().
04042 *          CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.
04043 ********************************************************/
04044 
04045 #ifdef G__MEMTEST
04046 #undef malloc
04047 #undef free
04048 #endif
04049 
04050 #if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
04051 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
04052 #endif
04053 
04054 extern "C" void G__cpp_reset_tagtableG__Proof();
04055 
04056 extern "C" void G__set_cpp_environmentG__Proof() {
04057   G__add_compiledheader("TObject.h");
04058   G__add_compiledheader("TMemberInspector.h");
04059   G__add_compiledheader("TCondor.h");
04060   G__add_compiledheader("TDataSetManagerFile.h");
04061   G__add_compiledheader("TDataSetManager.h");
04062   G__add_compiledheader("TDSet.h");
04063   G__add_compiledheader("TDSetProxy.h");
04064   G__add_compiledheader("TProofChain.h");
04065   G__add_compiledheader("TProofCondor.h");
04066   G__add_compiledheader("TProofDebug.h");
04067   G__add_compiledheader("TProof.h");
04068   G__add_compiledheader("TProofLite.h");
04069   G__add_compiledheader("TProofLog.h");
04070   G__add_compiledheader("TProofMgr.h");
04071   G__add_compiledheader("TProofMgrLite.h");
04072   G__add_compiledheader("TProofNodeInfo.h");
04073   G__add_compiledheader("TProofProgressStatus.h");
04074   G__add_compiledheader("TProofQueryResult.h");
04075   G__add_compiledheader("TProofResources.h");
04076   G__add_compiledheader("TProofResourcesStatic.h");
04077   G__add_compiledheader("TProofServ.h");
04078   G__add_compiledheader("TProofServLite.h");
04079   G__add_compiledheader("TProofSuperMaster.h");
04080   G__add_compiledheader("TQueryResultManager.h");
04081   G__add_compiledheader("TSlave.h");
04082   G__add_compiledheader("TSlaveLite.h");
04083   G__add_compiledheader("TVirtualProofPlayer.h");
04084   G__cpp_reset_tagtableG__Proof();
04085 }
04086 #include <new>
04087 extern "C" int G__cpp_dllrevG__Proof() { return(30051515); }
04088 
04089 /*********************************************************
04090 * Member function Interface Method
04091 *********************************************************/
04092 
04093 /* TCondorSlave */
04094 static int G__G__Proof_110_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04095 {
04096       G__letint(result7, 85, (long) TCondorSlave::Class());
04097    return(1 || funcname || hash || result7 || libp) ;
04098 }
04099 
04100 static int G__G__Proof_110_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04101 {
04102       G__letint(result7, 67, (long) TCondorSlave::Class_Name());
04103    return(1 || funcname || hash || result7 || libp) ;
04104 }
04105 
04106 static int G__G__Proof_110_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04107 {
04108       G__letint(result7, 115, (long) TCondorSlave::Class_Version());
04109    return(1 || funcname || hash || result7 || libp) ;
04110 }
04111 
04112 static int G__G__Proof_110_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04113 {
04114       TCondorSlave::Dictionary();
04115       G__setnull(result7);
04116    return(1 || funcname || hash || result7 || libp) ;
04117 }
04118 
04119 static int G__G__Proof_110_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04120 {
04121       ((TCondorSlave*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04122       G__setnull(result7);
04123    return(1 || funcname || hash || result7 || libp) ;
04124 }
04125 
04126 static int G__G__Proof_110_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04127 {
04128       G__letint(result7, 67, (long) TCondorSlave::DeclFileName());
04129    return(1 || funcname || hash || result7 || libp) ;
04130 }
04131 
04132 static int G__G__Proof_110_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04133 {
04134       G__letint(result7, 105, (long) TCondorSlave::ImplFileLine());
04135    return(1 || funcname || hash || result7 || libp) ;
04136 }
04137 
04138 static int G__G__Proof_110_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04139 {
04140       G__letint(result7, 67, (long) TCondorSlave::ImplFileName());
04141    return(1 || funcname || hash || result7 || libp) ;
04142 }
04143 
04144 static int G__G__Proof_110_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04145 {
04146       G__letint(result7, 105, (long) TCondorSlave::DeclFileLine());
04147    return(1 || funcname || hash || result7 || libp) ;
04148 }
04149 
04150 // automatic default constructor
04151 static int G__G__Proof_110_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04152 {
04153    TCondorSlave *p;
04154    char* gvp = (char*) G__getgvp();
04155    int n = G__getaryconstruct();
04156    if (n) {
04157      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04158        p = new TCondorSlave[n];
04159      } else {
04160        p = new((void*) gvp) TCondorSlave[n];
04161      }
04162    } else {
04163      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04164        p = new TCondorSlave;
04165      } else {
04166        p = new((void*) gvp) TCondorSlave;
04167      }
04168    }
04169    result7->obj.i = (long) p;
04170    result7->ref = (long) p;
04171    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TCondorSlave));
04172    return(1 || funcname || hash || result7 || libp) ;
04173 }
04174 
04175 // automatic copy constructor
04176 static int G__G__Proof_110_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04177 
04178 {
04179    TCondorSlave* p;
04180    void* tmp = (void*) G__int(libp->para[0]);
04181    p = new TCondorSlave(*(TCondorSlave*) tmp);
04182    result7->obj.i = (long) p;
04183    result7->ref = (long) p;
04184    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TCondorSlave));
04185    return(1 || funcname || hash || result7 || libp) ;
04186 }
04187 
04188 // automatic destructor
04189 typedef TCondorSlave G__TTCondorSlave;
04190 static int G__G__Proof_110_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04191 {
04192    char* gvp = (char*) G__getgvp();
04193    long soff = G__getstructoffset();
04194    int n = G__getaryconstruct();
04195    //
04196    //has_a_delete: 1
04197    //has_own_delete1arg: 0
04198    //has_own_delete2arg: 0
04199    //
04200    if (!soff) {
04201      return(1);
04202    }
04203    if (n) {
04204      if (gvp == (char*)G__PVOID) {
04205        delete[] (TCondorSlave*) soff;
04206      } else {
04207        G__setgvp((long) G__PVOID);
04208        for (int i = n - 1; i >= 0; --i) {
04209          ((TCondorSlave*) (soff+(sizeof(TCondorSlave)*i)))->~G__TTCondorSlave();
04210        }
04211        G__setgvp((long)gvp);
04212      }
04213    } else {
04214      if (gvp == (char*)G__PVOID) {
04215        delete (TCondorSlave*) soff;
04216      } else {
04217        G__setgvp((long) G__PVOID);
04218        ((TCondorSlave*) (soff))->~G__TTCondorSlave();
04219        G__setgvp((long)gvp);
04220      }
04221    }
04222    G__setnull(result7);
04223    return(1 || funcname || hash || result7 || libp) ;
04224 }
04225 
04226 // automatic assignment operator
04227 static int G__G__Proof_110_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04228 {
04229    TCondorSlave* dest = (TCondorSlave*) G__getstructoffset();
04230    *dest = *(TCondorSlave*) libp->para[0].ref;
04231    const TCondorSlave& obj = *dest;
04232    result7->ref = (long) (&obj);
04233    result7->obj.i = (long) (&obj);
04234    return(1 || funcname || hash || result7 || libp) ;
04235 }
04236 
04237 
04238 /* TCondor */
04239 static int G__G__Proof_111_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04240 {
04241    TCondor* p = NULL;
04242    char* gvp = (char*) G__getgvp();
04243    switch (libp->paran) {
04244    case 1:
04245      //m: 1
04246      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04247        p = new TCondor((const char*) G__int(libp->para[0]));
04248      } else {
04249        p = new((void*) gvp) TCondor((const char*) G__int(libp->para[0]));
04250      }
04251      break;
04252    case 0:
04253      int n = G__getaryconstruct();
04254      if (n) {
04255        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04256          p = new TCondor[n];
04257        } else {
04258          p = new((void*) gvp) TCondor[n];
04259        }
04260      } else {
04261        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04262          p = new TCondor;
04263        } else {
04264          p = new((void*) gvp) TCondor;
04265        }
04266      }
04267      break;
04268    }
04269    result7->obj.i = (long) p;
04270    result7->ref = (long) p;
04271    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TCondor));
04272    return(1 || funcname || hash || result7 || libp) ;
04273 }
04274 
04275 static int G__G__Proof_111_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04276 {
04277       G__letint(result7, 103, (long) ((const TCondor*) G__getstructoffset())->IsValid());
04278    return(1 || funcname || hash || result7 || libp) ;
04279 }
04280 
04281 static int G__G__Proof_111_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04282 {
04283       G__letint(result7, 85, (long) ((const TCondor*) G__getstructoffset())->GetVirtualMachines());
04284    return(1 || funcname || hash || result7 || libp) ;
04285 }
04286 
04287 static int G__G__Proof_111_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04288 {
04289       G__letint(result7, 85, (long) ((TCondor*) G__getstructoffset())->Claim((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
04290    return(1 || funcname || hash || result7 || libp) ;
04291 }
04292 
04293 static int G__G__Proof_111_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04294 {
04295       G__letint(result7, 85, (long) ((TCondor*) G__getstructoffset())->Claim((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
04296    return(1 || funcname || hash || result7 || libp) ;
04297 }
04298 
04299 static int G__G__Proof_111_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04300 {
04301       G__letint(result7, 103, (long) ((TCondor*) G__getstructoffset())->SetState((TCondor::EState) G__int(libp->para[0])));
04302    return(1 || funcname || hash || result7 || libp) ;
04303 }
04304 
04305 static int G__G__Proof_111_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04306 {
04307       G__letint(result7, 105, (long) ((const TCondor*) G__getstructoffset())->GetState());
04308    return(1 || funcname || hash || result7 || libp) ;
04309 }
04310 
04311 static int G__G__Proof_111_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04312 {
04313       G__letint(result7, 103, (long) ((TCondor*) G__getstructoffset())->Suspend());
04314    return(1 || funcname || hash || result7 || libp) ;
04315 }
04316 
04317 static int G__G__Proof_111_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04318 {
04319       G__letint(result7, 103, (long) ((TCondor*) G__getstructoffset())->Resume());
04320    return(1 || funcname || hash || result7 || libp) ;
04321 }
04322 
04323 static int G__G__Proof_111_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04324 {
04325       G__letint(result7, 103, (long) ((TCondor*) G__getstructoffset())->Release());
04326    return(1 || funcname || hash || result7 || libp) ;
04327 }
04328 
04329 static int G__G__Proof_111_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04330 {
04331       G__letint(result7, 103, (long) ((const TCondor*) G__getstructoffset())->GetVmInfo((const char*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
04332 , *(Int_t*) G__Intref(&libp->para[2])));
04333    return(1 || funcname || hash || result7 || libp) ;
04334 }
04335 
04336 static int G__G__Proof_111_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04337 {
04338       {
04339          const TString* pobj;
04340          const TString xobj = ((const TCondor*) G__getstructoffset())->GetImage((const char*) G__int(libp->para[0]));
04341          pobj = new TString(xobj);
04342          result7->obj.i = (long) ((void*) pobj);
04343          result7->ref = result7->obj.i;
04344          G__store_tempobject(*result7);
04345       }
04346    return(1 || funcname || hash || result7 || libp) ;
04347 }
04348 
04349 static int G__G__Proof_111_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04350 {
04351       G__letint(result7, 85, (long) TCondor::Class());
04352    return(1 || funcname || hash || result7 || libp) ;
04353 }
04354 
04355 static int G__G__Proof_111_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04356 {
04357       G__letint(result7, 67, (long) TCondor::Class_Name());
04358    return(1 || funcname || hash || result7 || libp) ;
04359 }
04360 
04361 static int G__G__Proof_111_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04362 {
04363       G__letint(result7, 115, (long) TCondor::Class_Version());
04364    return(1 || funcname || hash || result7 || libp) ;
04365 }
04366 
04367 static int G__G__Proof_111_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04368 {
04369       TCondor::Dictionary();
04370       G__setnull(result7);
04371    return(1 || funcname || hash || result7 || libp) ;
04372 }
04373 
04374 static int G__G__Proof_111_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04375 {
04376       ((TCondor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04377       G__setnull(result7);
04378    return(1 || funcname || hash || result7 || libp) ;
04379 }
04380 
04381 static int G__G__Proof_111_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04382 {
04383       G__letint(result7, 67, (long) TCondor::DeclFileName());
04384    return(1 || funcname || hash || result7 || libp) ;
04385 }
04386 
04387 static int G__G__Proof_111_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04388 {
04389       G__letint(result7, 105, (long) TCondor::ImplFileLine());
04390    return(1 || funcname || hash || result7 || libp) ;
04391 }
04392 
04393 static int G__G__Proof_111_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04394 {
04395       G__letint(result7, 67, (long) TCondor::ImplFileName());
04396    return(1 || funcname || hash || result7 || libp) ;
04397 }
04398 
04399 static int G__G__Proof_111_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04400 {
04401       G__letint(result7, 105, (long) TCondor::DeclFileLine());
04402    return(1 || funcname || hash || result7 || libp) ;
04403 }
04404 
04405 // automatic copy constructor
04406 static int G__G__Proof_111_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04407 
04408 {
04409    TCondor* p;
04410    void* tmp = (void*) G__int(libp->para[0]);
04411    p = new TCondor(*(TCondor*) tmp);
04412    result7->obj.i = (long) p;
04413    result7->ref = (long) p;
04414    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TCondor));
04415    return(1 || funcname || hash || result7 || libp) ;
04416 }
04417 
04418 // automatic destructor
04419 typedef TCondor G__TTCondor;
04420 static int G__G__Proof_111_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04421 {
04422    char* gvp = (char*) G__getgvp();
04423    long soff = G__getstructoffset();
04424    int n = G__getaryconstruct();
04425    //
04426    //has_a_delete: 1
04427    //has_own_delete1arg: 0
04428    //has_own_delete2arg: 0
04429    //
04430    if (!soff) {
04431      return(1);
04432    }
04433    if (n) {
04434      if (gvp == (char*)G__PVOID) {
04435        delete[] (TCondor*) soff;
04436      } else {
04437        G__setgvp((long) G__PVOID);
04438        for (int i = n - 1; i >= 0; --i) {
04439          ((TCondor*) (soff+(sizeof(TCondor)*i)))->~G__TTCondor();
04440        }
04441        G__setgvp((long)gvp);
04442      }
04443    } else {
04444      if (gvp == (char*)G__PVOID) {
04445        delete (TCondor*) soff;
04446      } else {
04447        G__setgvp((long) G__PVOID);
04448        ((TCondor*) (soff))->~G__TTCondor();
04449        G__setgvp((long)gvp);
04450      }
04451    }
04452    G__setnull(result7);
04453    return(1 || funcname || hash || result7 || libp) ;
04454 }
04455 
04456 // automatic assignment operator
04457 static int G__G__Proof_111_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04458 {
04459    TCondor* dest = (TCondor*) G__getstructoffset();
04460    *dest = *(TCondor*) libp->para[0].ref;
04461    const TCondor& obj = *dest;
04462    result7->ref = (long) (&obj);
04463    result7->obj.i = (long) (&obj);
04464    return(1 || funcname || hash || result7 || libp) ;
04465 }
04466 
04467 
04468 /* TDataSetManager */
04469 static int G__G__Proof_132_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04470 {
04471    TDataSetManager* p = NULL;
04472    char* gvp = (char*) G__getgvp();
04473    switch (libp->paran) {
04474    case 3:
04475      //m: 3
04476      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04477        p = new TDataSetManager(
04478 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04479 , (const char*) G__int(libp->para[2]));
04480      } else {
04481        p = new((void*) gvp) TDataSetManager(
04482 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04483 , (const char*) G__int(libp->para[2]));
04484      }
04485      break;
04486    case 2:
04487      //m: 2
04488      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04489        p = new TDataSetManager((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
04490      } else {
04491        p = new((void*) gvp) TDataSetManager((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
04492      }
04493      break;
04494    case 1:
04495      //m: 1
04496      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04497        p = new TDataSetManager((const char*) G__int(libp->para[0]));
04498      } else {
04499        p = new((void*) gvp) TDataSetManager((const char*) G__int(libp->para[0]));
04500      }
04501      break;
04502    case 0:
04503      int n = G__getaryconstruct();
04504      if (n) {
04505        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04506          p = new TDataSetManager[n];
04507        } else {
04508          p = new((void*) gvp) TDataSetManager[n];
04509        }
04510      } else {
04511        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04512          p = new TDataSetManager;
04513        } else {
04514          p = new((void*) gvp) TDataSetManager;
04515        }
04516      }
04517      break;
04518    }
04519    result7->obj.i = (long) p;
04520    result7->ref = (long) p;
04521    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManager));
04522    return(1 || funcname || hash || result7 || libp) ;
04523 }
04524 
04525 static int G__G__Proof_132_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04526 {
04527       G__letint(result7, 105, (long) ((TDataSetManager*) G__getstructoffset())->ClearCache((const char*) G__int(libp->para[0])));
04528    return(1 || funcname || hash || result7 || libp) ;
04529 }
04530 
04531 static int G__G__Proof_132_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04532 {
04533       G__letLonglong(result7, 110, (G__int64) ((const TDataSetManager*) G__getstructoffset())->GetAvgFileSize());
04534    return(1 || funcname || hash || result7 || libp) ;
04535 }
04536 
04537 static int G__G__Proof_132_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04538 {
04539    switch (libp->paran) {
04540    case 2:
04541       G__letint(result7, 85, (long) ((TDataSetManager*) G__getstructoffset())->GetDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
04542       break;
04543    case 1:
04544       G__letint(result7, 85, (long) ((TDataSetManager*) G__getstructoffset())->GetDataSet((const char*) G__int(libp->para[0])));
04545       break;
04546    }
04547    return(1 || funcname || hash || result7 || libp) ;
04548 }
04549 
04550 static int G__G__Proof_132_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04551 {
04552    switch (libp->paran) {
04553    case 2:
04554       G__letint(result7, 85, (long) ((TDataSetManager*) G__getstructoffset())->GetDataSets((const char*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
04555       break;
04556    case 1:
04557       G__letint(result7, 85, (long) ((TDataSetManager*) G__getstructoffset())->GetDataSets((const char*) G__int(libp->para[0])));
04558       break;
04559    }
04560    return(1 || funcname || hash || result7 || libp) ;
04561 }
04562 
04563 static int G__G__Proof_132_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04564 {
04565       G__letint(result7, 85, (long) ((TDataSetManager*) G__getstructoffset())->GetSubDataSets((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
04566    return(1 || funcname || hash || result7 || libp) ;
04567 }
04568 
04569 static int G__G__Proof_132_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04570 {
04571       G__letLonglong(result7, 110, (G__int64) ((TDataSetManager*) G__getstructoffset())->GetGroupQuota((const char*) G__int(libp->para[0])));
04572    return(1 || funcname || hash || result7 || libp) ;
04573 }
04574 
04575 static int G__G__Proof_132_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04576 {
04577       G__letint(result7, 85, (long) ((TDataSetManager*) G__getstructoffset())->GetGroupQuotaMap());
04578    return(1 || funcname || hash || result7 || libp) ;
04579 }
04580 
04581 static int G__G__Proof_132_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04582 {
04583       G__letLonglong(result7, 110, (G__int64) ((TDataSetManager*) G__getstructoffset())->GetGroupUsed((const char*) G__int(libp->para[0])));
04584    return(1 || funcname || hash || result7 || libp) ;
04585 }
04586 
04587 static int G__G__Proof_132_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04588 {
04589       G__letint(result7, 103, (long) ((TDataSetManager*) G__getstructoffset())->ExistsDataSet((const char*) G__int(libp->para[0])));
04590    return(1 || funcname || hash || result7 || libp) ;
04591 }
04592 
04593 static int G__G__Proof_132_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04594 {
04595       ((TDataSetManager*) G__getstructoffset())->MonitorUsedSpace((TVirtualMonitoringWriter*) G__int(libp->para[0]));
04596       G__setnull(result7);
04597    return(1 || funcname || hash || result7 || libp) ;
04598 }
04599 
04600 static int G__G__Proof_132_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04601 {
04602    switch (libp->paran) {
04603    case 5:
04604       G__letint(result7, 105, (long) ((TDataSetManager*) G__getstructoffset())->NotifyUpdate((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04605 , (const char*) G__int(libp->para[2]), (Long_t) G__int(libp->para[3])
04606 , (const char*) G__int(libp->para[4])));
04607       break;
04608    case 4:
04609       G__letint(result7, 105, (long) ((TDataSetManager*) G__getstructoffset())->NotifyUpdate((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04610 , (const char*) G__int(libp->para[2]), (Long_t) G__int(libp->para[3])));
04611       break;
04612    case 3:
04613       G__letint(result7, 105, (long) ((TDataSetManager*) G__getstructoffset())->NotifyUpdate((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04614 , (const char*) G__int(libp->para[2])));
04615       break;
04616    case 2:
04617       G__letint(result7, 105, (long) ((TDataSetManager*) G__getstructoffset())->NotifyUpdate((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
04618       break;
04619    case 1:
04620       G__letint(result7, 105, (long) ((TDataSetManager*) G__getstructoffset())->NotifyUpdate((const char*) G__int(libp->para[0])));
04621       break;
04622    case 0:
04623       G__letint(result7, 105, (long) ((TDataSetManager*) G__getstructoffset())->NotifyUpdate());
04624       break;
04625    }
04626    return(1 || funcname || hash || result7 || libp) ;
04627 }
04628 
04629 static int G__G__Proof_132_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04630 {
04631    switch (libp->paran) {
04632    case 7:
04633       G__letint(result7, 103, (long) ((TDataSetManager*) G__getstructoffset())->ParseUri(
04634 (const char*) G__int(libp->para[0]), (TString*) G__int(libp->para[1])
04635 , (TString*) G__int(libp->para[2]), (TString*) G__int(libp->para[3])
04636 , (TString*) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])
04637 , (Bool_t) G__int(libp->para[6])));
04638       break;
04639    case 6:
04640       G__letint(result7, 103, (long) ((TDataSetManager*) G__getstructoffset())->ParseUri((const char*) G__int(libp->para[0]), (TString*) G__int(libp->para[1])
04641 , (TString*) G__int(libp->para[2]), (TString*) G__int(libp->para[3])
04642 , (TString*) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])));
04643       break;
04644    case 5:
04645       G__letint(result7, 103, (long) ((TDataSetManager*) G__getstructoffset())->ParseUri((const char*) G__int(libp->para[0]), (TString*) G__int(libp->para[1])
04646 , (TString*) G__int(libp->para[2]), (TString*) G__int(libp->para[3])
04647 , (TString*) G__int(libp->para[4])));
04648       break;
04649    case 4:
04650       G__letint(result7, 103, (long) ((TDataSetManager*) G__getstructoffset())->ParseUri((const char*) G__int(libp->para[0]), (TString*) G__int(libp->para[1])
04651 , (TString*) G__int(libp->para[2]), (TString*) G__int(libp->para[3])));
04652       break;
04653    case 3:
04654       G__letint(result7, 103, (long) ((TDataSetManager*) G__getstructoffset())->ParseUri((const char*) G__int(libp->para[0]), (TString*) G__int(libp->para[1])
04655 , (TString*) G__int(libp->para[2])));
04656       break;
04657    case 2:
04658       G__letint(result7, 103, (long) ((TDataSetManager*) G__getstructoffset())->ParseUri((const char*) G__int(libp->para[0]), (TString*) G__int(libp->para[1])));
04659       break;
04660    case 1:
04661       G__letint(result7, 103, (long) ((TDataSetManager*) G__getstructoffset())->ParseUri((const char*) G__int(libp->para[0])));
04662       break;
04663    }
04664    return(1 || funcname || hash || result7 || libp) ;
04665 }
04666 
04667 static int G__G__Proof_132_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04668 {
04669       ((TDataSetManager*) G__getstructoffset())->ParseInitOpts((const char*) G__int(libp->para[0]));
04670       G__setnull(result7);
04671    return(1 || funcname || hash || result7 || libp) ;
04672 }
04673 
04674 static int G__G__Proof_132_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04675 {
04676       G__letint(result7, 103, (long) ((TDataSetManager*) G__getstructoffset())->RemoveDataSet((const char*) G__int(libp->para[0])));
04677    return(1 || funcname || hash || result7 || libp) ;
04678 }
04679 
04680 static int G__G__Proof_132_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04681 {
04682       G__letint(result7, 105, (long) ((TDataSetManager*) G__getstructoffset())->RegisterDataSet((const char*) G__int(libp->para[0]), (TFileCollection*) G__int(libp->para[1])
04683 , (const char*) G__int(libp->para[2])));
04684    return(1 || funcname || hash || result7 || libp) ;
04685 }
04686 
04687 static int G__G__Proof_132_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04688 {
04689       G__letint(result7, 105, (long) ((TDataSetManager*) G__getstructoffset())->ScanDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
04690    return(1 || funcname || hash || result7 || libp) ;
04691 }
04692 
04693 static int G__G__Proof_132_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04694 {
04695    switch (libp->paran) {
04696    case 2:
04697       G__letint(result7, 105, (long) ((TDataSetManager*) G__getstructoffset())->ScanDataSet((const char*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
04698       break;
04699    case 1:
04700       G__letint(result7, 105, (long) ((TDataSetManager*) G__getstructoffset())->ScanDataSet((const char*) G__int(libp->para[0])));
04701       break;
04702    }
04703    return(1 || funcname || hash || result7 || libp) ;
04704 }
04705 
04706 static int G__G__Proof_132_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04707 {
04708    switch (libp->paran) {
04709    case 3:
04710       ((TDataSetManager*) G__getstructoffset())->SetScanCounters((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04711 , (Int_t) G__int(libp->para[2]));
04712       G__setnull(result7);
04713       break;
04714    case 2:
04715       ((TDataSetManager*) G__getstructoffset())->SetScanCounters((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
04716       G__setnull(result7);
04717       break;
04718    case 1:
04719       ((TDataSetManager*) G__getstructoffset())->SetScanCounters((Int_t) G__int(libp->para[0]));
04720       G__setnull(result7);
04721       break;
04722    case 0:
04723       ((TDataSetManager*) G__getstructoffset())->SetScanCounters();
04724       G__setnull(result7);
04725       break;
04726    }
04727    return(1 || funcname || hash || result7 || libp) ;
04728 }
04729 
04730 static int G__G__Proof_132_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04731 {
04732       G__letint(result7, 105, (long) ((TDataSetManager*) G__getstructoffset())->ShowCache((const char*) G__int(libp->para[0])));
04733    return(1 || funcname || hash || result7 || libp) ;
04734 }
04735 
04736 static int G__G__Proof_132_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04737 {
04738       ((TDataSetManager*) G__getstructoffset())->ShowQuota((const char*) G__int(libp->para[0]));
04739       G__setnull(result7);
04740    return(1 || funcname || hash || result7 || libp) ;
04741 }
04742 
04743 static int G__G__Proof_132_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04744 {
04745    switch (libp->paran) {
04746    case 2:
04747       ((TDataSetManager*) G__getstructoffset())->ShowDataSets((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
04748       G__setnull(result7);
04749       break;
04750    case 1:
04751       ((TDataSetManager*) G__getstructoffset())->ShowDataSets((const char*) G__int(libp->para[0]));
04752       G__setnull(result7);
04753       break;
04754    case 0:
04755       ((TDataSetManager*) G__getstructoffset())->ShowDataSets();
04756       G__setnull(result7);
04757       break;
04758    }
04759    return(1 || funcname || hash || result7 || libp) ;
04760 }
04761 
04762 static int G__G__Proof_132_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04763 {
04764    switch (libp->paran) {
04765    case 4:
04766       {
04767          TString* pobj;
04768          TString xobj = TDataSetManager::CreateUri((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04769 , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
04770          pobj = new TString(xobj);
04771          result7->obj.i = (long) ((void*) pobj);
04772          result7->ref = result7->obj.i;
04773          G__store_tempobject(*result7);
04774       }
04775       break;
04776    case 3:
04777       {
04778          TString* pobj;
04779          TString xobj = TDataSetManager::CreateUri((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04780 , (const char*) G__int(libp->para[2]));
04781          pobj = new TString(xobj);
04782          result7->obj.i = (long) ((void*) pobj);
04783          result7->ref = result7->obj.i;
04784          G__store_tempobject(*result7);
04785       }
04786       break;
04787    case 2:
04788       {
04789          TString* pobj;
04790          TString xobj = TDataSetManager::CreateUri((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
04791          pobj = new TString(xobj);
04792          result7->obj.i = (long) ((void*) pobj);
04793          result7->ref = result7->obj.i;
04794          G__store_tempobject(*result7);
04795       }
04796       break;
04797    case 1:
04798       {
04799          TString* pobj;
04800          TString xobj = TDataSetManager::CreateUri((const char*) G__int(libp->para[0]));
04801          pobj = new TString(xobj);
04802          result7->obj.i = (long) ((void*) pobj);
04803          result7->ref = result7->obj.i;
04804          G__store_tempobject(*result7);
04805       }
04806       break;
04807    case 0:
04808       {
04809          TString* pobj;
04810          TString xobj = TDataSetManager::CreateUri();
04811          pobj = new TString(xobj);
04812          result7->obj.i = (long) ((void*) pobj);
04813          result7->ref = result7->obj.i;
04814          G__store_tempobject(*result7);
04815       }
04816       break;
04817    }
04818    return(1 || funcname || hash || result7 || libp) ;
04819 }
04820 
04821 static int G__G__Proof_132_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04822 {
04823    switch (libp->paran) {
04824    case 3:
04825       G__letint(result7, 103, (long) TDataSetManager::CheckDataSetSrvMaps((TUrl*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
04826 , (TList*) G__int(libp->para[2])));
04827       break;
04828    case 2:
04829       G__letint(result7, 103, (long) TDataSetManager::CheckDataSetSrvMaps((TUrl*) G__int(libp->para[0]), *(TString*) libp->para[1].ref));
04830       break;
04831    }
04832    return(1 || funcname || hash || result7 || libp) ;
04833 }
04834 
04835 static int G__G__Proof_132_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04836 {
04837       G__letint(result7, 85, (long) TDataSetManager::GetDataSetSrvMaps());
04838    return(1 || funcname || hash || result7 || libp) ;
04839 }
04840 
04841 static int G__G__Proof_132_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04842 {
04843       G__letint(result7, 85, (long) TDataSetManager::ParseDataSetSrvMaps(*(TString*) libp->para[0].ref));
04844    return(1 || funcname || hash || result7 || libp) ;
04845 }
04846 
04847 static int G__G__Proof_132_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04848 {
04849    switch (libp->paran) {
04850    case 13:
04851       G__letint(result7, 105, (long) TDataSetManager::ScanDataSet(
04852 (TFileCollection*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04853 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
04854 , (Bool_t) G__int(libp->para[4]), (Int_t*) G__int(libp->para[5])
04855 , (Int_t*) G__int(libp->para[6]), (Int_t*) G__int(libp->para[7])
04856 , (TList*) G__int(libp->para[8]), (Long64_t) G__Longlong(libp->para[9])
04857 , (const char*) G__int(libp->para[10]), (Int_t) G__int(libp->para[11])
04858 , (const char*) G__int(libp->para[12])));
04859       break;
04860    case 12:
04861       G__letint(result7, 105, (long) TDataSetManager::ScanDataSet(
04862 (TFileCollection*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04863 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
04864 , (Bool_t) G__int(libp->para[4]), (Int_t*) G__int(libp->para[5])
04865 , (Int_t*) G__int(libp->para[6]), (Int_t*) G__int(libp->para[7])
04866 , (TList*) G__int(libp->para[8]), (Long64_t) G__Longlong(libp->para[9])
04867 , (const char*) G__int(libp->para[10]), (Int_t) G__int(libp->para[11])));
04868       break;
04869    case 11:
04870       G__letint(result7, 105, (long) TDataSetManager::ScanDataSet(
04871 (TFileCollection*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04872 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
04873 , (Bool_t) G__int(libp->para[4]), (Int_t*) G__int(libp->para[5])
04874 , (Int_t*) G__int(libp->para[6]), (Int_t*) G__int(libp->para[7])
04875 , (TList*) G__int(libp->para[8]), (Long64_t) G__Longlong(libp->para[9])
04876 , (const char*) G__int(libp->para[10])));
04877       break;
04878    case 10:
04879       G__letint(result7, 105, (long) TDataSetManager::ScanDataSet(
04880 (TFileCollection*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04881 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
04882 , (Bool_t) G__int(libp->para[4]), (Int_t*) G__int(libp->para[5])
04883 , (Int_t*) G__int(libp->para[6]), (Int_t*) G__int(libp->para[7])
04884 , (TList*) G__int(libp->para[8]), (Long64_t) G__Longlong(libp->para[9])));
04885       break;
04886    case 9:
04887       G__letint(result7, 105, (long) TDataSetManager::ScanDataSet(
04888 (TFileCollection*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04889 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
04890 , (Bool_t) G__int(libp->para[4]), (Int_t*) G__int(libp->para[5])
04891 , (Int_t*) G__int(libp->para[6]), (Int_t*) G__int(libp->para[7])
04892 , (TList*) G__int(libp->para[8])));
04893       break;
04894    case 8:
04895       G__letint(result7, 105, (long) TDataSetManager::ScanDataSet(
04896 (TFileCollection*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04897 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
04898 , (Bool_t) G__int(libp->para[4]), (Int_t*) G__int(libp->para[5])
04899 , (Int_t*) G__int(libp->para[6]), (Int_t*) G__int(libp->para[7])));
04900       break;
04901    case 7:
04902       G__letint(result7, 105, (long) TDataSetManager::ScanDataSet(
04903 (TFileCollection*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04904 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
04905 , (Bool_t) G__int(libp->para[4]), (Int_t*) G__int(libp->para[5])
04906 , (Int_t*) G__int(libp->para[6])));
04907       break;
04908    case 6:
04909       G__letint(result7, 105, (long) TDataSetManager::ScanDataSet((TFileCollection*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04910 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
04911 , (Bool_t) G__int(libp->para[4]), (Int_t*) G__int(libp->para[5])));
04912       break;
04913    case 5:
04914       G__letint(result7, 105, (long) TDataSetManager::ScanDataSet((TFileCollection*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04915 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
04916 , (Bool_t) G__int(libp->para[4])));
04917       break;
04918    case 4:
04919       G__letint(result7, 105, (long) TDataSetManager::ScanDataSet((TFileCollection*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04920 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
04921       break;
04922    case 3:
04923       G__letint(result7, 105, (long) TDataSetManager::ScanDataSet((TFileCollection*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
04924 , (Int_t) G__int(libp->para[2])));
04925       break;
04926    case 2:
04927       G__letint(result7, 105, (long) TDataSetManager::ScanDataSet((TFileCollection*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
04928       break;
04929    }
04930    return(1 || funcname || hash || result7 || libp) ;
04931 }
04932 
04933 static int G__G__Proof_132_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04934 {
04935       G__letint(result7, 105, (long) TDataSetManager::ScanFile((TFileInfo*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
04936    return(1 || funcname || hash || result7 || libp) ;
04937 }
04938 
04939 static int G__G__Proof_132_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04940 {
04941    switch (libp->paran) {
04942    case 3:
04943       G__letint(result7, 105, (long) TDataSetManager::FillMetaData((TFileInfo*) G__int(libp->para[0]), (TDirectory*) G__int(libp->para[1])
04944 , (const char*) G__int(libp->para[2])));
04945       break;
04946    case 2:
04947       G__letint(result7, 105, (long) TDataSetManager::FillMetaData((TFileInfo*) G__int(libp->para[0]), (TDirectory*) G__int(libp->para[1])));
04948       break;
04949    }
04950    return(1 || funcname || hash || result7 || libp) ;
04951 }
04952 
04953 static int G__G__Proof_132_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04954 {
04955       G__letint(result7, 85, (long) TDataSetManager::Class());
04956    return(1 || funcname || hash || result7 || libp) ;
04957 }
04958 
04959 static int G__G__Proof_132_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04960 {
04961       G__letint(result7, 67, (long) TDataSetManager::Class_Name());
04962    return(1 || funcname || hash || result7 || libp) ;
04963 }
04964 
04965 static int G__G__Proof_132_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04966 {
04967       G__letint(result7, 115, (long) TDataSetManager::Class_Version());
04968    return(1 || funcname || hash || result7 || libp) ;
04969 }
04970 
04971 static int G__G__Proof_132_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04972 {
04973       TDataSetManager::Dictionary();
04974       G__setnull(result7);
04975    return(1 || funcname || hash || result7 || libp) ;
04976 }
04977 
04978 static int G__G__Proof_132_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04979 {
04980       ((TDataSetManager*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04981       G__setnull(result7);
04982    return(1 || funcname || hash || result7 || libp) ;
04983 }
04984 
04985 static int G__G__Proof_132_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04986 {
04987       G__letint(result7, 67, (long) TDataSetManager::DeclFileName());
04988    return(1 || funcname || hash || result7 || libp) ;
04989 }
04990 
04991 static int G__G__Proof_132_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04992 {
04993       G__letint(result7, 105, (long) TDataSetManager::ImplFileLine());
04994    return(1 || funcname || hash || result7 || libp) ;
04995 }
04996 
04997 static int G__G__Proof_132_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04998 {
04999       G__letint(result7, 67, (long) TDataSetManager::ImplFileName());
05000    return(1 || funcname || hash || result7 || libp) ;
05001 }
05002 
05003 static int G__G__Proof_132_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05004 {
05005       G__letint(result7, 105, (long) TDataSetManager::DeclFileLine());
05006    return(1 || funcname || hash || result7 || libp) ;
05007 }
05008 
05009 // automatic destructor
05010 typedef TDataSetManager G__TTDataSetManager;
05011 static int G__G__Proof_132_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05012 {
05013    char* gvp = (char*) G__getgvp();
05014    long soff = G__getstructoffset();
05015    int n = G__getaryconstruct();
05016    //
05017    //has_a_delete: 1
05018    //has_own_delete1arg: 0
05019    //has_own_delete2arg: 0
05020    //
05021    if (!soff) {
05022      return(1);
05023    }
05024    if (n) {
05025      if (gvp == (char*)G__PVOID) {
05026        delete[] (TDataSetManager*) soff;
05027      } else {
05028        G__setgvp((long) G__PVOID);
05029        for (int i = n - 1; i >= 0; --i) {
05030          ((TDataSetManager*) (soff+(sizeof(TDataSetManager)*i)))->~G__TTDataSetManager();
05031        }
05032        G__setgvp((long)gvp);
05033      }
05034    } else {
05035      if (gvp == (char*)G__PVOID) {
05036        delete (TDataSetManager*) soff;
05037      } else {
05038        G__setgvp((long) G__PVOID);
05039        ((TDataSetManager*) (soff))->~G__TTDataSetManager();
05040        G__setgvp((long)gvp);
05041      }
05042    }
05043    G__setnull(result7);
05044    return(1 || funcname || hash || result7 || libp) ;
05045 }
05046 
05047 
05048 /* TDataSetManagerFile */
05049 static int G__G__Proof_135_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05050 {
05051    TDataSetManagerFile* p = NULL;
05052    char* gvp = (char*) G__getgvp();
05053    int n = G__getaryconstruct();
05054    if (n) {
05055      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05056        p = new TDataSetManagerFile[n];
05057      } else {
05058        p = new((void*) gvp) TDataSetManagerFile[n];
05059      }
05060    } else {
05061      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05062        p = new TDataSetManagerFile;
05063      } else {
05064        p = new((void*) gvp) TDataSetManagerFile;
05065      }
05066    }
05067    result7->obj.i = (long) p;
05068    result7->ref = (long) p;
05069    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagerFile));
05070    return(1 || funcname || hash || result7 || libp) ;
05071 }
05072 
05073 static int G__G__Proof_135_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05074 {
05075    TDataSetManagerFile* p = NULL;
05076    char* gvp = (char*) G__getgvp();
05077    //m: 3
05078    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05079      p = new TDataSetManagerFile(
05080 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05081 , (const char*) G__int(libp->para[2]));
05082    } else {
05083      p = new((void*) gvp) TDataSetManagerFile(
05084 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05085 , (const char*) G__int(libp->para[2]));
05086    }
05087    result7->obj.i = (long) p;
05088    result7->ref = (long) p;
05089    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagerFile));
05090    return(1 || funcname || hash || result7 || libp) ;
05091 }
05092 
05093 static int G__G__Proof_135_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05094 {
05095    TDataSetManagerFile* p = NULL;
05096    char* gvp = (char*) G__getgvp();
05097    //m: 1
05098    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05099      p = new TDataSetManagerFile((const char*) G__int(libp->para[0]));
05100    } else {
05101      p = new((void*) gvp) TDataSetManagerFile((const char*) G__int(libp->para[0]));
05102    }
05103    result7->obj.i = (long) p;
05104    result7->ref = (long) p;
05105    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagerFile));
05106    return(1 || funcname || hash || result7 || libp) ;
05107 }
05108 
05109 static int G__G__Proof_135_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05110 {
05111    switch (libp->paran) {
05112    case 1:
05113       G__letint(result7, 105, (long) ((TDataSetManagerFile*) G__getstructoffset())->ClearCache((const char*) G__int(libp->para[0])));
05114       break;
05115    case 0:
05116       G__letint(result7, 105, (long) ((TDataSetManagerFile*) G__getstructoffset())->ClearCache());
05117       break;
05118    }
05119    return(1 || funcname || hash || result7 || libp) ;
05120 }
05121 
05122 static int G__G__Proof_135_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05123 {
05124    switch (libp->paran) {
05125    case 1:
05126       G__letint(result7, 105, (long) ((TDataSetManagerFile*) G__getstructoffset())->ShowCache((const char*) G__int(libp->para[0])));
05127       break;
05128    case 0:
05129       G__letint(result7, 105, (long) ((TDataSetManagerFile*) G__getstructoffset())->ShowCache());
05130       break;
05131    }
05132    return(1 || funcname || hash || result7 || libp) ;
05133 }
05134 
05135 static int G__G__Proof_135_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05136 {
05137    switch (libp->paran) {
05138    case 5:
05139       G__letint(result7, 85, (long) ((TDataSetManagerFile*) G__getstructoffset())->GetDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05140 , (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
05141 , (TMD5**) G__int(libp->para[4])));
05142       break;
05143    case 4:
05144       G__letint(result7, 85, (long) ((TDataSetManagerFile*) G__getstructoffset())->GetDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05145 , (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])));
05146       break;
05147    case 3:
05148       G__letint(result7, 85, (long) ((TDataSetManagerFile*) G__getstructoffset())->GetDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05149 , (const char*) G__int(libp->para[2])));
05150       break;
05151    }
05152    return(1 || funcname || hash || result7 || libp) ;
05153 }
05154 
05155 static int G__G__Proof_135_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05156 {
05157    switch (libp->paran) {
05158    case 4:
05159       G__letint(result7, 85, (long) ((TDataSetManagerFile*) G__getstructoffset())->GetDataSets((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05160 , (const char*) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])));
05161       break;
05162    case 3:
05163       G__letint(result7, 85, (long) ((TDataSetManagerFile*) G__getstructoffset())->GetDataSets((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05164 , (const char*) G__int(libp->para[2])));
05165       break;
05166    case 2:
05167       G__letint(result7, 85, (long) ((TDataSetManagerFile*) G__getstructoffset())->GetDataSets((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
05168       break;
05169    }
05170    return(1 || funcname || hash || result7 || libp) ;
05171 }
05172 
05173 static int G__G__Proof_135_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05174 {
05175       G__letint(result7, 67, (long) ((const TDataSetManagerFile*) G__getstructoffset())->GetMSSUrl());
05176    return(1 || funcname || hash || result7 || libp) ;
05177 }
05178 
05179 static int G__G__Proof_135_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05180 {
05181       G__letint(result7, 67, (long) ((const TDataSetManagerFile*) G__getstructoffset())->GetStageOpts());
05182    return(1 || funcname || hash || result7 || libp) ;
05183 }
05184 
05185 static int G__G__Proof_135_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05186 {
05187    switch (libp->paran) {
05188    case 6:
05189       G__letint(result7, 105, (long) ((TDataSetManagerFile*) G__getstructoffset())->WriteDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05190 , (const char*) G__int(libp->para[2]), (TFileCollection*) G__int(libp->para[3])
05191 , (UInt_t) G__int(libp->para[4]), (TMD5*) G__int(libp->para[5])));
05192       break;
05193    case 5:
05194       G__letint(result7, 105, (long) ((TDataSetManagerFile*) G__getstructoffset())->WriteDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05195 , (const char*) G__int(libp->para[2]), (TFileCollection*) G__int(libp->para[3])
05196 , (UInt_t) G__int(libp->para[4])));
05197       break;
05198    case 4:
05199       G__letint(result7, 105, (long) ((TDataSetManagerFile*) G__getstructoffset())->WriteDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05200 , (const char*) G__int(libp->para[2]), (TFileCollection*) G__int(libp->para[3])));
05201       break;
05202    }
05203    return(1 || funcname || hash || result7 || libp) ;
05204 }
05205 
05206 static int G__G__Proof_135_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05207 {
05208       G__letint(result7, 85, (long) TDataSetManagerFile::Class());
05209    return(1 || funcname || hash || result7 || libp) ;
05210 }
05211 
05212 static int G__G__Proof_135_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05213 {
05214       G__letint(result7, 67, (long) TDataSetManagerFile::Class_Name());
05215    return(1 || funcname || hash || result7 || libp) ;
05216 }
05217 
05218 static int G__G__Proof_135_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05219 {
05220       G__letint(result7, 115, (long) TDataSetManagerFile::Class_Version());
05221    return(1 || funcname || hash || result7 || libp) ;
05222 }
05223 
05224 static int G__G__Proof_135_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05225 {
05226       TDataSetManagerFile::Dictionary();
05227       G__setnull(result7);
05228    return(1 || funcname || hash || result7 || libp) ;
05229 }
05230 
05231 static int G__G__Proof_135_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05232 {
05233       ((TDataSetManagerFile*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05234       G__setnull(result7);
05235    return(1 || funcname || hash || result7 || libp) ;
05236 }
05237 
05238 static int G__G__Proof_135_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05239 {
05240       G__letint(result7, 67, (long) TDataSetManagerFile::DeclFileName());
05241    return(1 || funcname || hash || result7 || libp) ;
05242 }
05243 
05244 static int G__G__Proof_135_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05245 {
05246       G__letint(result7, 105, (long) TDataSetManagerFile::ImplFileLine());
05247    return(1 || funcname || hash || result7 || libp) ;
05248 }
05249 
05250 static int G__G__Proof_135_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05251 {
05252       G__letint(result7, 67, (long) TDataSetManagerFile::ImplFileName());
05253    return(1 || funcname || hash || result7 || libp) ;
05254 }
05255 
05256 static int G__G__Proof_135_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05257 {
05258       G__letint(result7, 105, (long) TDataSetManagerFile::DeclFileLine());
05259    return(1 || funcname || hash || result7 || libp) ;
05260 }
05261 
05262 // automatic destructor
05263 typedef TDataSetManagerFile G__TTDataSetManagerFile;
05264 static int G__G__Proof_135_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05265 {
05266    char* gvp = (char*) G__getgvp();
05267    long soff = G__getstructoffset();
05268    int n = G__getaryconstruct();
05269    //
05270    //has_a_delete: 1
05271    //has_own_delete1arg: 0
05272    //has_own_delete2arg: 0
05273    //
05274    if (!soff) {
05275      return(1);
05276    }
05277    if (n) {
05278      if (gvp == (char*)G__PVOID) {
05279        delete[] (TDataSetManagerFile*) soff;
05280      } else {
05281        G__setgvp((long) G__PVOID);
05282        for (int i = n - 1; i >= 0; --i) {
05283          ((TDataSetManagerFile*) (soff+(sizeof(TDataSetManagerFile)*i)))->~G__TTDataSetManagerFile();
05284        }
05285        G__setgvp((long)gvp);
05286      }
05287    } else {
05288      if (gvp == (char*)G__PVOID) {
05289        delete (TDataSetManagerFile*) soff;
05290      } else {
05291        G__setgvp((long) G__PVOID);
05292        ((TDataSetManagerFile*) (soff))->~G__TTDataSetManagerFile();
05293        G__setgvp((long)gvp);
05294      }
05295    }
05296    G__setnull(result7);
05297    return(1 || funcname || hash || result7 || libp) ;
05298 }
05299 
05300 
05301 /* TDSet */
05302 static int G__G__Proof_138_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05303 {
05304    TDSet* p = NULL;
05305    char* gvp = (char*) G__getgvp();
05306    int n = G__getaryconstruct();
05307    if (n) {
05308      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05309        p = new TDSet[n];
05310      } else {
05311        p = new((void*) gvp) TDSet[n];
05312      }
05313    } else {
05314      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05315        p = new TDSet;
05316      } else {
05317        p = new((void*) gvp) TDSet;
05318      }
05319    }
05320    result7->obj.i = (long) p;
05321    result7->ref = (long) p;
05322    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TDSet));
05323    return(1 || funcname || hash || result7 || libp) ;
05324 }
05325 
05326 static int G__G__Proof_138_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05327 {
05328    TDSet* p = NULL;
05329    char* gvp = (char*) G__getgvp();
05330    switch (libp->paran) {
05331    case 4:
05332      //m: 4
05333      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05334        p = new TDSet(
05335 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05336 , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
05337      } else {
05338        p = new((void*) gvp) TDSet(
05339 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05340 , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
05341      }
05342      break;
05343    case 3:
05344      //m: 3
05345      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05346        p = new TDSet(
05347 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05348 , (const char*) G__int(libp->para[2]));
05349      } else {
05350        p = new((void*) gvp) TDSet(
05351 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05352 , (const char*) G__int(libp->para[2]));
05353      }
05354      break;
05355    case 2:
05356      //m: 2
05357      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05358        p = new TDSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
05359      } else {
05360        p = new((void*) gvp) TDSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
05361      }
05362      break;
05363    case 1:
05364      //m: 1
05365      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05366        p = new TDSet((const char*) G__int(libp->para[0]));
05367      } else {
05368        p = new((void*) gvp) TDSet((const char*) G__int(libp->para[0]));
05369      }
05370      break;
05371    }
05372    result7->obj.i = (long) p;
05373    result7->ref = (long) p;
05374    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TDSet));
05375    return(1 || funcname || hash || result7 || libp) ;
05376 }
05377 
05378 static int G__G__Proof_138_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05379 {
05380    TDSet* p = NULL;
05381    char* gvp = (char*) G__getgvp();
05382    switch (libp->paran) {
05383    case 2:
05384      //m: 2
05385      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05386        p = new TDSet(*(TChain*) libp->para[0].ref, (Bool_t) G__int(libp->para[1]));
05387      } else {
05388        p = new((void*) gvp) TDSet(*(TChain*) libp->para[0].ref, (Bool_t) G__int(libp->para[1]));
05389      }
05390      break;
05391    case 1:
05392      //m: 1
05393      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05394        p = new TDSet(*(TChain*) libp->para[0].ref);
05395      } else {
05396        p = new((void*) gvp) TDSet(*(TChain*) libp->para[0].ref);
05397      }
05398      break;
05399    }
05400    result7->obj.i = (long) p;
05401    result7->ref = (long) p;
05402    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TDSet));
05403    return(1 || funcname || hash || result7 || libp) ;
05404 }
05405 
05406 static int G__G__Proof_138_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05407 {
05408    switch (libp->paran) {
05409    case 6:
05410       G__letint(result7, 103, (long) ((TDSet*) G__getstructoffset())->Add((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05411 , (const char*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
05412 , (Long64_t) G__Longlong(libp->para[4]), (const char*) G__int(libp->para[5])));
05413       break;
05414    case 5:
05415       G__letint(result7, 103, (long) ((TDSet*) G__getstructoffset())->Add((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05416 , (const char*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
05417 , (Long64_t) G__Longlong(libp->para[4])));
05418       break;
05419    case 4:
05420       G__letint(result7, 103, (long) ((TDSet*) G__getstructoffset())->Add((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05421 , (const char*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
05422       break;
05423    case 3:
05424       G__letint(result7, 103, (long) ((TDSet*) G__getstructoffset())->Add((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05425 , (const char*) G__int(libp->para[2])));
05426       break;
05427    case 2:
05428       G__letint(result7, 103, (long) ((TDSet*) G__getstructoffset())->Add((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
05429       break;
05430    case 1:
05431       G__letint(result7, 103, (long) ((TDSet*) G__getstructoffset())->Add((const char*) G__int(libp->para[0])));
05432       break;
05433    }
05434    return(1 || funcname || hash || result7 || libp) ;
05435 }
05436 
05437 static int G__G__Proof_138_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05438 {
05439       G__letint(result7, 103, (long) ((TDSet*) G__getstructoffset())->Add((TDSet*) G__int(libp->para[0])));
05440    return(1 || funcname || hash || result7 || libp) ;
05441 }
05442 
05443 static int G__G__Proof_138_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05444 {
05445    switch (libp->paran) {
05446    case 4:
05447       G__letint(result7, 103, (long) ((TDSet*) G__getstructoffset())->Add((TCollection*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05448 , (Bool_t) G__int(libp->para[2]), (TCollection*) G__int(libp->para[3])));
05449       break;
05450    case 3:
05451       G__letint(result7, 103, (long) ((TDSet*) G__getstructoffset())->Add((TCollection*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05452 , (Bool_t) G__int(libp->para[2])));
05453       break;
05454    case 2:
05455       G__letint(result7, 103, (long) ((TDSet*) G__getstructoffset())->Add((TCollection*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
05456       break;
05457    case 1:
05458       G__letint(result7, 103, (long) ((TDSet*) G__getstructoffset())->Add((TCollection*) G__int(libp->para[0])));
05459       break;
05460    }
05461    return(1 || funcname || hash || result7 || libp) ;
05462 }
05463 
05464 static int G__G__Proof_138_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05465 {
05466    switch (libp->paran) {
05467    case 2:
05468       G__letint(result7, 103, (long) ((TDSet*) G__getstructoffset())->Add((TFileInfo*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
05469       break;
05470    case 1:
05471       G__letint(result7, 103, (long) ((TDSet*) G__getstructoffset())->Add((TFileInfo*) G__int(libp->para[0])));
05472       break;
05473    }
05474    return(1 || funcname || hash || result7 || libp) ;
05475 }
05476 
05477 static int G__G__Proof_138_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05478 {
05479       ((TDSet*) G__getstructoffset())->AddFriend((TDSet*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
05480       G__setnull(result7);
05481    return(1 || funcname || hash || result7 || libp) ;
05482 }
05483 
05484 static int G__G__Proof_138_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05485 {
05486    switch (libp->paran) {
05487    case 5:
05488       G__letLonglong(result7, 110, (G__int64) ((TDSet*) G__getstructoffset())->Process((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
05489 , (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
05490 , (TObject*) G__int(libp->para[4])));
05491       break;
05492    case 4:
05493       G__letLonglong(result7, 110, (G__int64) ((TDSet*) G__getstructoffset())->Process((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
05494 , (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
05495       break;
05496    case 3:
05497       G__letLonglong(result7, 110, (G__int64) ((TDSet*) G__getstructoffset())->Process((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
05498 , (Long64_t) G__Longlong(libp->para[2])));
05499       break;
05500    case 2:
05501       G__letLonglong(result7, 110, (G__int64) ((TDSet*) G__getstructoffset())->Process((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
05502       break;
05503    case 1:
05504       G__letLonglong(result7, 110, (G__int64) ((TDSet*) G__getstructoffset())->Process((const char*) G__int(libp->para[0])));
05505       break;
05506    }
05507    return(1 || funcname || hash || result7 || libp) ;
05508 }
05509 
05510 static int G__G__Proof_138_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05511 {
05512    switch (libp->paran) {
05513    case 5:
05514       G__letLonglong(result7, 110, (G__int64) ((TDSet*) G__getstructoffset())->Draw((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05515 , (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
05516 , (Long64_t) G__Longlong(libp->para[4])));
05517       break;
05518    case 4:
05519       G__letLonglong(result7, 110, (G__int64) ((TDSet*) G__getstructoffset())->Draw((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05520 , (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
05521       break;
05522    case 3:
05523       G__letLonglong(result7, 110, (G__int64) ((TDSet*) G__getstructoffset())->Draw((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05524 , (Option_t*) G__int(libp->para[2])));
05525       break;
05526    case 2:
05527       G__letLonglong(result7, 110, (G__int64) ((TDSet*) G__getstructoffset())->Draw((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
05528       break;
05529    }
05530    return(1 || funcname || hash || result7 || libp) ;
05531 }
05532 
05533 static int G__G__Proof_138_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05534 {
05535    switch (libp->paran) {
05536    case 5:
05537       G__letLonglong(result7, 110, (G__int64) ((TDSet*) G__getstructoffset())->Draw((const char*) G__int(libp->para[0]), *(TCut*) libp->para[1].ref
05538 , (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
05539 , (Long64_t) G__Longlong(libp->para[4])));
05540       break;
05541    case 4:
05542       G__letLonglong(result7, 110, (G__int64) ((TDSet*) G__getstructoffset())->Draw((const char*) G__int(libp->para[0]), *(TCut*) libp->para[1].ref
05543 , (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
05544       break;
05545    case 3:
05546       G__letLonglong(result7, 110, (G__int64) ((TDSet*) G__getstructoffset())->Draw((const char*) G__int(libp->para[0]), *(TCut*) libp->para[1].ref
05547 , (Option_t*) G__int(libp->para[2])));
05548       break;
05549    case 2:
05550       G__letLonglong(result7, 110, (G__int64) ((TDSet*) G__getstructoffset())->Draw((const char*) G__int(libp->para[0]), *(TCut*) libp->para[1].ref));
05551       break;
05552    }
05553    return(1 || funcname || hash || result7 || libp) ;
05554 }
05555 
05556 static int G__G__Proof_138_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05557 {
05558    switch (libp->paran) {
05559    case 2:
05560       G__letint(result7, 105, (long) ((TDSet*) G__getstructoffset())->ExportFileList((const char*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
05561       break;
05562    case 1:
05563       G__letint(result7, 105, (long) ((TDSet*) G__getstructoffset())->ExportFileList((const char*) G__int(libp->para[0])));
05564       break;
05565    }
05566    return(1 || funcname || hash || result7 || libp) ;
05567 }
05568 
05569 static int G__G__Proof_138_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05570 {
05571       ((TDSet*) G__getstructoffset())->SetObjName((const char*) G__int(libp->para[0]));
05572       G__setnull(result7);
05573    return(1 || funcname || hash || result7 || libp) ;
05574 }
05575 
05576 static int G__G__Proof_138_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05577 {
05578       ((TDSet*) G__getstructoffset())->SetDirectory((const char*) G__int(libp->para[0]));
05579       G__setnull(result7);
05580    return(1 || funcname || hash || result7 || libp) ;
05581 }
05582 
05583 static int G__G__Proof_138_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05584 {
05585       G__letint(result7, 103, (long) ((const TDSet*) G__getstructoffset())->IsTree());
05586    return(1 || funcname || hash || result7 || libp) ;
05587 }
05588 
05589 static int G__G__Proof_138_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05590 {
05591       G__letint(result7, 103, (long) ((const TDSet*) G__getstructoffset())->IsValid());
05592    return(1 || funcname || hash || result7 || libp) ;
05593 }
05594 
05595 static int G__G__Proof_138_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05596 {
05597       G__letint(result7, 103, (long) ((TDSet*) G__getstructoffset())->ElementsValid());
05598    return(1 || funcname || hash || result7 || libp) ;
05599 }
05600 
05601 static int G__G__Proof_138_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05602 {
05603       G__letint(result7, 67, (long) ((const TDSet*) G__getstructoffset())->GetType());
05604    return(1 || funcname || hash || result7 || libp) ;
05605 }
05606 
05607 static int G__G__Proof_138_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05608 {
05609       G__letint(result7, 67, (long) ((const TDSet*) G__getstructoffset())->GetObjName());
05610    return(1 || funcname || hash || result7 || libp) ;
05611 }
05612 
05613 static int G__G__Proof_138_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05614 {
05615       G__letint(result7, 67, (long) ((const TDSet*) G__getstructoffset())->GetDirectory());
05616    return(1 || funcname || hash || result7 || libp) ;
05617 }
05618 
05619 static int G__G__Proof_138_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05620 {
05621       G__letint(result7, 85, (long) ((const TDSet*) G__getstructoffset())->GetListOfElements());
05622    return(1 || funcname || hash || result7 || libp) ;
05623 }
05624 
05625 static int G__G__Proof_138_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05626 {
05627       G__letint(result7, 105, (long) ((TDSet*) G__getstructoffset())->GetNumOfFiles());
05628    return(1 || funcname || hash || result7 || libp) ;
05629 }
05630 
05631 static int G__G__Proof_138_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05632 {
05633    switch (libp->paran) {
05634    case 2:
05635       G__letint(result7, 105, (long) ((TDSet*) G__getstructoffset())->Remove((TDSetElement*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
05636       break;
05637    case 1:
05638       G__letint(result7, 105, (long) ((TDSet*) G__getstructoffset())->Remove((TDSetElement*) G__int(libp->para[0])));
05639       break;
05640    }
05641    return(1 || funcname || hash || result7 || libp) ;
05642 }
05643 
05644 static int G__G__Proof_138_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05645 {
05646       ((TDSet*) G__getstructoffset())->Reset();
05647       G__setnull(result7);
05648    return(1 || funcname || hash || result7 || libp) ;
05649 }
05650 
05651 static int G__G__Proof_138_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05652 {
05653    switch (libp->paran) {
05654    case 1:
05655       G__letint(result7, 85, (long) ((TDSet*) G__getstructoffset())->Next((Long64_t) G__Longlong(libp->para[0])));
05656       break;
05657    case 0:
05658       G__letint(result7, 85, (long) ((TDSet*) G__getstructoffset())->Next());
05659       break;
05660    }
05661    return(1 || funcname || hash || result7 || libp) ;
05662 }
05663 
05664 static int G__G__Proof_138_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05665 {
05666       G__letint(result7, 85, (long) ((const TDSet*) G__getstructoffset())->Current());
05667    return(1 || funcname || hash || result7 || libp) ;
05668 }
05669 
05670 static int G__G__Proof_138_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05671 {
05672       G__letLonglong(result7, 110, (G__int64) TDSet::GetEntries((Bool_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05673 , (const char*) G__int(libp->para[2]), *(TString*) libp->para[3].ref));
05674    return(1 || funcname || hash || result7 || libp) ;
05675 }
05676 
05677 static int G__G__Proof_138_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05678 {
05679       ((TDSet*) G__getstructoffset())->AddInput((TObject*) G__int(libp->para[0]));
05680       G__setnull(result7);
05681    return(1 || funcname || hash || result7 || libp) ;
05682 }
05683 
05684 static int G__G__Proof_138_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05685 {
05686       ((TDSet*) G__getstructoffset())->ClearInput();
05687       G__setnull(result7);
05688    return(1 || funcname || hash || result7 || libp) ;
05689 }
05690 
05691 static int G__G__Proof_138_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05692 {
05693       G__letint(result7, 85, (long) ((TDSet*) G__getstructoffset())->GetOutput((const char*) G__int(libp->para[0])));
05694    return(1 || funcname || hash || result7 || libp) ;
05695 }
05696 
05697 static int G__G__Proof_138_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05698 {
05699       G__letint(result7, 85, (long) ((TDSet*) G__getstructoffset())->GetOutputList());
05700    return(1 || funcname || hash || result7 || libp) ;
05701 }
05702 
05703 static int G__G__Proof_138_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05704 {
05705       ((TDSet*) G__getstructoffset())->StartViewer();
05706       G__setnull(result7);
05707    return(1 || funcname || hash || result7 || libp) ;
05708 }
05709 
05710 static int G__G__Proof_138_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05711 {
05712       G__letint(result7, 85, (long) ((TDSet*) G__getstructoffset())->GetTreeHeader((TProof*) G__int(libp->para[0])));
05713    return(1 || funcname || hash || result7 || libp) ;
05714 }
05715 
05716 static int G__G__Proof_138_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05717 {
05718       ((TDSet*) G__getstructoffset())->SetEntryList((TObject*) G__int(libp->para[0]));
05719       G__setnull(result7);
05720    return(1 || funcname || hash || result7 || libp) ;
05721 }
05722 
05723 static int G__G__Proof_138_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05724 {
05725       G__letint(result7, 85, (long) ((const TDSet*) G__getstructoffset())->GetEntryList());
05726    return(1 || funcname || hash || result7 || libp) ;
05727 }
05728 
05729 static int G__G__Proof_138_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05730 {
05731       ((TDSet*) G__getstructoffset())->Validate();
05732       G__setnull(result7);
05733    return(1 || funcname || hash || result7 || libp) ;
05734 }
05735 
05736 static int G__G__Proof_138_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05737 {
05738       ((TDSet*) G__getstructoffset())->Validate((TDSet*) G__int(libp->para[0]));
05739       G__setnull(result7);
05740    return(1 || funcname || hash || result7 || libp) ;
05741 }
05742 
05743 static int G__G__Proof_138_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05744 {
05745    switch (libp->paran) {
05746    case 2:
05747       ((TDSet*) G__getstructoffset())->Lookup((Bool_t) G__int(libp->para[0]), (TList**) G__int(libp->para[1]));
05748       G__setnull(result7);
05749       break;
05750    case 1:
05751       ((TDSet*) G__getstructoffset())->Lookup((Bool_t) G__int(libp->para[0]));
05752       G__setnull(result7);
05753       break;
05754    case 0:
05755       ((TDSet*) G__getstructoffset())->Lookup();
05756       G__setnull(result7);
05757       break;
05758    }
05759    return(1 || funcname || hash || result7 || libp) ;
05760 }
05761 
05762 static int G__G__Proof_138_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05763 {
05764       ((TDSet*) G__getstructoffset())->SetLookedUp();
05765       G__setnull(result7);
05766    return(1 || funcname || hash || result7 || libp) ;
05767 }
05768 
05769 static int G__G__Proof_138_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05770 {
05771    switch (libp->paran) {
05772    case 1:
05773       ((TDSet*) G__getstructoffset())->SetSrvMaps((TList*) G__int(libp->para[0]));
05774       G__setnull(result7);
05775       break;
05776    case 0:
05777       ((TDSet*) G__getstructoffset())->SetSrvMaps();
05778       G__setnull(result7);
05779       break;
05780    }
05781    return(1 || funcname || hash || result7 || libp) ;
05782 }
05783 
05784 static int G__G__Proof_138_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05785 {
05786    switch (libp->paran) {
05787    case 1:
05788       ((TDSet*) G__getstructoffset())->SetWriteV3((Bool_t) G__int(libp->para[0]));
05789       G__setnull(result7);
05790       break;
05791    case 0:
05792       ((TDSet*) G__getstructoffset())->SetWriteV3();
05793       G__setnull(result7);
05794       break;
05795    }
05796    return(1 || funcname || hash || result7 || libp) ;
05797 }
05798 
05799 static int G__G__Proof_138_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05800 {
05801       G__letint(result7, 85, (long) TDSet::Class());
05802    return(1 || funcname || hash || result7 || libp) ;
05803 }
05804 
05805 static int G__G__Proof_138_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05806 {
05807       G__letint(result7, 67, (long) TDSet::Class_Name());
05808    return(1 || funcname || hash || result7 || libp) ;
05809 }
05810 
05811 static int G__G__Proof_138_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05812 {
05813       G__letint(result7, 115, (long) TDSet::Class_Version());
05814    return(1 || funcname || hash || result7 || libp) ;
05815 }
05816 
05817 static int G__G__Proof_138_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05818 {
05819       TDSet::Dictionary();
05820       G__setnull(result7);
05821    return(1 || funcname || hash || result7 || libp) ;
05822 }
05823 
05824 static int G__G__Proof_138_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05825 {
05826       ((TDSet*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05827       G__setnull(result7);
05828    return(1 || funcname || hash || result7 || libp) ;
05829 }
05830 
05831 static int G__G__Proof_138_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05832 {
05833       G__letint(result7, 67, (long) TDSet::DeclFileName());
05834    return(1 || funcname || hash || result7 || libp) ;
05835 }
05836 
05837 static int G__G__Proof_138_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05838 {
05839       G__letint(result7, 105, (long) TDSet::ImplFileLine());
05840    return(1 || funcname || hash || result7 || libp) ;
05841 }
05842 
05843 static int G__G__Proof_138_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05844 {
05845       G__letint(result7, 67, (long) TDSet::ImplFileName());
05846    return(1 || funcname || hash || result7 || libp) ;
05847 }
05848 
05849 static int G__G__Proof_138_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05850 {
05851       G__letint(result7, 105, (long) TDSet::DeclFileLine());
05852    return(1 || funcname || hash || result7 || libp) ;
05853 }
05854 
05855 // automatic destructor
05856 typedef TDSet G__TTDSet;
05857 static int G__G__Proof_138_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05858 {
05859    char* gvp = (char*) G__getgvp();
05860    long soff = G__getstructoffset();
05861    int n = G__getaryconstruct();
05862    //
05863    //has_a_delete: 1
05864    //has_own_delete1arg: 0
05865    //has_own_delete2arg: 0
05866    //
05867    if (!soff) {
05868      return(1);
05869    }
05870    if (n) {
05871      if (gvp == (char*)G__PVOID) {
05872        delete[] (TDSet*) soff;
05873      } else {
05874        G__setgvp((long) G__PVOID);
05875        for (int i = n - 1; i >= 0; --i) {
05876          ((TDSet*) (soff+(sizeof(TDSet)*i)))->~G__TTDSet();
05877        }
05878        G__setgvp((long)gvp);
05879      }
05880    } else {
05881      if (gvp == (char*)G__PVOID) {
05882        delete (TDSet*) soff;
05883      } else {
05884        G__setgvp((long) G__PVOID);
05885        ((TDSet*) (soff))->~G__TTDSet();
05886        G__setgvp((long)gvp);
05887      }
05888    }
05889    G__setnull(result7);
05890    return(1 || funcname || hash || result7 || libp) ;
05891 }
05892 
05893 
05894 /* TProof */
05895 static int G__G__Proof_142_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05896 {
05897    TProof* p = NULL;
05898    char* gvp = (char*) G__getgvp();
05899    switch (libp->paran) {
05900    case 6:
05901      //m: 6
05902      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05903        p = new TProof(
05904 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05905 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
05906 , (const char*) G__int(libp->para[4]), (TProofMgr*) G__int(libp->para[5]));
05907      } else {
05908        p = new((void*) gvp) TProof(
05909 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05910 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
05911 , (const char*) G__int(libp->para[4]), (TProofMgr*) G__int(libp->para[5]));
05912      }
05913      break;
05914    case 5:
05915      //m: 5
05916      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05917        p = new TProof(
05918 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05919 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
05920 , (const char*) G__int(libp->para[4]));
05921      } else {
05922        p = new((void*) gvp) TProof(
05923 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05924 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
05925 , (const char*) G__int(libp->para[4]));
05926      }
05927      break;
05928    case 4:
05929      //m: 4
05930      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05931        p = new TProof(
05932 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05933 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
05934      } else {
05935        p = new((void*) gvp) TProof(
05936 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05937 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
05938      }
05939      break;
05940    case 3:
05941      //m: 3
05942      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05943        p = new TProof(
05944 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05945 , (const char*) G__int(libp->para[2]));
05946      } else {
05947        p = new((void*) gvp) TProof(
05948 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05949 , (const char*) G__int(libp->para[2]));
05950      }
05951      break;
05952    case 2:
05953      //m: 2
05954      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05955        p = new TProof((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
05956      } else {
05957        p = new((void*) gvp) TProof((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
05958      }
05959      break;
05960    case 1:
05961      //m: 1
05962      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05963        p = new TProof((const char*) G__int(libp->para[0]));
05964      } else {
05965        p = new((void*) gvp) TProof((const char*) G__int(libp->para[0]));
05966      }
05967      break;
05968    }
05969    result7->obj.i = (long) p;
05970    result7->ref = (long) p;
05971    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProof));
05972    return(1 || funcname || hash || result7 || libp) ;
05973 }
05974 
05975 static int G__G__Proof_142_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05976 {
05977    switch (libp->paran) {
05978    case 1:
05979       ((TProof*) G__getstructoffset())->cd((Int_t) G__int(libp->para[0]));
05980       G__setnull(result7);
05981       break;
05982    case 0:
05983       ((TProof*) G__getstructoffset())->cd();
05984       G__setnull(result7);
05985       break;
05986    }
05987    return(1 || funcname || hash || result7 || libp) ;
05988 }
05989 
05990 static int G__G__Proof_142_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05991 {
05992       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->Ping());
05993    return(1 || funcname || hash || result7 || libp) ;
05994 }
05995 
05996 static int G__G__Proof_142_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05997 {
05998       ((TProof*) G__getstructoffset())->Touch();
05999       G__setnull(result7);
06000    return(1 || funcname || hash || result7 || libp) ;
06001 }
06002 
06003 static int G__G__Proof_142_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06004 {
06005    switch (libp->paran) {
06006    case 2:
06007       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->Exec((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
06008       break;
06009    case 1:
06010       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->Exec((const char*) G__int(libp->para[0])));
06011       break;
06012    }
06013    return(1 || funcname || hash || result7 || libp) ;
06014 }
06015 
06016 static int G__G__Proof_142_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06017 {
06018    switch (libp->paran) {
06019    case 5:
06020       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->Process((TDSet*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06021 , (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
06022 , (Long64_t) G__Longlong(libp->para[4])));
06023       break;
06024    case 4:
06025       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->Process((TDSet*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06026 , (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
06027       break;
06028    case 3:
06029       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->Process((TDSet*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06030 , (Option_t*) G__int(libp->para[2])));
06031       break;
06032    case 2:
06033       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->Process((TDSet*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06034       break;
06035    }
06036    return(1 || funcname || hash || result7 || libp) ;
06037 }
06038 
06039 static int G__G__Proof_142_0_126(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06040 {
06041    switch (libp->paran) {
06042    case 5:
06043       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->Process((TFileCollection*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06044 , (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
06045 , (Long64_t) G__Longlong(libp->para[4])));
06046       break;
06047    case 4:
06048       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->Process((TFileCollection*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06049 , (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
06050       break;
06051    case 3:
06052       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->Process((TFileCollection*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06053 , (Option_t*) G__int(libp->para[2])));
06054       break;
06055    case 2:
06056       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->Process((TFileCollection*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06057       break;
06058    }
06059    return(1 || funcname || hash || result7 || libp) ;
06060 }
06061 
06062 static int G__G__Proof_142_0_127(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06063 {
06064    switch (libp->paran) {
06065    case 6:
06066       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->Process((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06067 , (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
06068 , (Long64_t) G__Longlong(libp->para[4]), (TObject*) G__int(libp->para[5])));
06069       break;
06070    case 5:
06071       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->Process((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06072 , (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
06073 , (Long64_t) G__Longlong(libp->para[4])));
06074       break;
06075    case 4:
06076       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->Process((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06077 , (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
06078       break;
06079    case 3:
06080       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->Process((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06081 , (Option_t*) G__int(libp->para[2])));
06082       break;
06083    case 2:
06084       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->Process((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06085       break;
06086    }
06087    return(1 || funcname || hash || result7 || libp) ;
06088 }
06089 
06090 static int G__G__Proof_142_0_128(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06091 {
06092    switch (libp->paran) {
06093    case 3:
06094       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->Process((const char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
06095 , (Option_t*) G__int(libp->para[2])));
06096       break;
06097    case 2:
06098       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->Process((const char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])));
06099       break;
06100    }
06101    return(1 || funcname || hash || result7 || libp) ;
06102 }
06103 
06104 static int G__G__Proof_142_0_129(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06105 {
06106    switch (libp->paran) {
06107    case 6:
06108       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->DrawSelect((TDSet*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06109 , (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])
06110 , (Long64_t) G__Longlong(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])));
06111       break;
06112    case 5:
06113       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->DrawSelect((TDSet*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06114 , (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])
06115 , (Long64_t) G__Longlong(libp->para[4])));
06116       break;
06117    case 4:
06118       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->DrawSelect((TDSet*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06119 , (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])));
06120       break;
06121    case 3:
06122       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->DrawSelect((TDSet*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06123 , (const char*) G__int(libp->para[2])));
06124       break;
06125    case 2:
06126       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->DrawSelect((TDSet*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06127       break;
06128    }
06129    return(1 || funcname || hash || result7 || libp) ;
06130 }
06131 
06132 static int G__G__Proof_142_0_130(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06133 {
06134    switch (libp->paran) {
06135    case 7:
06136       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->DrawSelect(
06137 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06138 , (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])
06139 , (Long64_t) G__Longlong(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])
06140 , (TObject*) G__int(libp->para[6])));
06141       break;
06142    case 6:
06143       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->DrawSelect((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06144 , (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])
06145 , (Long64_t) G__Longlong(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])));
06146       break;
06147    case 5:
06148       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->DrawSelect((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06149 , (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])
06150 , (Long64_t) G__Longlong(libp->para[4])));
06151       break;
06152    case 4:
06153       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->DrawSelect((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06154 , (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])));
06155       break;
06156    case 3:
06157       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->DrawSelect((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06158 , (const char*) G__int(libp->para[2])));
06159       break;
06160    case 2:
06161       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->DrawSelect((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06162       break;
06163    }
06164    return(1 || funcname || hash || result7 || libp) ;
06165 }
06166 
06167 static int G__G__Proof_142_0_131(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06168 {
06169       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->Archive((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06170    return(1 || funcname || hash || result7 || libp) ;
06171 }
06172 
06173 static int G__G__Proof_142_0_132(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06174 {
06175    switch (libp->paran) {
06176    case 2:
06177       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->Archive((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06178       break;
06179    case 1:
06180       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->Archive((const char*) G__int(libp->para[0])));
06181       break;
06182    }
06183    return(1 || funcname || hash || result7 || libp) ;
06184 }
06185 
06186 static int G__G__Proof_142_0_133(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06187 {
06188       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->CleanupSession((const char*) G__int(libp->para[0])));
06189    return(1 || funcname || hash || result7 || libp) ;
06190 }
06191 
06192 static int G__G__Proof_142_0_134(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06193 {
06194    switch (libp->paran) {
06195    case 2:
06196       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->Finalize((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
06197       break;
06198    case 1:
06199       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->Finalize((Int_t) G__int(libp->para[0])));
06200       break;
06201    case 0:
06202       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->Finalize());
06203       break;
06204    }
06205    return(1 || funcname || hash || result7 || libp) ;
06206 }
06207 
06208 static int G__G__Proof_142_0_135(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06209 {
06210    switch (libp->paran) {
06211    case 2:
06212       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->Finalize((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
06213       break;
06214    case 1:
06215       G__letLonglong(result7, 110, (G__int64) ((TProof*) G__getstructoffset())->Finalize((const char*) G__int(libp->para[0])));
06216       break;
06217    }
06218    return(1 || funcname || hash || result7 || libp) ;
06219 }
06220 
06221 static int G__G__Proof_142_0_136(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06222 {
06223    switch (libp->paran) {
06224    case 2:
06225       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->Remove((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
06226       break;
06227    case 1:
06228       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->Remove((Int_t) G__int(libp->para[0])));
06229       break;
06230    }
06231    return(1 || funcname || hash || result7 || libp) ;
06232 }
06233 
06234 static int G__G__Proof_142_0_137(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06235 {
06236    switch (libp->paran) {
06237    case 2:
06238       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->Remove((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
06239       break;
06240    case 1:
06241       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->Remove((const char*) G__int(libp->para[0])));
06242       break;
06243    }
06244    return(1 || funcname || hash || result7 || libp) ;
06245 }
06246 
06247 static int G__G__Proof_142_0_138(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06248 {
06249    switch (libp->paran) {
06250    case 2:
06251       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->Retrieve((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06252       break;
06253    case 1:
06254       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->Retrieve((Int_t) G__int(libp->para[0])));
06255       break;
06256    }
06257    return(1 || funcname || hash || result7 || libp) ;
06258 }
06259 
06260 static int G__G__Proof_142_0_139(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06261 {
06262    switch (libp->paran) {
06263    case 2:
06264       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->Retrieve((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06265       break;
06266    case 1:
06267       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->Retrieve((const char*) G__int(libp->para[0])));
06268       break;
06269    }
06270    return(1 || funcname || hash || result7 || libp) ;
06271 }
06272 
06273 static int G__G__Proof_142_0_140(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06274 {
06275       ((TProof*) G__getstructoffset())->DisableGoAsyn();
06276       G__setnull(result7);
06277    return(1 || funcname || hash || result7 || libp) ;
06278 }
06279 
06280 static int G__G__Proof_142_0_141(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06281 {
06282       ((TProof*) G__getstructoffset())->GoAsynchronous();
06283       G__setnull(result7);
06284    return(1 || funcname || hash || result7 || libp) ;
06285 }
06286 
06287 static int G__G__Proof_142_0_142(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06288 {
06289    switch (libp->paran) {
06290    case 2:
06291       ((TProof*) G__getstructoffset())->StopProcess((Bool_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
06292       G__setnull(result7);
06293       break;
06294    case 1:
06295       ((TProof*) G__getstructoffset())->StopProcess((Bool_t) G__int(libp->para[0]));
06296       G__setnull(result7);
06297       break;
06298    }
06299    return(1 || funcname || hash || result7 || libp) ;
06300 }
06301 
06302 static int G__G__Proof_142_0_144(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06303 {
06304    switch (libp->paran) {
06305    case 2:
06306       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->SetParallel((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
06307       break;
06308    case 1:
06309       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->SetParallel((Int_t) G__int(libp->para[0])));
06310       break;
06311    case 0:
06312       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->SetParallel());
06313       break;
06314    }
06315    return(1 || funcname || hash || result7 || libp) ;
06316 }
06317 
06318 static int G__G__Proof_142_0_145(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06319 {
06320    switch (libp->paran) {
06321    case 2:
06322       ((TProof*) G__getstructoffset())->SetLogLevel((Int_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
06323       G__setnull(result7);
06324       break;
06325    case 1:
06326       ((TProof*) G__getstructoffset())->SetLogLevel((Int_t) G__int(libp->para[0]));
06327       G__setnull(result7);
06328       break;
06329    }
06330    return(1 || funcname || hash || result7 || libp) ;
06331 }
06332 
06333 static int G__G__Proof_142_0_146(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06334 {
06335    switch (libp->paran) {
06336    case 1:
06337       ((TProof*) G__getstructoffset())->Close((Option_t*) G__int(libp->para[0]));
06338       G__setnull(result7);
06339       break;
06340    case 0:
06341       ((TProof*) G__getstructoffset())->Close();
06342       G__setnull(result7);
06343       break;
06344    }
06345    return(1 || funcname || hash || result7 || libp) ;
06346 }
06347 
06348 static int G__G__Proof_142_0_148(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06349 {
06350    switch (libp->paran) {
06351    case 1:
06352       ((TProof*) G__getstructoffset())->ShowCache((Bool_t) G__int(libp->para[0]));
06353       G__setnull(result7);
06354       break;
06355    case 0:
06356       ((TProof*) G__getstructoffset())->ShowCache();
06357       G__setnull(result7);
06358       break;
06359    }
06360    return(1 || funcname || hash || result7 || libp) ;
06361 }
06362 
06363 static int G__G__Proof_142_0_149(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06364 {
06365    switch (libp->paran) {
06366    case 1:
06367       ((TProof*) G__getstructoffset())->ClearCache((const char*) G__int(libp->para[0]));
06368       G__setnull(result7);
06369       break;
06370    case 0:
06371       ((TProof*) G__getstructoffset())->ClearCache();
06372       G__setnull(result7);
06373       break;
06374    }
06375    return(1 || funcname || hash || result7 || libp) ;
06376 }
06377 
06378 static int G__G__Proof_142_0_150(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06379 {
06380       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetListOfPackages());
06381    return(1 || funcname || hash || result7 || libp) ;
06382 }
06383 
06384 static int G__G__Proof_142_0_151(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06385 {
06386       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetListOfEnabledPackages());
06387    return(1 || funcname || hash || result7 || libp) ;
06388 }
06389 
06390 static int G__G__Proof_142_0_152(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06391 {
06392    switch (libp->paran) {
06393    case 2:
06394       ((TProof*) G__getstructoffset())->ShowPackages((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
06395       G__setnull(result7);
06396       break;
06397    case 1:
06398       ((TProof*) G__getstructoffset())->ShowPackages((Bool_t) G__int(libp->para[0]));
06399       G__setnull(result7);
06400       break;
06401    case 0:
06402       ((TProof*) G__getstructoffset())->ShowPackages();
06403       G__setnull(result7);
06404       break;
06405    }
06406    return(1 || funcname || hash || result7 || libp) ;
06407 }
06408 
06409 static int G__G__Proof_142_0_153(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06410 {
06411    switch (libp->paran) {
06412    case 1:
06413       ((TProof*) G__getstructoffset())->ShowEnabledPackages((Bool_t) G__int(libp->para[0]));
06414       G__setnull(result7);
06415       break;
06416    case 0:
06417       ((TProof*) G__getstructoffset())->ShowEnabledPackages();
06418       G__setnull(result7);
06419       break;
06420    }
06421    return(1 || funcname || hash || result7 || libp) ;
06422 }
06423 
06424 static int G__G__Proof_142_0_154(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06425 {
06426       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->ClearPackages());
06427    return(1 || funcname || hash || result7 || libp) ;
06428 }
06429 
06430 static int G__G__Proof_142_0_155(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06431 {
06432       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->ClearPackage((const char*) G__int(libp->para[0])));
06433    return(1 || funcname || hash || result7 || libp) ;
06434 }
06435 
06436 static int G__G__Proof_142_0_156(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06437 {
06438    switch (libp->paran) {
06439    case 2:
06440       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->DownloadPackage((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06441       break;
06442    case 1:
06443       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->DownloadPackage((const char*) G__int(libp->para[0])));
06444       break;
06445    }
06446    return(1 || funcname || hash || result7 || libp) ;
06447 }
06448 
06449 static int G__G__Proof_142_0_157(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06450 {
06451    switch (libp->paran) {
06452    case 2:
06453       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->EnablePackage((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
06454       break;
06455    case 1:
06456       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->EnablePackage((const char*) G__int(libp->para[0])));
06457       break;
06458    }
06459    return(1 || funcname || hash || result7 || libp) ;
06460 }
06461 
06462 static int G__G__Proof_142_0_158(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06463 {
06464    switch (libp->paran) {
06465    case 3:
06466       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->EnablePackage((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06467 , (Bool_t) G__int(libp->para[2])));
06468       break;
06469    case 2:
06470       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->EnablePackage((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06471       break;
06472    }
06473    return(1 || funcname || hash || result7 || libp) ;
06474 }
06475 
06476 static int G__G__Proof_142_0_159(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06477 {
06478    switch (libp->paran) {
06479    case 3:
06480       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->EnablePackage((const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
06481 , (Bool_t) G__int(libp->para[2])));
06482       break;
06483    case 2:
06484       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->EnablePackage((const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])));
06485       break;
06486    }
06487    return(1 || funcname || hash || result7 || libp) ;
06488 }
06489 
06490 static int G__G__Proof_142_0_160(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06491 {
06492    switch (libp->paran) {
06493    case 2:
06494       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->UploadPackage((const char*) G__int(libp->para[0]), (TProof::EUploadPackageOpt) G__int(libp->para[1])));
06495       break;
06496    case 1:
06497       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->UploadPackage((const char*) G__int(libp->para[0])));
06498       break;
06499    }
06500    return(1 || funcname || hash || result7 || libp) ;
06501 }
06502 
06503 static int G__G__Proof_142_0_161(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06504 {
06505    switch (libp->paran) {
06506    case 4:
06507       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->Load((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
06508 , (Bool_t) G__int(libp->para[2]), (TList*) G__int(libp->para[3])));
06509       break;
06510    case 3:
06511       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->Load((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
06512 , (Bool_t) G__int(libp->para[2])));
06513       break;
06514    case 2:
06515       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->Load((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
06516       break;
06517    case 1:
06518       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->Load((const char*) G__int(libp->para[0])));
06519       break;
06520    }
06521    return(1 || funcname || hash || result7 || libp) ;
06522 }
06523 
06524 static int G__G__Proof_142_0_162(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06525 {
06526    switch (libp->paran) {
06527    case 3:
06528       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->AddDynamicPath((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
06529 , (TList*) G__int(libp->para[2])));
06530       break;
06531    case 2:
06532       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->AddDynamicPath((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
06533       break;
06534    case 1:
06535       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->AddDynamicPath((const char*) G__int(libp->para[0])));
06536       break;
06537    }
06538    return(1 || funcname || hash || result7 || libp) ;
06539 }
06540 
06541 static int G__G__Proof_142_0_163(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06542 {
06543    switch (libp->paran) {
06544    case 3:
06545       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->AddIncludePath((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
06546 , (TList*) G__int(libp->para[2])));
06547       break;
06548    case 2:
06549       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->AddIncludePath((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
06550       break;
06551    case 1:
06552       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->AddIncludePath((const char*) G__int(libp->para[0])));
06553       break;
06554    }
06555    return(1 || funcname || hash || result7 || libp) ;
06556 }
06557 
06558 static int G__G__Proof_142_0_164(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06559 {
06560    switch (libp->paran) {
06561    case 2:
06562       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->RemoveDynamicPath((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
06563       break;
06564    case 1:
06565       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->RemoveDynamicPath((const char*) G__int(libp->para[0])));
06566       break;
06567    }
06568    return(1 || funcname || hash || result7 || libp) ;
06569 }
06570 
06571 static int G__G__Proof_142_0_165(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06572 {
06573    switch (libp->paran) {
06574    case 2:
06575       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->RemoveIncludePath((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
06576       break;
06577    case 1:
06578       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->RemoveIncludePath((const char*) G__int(libp->para[0])));
06579       break;
06580    }
06581    return(1 || funcname || hash || result7 || libp) ;
06582 }
06583 
06584 static int G__G__Proof_142_0_166(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06585 {
06586    switch (libp->paran) {
06587    case 5:
06588       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->UploadDataSet((const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
06589 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
06590 , (TList*) G__int(libp->para[4])));
06591       break;
06592    case 4:
06593       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->UploadDataSet((const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
06594 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
06595       break;
06596    case 3:
06597       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->UploadDataSet((const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
06598 , (const char*) G__int(libp->para[2])));
06599       break;
06600    case 2:
06601       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->UploadDataSet((const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])));
06602       break;
06603    }
06604    return(1 || funcname || hash || result7 || libp) ;
06605 }
06606 
06607 static int G__G__Proof_142_0_167(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06608 {
06609    switch (libp->paran) {
06610    case 5:
06611       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->UploadDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06612 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
06613 , (TList*) G__int(libp->para[4])));
06614       break;
06615    case 4:
06616       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->UploadDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06617 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
06618       break;
06619    case 3:
06620       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->UploadDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06621 , (const char*) G__int(libp->para[2])));
06622       break;
06623    case 2:
06624       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->UploadDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06625       break;
06626    }
06627    return(1 || funcname || hash || result7 || libp) ;
06628 }
06629 
06630 static int G__G__Proof_142_0_168(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06631 {
06632    switch (libp->paran) {
06633    case 5:
06634       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->UploadDataSetFromFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06635 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
06636 , (TList*) G__int(libp->para[4])));
06637       break;
06638    case 4:
06639       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->UploadDataSetFromFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06640 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
06641       break;
06642    case 3:
06643       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->UploadDataSetFromFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
06644 , (const char*) G__int(libp->para[2])));
06645       break;
06646    case 2:
06647       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->UploadDataSetFromFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06648       break;
06649    }
06650    return(1 || funcname || hash || result7 || libp) ;
06651 }
06652 
06653 static int G__G__Proof_142_0_169(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06654 {
06655    switch (libp->paran) {
06656    case 3:
06657       G__letint(result7, 103, (long) ((TProof*) G__getstructoffset())->RegisterDataSet((const char*) G__int(libp->para[0]), (TFileCollection*) G__int(libp->para[1])
06658 , (const char*) G__int(libp->para[2])));
06659       break;
06660    case 2:
06661       G__letint(result7, 103, (long) ((TProof*) G__getstructoffset())->RegisterDataSet((const char*) G__int(libp->para[0]), (TFileCollection*) G__int(libp->para[1])));
06662       break;
06663    }
06664    return(1 || funcname || hash || result7 || libp) ;
06665 }
06666 
06667 static int G__G__Proof_142_0_170(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06668 {
06669    switch (libp->paran) {
06670    case 2:
06671       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetDataSets((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06672       break;
06673    case 1:
06674       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetDataSets((const char*) G__int(libp->para[0])));
06675       break;
06676    case 0:
06677       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetDataSets());
06678       break;
06679    }
06680    return(1 || funcname || hash || result7 || libp) ;
06681 }
06682 
06683 static int G__G__Proof_142_0_171(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06684 {
06685    switch (libp->paran) {
06686    case 2:
06687       ((TProof*) G__getstructoffset())->ShowDataSets((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
06688       G__setnull(result7);
06689       break;
06690    case 1:
06691       ((TProof*) G__getstructoffset())->ShowDataSets((const char*) G__int(libp->para[0]));
06692       G__setnull(result7);
06693       break;
06694    case 0:
06695       ((TProof*) G__getstructoffset())->ShowDataSets();
06696       G__setnull(result7);
06697       break;
06698    }
06699    return(1 || funcname || hash || result7 || libp) ;
06700 }
06701 
06702 static int G__G__Proof_142_0_172(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06703 {
06704    switch (libp->paran) {
06705    case 1:
06706       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetDataSetQuota((const char*) G__int(libp->para[0])));
06707       break;
06708    case 0:
06709       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetDataSetQuota());
06710       break;
06711    }
06712    return(1 || funcname || hash || result7 || libp) ;
06713 }
06714 
06715 static int G__G__Proof_142_0_173(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06716 {
06717    switch (libp->paran) {
06718    case 1:
06719       ((TProof*) G__getstructoffset())->ShowDataSetQuota((Option_t*) G__int(libp->para[0]));
06720       G__setnull(result7);
06721       break;
06722    case 0:
06723       ((TProof*) G__getstructoffset())->ShowDataSetQuota();
06724       G__setnull(result7);
06725       break;
06726    }
06727    return(1 || funcname || hash || result7 || libp) ;
06728 }
06729 
06730 static int G__G__Proof_142_0_174(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06731 {
06732       G__letint(result7, 103, (long) ((TProof*) G__getstructoffset())->ExistsDataSet((const char*) G__int(libp->para[0])));
06733    return(1 || funcname || hash || result7 || libp) ;
06734 }
06735 
06736 static int G__G__Proof_142_0_175(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06737 {
06738    switch (libp->paran) {
06739    case 2:
06740       ((TProof*) G__getstructoffset())->ShowDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
06741       G__setnull(result7);
06742       break;
06743    case 1:
06744       ((TProof*) G__getstructoffset())->ShowDataSet((const char*) G__int(libp->para[0]));
06745       G__setnull(result7);
06746       break;
06747    case 0:
06748       ((TProof*) G__getstructoffset())->ShowDataSet();
06749       G__setnull(result7);
06750       break;
06751    }
06752    return(1 || funcname || hash || result7 || libp) ;
06753 }
06754 
06755 static int G__G__Proof_142_0_176(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06756 {
06757    switch (libp->paran) {
06758    case 2:
06759       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->RemoveDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06760       break;
06761    case 1:
06762       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->RemoveDataSet((const char*) G__int(libp->para[0])));
06763       break;
06764    }
06765    return(1 || funcname || hash || result7 || libp) ;
06766 }
06767 
06768 static int G__G__Proof_142_0_177(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06769 {
06770    switch (libp->paran) {
06771    case 2:
06772       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->VerifyDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06773       break;
06774    case 1:
06775       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->VerifyDataSet((const char*) G__int(libp->para[0])));
06776       break;
06777    }
06778    return(1 || funcname || hash || result7 || libp) ;
06779 }
06780 
06781 static int G__G__Proof_142_0_178(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06782 {
06783    switch (libp->paran) {
06784    case 2:
06785       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetDataSet((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06786       break;
06787    case 1:
06788       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetDataSet((const char*) G__int(libp->para[0])));
06789       break;
06790    }
06791    return(1 || funcname || hash || result7 || libp) ;
06792 }
06793 
06794 static int G__G__Proof_142_0_179(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06795 {
06796    switch (libp->paran) {
06797    case 2:
06798       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->FindDataSets((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06799       break;
06800    case 1:
06801       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->FindDataSets((const char*) G__int(libp->para[0])));
06802       break;
06803    }
06804    return(1 || funcname || hash || result7 || libp) ;
06805 }
06806 
06807 static int G__G__Proof_142_0_180(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06808 {
06809       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->SetDataSetTreeName((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
06810    return(1 || funcname || hash || result7 || libp) ;
06811 }
06812 
06813 static int G__G__Proof_142_0_181(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06814 {
06815    switch (libp->paran) {
06816    case 1:
06817       ((TProof*) G__getstructoffset())->ShowDataSetCache((const char*) G__int(libp->para[0]));
06818       G__setnull(result7);
06819       break;
06820    case 0:
06821       ((TProof*) G__getstructoffset())->ShowDataSetCache();
06822       G__setnull(result7);
06823       break;
06824    }
06825    return(1 || funcname || hash || result7 || libp) ;
06826 }
06827 
06828 static int G__G__Proof_142_0_182(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06829 {
06830    switch (libp->paran) {
06831    case 1:
06832       ((TProof*) G__getstructoffset())->ClearDataSetCache((const char*) G__int(libp->para[0]));
06833       G__setnull(result7);
06834       break;
06835    case 0:
06836       ((TProof*) G__getstructoffset())->ClearDataSetCache();
06837       G__setnull(result7);
06838       break;
06839    }
06840    return(1 || funcname || hash || result7 || libp) ;
06841 }
06842 
06843 static int G__G__Proof_142_0_183(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06844 {
06845       ((TProof*) G__getstructoffset())->ShowData();
06846       G__setnull(result7);
06847    return(1 || funcname || hash || result7 || libp) ;
06848 }
06849 
06850 static int G__G__Proof_142_0_184(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06851 {
06852    switch (libp->paran) {
06853    case 2:
06854       ((TProof*) G__getstructoffset())->ClearData((UInt_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
06855       G__setnull(result7);
06856       break;
06857    case 1:
06858       ((TProof*) G__getstructoffset())->ClearData((UInt_t) G__int(libp->para[0]));
06859       G__setnull(result7);
06860       break;
06861    case 0:
06862       ((TProof*) G__getstructoffset())->ClearData();
06863       G__setnull(result7);
06864       break;
06865    }
06866    return(1 || funcname || hash || result7 || libp) ;
06867 }
06868 
06869 static int G__G__Proof_142_0_185(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06870 {
06871       G__letint(result7, 67, (long) ((const TProof*) G__getstructoffset())->GetMaster());
06872    return(1 || funcname || hash || result7 || libp) ;
06873 }
06874 
06875 static int G__G__Proof_142_0_186(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06876 {
06877       G__letint(result7, 67, (long) ((const TProof*) G__getstructoffset())->GetConfDir());
06878    return(1 || funcname || hash || result7 || libp) ;
06879 }
06880 
06881 static int G__G__Proof_142_0_187(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06882 {
06883       G__letint(result7, 67, (long) ((const TProof*) G__getstructoffset())->GetConfFile());
06884    return(1 || funcname || hash || result7 || libp) ;
06885 }
06886 
06887 static int G__G__Proof_142_0_188(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06888 {
06889       G__letint(result7, 67, (long) ((const TProof*) G__getstructoffset())->GetUser());
06890    return(1 || funcname || hash || result7 || libp) ;
06891 }
06892 
06893 static int G__G__Proof_142_0_189(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06894 {
06895       G__letint(result7, 67, (long) ((const TProof*) G__getstructoffset())->GetGroup());
06896    return(1 || funcname || hash || result7 || libp) ;
06897 }
06898 
06899 static int G__G__Proof_142_0_190(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06900 {
06901       G__letint(result7, 67, (long) ((const TProof*) G__getstructoffset())->GetWorkDir());
06902    return(1 || funcname || hash || result7 || libp) ;
06903 }
06904 
06905 static int G__G__Proof_142_0_191(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06906 {
06907       G__letint(result7, 67, (long) ((const TProof*) G__getstructoffset())->GetSessionTag());
06908    return(1 || funcname || hash || result7 || libp) ;
06909 }
06910 
06911 static int G__G__Proof_142_0_192(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06912 {
06913       G__letint(result7, 67, (long) ((const TProof*) G__getstructoffset())->GetImage());
06914    return(1 || funcname || hash || result7 || libp) ;
06915 }
06916 
06917 static int G__G__Proof_142_0_193(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06918 {
06919       G__letint(result7, 67, (long) ((TProof*) G__getstructoffset())->GetUrl());
06920    return(1 || funcname || hash || result7 || libp) ;
06921 }
06922 
06923 static int G__G__Proof_142_0_194(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06924 {
06925       G__letint(result7, 105, (long) ((const TProof*) G__getstructoffset())->GetPort());
06926    return(1 || funcname || hash || result7 || libp) ;
06927 }
06928 
06929 static int G__G__Proof_142_0_195(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06930 {
06931       G__letint(result7, 105, (long) ((const TProof*) G__getstructoffset())->GetRemoteProtocol());
06932    return(1 || funcname || hash || result7 || libp) ;
06933 }
06934 
06935 static int G__G__Proof_142_0_196(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06936 {
06937       G__letint(result7, 105, (long) ((const TProof*) G__getstructoffset())->GetClientProtocol());
06938    return(1 || funcname || hash || result7 || libp) ;
06939 }
06940 
06941 static int G__G__Proof_142_0_197(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06942 {
06943       G__letint(result7, 105, (long) ((const TProof*) G__getstructoffset())->GetStatus());
06944    return(1 || funcname || hash || result7 || libp) ;
06945 }
06946 
06947 static int G__G__Proof_142_0_198(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06948 {
06949       G__letint(result7, 105, (long) ((const TProof*) G__getstructoffset())->GetLogLevel());
06950    return(1 || funcname || hash || result7 || libp) ;
06951 }
06952 
06953 static int G__G__Proof_142_0_199(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06954 {
06955       G__letint(result7, 105, (long) ((const TProof*) G__getstructoffset())->GetParallel());
06956    return(1 || funcname || hash || result7 || libp) ;
06957 }
06958 
06959 static int G__G__Proof_142_0_200(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06960 {
06961       G__letint(result7, 105, (long) ((const TProof*) G__getstructoffset())->GetSeqNum());
06962    return(1 || funcname || hash || result7 || libp) ;
06963 }
06964 
06965 static int G__G__Proof_142_0_201(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06966 {
06967       G__letint(result7, 105, (long) ((const TProof*) G__getstructoffset())->GetSessionID());
06968    return(1 || funcname || hash || result7 || libp) ;
06969 }
06970 
06971 static int G__G__Proof_142_0_202(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06972 {
06973       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetListOfSlaveInfos());
06974    return(1 || funcname || hash || result7 || libp) ;
06975 }
06976 
06977 static int G__G__Proof_142_0_203(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06978 {
06979       G__letint(result7, 103, (long) ((const TProof*) G__getstructoffset())->UseDynamicStartup());
06980    return(1 || funcname || hash || result7 || libp) ;
06981 }
06982 
06983 static int G__G__Proof_142_0_204(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06984 {
06985    switch (libp->paran) {
06986    case 1:
06987       G__letint(result7, 105, (long) ((const TProof*) G__getstructoffset())->GetQueryMode((Option_t*) G__int(libp->para[0])));
06988       break;
06989    case 0:
06990       G__letint(result7, 105, (long) ((const TProof*) G__getstructoffset())->GetQueryMode());
06991       break;
06992    }
06993    return(1 || funcname || hash || result7 || libp) ;
06994 }
06995 
06996 static int G__G__Proof_142_0_205(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06997 {
06998       ((TProof*) G__getstructoffset())->SetQueryMode((TProof::EQueryMode) G__int(libp->para[0]));
06999       G__setnull(result7);
07000    return(1 || funcname || hash || result7 || libp) ;
07001 }
07002 
07003 static int G__G__Proof_142_0_206(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07004 {
07005    switch (libp->paran) {
07006    case 1:
07007       ((TProof*) G__getstructoffset())->SetRealTimeLog((Bool_t) G__int(libp->para[0]));
07008       G__setnull(result7);
07009       break;
07010    case 0:
07011       ((TProof*) G__getstructoffset())->SetRealTimeLog();
07012       G__setnull(result7);
07013       break;
07014    }
07015    return(1 || funcname || hash || result7 || libp) ;
07016 }
07017 
07018 static int G__G__Proof_142_0_207(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07019 {
07020    switch (libp->paran) {
07021    case 1:
07022       ((TProof*) G__getstructoffset())->GetStatistics((Bool_t) G__int(libp->para[0]));
07023       G__setnull(result7);
07024       break;
07025    case 0:
07026       ((TProof*) G__getstructoffset())->GetStatistics();
07027       G__setnull(result7);
07028       break;
07029    }
07030    return(1 || funcname || hash || result7 || libp) ;
07031 }
07032 
07033 static int G__G__Proof_142_0_208(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07034 {
07035       G__letLonglong(result7, 110, (G__int64) ((const TProof*) G__getstructoffset())->GetBytesRead());
07036    return(1 || funcname || hash || result7 || libp) ;
07037 }
07038 
07039 static int G__G__Proof_142_0_209(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07040 {
07041       G__letdouble(result7, 102, (double) ((const TProof*) G__getstructoffset())->GetRealTime());
07042    return(1 || funcname || hash || result7 || libp) ;
07043 }
07044 
07045 static int G__G__Proof_142_0_210(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07046 {
07047       G__letdouble(result7, 102, (double) ((const TProof*) G__getstructoffset())->GetCpuTime());
07048    return(1 || funcname || hash || result7 || libp) ;
07049 }
07050 
07051 static int G__G__Proof_142_0_211(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07052 {
07053       G__letint(result7, 103, (long) ((const TProof*) G__getstructoffset())->IsLite());
07054    return(1 || funcname || hash || result7 || libp) ;
07055 }
07056 
07057 static int G__G__Proof_142_0_212(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07058 {
07059       G__letint(result7, 103, (long) ((const TProof*) G__getstructoffset())->IsProofd());
07060    return(1 || funcname || hash || result7 || libp) ;
07061 }
07062 
07063 static int G__G__Proof_142_0_214(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07064 {
07065       G__letint(result7, 103, (long) ((const TProof*) G__getstructoffset())->IsMaster());
07066    return(1 || funcname || hash || result7 || libp) ;
07067 }
07068 
07069 static int G__G__Proof_142_0_215(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07070 {
07071       G__letint(result7, 103, (long) ((const TProof*) G__getstructoffset())->IsValid());
07072    return(1 || funcname || hash || result7 || libp) ;
07073 }
07074 
07075 static int G__G__Proof_142_0_216(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07076 {
07077       G__letint(result7, 103, (long) ((const TProof*) G__getstructoffset())->IsParallel());
07078    return(1 || funcname || hash || result7 || libp) ;
07079 }
07080 
07081 static int G__G__Proof_142_0_217(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07082 {
07083       G__letint(result7, 103, (long) ((const TProof*) G__getstructoffset())->IsIdle());
07084    return(1 || funcname || hash || result7 || libp) ;
07085 }
07086 
07087 static int G__G__Proof_142_0_218(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07088 {
07089       G__letint(result7, 103, (long) ((const TProof*) G__getstructoffset())->IsWaiting());
07090    return(1 || funcname || hash || result7 || libp) ;
07091 }
07092 
07093 static int G__G__Proof_142_0_219(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07094 {
07095       G__letint(result7, 105, (long) ((const TProof*) G__getstructoffset())->GetRunStatus());
07096    return(1 || funcname || hash || result7 || libp) ;
07097 }
07098 
07099 static int G__G__Proof_142_0_220(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07100 {
07101       G__letint(result7, 85, (long) ((const TProof*) G__getstructoffset())->GetLoadedMacros());
07102    return(1 || funcname || hash || result7 || libp) ;
07103 }
07104 
07105 static int G__G__Proof_142_0_221(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07106 {
07107       ((TProof*) G__getstructoffset())->SetParameter((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07108       G__setnull(result7);
07109    return(1 || funcname || hash || result7 || libp) ;
07110 }
07111 
07112 static int G__G__Proof_142_0_222(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07113 {
07114       ((TProof*) G__getstructoffset())->SetParameter((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
07115       G__setnull(result7);
07116    return(1 || funcname || hash || result7 || libp) ;
07117 }
07118 
07119 static int G__G__Proof_142_0_223(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07120 {
07121       ((TProof*) G__getstructoffset())->SetParameter((const char*) G__int(libp->para[0]), (Long_t) G__int(libp->para[1]));
07122       G__setnull(result7);
07123    return(1 || funcname || hash || result7 || libp) ;
07124 }
07125 
07126 static int G__G__Proof_142_0_224(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07127 {
07128       ((TProof*) G__getstructoffset())->SetParameter((const char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
07129       G__setnull(result7);
07130    return(1 || funcname || hash || result7 || libp) ;
07131 }
07132 
07133 static int G__G__Proof_142_0_225(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07134 {
07135       ((TProof*) G__getstructoffset())->SetParameter((const char*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
07136       G__setnull(result7);
07137    return(1 || funcname || hash || result7 || libp) ;
07138 }
07139 
07140 static int G__G__Proof_142_0_226(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07141 {
07142       G__letint(result7, 85, (long) ((const TProof*) G__getstructoffset())->GetParameter((const char*) G__int(libp->para[0])));
07143    return(1 || funcname || hash || result7 || libp) ;
07144 }
07145 
07146 static int G__G__Proof_142_0_227(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07147 {
07148       ((TProof*) G__getstructoffset())->DeleteParameters((const char*) G__int(libp->para[0]));
07149       G__setnull(result7);
07150    return(1 || funcname || hash || result7 || libp) ;
07151 }
07152 
07153 static int G__G__Proof_142_0_228(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07154 {
07155    switch (libp->paran) {
07156    case 1:
07157       ((const TProof*) G__getstructoffset())->ShowParameters((const char*) G__int(libp->para[0]));
07158       G__setnull(result7);
07159       break;
07160    case 0:
07161       ((const TProof*) G__getstructoffset())->ShowParameters();
07162       G__setnull(result7);
07163       break;
07164    }
07165    return(1 || funcname || hash || result7 || libp) ;
07166 }
07167 
07168 static int G__G__Proof_142_0_229(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07169 {
07170       ((TProof*) G__getstructoffset())->AddInput((TObject*) G__int(libp->para[0]));
07171       G__setnull(result7);
07172    return(1 || funcname || hash || result7 || libp) ;
07173 }
07174 
07175 static int G__G__Proof_142_0_230(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07176 {
07177       ((TProof*) G__getstructoffset())->ClearInput();
07178       G__setnull(result7);
07179    return(1 || funcname || hash || result7 || libp) ;
07180 }
07181 
07182 static int G__G__Proof_142_0_231(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07183 {
07184       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetInputList());
07185    return(1 || funcname || hash || result7 || libp) ;
07186 }
07187 
07188 static int G__G__Proof_142_0_232(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07189 {
07190       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetOutput((const char*) G__int(libp->para[0])));
07191    return(1 || funcname || hash || result7 || libp) ;
07192 }
07193 
07194 static int G__G__Proof_142_0_233(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07195 {
07196       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetOutputList());
07197    return(1 || funcname || hash || result7 || libp) ;
07198 }
07199 
07200 static int G__G__Proof_142_0_234(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07201 {
07202    switch (libp->paran) {
07203    case 1:
07204       ((TProof*) G__getstructoffset())->ShowMissingFiles((TQueryResult*) G__int(libp->para[0]));
07205       G__setnull(result7);
07206       break;
07207    case 0:
07208       ((TProof*) G__getstructoffset())->ShowMissingFiles();
07209       G__setnull(result7);
07210       break;
07211    }
07212    return(1 || funcname || hash || result7 || libp) ;
07213 }
07214 
07215 static int G__G__Proof_142_0_235(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07216 {
07217    switch (libp->paran) {
07218    case 1:
07219       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetMissingFiles((TQueryResult*) G__int(libp->para[0])));
07220       break;
07221    case 0:
07222       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetMissingFiles());
07223       break;
07224    }
07225    return(1 || funcname || hash || result7 || libp) ;
07226 }
07227 
07228 static int G__G__Proof_142_0_236(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07229 {
07230    switch (libp->paran) {
07231    case 2:
07232       ((TProof*) G__getstructoffset())->AddInputData((TObject*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
07233       G__setnull(result7);
07234       break;
07235    case 1:
07236       ((TProof*) G__getstructoffset())->AddInputData((TObject*) G__int(libp->para[0]));
07237       G__setnull(result7);
07238       break;
07239    }
07240    return(1 || funcname || hash || result7 || libp) ;
07241 }
07242 
07243 static int G__G__Proof_142_0_237(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07244 {
07245       ((TProof*) G__getstructoffset())->SetInputDataFile((const char*) G__int(libp->para[0]));
07246       G__setnull(result7);
07247    return(1 || funcname || hash || result7 || libp) ;
07248 }
07249 
07250 static int G__G__Proof_142_0_238(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07251 {
07252    switch (libp->paran) {
07253    case 1:
07254       ((TProof*) G__getstructoffset())->ClearInputData((TObject*) G__int(libp->para[0]));
07255       G__setnull(result7);
07256       break;
07257    case 0:
07258       ((TProof*) G__getstructoffset())->ClearInputData();
07259       G__setnull(result7);
07260       break;
07261    }
07262    return(1 || funcname || hash || result7 || libp) ;
07263 }
07264 
07265 static int G__G__Proof_142_0_239(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07266 {
07267       ((TProof*) G__getstructoffset())->ClearInputData((const char*) G__int(libp->para[0]));
07268       G__setnull(result7);
07269    return(1 || funcname || hash || result7 || libp) ;
07270 }
07271 
07272 static int G__G__Proof_142_0_240(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07273 {
07274       ((TProof*) G__getstructoffset())->AddFeedback((const char*) G__int(libp->para[0]));
07275       G__setnull(result7);
07276    return(1 || funcname || hash || result7 || libp) ;
07277 }
07278 
07279 static int G__G__Proof_142_0_241(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07280 {
07281       ((TProof*) G__getstructoffset())->RemoveFeedback((const char*) G__int(libp->para[0]));
07282       G__setnull(result7);
07283    return(1 || funcname || hash || result7 || libp) ;
07284 }
07285 
07286 static int G__G__Proof_142_0_242(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07287 {
07288       ((TProof*) G__getstructoffset())->ClearFeedback();
07289       G__setnull(result7);
07290    return(1 || funcname || hash || result7 || libp) ;
07291 }
07292 
07293 static int G__G__Proof_142_0_243(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07294 {
07295       ((const TProof*) G__getstructoffset())->ShowFeedback();
07296       G__setnull(result7);
07297    return(1 || funcname || hash || result7 || libp) ;
07298 }
07299 
07300 static int G__G__Proof_142_0_244(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07301 {
07302       G__letint(result7, 85, (long) ((const TProof*) G__getstructoffset())->GetFeedbackList());
07303    return(1 || funcname || hash || result7 || libp) ;
07304 }
07305 
07306 static int G__G__Proof_142_0_245(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07307 {
07308    switch (libp->paran) {
07309    case 1:
07310       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetListOfQueries((Option_t*) G__int(libp->para[0])));
07311       break;
07312    case 0:
07313       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetListOfQueries());
07314       break;
07315    }
07316    return(1 || funcname || hash || result7 || libp) ;
07317 }
07318 
07319 static int G__G__Proof_142_0_246(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07320 {
07321       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->GetNumberOfQueries());
07322    return(1 || funcname || hash || result7 || libp) ;
07323 }
07324 
07325 static int G__G__Proof_142_0_247(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07326 {
07327       G__letint(result7, 105, (long) ((TProof*) G__getstructoffset())->GetNumberOfDrawQueries());
07328    return(1 || funcname || hash || result7 || libp) ;
07329 }
07330 
07331 static int G__G__Proof_142_0_248(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07332 {
07333       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetQueryResults());
07334    return(1 || funcname || hash || result7 || libp) ;
07335 }
07336 
07337 static int G__G__Proof_142_0_249(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07338 {
07339    switch (libp->paran) {
07340    case 1:
07341       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetQueryResult((const char*) G__int(libp->para[0])));
07342       break;
07343    case 0:
07344       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetQueryResult());
07345       break;
07346    }
07347    return(1 || funcname || hash || result7 || libp) ;
07348 }
07349 
07350 static int G__G__Proof_142_0_250(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07351 {
07352       ((TProof*) G__getstructoffset())->GetMaxQueries();
07353       G__setnull(result7);
07354    return(1 || funcname || hash || result7 || libp) ;
07355 }
07356 
07357 static int G__G__Proof_142_0_251(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07358 {
07359       ((TProof*) G__getstructoffset())->SetMaxDrawQueries((Int_t) G__int(libp->para[0]));
07360       G__setnull(result7);
07361    return(1 || funcname || hash || result7 || libp) ;
07362 }
07363 
07364 static int G__G__Proof_142_0_252(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07365 {
07366    switch (libp->paran) {
07367    case 1:
07368       ((TProof*) G__getstructoffset())->ShowQueries((Option_t*) G__int(libp->para[0]));
07369       G__setnull(result7);
07370       break;
07371    case 0:
07372       ((TProof*) G__getstructoffset())->ShowQueries();
07373       G__setnull(result7);
07374       break;
07375    }
07376    return(1 || funcname || hash || result7 || libp) ;
07377 }
07378 
07379 static int G__G__Proof_142_0_253(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07380 {
07381       G__letint(result7, 103, (long) ((TProof*) G__getstructoffset())->IsDataReady(*(Long64_t*) G__Longlongref(&libp->para[0]), *(Long64_t*) G__Longlongref(&libp->para[1])));
07382    return(1 || funcname || hash || result7 || libp) ;
07383 }
07384 
07385 static int G__G__Proof_142_0_254(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07386 {
07387    switch (libp->paran) {
07388    case 1:
07389       ((TProof*) G__getstructoffset())->SetActive((Bool_t) G__int(libp->para[0]));
07390       G__setnull(result7);
07391       break;
07392    case 0:
07393       ((TProof*) G__getstructoffset())->SetActive();
07394       G__setnull(result7);
07395       break;
07396    }
07397    return(1 || funcname || hash || result7 || libp) ;
07398 }
07399 
07400 static int G__G__Proof_142_0_255(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07401 {
07402       ((TProof*) G__getstructoffset())->LogMessage((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
07403       G__setnull(result7);
07404    return(1 || funcname || hash || result7 || libp) ;
07405 }
07406 
07407 static int G__G__Proof_142_0_256(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07408 {
07409       ((TProof*) G__getstructoffset())->Progress((Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
07410       G__setnull(result7);
07411    return(1 || funcname || hash || result7 || libp) ;
07412 }
07413 
07414 static int G__G__Proof_142_0_257(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07415 {
07416       ((TProof*) G__getstructoffset())->Progress(
07417 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
07418 , (Long64_t) G__Longlong(libp->para[2]), (Float_t) G__double(libp->para[3])
07419 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
07420 , (Float_t) G__double(libp->para[6]));
07421       G__setnull(result7);
07422    return(1 || funcname || hash || result7 || libp) ;
07423 }
07424 
07425 static int G__G__Proof_142_0_258(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07426 {
07427       ((TProof*) G__getstructoffset())->Progress(
07428 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
07429 , (Long64_t) G__Longlong(libp->para[2]), (Float_t) G__double(libp->para[3])
07430 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
07431 , (Float_t) G__double(libp->para[6]), (Int_t) G__int(libp->para[7])
07432 , (Int_t) G__int(libp->para[8]), (Float_t) G__double(libp->para[9]));
07433       G__setnull(result7);
07434    return(1 || funcname || hash || result7 || libp) ;
07435 }
07436 
07437 static int G__G__Proof_142_0_259(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07438 {
07439       ((TProof*) G__getstructoffset())->Feedback((TList*) G__int(libp->para[0]));
07440       G__setnull(result7);
07441    return(1 || funcname || hash || result7 || libp) ;
07442 }
07443 
07444 static int G__G__Proof_142_0_260(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07445 {
07446       ((TProof*) G__getstructoffset())->QueryResultReady((const char*) G__int(libp->para[0]));
07447       G__setnull(result7);
07448    return(1 || funcname || hash || result7 || libp) ;
07449 }
07450 
07451 static int G__G__Proof_142_0_261(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07452 {
07453       ((TProof*) G__getstructoffset())->CloseProgressDialog();
07454       G__setnull(result7);
07455    return(1 || funcname || hash || result7 || libp) ;
07456 }
07457 
07458 static int G__G__Proof_142_0_262(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07459 {
07460       ((TProof*) G__getstructoffset())->ResetProgressDialog((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
07461 , (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3]));
07462       G__setnull(result7);
07463    return(1 || funcname || hash || result7 || libp) ;
07464 }
07465 
07466 static int G__G__Proof_142_0_263(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07467 {
07468       ((TProof*) G__getstructoffset())->StartupMessage((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
07469 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
07470       G__setnull(result7);
07471    return(1 || funcname || hash || result7 || libp) ;
07472 }
07473 
07474 static int G__G__Proof_142_0_264(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07475 {
07476       ((TProof*) G__getstructoffset())->DataSetStatus((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
07477 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
07478       G__setnull(result7);
07479    return(1 || funcname || hash || result7 || libp) ;
07480 }
07481 
07482 static int G__G__Proof_142_0_265(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07483 {
07484       ((TProof*) G__getstructoffset())->SendDataSetStatus((const char*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
07485 , (UInt_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
07486       G__setnull(result7);
07487    return(1 || funcname || hash || result7 || libp) ;
07488 }
07489 
07490 static int G__G__Proof_142_0_266(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07491 {
07492    switch (libp->paran) {
07493    case 2:
07494       ((TProof*) G__getstructoffset())->GetLog((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
07495       G__setnull(result7);
07496       break;
07497    case 1:
07498       ((TProof*) G__getstructoffset())->GetLog((Int_t) G__int(libp->para[0]));
07499       G__setnull(result7);
07500       break;
07501    case 0:
07502       ((TProof*) G__getstructoffset())->GetLog();
07503       G__setnull(result7);
07504       break;
07505    }
07506    return(1 || funcname || hash || result7 || libp) ;
07507 }
07508 
07509 static int G__G__Proof_142_0_267(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07510 {
07511       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetLastLog());
07512    return(1 || funcname || hash || result7 || libp) ;
07513 }
07514 
07515 static int G__G__Proof_142_0_268(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07516 {
07517       ((TProof*) G__getstructoffset())->PutLog((TQueryResult*) G__int(libp->para[0]));
07518       G__setnull(result7);
07519    return(1 || funcname || hash || result7 || libp) ;
07520 }
07521 
07522 static int G__G__Proof_142_0_269(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07523 {
07524    switch (libp->paran) {
07525    case 1:
07526       ((TProof*) G__getstructoffset())->ShowLog((Int_t) G__int(libp->para[0]));
07527       G__setnull(result7);
07528       break;
07529    case 0:
07530       ((TProof*) G__getstructoffset())->ShowLog();
07531       G__setnull(result7);
07532       break;
07533    }
07534    return(1 || funcname || hash || result7 || libp) ;
07535 }
07536 
07537 static int G__G__Proof_142_0_270(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07538 {
07539       ((TProof*) G__getstructoffset())->ShowLog((const char*) G__int(libp->para[0]));
07540       G__setnull(result7);
07541    return(1 || funcname || hash || result7 || libp) ;
07542 }
07543 
07544 static int G__G__Proof_142_0_271(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07545 {
07546       G__letint(result7, 103, (long) ((const TProof*) G__getstructoffset())->SendingLogToWindow());
07547    return(1 || funcname || hash || result7 || libp) ;
07548 }
07549 
07550 static int G__G__Proof_142_0_272(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07551 {
07552       ((TProof*) G__getstructoffset())->SendLogToWindow((Bool_t) G__int(libp->para[0]));
07553       G__setnull(result7);
07554    return(1 || funcname || hash || result7 || libp) ;
07555 }
07556 
07557 static int G__G__Proof_142_0_273(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07558 {
07559       ((TProof*) G__getstructoffset())->ResetProgressDialogStatus();
07560       G__setnull(result7);
07561    return(1 || funcname || hash || result7 || libp) ;
07562 }
07563 
07564 static int G__G__Proof_142_0_274(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07565 {
07566       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetTreeHeader((TDSet*) G__int(libp->para[0])));
07567    return(1 || funcname || hash || result7 || libp) ;
07568 }
07569 
07570 static int G__G__Proof_142_0_275(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07571 {
07572       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetOutputNames());
07573    return(1 || funcname || hash || result7 || libp) ;
07574 }
07575 
07576 static int G__G__Proof_142_0_276(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07577 {
07578       ((TProof*) G__getstructoffset())->AddChain((TChain*) G__int(libp->para[0]));
07579       G__setnull(result7);
07580    return(1 || funcname || hash || result7 || libp) ;
07581 }
07582 
07583 static int G__G__Proof_142_0_277(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07584 {
07585       ((TProof*) G__getstructoffset())->RemoveChain((TChain*) G__int(libp->para[0]));
07586       G__setnull(result7);
07587    return(1 || funcname || hash || result7 || libp) ;
07588 }
07589 
07590 static int G__G__Proof_142_0_278(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07591 {
07592       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->CreateDrawFeedback());
07593    return(1 || funcname || hash || result7 || libp) ;
07594 }
07595 
07596 static int G__G__Proof_142_0_279(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07597 {
07598       ((TProof*) G__getstructoffset())->SetDrawFeedbackOption((TDrawFeedback*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
07599       G__setnull(result7);
07600    return(1 || funcname || hash || result7 || libp) ;
07601 }
07602 
07603 static int G__G__Proof_142_0_280(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07604 {
07605       ((TProof*) G__getstructoffset())->DeleteDrawFeedback((TDrawFeedback*) G__int(libp->para[0]));
07606       G__setnull(result7);
07607    return(1 || funcname || hash || result7 || libp) ;
07608 }
07609 
07610 static int G__G__Proof_142_0_281(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07611 {
07612    switch (libp->paran) {
07613    case 1:
07614       ((TProof*) G__getstructoffset())->Detach((Option_t*) G__int(libp->para[0]));
07615       G__setnull(result7);
07616       break;
07617    case 0:
07618       ((TProof*) G__getstructoffset())->Detach();
07619       G__setnull(result7);
07620       break;
07621    }
07622    return(1 || funcname || hash || result7 || libp) ;
07623 }
07624 
07625 static int G__G__Proof_142_0_282(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07626 {
07627    switch (libp->paran) {
07628    case 1:
07629       ((TProof*) G__getstructoffset())->SetAlias((const char*) G__int(libp->para[0]));
07630       G__setnull(result7);
07631       break;
07632    case 0:
07633       ((TProof*) G__getstructoffset())->SetAlias();
07634       G__setnull(result7);
07635       break;
07636    }
07637    return(1 || funcname || hash || result7 || libp) ;
07638 }
07639 
07640 static int G__G__Proof_142_0_283(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07641 {
07642       G__letint(result7, 85, (long) ((TProof*) G__getstructoffset())->GetManager());
07643    return(1 || funcname || hash || result7 || libp) ;
07644 }
07645 
07646 static int G__G__Proof_142_0_284(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07647 {
07648       ((TProof*) G__getstructoffset())->SetManager((TProofMgr*) G__int(libp->para[0]));
07649       G__setnull(result7);
07650    return(1 || funcname || hash || result7 || libp) ;
07651 }
07652 
07653 static int G__G__Proof_142_0_285(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07654 {
07655       ((TProof*) G__getstructoffset())->ActivateWorker((const char*) G__int(libp->para[0]));
07656       G__setnull(result7);
07657    return(1 || funcname || hash || result7 || libp) ;
07658 }
07659 
07660 static int G__G__Proof_142_0_286(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07661 {
07662       ((TProof*) G__getstructoffset())->DeactivateWorker((const char*) G__int(libp->para[0]));
07663       G__setnull(result7);
07664    return(1 || funcname || hash || result7 || libp) ;
07665 }
07666 
07667 static int G__G__Proof_142_0_287(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07668 {
07669       G__letint(result7, 67, (long) ((const TProof*) G__getstructoffset())->GetDataPoolUrl());
07670    return(1 || funcname || hash || result7 || libp) ;
07671 }
07672 
07673 static int G__G__Proof_142_0_288(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07674 {
07675       ((TProof*) G__getstructoffset())->SetDataPoolUrl((const char*) G__int(libp->para[0]));
07676       G__setnull(result7);
07677    return(1 || funcname || hash || result7 || libp) ;
07678 }
07679 
07680 static int G__G__Proof_142_0_289(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07681 {
07682       ((TProof*) G__getstructoffset())->SetPrintProgress((PrintProgress_t) G__int(libp->para[0]));
07683       G__setnull(result7);
07684    return(1 || funcname || hash || result7 || libp) ;
07685 }
07686 
07687 static int G__G__Proof_142_0_290(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07688 {
07689    switch (libp->paran) {
07690    case 1:
07691       ((TProof*) G__getstructoffset())->SetProgressDialog((Bool_t) G__int(libp->para[0]));
07692       G__setnull(result7);
07693       break;
07694    case 0:
07695       ((TProof*) G__getstructoffset())->SetProgressDialog();
07696       G__setnull(result7);
07697       break;
07698    }
07699    return(1 || funcname || hash || result7 || libp) ;
07700 }
07701 
07702 static int G__G__Proof_142_0_291(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07703 {
07704    switch (libp->paran) {
07705    case 4:
07706       G__letint(result7, 85, (long) TProof::Open((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07707 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])));
07708       break;
07709    case 3:
07710       G__letint(result7, 85, (long) TProof::Open((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07711 , (const char*) G__int(libp->para[2])));
07712       break;
07713    case 2:
07714       G__letint(result7, 85, (long) TProof::Open((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
07715       break;
07716    case 1:
07717       G__letint(result7, 85, (long) TProof::Open((const char*) G__int(libp->para[0])));
07718       break;
07719    case 0:
07720       G__letint(result7, 85, (long) TProof::Open());
07721       break;
07722    }
07723    return(1 || funcname || hash || result7 || libp) ;
07724 }
07725 
07726 static int G__G__Proof_142_0_292(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07727 {
07728    switch (libp->paran) {
07729    case 2:
07730       TProof::LogViewer((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
07731       G__setnull(result7);
07732       break;
07733    case 1:
07734       TProof::LogViewer((const char*) G__int(libp->para[0]));
07735       G__setnull(result7);
07736       break;
07737    case 0:
07738       TProof::LogViewer();
07739       G__setnull(result7);
07740       break;
07741    }
07742    return(1 || funcname || hash || result7 || libp) ;
07743 }
07744 
07745 static int G__G__Proof_142_0_293(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07746 {
07747       G__letint(result7, 85, (long) TProof::Mgr((const char*) G__int(libp->para[0])));
07748    return(1 || funcname || hash || result7 || libp) ;
07749 }
07750 
07751 static int G__G__Proof_142_0_294(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07752 {
07753    switch (libp->paran) {
07754    case 2:
07755       TProof::Reset((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
07756       G__setnull(result7);
07757       break;
07758    case 1:
07759       TProof::Reset((const char*) G__int(libp->para[0]));
07760       G__setnull(result7);
07761       break;
07762    }
07763    return(1 || funcname || hash || result7 || libp) ;
07764 }
07765 
07766 static int G__G__Proof_142_0_295(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07767 {
07768       TProof::AddEnvVar((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
07769       G__setnull(result7);
07770    return(1 || funcname || hash || result7 || libp) ;
07771 }
07772 
07773 static int G__G__Proof_142_0_296(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07774 {
07775       TProof::DelEnvVar((const char*) G__int(libp->para[0]));
07776       G__setnull(result7);
07777    return(1 || funcname || hash || result7 || libp) ;
07778 }
07779 
07780 static int G__G__Proof_142_0_297(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07781 {
07782       G__letint(result7, 85, (long) TProof::GetEnvVars());
07783    return(1 || funcname || hash || result7 || libp) ;
07784 }
07785 
07786 static int G__G__Proof_142_0_298(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07787 {
07788       TProof::ResetEnvVars();
07789       G__setnull(result7);
07790    return(1 || funcname || hash || result7 || libp) ;
07791 }
07792 
07793 static int G__G__Proof_142_0_299(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07794 {
07795       G__letint(result7, 105, (long) TProof::GetParameter((TCollection*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07796 , *(TString*) libp->para[2].ref));
07797    return(1 || funcname || hash || result7 || libp) ;
07798 }
07799 
07800 static int G__G__Proof_142_0_300(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07801 {
07802       G__letint(result7, 105, (long) TProof::GetParameter((TCollection*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07803 , *(Int_t*) G__Intref(&libp->para[2])));
07804    return(1 || funcname || hash || result7 || libp) ;
07805 }
07806 
07807 static int G__G__Proof_142_0_301(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07808 {
07809       G__letint(result7, 105, (long) TProof::GetParameter((TCollection*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07810 , *(Long_t*) G__Longref(&libp->para[2])));
07811    return(1 || funcname || hash || result7 || libp) ;
07812 }
07813 
07814 static int G__G__Proof_142_0_302(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07815 {
07816       G__letint(result7, 105, (long) TProof::GetParameter((TCollection*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07817 , *(Long64_t*) G__Longlongref(&libp->para[2])));
07818    return(1 || funcname || hash || result7 || libp) ;
07819 }
07820 
07821 static int G__G__Proof_142_0_303(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07822 {
07823       G__letint(result7, 105, (long) TProof::GetParameter((TCollection*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
07824 , *(Double_t*) G__Doubleref(&libp->para[2])));
07825    return(1 || funcname || hash || result7 || libp) ;
07826 }
07827 
07828 static int G__G__Proof_142_0_304(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07829 {
07830       G__letint(result7, 85, (long) TProof::Class());
07831    return(1 || funcname || hash || result7 || libp) ;
07832 }
07833 
07834 static int G__G__Proof_142_0_305(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07835 {
07836       G__letint(result7, 67, (long) TProof::Class_Name());
07837    return(1 || funcname || hash || result7 || libp) ;
07838 }
07839 
07840 static int G__G__Proof_142_0_306(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07841 {
07842       G__letint(result7, 115, (long) TProof::Class_Version());
07843    return(1 || funcname || hash || result7 || libp) ;
07844 }
07845 
07846 static int G__G__Proof_142_0_307(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07847 {
07848       TProof::Dictionary();
07849       G__setnull(result7);
07850    return(1 || funcname || hash || result7 || libp) ;
07851 }
07852 
07853 static int G__G__Proof_142_0_311(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07854 {
07855       ((TProof*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
07856       G__setnull(result7);
07857    return(1 || funcname || hash || result7 || libp) ;
07858 }
07859 
07860 static int G__G__Proof_142_0_312(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07861 {
07862       G__letint(result7, 67, (long) TProof::DeclFileName());
07863    return(1 || funcname || hash || result7 || libp) ;
07864 }
07865 
07866 static int G__G__Proof_142_0_313(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07867 {
07868       G__letint(result7, 105, (long) TProof::ImplFileLine());
07869    return(1 || funcname || hash || result7 || libp) ;
07870 }
07871 
07872 static int G__G__Proof_142_0_314(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07873 {
07874       G__letint(result7, 67, (long) TProof::ImplFileName());
07875    return(1 || funcname || hash || result7 || libp) ;
07876 }
07877 
07878 static int G__G__Proof_142_0_315(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07879 {
07880       G__letint(result7, 105, (long) TProof::DeclFileLine());
07881    return(1 || funcname || hash || result7 || libp) ;
07882 }
07883 
07884 // automatic destructor
07885 typedef TProof G__TTProof;
07886 static int G__G__Proof_142_0_316(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07887 {
07888    char* gvp = (char*) G__getgvp();
07889    long soff = G__getstructoffset();
07890    int n = G__getaryconstruct();
07891    //
07892    //has_a_delete: 1
07893    //has_own_delete1arg: 0
07894    //has_own_delete2arg: 0
07895    //
07896    if (!soff) {
07897      return(1);
07898    }
07899    if (n) {
07900      if (gvp == (char*)G__PVOID) {
07901        delete[] (TProof*) soff;
07902      } else {
07903        G__setgvp((long) G__PVOID);
07904        for (int i = n - 1; i >= 0; --i) {
07905          ((TProof*) (soff+(sizeof(TProof)*i)))->~G__TTProof();
07906        }
07907        G__setgvp((long)gvp);
07908      }
07909    } else {
07910      if (gvp == (char*)G__PVOID) {
07911        delete (TProof*) soff;
07912      } else {
07913        G__setgvp((long) G__PVOID);
07914        ((TProof*) (soff))->~G__TTProof();
07915        G__setgvp((long)gvp);
07916      }
07917    }
07918    G__setnull(result7);
07919    return(1 || funcname || hash || result7 || libp) ;
07920 }
07921 
07922 
07923 /* TProofChain */
07924 static int G__G__Proof_143_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07925 {
07926    TProofChain* p = NULL;
07927    char* gvp = (char*) G__getgvp();
07928    int n = G__getaryconstruct();
07929    if (n) {
07930      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07931        p = new TProofChain[n];
07932      } else {
07933        p = new((void*) gvp) TProofChain[n];
07934      }
07935    } else {
07936      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07937        p = new TProofChain;
07938      } else {
07939        p = new((void*) gvp) TProofChain;
07940      }
07941    }
07942    result7->obj.i = (long) p;
07943    result7->ref = (long) p;
07944    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofChain));
07945    return(1 || funcname || hash || result7 || libp) ;
07946 }
07947 
07948 static int G__G__Proof_143_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07949 {
07950    TProofChain* p = NULL;
07951    char* gvp = (char*) G__getgvp();
07952    //m: 2
07953    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07954      p = new TProofChain((TChain*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
07955    } else {
07956      p = new((void*) gvp) TProofChain((TChain*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
07957    }
07958    result7->obj.i = (long) p;
07959    result7->ref = (long) p;
07960    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofChain));
07961    return(1 || funcname || hash || result7 || libp) ;
07962 }
07963 
07964 static int G__G__Proof_143_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07965 {
07966    TProofChain* p = NULL;
07967    char* gvp = (char*) G__getgvp();
07968    //m: 2
07969    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
07970      p = new TProofChain((TDSet*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
07971    } else {
07972      p = new((void*) gvp) TProofChain((TDSet*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
07973    }
07974    result7->obj.i = (long) p;
07975    result7->ref = (long) p;
07976    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofChain));
07977    return(1 || funcname || hash || result7 || libp) ;
07978 }
07979 
07980 static int G__G__Proof_143_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07981 {
07982       G__letint(result7, 105, (long) ((const TProofChain*) G__getstructoffset())->Debug());
07983    return(1 || funcname || hash || result7 || libp) ;
07984 }
07985 
07986 static int G__G__Proof_143_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07987 {
07988       G__letint(result7, 105, (long) ((const TProofChain*) G__getstructoffset())->GetMakeClass());
07989    return(1 || funcname || hash || result7 || libp) ;
07990 }
07991 
07992 static int G__G__Proof_143_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07993 {
07994       G__letint(result7, 85, (long) ((TProofChain*) G__getstructoffset())->GetPlayer());
07995    return(1 || funcname || hash || result7 || libp) ;
07996 }
07997 
07998 static int G__G__Proof_143_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07999 {
08000       G__letint(result7, 103, (long) ((const TProofChain*) G__getstructoffset())->HasTreeHeader());
08001    return(1 || funcname || hash || result7 || libp) ;
08002 }
08003 
08004 static int G__G__Proof_143_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08005 {
08006       ((TProofChain*) G__getstructoffset())->Progress((Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
08007       G__setnull(result7);
08008    return(1 || funcname || hash || result7 || libp) ;
08009 }
08010 
08011 static int G__G__Proof_143_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08012 {
08013    switch (libp->paran) {
08014    case 4:
08015       G__letLonglong(result7, 110, (G__int64) ((TProofChain*) G__getstructoffset())->Process((TSelector*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
08016 , (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
08017       break;
08018    case 3:
08019       G__letLonglong(result7, 110, (G__int64) ((TProofChain*) G__getstructoffset())->Process((TSelector*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
08020 , (Long64_t) G__Longlong(libp->para[2])));
08021       break;
08022    case 2:
08023       G__letLonglong(result7, 110, (G__int64) ((TProofChain*) G__getstructoffset())->Process((TSelector*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
08024       break;
08025    case 1:
08026       G__letLonglong(result7, 110, (G__int64) ((TProofChain*) G__getstructoffset())->Process((TSelector*) G__int(libp->para[0])));
08027       break;
08028    }
08029    return(1 || funcname || hash || result7 || libp) ;
08030 }
08031 
08032 static int G__G__Proof_143_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08033 {
08034       ((TProofChain*) G__getstructoffset())->ConnectProof();
08035       G__setnull(result7);
08036    return(1 || funcname || hash || result7 || libp) ;
08037 }
08038 
08039 static int G__G__Proof_143_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08040 {
08041       ((TProofChain*) G__getstructoffset())->ReleaseProof();
08042       G__setnull(result7);
08043    return(1 || funcname || hash || result7 || libp) ;
08044 }
08045 
08046 static int G__G__Proof_143_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08047 {
08048       G__letint(result7, 85, (long) TProofChain::Class());
08049    return(1 || funcname || hash || result7 || libp) ;
08050 }
08051 
08052 static int G__G__Proof_143_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08053 {
08054       G__letint(result7, 67, (long) TProofChain::Class_Name());
08055    return(1 || funcname || hash || result7 || libp) ;
08056 }
08057 
08058 static int G__G__Proof_143_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08059 {
08060       G__letint(result7, 115, (long) TProofChain::Class_Version());
08061    return(1 || funcname || hash || result7 || libp) ;
08062 }
08063 
08064 static int G__G__Proof_143_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08065 {
08066       TProofChain::Dictionary();
08067       G__setnull(result7);
08068    return(1 || funcname || hash || result7 || libp) ;
08069 }
08070 
08071 static int G__G__Proof_143_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08072 {
08073       ((TProofChain*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08074       G__setnull(result7);
08075    return(1 || funcname || hash || result7 || libp) ;
08076 }
08077 
08078 static int G__G__Proof_143_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08079 {
08080       G__letint(result7, 67, (long) TProofChain::DeclFileName());
08081    return(1 || funcname || hash || result7 || libp) ;
08082 }
08083 
08084 static int G__G__Proof_143_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08085 {
08086       G__letint(result7, 105, (long) TProofChain::ImplFileLine());
08087    return(1 || funcname || hash || result7 || libp) ;
08088 }
08089 
08090 static int G__G__Proof_143_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08091 {
08092       G__letint(result7, 67, (long) TProofChain::ImplFileName());
08093    return(1 || funcname || hash || result7 || libp) ;
08094 }
08095 
08096 static int G__G__Proof_143_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08097 {
08098       G__letint(result7, 105, (long) TProofChain::DeclFileLine());
08099    return(1 || funcname || hash || result7 || libp) ;
08100 }
08101 
08102 // automatic destructor
08103 typedef TProofChain G__TTProofChain;
08104 static int G__G__Proof_143_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08105 {
08106    char* gvp = (char*) G__getgvp();
08107    long soff = G__getstructoffset();
08108    int n = G__getaryconstruct();
08109    //
08110    //has_a_delete: 1
08111    //has_own_delete1arg: 0
08112    //has_own_delete2arg: 0
08113    //
08114    if (!soff) {
08115      return(1);
08116    }
08117    if (n) {
08118      if (gvp == (char*)G__PVOID) {
08119        delete[] (TProofChain*) soff;
08120      } else {
08121        G__setgvp((long) G__PVOID);
08122        for (int i = n - 1; i >= 0; --i) {
08123          ((TProofChain*) (soff+(sizeof(TProofChain)*i)))->~G__TTProofChain();
08124        }
08125        G__setgvp((long)gvp);
08126      }
08127    } else {
08128      if (gvp == (char*)G__PVOID) {
08129        delete (TProofChain*) soff;
08130      } else {
08131        G__setgvp((long) G__PVOID);
08132        ((TProofChain*) (soff))->~G__TTProofChain();
08133        G__setgvp((long)gvp);
08134      }
08135    }
08136    G__setnull(result7);
08137    return(1 || funcname || hash || result7 || libp) ;
08138 }
08139 
08140 
08141 /* TDSetElement */
08142 static int G__G__Proof_145_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08143 {
08144    TDSetElement* p = NULL;
08145    char* gvp = (char*) G__getgvp();
08146    int n = G__getaryconstruct();
08147    if (n) {
08148      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08149        p = new TDSetElement[n];
08150      } else {
08151        p = new((void*) gvp) TDSetElement[n];
08152      }
08153    } else {
08154      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08155        p = new TDSetElement;
08156      } else {
08157        p = new((void*) gvp) TDSetElement;
08158      }
08159    }
08160    result7->obj.i = (long) p;
08161    result7->ref = (long) p;
08162    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TDSetElement));
08163    return(1 || funcname || hash || result7 || libp) ;
08164 }
08165 
08166 static int G__G__Proof_145_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08167 {
08168    TDSetElement* p = NULL;
08169    char* gvp = (char*) G__getgvp();
08170    switch (libp->paran) {
08171    case 7:
08172      //m: 7
08173      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08174        p = new TDSetElement(
08175 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08176 , (const char*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
08177 , (Long64_t) G__Longlong(libp->para[4]), (const char*) G__int(libp->para[5])
08178 , (const char*) G__int(libp->para[6]));
08179      } else {
08180        p = new((void*) gvp) TDSetElement(
08181 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08182 , (const char*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
08183 , (Long64_t) G__Longlong(libp->para[4]), (const char*) G__int(libp->para[5])
08184 , (const char*) G__int(libp->para[6]));
08185      }
08186      break;
08187    case 6:
08188      //m: 6
08189      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08190        p = new TDSetElement(
08191 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08192 , (const char*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
08193 , (Long64_t) G__Longlong(libp->para[4]), (const char*) G__int(libp->para[5]));
08194      } else {
08195        p = new((void*) gvp) TDSetElement(
08196 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08197 , (const char*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
08198 , (Long64_t) G__Longlong(libp->para[4]), (const char*) G__int(libp->para[5]));
08199      }
08200      break;
08201    case 5:
08202      //m: 5
08203      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08204        p = new TDSetElement(
08205 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08206 , (const char*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
08207 , (Long64_t) G__Longlong(libp->para[4]));
08208      } else {
08209        p = new((void*) gvp) TDSetElement(
08210 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08211 , (const char*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
08212 , (Long64_t) G__Longlong(libp->para[4]));
08213      }
08214      break;
08215    case 4:
08216      //m: 4
08217      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08218        p = new TDSetElement(
08219 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08220 , (const char*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3]));
08221      } else {
08222        p = new((void*) gvp) TDSetElement(
08223 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08224 , (const char*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3]));
08225      }
08226      break;
08227    case 3:
08228      //m: 3
08229      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08230        p = new TDSetElement(
08231 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08232 , (const char*) G__int(libp->para[2]));
08233      } else {
08234        p = new((void*) gvp) TDSetElement(
08235 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
08236 , (const char*) G__int(libp->para[2]));
08237      }
08238      break;
08239    case 2:
08240      //m: 2
08241      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08242        p = new TDSetElement((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
08243      } else {
08244        p = new((void*) gvp) TDSetElement((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
08245      }
08246      break;
08247    case 1:
08248      //m: 1
08249      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08250        p = new TDSetElement((const char*) G__int(libp->para[0]));
08251      } else {
08252        p = new((void*) gvp) TDSetElement((const char*) G__int(libp->para[0]));
08253      }
08254      break;
08255    }
08256    result7->obj.i = (long) p;
08257    result7->ref = (long) p;
08258    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TDSetElement));
08259    return(1 || funcname || hash || result7 || libp) ;
08260 }
08261 
08262 static int G__G__Proof_145_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08263 {
08264    TDSetElement* p = NULL;
08265    char* gvp = (char*) G__getgvp();
08266    //m: 1
08267    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08268      p = new TDSetElement(*(TDSetElement*) libp->para[0].ref);
08269    } else {
08270      p = new((void*) gvp) TDSetElement(*(TDSetElement*) libp->para[0].ref);
08271    }
08272    result7->obj.i = (long) p;
08273    result7->ref = (long) p;
08274    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TDSetElement));
08275    return(1 || funcname || hash || result7 || libp) ;
08276 }
08277 
08278 static int G__G__Proof_145_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08279 {
08280       G__letint(result7, 85, (long) ((const TDSetElement*) G__getstructoffset())->GetListOfFriends());
08281    return(1 || funcname || hash || result7 || libp) ;
08282 }
08283 
08284 static int G__G__Proof_145_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08285 {
08286       ((TDSetElement*) G__getstructoffset())->AddFriend((TDSetElement*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
08287       G__setnull(result7);
08288    return(1 || funcname || hash || result7 || libp) ;
08289 }
08290 
08291 static int G__G__Proof_145_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08292 {
08293       ((TDSetElement*) G__getstructoffset())->DeleteFriends();
08294       G__setnull(result7);
08295    return(1 || funcname || hash || result7 || libp) ;
08296 }
08297 
08298 static int G__G__Proof_145_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08299 {
08300       G__letint(result7, 67, (long) ((const TDSetElement*) G__getstructoffset())->GetFileName());
08301    return(1 || funcname || hash || result7 || libp) ;
08302 }
08303 
08304 static int G__G__Proof_145_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08305 {
08306       G__letLonglong(result7, 110, (G__int64) ((const TDSetElement*) G__getstructoffset())->GetFirst());
08307    return(1 || funcname || hash || result7 || libp) ;
08308 }
08309 
08310 static int G__G__Proof_145_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08311 {
08312       ((TDSetElement*) G__getstructoffset())->SetFirst((Long64_t) G__Longlong(libp->para[0]));
08313       G__setnull(result7);
08314    return(1 || funcname || hash || result7 || libp) ;
08315 }
08316 
08317 static int G__G__Proof_145_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08318 {
08319       G__letLonglong(result7, 110, (G__int64) ((const TDSetElement*) G__getstructoffset())->GetNum());
08320    return(1 || funcname || hash || result7 || libp) ;
08321 }
08322 
08323 static int G__G__Proof_145_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08324 {
08325    switch (libp->paran) {
08326    case 2:
08327       G__letLonglong(result7, 110, (G__int64) ((TDSetElement*) G__getstructoffset())->GetEntries((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
08328       break;
08329    case 1:
08330       G__letLonglong(result7, 110, (G__int64) ((TDSetElement*) G__getstructoffset())->GetEntries((Bool_t) G__int(libp->para[0])));
08331       break;
08332    case 0:
08333       G__letLonglong(result7, 110, (G__int64) ((TDSetElement*) G__getstructoffset())->GetEntries());
08334       break;
08335    }
08336    return(1 || funcname || hash || result7 || libp) ;
08337 }
08338 
08339 static int G__G__Proof_145_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08340 {
08341       ((TDSetElement*) G__getstructoffset())->SetEntries((Long64_t) G__Longlong(libp->para[0]));
08342       G__setnull(result7);
08343    return(1 || funcname || hash || result7 || libp) ;
08344 }
08345 
08346 static int G__G__Proof_145_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08347 {
08348       G__letint(result7, 67, (long) ((const TDSetElement*) G__getstructoffset())->GetMsd());
08349    return(1 || funcname || hash || result7 || libp) ;
08350 }
08351 
08352 static int G__G__Proof_145_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08353 {
08354       ((TDSetElement*) G__getstructoffset())->SetNum((Long64_t) G__Longlong(libp->para[0]));
08355       G__setnull(result7);
08356    return(1 || funcname || hash || result7 || libp) ;
08357 }
08358 
08359 static int G__G__Proof_145_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08360 {
08361       G__letint(result7, 103, (long) ((const TDSetElement*) G__getstructoffset())->GetValid());
08362    return(1 || funcname || hash || result7 || libp) ;
08363 }
08364 
08365 static int G__G__Proof_145_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08366 {
08367       G__letint(result7, 67, (long) ((const TDSetElement*) G__getstructoffset())->GetObjName());
08368    return(1 || funcname || hash || result7 || libp) ;
08369 }
08370 
08371 static int G__G__Proof_145_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08372 {
08373       G__letint(result7, 67, (long) ((const TDSetElement*) G__getstructoffset())->GetDirectory());
08374    return(1 || funcname || hash || result7 || libp) ;
08375 }
08376 
08377 static int G__G__Proof_145_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08378 {
08379       G__letint(result7, 67, (long) ((const TDSetElement*) G__getstructoffset())->GetDataSet());
08380    return(1 || funcname || hash || result7 || libp) ;
08381 }
08382 
08383 static int G__G__Proof_145_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08384 {
08385       ((TDSetElement*) G__getstructoffset())->SetDataSet((const char*) G__int(libp->para[0]));
08386       G__setnull(result7);
08387    return(1 || funcname || hash || result7 || libp) ;
08388 }
08389 
08390 static int G__G__Proof_145_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08391 {
08392       ((TDSetElement*) G__getstructoffset())->AddAssocObj((TObject*) G__int(libp->para[0]));
08393       G__setnull(result7);
08394    return(1 || funcname || hash || result7 || libp) ;
08395 }
08396 
08397 static int G__G__Proof_145_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08398 {
08399       G__letint(result7, 85, (long) ((const TDSetElement*) G__getstructoffset())->GetListOfAssocObjs());
08400    return(1 || funcname || hash || result7 || libp) ;
08401 }
08402 
08403 static int G__G__Proof_145_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08404 {
08405    switch (libp->paran) {
08406    case 2:
08407       G__letint(result7, 85, (long) ((TDSetElement*) G__getstructoffset())->GetAssocObj((Long64_t) G__Longlong(libp->para[0]), (Bool_t) G__int(libp->para[1])));
08408       break;
08409    case 1:
08410       G__letint(result7, 85, (long) ((TDSetElement*) G__getstructoffset())->GetAssocObj((Long64_t) G__Longlong(libp->para[0])));
08411       break;
08412    }
08413    return(1 || funcname || hash || result7 || libp) ;
08414 }
08415 
08416 static int G__G__Proof_145_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08417 {
08418       G__letLonglong(result7, 110, (G__int64) ((const TDSetElement*) G__getstructoffset())->GetTDSetOffset());
08419    return(1 || funcname || hash || result7 || libp) ;
08420 }
08421 
08422 static int G__G__Proof_145_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08423 {
08424       ((TDSetElement*) G__getstructoffset())->SetTDSetOffset((Long64_t) G__Longlong(libp->para[0]));
08425       G__setnull(result7);
08426    return(1 || funcname || hash || result7 || libp) ;
08427 }
08428 
08429 static int G__G__Proof_145_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08430 {
08431    switch (libp->paran) {
08432    case 3:
08433       ((TDSetElement*) G__getstructoffset())->SetEntryList((TObject*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
08434 , (Long64_t) G__Longlong(libp->para[2]));
08435       G__setnull(result7);
08436       break;
08437    case 2:
08438       ((TDSetElement*) G__getstructoffset())->SetEntryList((TObject*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
08439       G__setnull(result7);
08440       break;
08441    case 1:
08442       ((TDSetElement*) G__getstructoffset())->SetEntryList((TObject*) G__int(libp->para[0]));
08443       G__setnull(result7);
08444       break;
08445    }
08446    return(1 || funcname || hash || result7 || libp) ;
08447 }
08448 
08449 static int G__G__Proof_145_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08450 {
08451       G__letint(result7, 85, (long) ((const TDSetElement*) G__getstructoffset())->GetEntryList());
08452    return(1 || funcname || hash || result7 || libp) ;
08453 }
08454 
08455 static int G__G__Proof_145_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08456 {
08457       ((TDSetElement*) G__getstructoffset())->Validate((Bool_t) G__int(libp->para[0]));
08458       G__setnull(result7);
08459    return(1 || funcname || hash || result7 || libp) ;
08460 }
08461 
08462 static int G__G__Proof_145_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08463 {
08464       ((TDSetElement*) G__getstructoffset())->Validate((TDSetElement*) G__int(libp->para[0]));
08465       G__setnull(result7);
08466    return(1 || funcname || hash || result7 || libp) ;
08467 }
08468 
08469 static int G__G__Proof_145_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08470 {
08471       ((TDSetElement*) G__getstructoffset())->Invalidate();
08472       G__setnull(result7);
08473    return(1 || funcname || hash || result7 || libp) ;
08474 }
08475 
08476 static int G__G__Proof_145_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08477 {
08478       ((TDSetElement*) G__getstructoffset())->SetValid();
08479       G__setnull(result7);
08480    return(1 || funcname || hash || result7 || libp) ;
08481 }
08482 
08483 static int G__G__Proof_145_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08484 {
08485    switch (libp->paran) {
08486    case 1:
08487       G__letint(result7, 105, (long) ((TDSetElement*) G__getstructoffset())->Lookup((Bool_t) G__int(libp->para[0])));
08488       break;
08489    case 0:
08490       G__letint(result7, 105, (long) ((TDSetElement*) G__getstructoffset())->Lookup());
08491       break;
08492    }
08493    return(1 || funcname || hash || result7 || libp) ;
08494 }
08495 
08496 static int G__G__Proof_145_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08497 {
08498       ((TDSetElement*) G__getstructoffset())->SetLookedUp();
08499       G__setnull(result7);
08500    return(1 || funcname || hash || result7 || libp) ;
08501 }
08502 
08503 static int G__G__Proof_145_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08504 {
08505    switch (libp->paran) {
08506    case 1:
08507       G__letint(result7, 85, (long) ((TDSetElement*) G__getstructoffset())->GetFileInfo((const char*) G__int(libp->para[0])));
08508       break;
08509    case 0:
08510       G__letint(result7, 85, (long) ((TDSetElement*) G__getstructoffset())->GetFileInfo());
08511       break;
08512    }
08513    return(1 || funcname || hash || result7 || libp) ;
08514 }
08515 
08516 static int G__G__Proof_145_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08517 {
08518       G__letint(result7, 105, (long) ((TDSetElement*) G__getstructoffset())->MergeElement((TDSetElement*) G__int(libp->para[0])));
08519    return(1 || funcname || hash || result7 || libp) ;
08520 }
08521 
08522 static int G__G__Proof_145_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08523 {
08524       G__letint(result7, 85, (long) TDSetElement::Class());
08525    return(1 || funcname || hash || result7 || libp) ;
08526 }
08527 
08528 static int G__G__Proof_145_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08529 {
08530       G__letint(result7, 67, (long) TDSetElement::Class_Name());
08531    return(1 || funcname || hash || result7 || libp) ;
08532 }
08533 
08534 static int G__G__Proof_145_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08535 {
08536       G__letint(result7, 115, (long) TDSetElement::Class_Version());
08537    return(1 || funcname || hash || result7 || libp) ;
08538 }
08539 
08540 static int G__G__Proof_145_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08541 {
08542       TDSetElement::Dictionary();
08543       G__setnull(result7);
08544    return(1 || funcname || hash || result7 || libp) ;
08545 }
08546 
08547 static int G__G__Proof_145_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08548 {
08549       ((TDSetElement*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
08550       G__setnull(result7);
08551    return(1 || funcname || hash || result7 || libp) ;
08552 }
08553 
08554 static int G__G__Proof_145_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08555 {
08556       G__letint(result7, 67, (long) TDSetElement::DeclFileName());
08557    return(1 || funcname || hash || result7 || libp) ;
08558 }
08559 
08560 static int G__G__Proof_145_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08561 {
08562       G__letint(result7, 105, (long) TDSetElement::ImplFileLine());
08563    return(1 || funcname || hash || result7 || libp) ;
08564 }
08565 
08566 static int G__G__Proof_145_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08567 {
08568       G__letint(result7, 67, (long) TDSetElement::ImplFileName());
08569    return(1 || funcname || hash || result7 || libp) ;
08570 }
08571 
08572 static int G__G__Proof_145_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08573 {
08574       G__letint(result7, 105, (long) TDSetElement::DeclFileLine());
08575    return(1 || funcname || hash || result7 || libp) ;
08576 }
08577 
08578 // automatic destructor
08579 typedef TDSetElement G__TTDSetElement;
08580 static int G__G__Proof_145_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08581 {
08582    char* gvp = (char*) G__getgvp();
08583    long soff = G__getstructoffset();
08584    int n = G__getaryconstruct();
08585    //
08586    //has_a_delete: 1
08587    //has_own_delete1arg: 0
08588    //has_own_delete2arg: 0
08589    //
08590    if (!soff) {
08591      return(1);
08592    }
08593    if (n) {
08594      if (gvp == (char*)G__PVOID) {
08595        delete[] (TDSetElement*) soff;
08596      } else {
08597        G__setgvp((long) G__PVOID);
08598        for (int i = n - 1; i >= 0; --i) {
08599          ((TDSetElement*) (soff+(sizeof(TDSetElement)*i)))->~G__TTDSetElement();
08600        }
08601        G__setgvp((long)gvp);
08602      }
08603    } else {
08604      if (gvp == (char*)G__PVOID) {
08605        delete (TDSetElement*) soff;
08606      } else {
08607        G__setgvp((long) G__PVOID);
08608        ((TDSetElement*) (soff))->~G__TTDSetElement();
08609        G__setgvp((long)gvp);
08610      }
08611    }
08612    G__setnull(result7);
08613    return(1 || funcname || hash || result7 || libp) ;
08614 }
08615 
08616 
08617 /* pair<TDSetElement*,TString> */
08618 static int G__G__Proof_146_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08619 {
08620    pair<TDSetElement*,TString>* p = NULL;
08621    char* gvp = (char*) G__getgvp();
08622    int n = G__getaryconstruct();
08623    if (n) {
08624      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08625        p = new pair<TDSetElement*,TString>[n];
08626      } else {
08627        p = new((void*) gvp) pair<TDSetElement*,TString>[n];
08628      }
08629    } else {
08630      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08631        p = new pair<TDSetElement*,TString>;
08632      } else {
08633        p = new((void*) gvp) pair<TDSetElement*,TString>;
08634      }
08635    }
08636    result7->obj.i = (long) p;
08637    result7->ref = (long) p;
08638    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_pairlETDSetElementmUcOTStringgR));
08639    return(1 || funcname || hash || result7 || libp) ;
08640 }
08641 
08642 static int G__G__Proof_146_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08643 {
08644    pair<TDSetElement*,TString>* p = NULL;
08645    char* gvp = (char*) G__getgvp();
08646    //m: 2
08647    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08648      p = new pair<TDSetElement*,TString>(libp->para[0].ref ? *(TDSetElement**) libp->para[0].ref : *(TDSetElement**) (void*) (&G__Mlong(libp->para[0])), *(TString*) libp->para[1].ref);
08649    } else {
08650      p = new((void*) gvp) pair<TDSetElement*,TString>(libp->para[0].ref ? *(TDSetElement**) libp->para[0].ref : *(TDSetElement**) (void*) (&G__Mlong(libp->para[0])), *(TString*) libp->para[1].ref);
08651    }
08652    result7->obj.i = (long) p;
08653    result7->ref = (long) p;
08654    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_pairlETDSetElementmUcOTStringgR));
08655    return(1 || funcname || hash || result7 || libp) ;
08656 }
08657 
08658 // automatic copy constructor
08659 static int G__G__Proof_146_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08660 
08661 {
08662    pair<TDSetElement*,TString>* p;
08663    void* tmp = (void*) G__int(libp->para[0]);
08664    p = new pair<TDSetElement*,TString>(*(pair<TDSetElement*,TString>*) tmp);
08665    result7->obj.i = (long) p;
08666    result7->ref = (long) p;
08667    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_pairlETDSetElementmUcOTStringgR));
08668    return(1 || funcname || hash || result7 || libp) ;
08669 }
08670 
08671 // automatic destructor
08672 typedef pair<TDSetElement*,TString> G__TpairlETDSetElementmUcOTStringgR;
08673 static int G__G__Proof_146_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08674 {
08675    char* gvp = (char*) G__getgvp();
08676    long soff = G__getstructoffset();
08677    int n = G__getaryconstruct();
08678    //
08679    //has_a_delete: 0
08680    //has_own_delete1arg: 0
08681    //has_own_delete2arg: 0
08682    //
08683    if (!soff) {
08684      return(1);
08685    }
08686    if (n) {
08687      if (gvp == (char*)G__PVOID) {
08688        delete[] (pair<TDSetElement*,TString>*) soff;
08689      } else {
08690        G__setgvp((long) G__PVOID);
08691        for (int i = n - 1; i >= 0; --i) {
08692          ((pair<TDSetElement*,TString>*) (soff+(sizeof(pair<TDSetElement*,TString>)*i)))->~G__TpairlETDSetElementmUcOTStringgR();
08693        }
08694        G__setgvp((long)gvp);
08695      }
08696    } else {
08697      if (gvp == (char*)G__PVOID) {
08698        delete (pair<TDSetElement*,TString>*) soff;
08699      } else {
08700        G__setgvp((long) G__PVOID);
08701        ((pair<TDSetElement*,TString>*) (soff))->~G__TpairlETDSetElementmUcOTStringgR();
08702        G__setgvp((long)gvp);
08703      }
08704    }
08705    G__setnull(result7);
08706    return(1 || funcname || hash || result7 || libp) ;
08707 }
08708 
08709 
08710 /* list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > > */
08711 static int G__G__Proof_148_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08712 {
08713    list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >* p = NULL;
08714    char* gvp = (char*) G__getgvp();
08715    int n = G__getaryconstruct();
08716    if (n) {
08717      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08718        p = new list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >[n];
08719      } else {
08720        p = new((void*) gvp) list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >[n];
08721      }
08722    } else {
08723      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08724        p = new list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >;
08725      } else {
08726        p = new((void*) gvp) list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >;
08727      }
08728    }
08729    result7->obj.i = (long) p;
08730    result7->ref = (long) p;
08731    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR));
08732    return(1 || funcname || hash || result7 || libp) ;
08733 }
08734 
08735 static int G__G__Proof_148_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08736 {
08737       {
08738          list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator* pobj;
08739          list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator xobj = ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->begin();
08740          pobj = new list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator(xobj);
08741          result7->obj.i = (long) ((void*) pobj);
08742          result7->ref = result7->obj.i;
08743          G__store_tempobject(*result7);
08744       }
08745    return(1 || funcname || hash || result7 || libp) ;
08746 }
08747 
08748 static int G__G__Proof_148_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08749 {
08750       {
08751          list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator* pobj;
08752          list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator xobj = ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->end();
08753          pobj = new list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator(xobj);
08754          result7->obj.i = (long) ((void*) pobj);
08755          result7->ref = result7->obj.i;
08756          G__store_tempobject(*result7);
08757       }
08758    return(1 || funcname || hash || result7 || libp) ;
08759 }
08760 
08761 static int G__G__Proof_148_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08762 {
08763       {
08764          list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::reverse_iterator* pobj;
08765          list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::reverse_iterator xobj = ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->rbegin();
08766          pobj = new list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::reverse_iterator(xobj);
08767          result7->obj.i = (long) ((void*) pobj);
08768          result7->ref = result7->obj.i;
08769          G__store_tempobject(*result7);
08770       }
08771    return(1 || funcname || hash || result7 || libp) ;
08772 }
08773 
08774 static int G__G__Proof_148_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08775 {
08776       {
08777          list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::reverse_iterator* pobj;
08778          list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::reverse_iterator xobj = ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->rend();
08779          pobj = new list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::reverse_iterator(xobj);
08780          result7->obj.i = (long) ((void*) pobj);
08781          result7->ref = result7->obj.i;
08782          G__store_tempobject(*result7);
08783       }
08784    return(1 || funcname || hash || result7 || libp) ;
08785 }
08786 
08787 static int G__G__Proof_148_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08788 {
08789       G__letint(result7, 103, (long) ((const list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->empty());
08790    return(1 || funcname || hash || result7 || libp) ;
08791 }
08792 
08793 static int G__G__Proof_148_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08794 {
08795       G__letint(result7, 104, (long) ((const list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->size());
08796    return(1 || funcname || hash || result7 || libp) ;
08797 }
08798 
08799 static int G__G__Proof_148_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08800 {
08801       G__letint(result7, 104, (long) ((const list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->max_size());
08802    return(1 || funcname || hash || result7 || libp) ;
08803 }
08804 
08805 static int G__G__Proof_148_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08806 {
08807       {
08808          const pair<TDSetElement*,TString>& obj = ((const list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->front();
08809          result7->ref = (long) (&obj);
08810          result7->obj.i = (long) (&obj);
08811       }
08812    return(1 || funcname || hash || result7 || libp) ;
08813 }
08814 
08815 static int G__G__Proof_148_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08816 {
08817       {
08818          const pair<TDSetElement*,TString>& obj = ((const list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->back();
08819          result7->ref = (long) (&obj);
08820          result7->obj.i = (long) (&obj);
08821       }
08822    return(1 || funcname || hash || result7 || libp) ;
08823 }
08824 
08825 static int G__G__Proof_148_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08826 {
08827       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->swap(*(list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) libp->para[0].ref);
08828       G__setnull(result7);
08829    return(1 || funcname || hash || result7 || libp) ;
08830 }
08831 
08832 static int G__G__Proof_148_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08833 {
08834       {
08835          list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator* pobj;
08836          list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator xobj = ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->insert(*((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator*) G__int(libp->para[0])), *(pair<TDSetElement*,TString>*) libp->para[1].ref);
08837          pobj = new list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator(xobj);
08838          result7->obj.i = (long) ((void*) pobj);
08839          result7->ref = result7->obj.i;
08840          G__store_tempobject(*result7);
08841       }
08842    return(1 || funcname || hash || result7 || libp) ;
08843 }
08844 
08845 static int G__G__Proof_148_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08846 {
08847       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->insert(*((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator*) G__int(libp->para[0])), (pair<TDSetElement*,TString>*) G__int(libp->para[1])
08848 , (pair<TDSetElement*,TString>*) G__int(libp->para[2]));
08849       G__setnull(result7);
08850    return(1 || funcname || hash || result7 || libp) ;
08851 }
08852 
08853 static int G__G__Proof_148_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08854 {
08855       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->insert(*((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator*) G__int(libp->para[0])), *((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator*) G__int(libp->para[1]))
08856 , *((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator*) G__int(libp->para[2])));
08857       G__setnull(result7);
08858    return(1 || funcname || hash || result7 || libp) ;
08859 }
08860 
08861 static int G__G__Proof_148_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08862 {
08863       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->insert(*((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator*) G__int(libp->para[0])), (list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::size_type) G__int(libp->para[1])
08864 , *(pair<TDSetElement*,TString>*) libp->para[2].ref);
08865       G__setnull(result7);
08866    return(1 || funcname || hash || result7 || libp) ;
08867 }
08868 
08869 static int G__G__Proof_148_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08870 {
08871       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->push_front(*(pair<TDSetElement*,TString>*) libp->para[0].ref);
08872       G__setnull(result7);
08873    return(1 || funcname || hash || result7 || libp) ;
08874 }
08875 
08876 static int G__G__Proof_148_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08877 {
08878       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->push_back(*(pair<TDSetElement*,TString>*) libp->para[0].ref);
08879       G__setnull(result7);
08880    return(1 || funcname || hash || result7 || libp) ;
08881 }
08882 
08883 static int G__G__Proof_148_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08884 {
08885       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->resize((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::size_type) G__int(libp->para[0]));
08886       G__setnull(result7);
08887    return(1 || funcname || hash || result7 || libp) ;
08888 }
08889 
08890 static int G__G__Proof_148_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08891 {
08892       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->resize((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::size_type) G__int(libp->para[0]), *((pair<TDSetElement*,TString>*) G__int(libp->para[1])));
08893       G__setnull(result7);
08894    return(1 || funcname || hash || result7 || libp) ;
08895 }
08896 
08897 static int G__G__Proof_148_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08898 {
08899       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->erase(*((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator*) G__int(libp->para[0])));
08900       G__setnull(result7);
08901    return(1 || funcname || hash || result7 || libp) ;
08902 }
08903 
08904 static int G__G__Proof_148_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08905 {
08906       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->erase(*((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator*) G__int(libp->para[0])), *((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator*) G__int(libp->para[1])));
08907       G__setnull(result7);
08908    return(1 || funcname || hash || result7 || libp) ;
08909 }
08910 
08911 static int G__G__Proof_148_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08912 {
08913       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->clear();
08914       G__setnull(result7);
08915    return(1 || funcname || hash || result7 || libp) ;
08916 }
08917 
08918 static int G__G__Proof_148_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08919 {
08920       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->pop_front();
08921       G__setnull(result7);
08922    return(1 || funcname || hash || result7 || libp) ;
08923 }
08924 
08925 static int G__G__Proof_148_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08926 {
08927       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->pop_back();
08928       G__setnull(result7);
08929    return(1 || funcname || hash || result7 || libp) ;
08930 }
08931 
08932 static int G__G__Proof_148_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08933 {
08934    list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >* p = NULL;
08935    char* gvp = (char*) G__getgvp();
08936    switch (libp->paran) {
08937    case 2:
08938      //m: 2
08939      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08940        p = new list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::size_type) G__int(libp->para[0]), *(pair<TDSetElement*,TString>*) libp->para[1].ref);
08941      } else {
08942        p = new((void*) gvp) list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::size_type) G__int(libp->para[0]), *(pair<TDSetElement*,TString>*) libp->para[1].ref);
08943      }
08944      break;
08945    case 1:
08946      //m: 1
08947      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08948        p = new list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::size_type) G__int(libp->para[0]));
08949      } else {
08950        p = new((void*) gvp) list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::size_type) G__int(libp->para[0]));
08951      }
08952      break;
08953    }
08954    result7->obj.i = (long) p;
08955    result7->ref = (long) p;
08956    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR));
08957    return(1 || funcname || hash || result7 || libp) ;
08958 }
08959 
08960 static int G__G__Proof_148_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08961 {
08962    list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >* p = NULL;
08963    char* gvp = (char*) G__getgvp();
08964    //m: 2
08965    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08966      p = new list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >((pair<TDSetElement*,TString>*) G__int(libp->para[0]), (pair<TDSetElement*,TString>*) G__int(libp->para[1]));
08967    } else {
08968      p = new((void*) gvp) list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >((pair<TDSetElement*,TString>*) G__int(libp->para[0]), (pair<TDSetElement*,TString>*) G__int(libp->para[1]));
08969    }
08970    result7->obj.i = (long) p;
08971    result7->ref = (long) p;
08972    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR));
08973    return(1 || funcname || hash || result7 || libp) ;
08974 }
08975 
08976 static int G__G__Proof_148_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08977 {
08978    list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >* p = NULL;
08979    char* gvp = (char*) G__getgvp();
08980    //m: 2
08981    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08982      p = new list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >(*((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::const_iterator*) G__int(libp->para[0])), *((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::const_iterator*) G__int(libp->para[1])));
08983    } else {
08984      p = new((void*) gvp) list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >(*((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::const_iterator*) G__int(libp->para[0])), *((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::const_iterator*) G__int(libp->para[1])));
08985    }
08986    result7->obj.i = (long) p;
08987    result7->ref = (long) p;
08988    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR));
08989    return(1 || funcname || hash || result7 || libp) ;
08990 }
08991 
08992 static int G__G__Proof_148_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
08993 {
08994    list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >* p = NULL;
08995    char* gvp = (char*) G__getgvp();
08996    //m: 1
08997    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
08998      p = new list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >(*(list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) libp->para[0].ref);
08999    } else {
09000      p = new((void*) gvp) list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >(*(list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) libp->para[0].ref);
09001    }
09002    result7->obj.i = (long) p;
09003    result7->ref = (long) p;
09004    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR));
09005    return(1 || funcname || hash || result7 || libp) ;
09006 }
09007 
09008 static int G__G__Proof_148_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09009 {
09010       {
09011          const list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >& obj = ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->operator=(*(list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) libp->para[0].ref);
09012          result7->ref = (long) (&obj);
09013          result7->obj.i = (long) (&obj);
09014       }
09015    return(1 || funcname || hash || result7 || libp) ;
09016 }
09017 
09018 static int G__G__Proof_148_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09019 {
09020       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->splice(*((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator*) G__int(libp->para[0])), *(list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) libp->para[1].ref);
09021       G__setnull(result7);
09022    return(1 || funcname || hash || result7 || libp) ;
09023 }
09024 
09025 static int G__G__Proof_148_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09026 {
09027       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->splice(*((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator*) G__int(libp->para[0])), *(list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) libp->para[1].ref
09028 , *((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator*) G__int(libp->para[2])));
09029       G__setnull(result7);
09030    return(1 || funcname || hash || result7 || libp) ;
09031 }
09032 
09033 static int G__G__Proof_148_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09034 {
09035       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->splice(*((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator*) G__int(libp->para[0])), *(list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) libp->para[1].ref
09036 , *((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator*) G__int(libp->para[2])), *((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator*) G__int(libp->para[3])));
09037       G__setnull(result7);
09038    return(1 || funcname || hash || result7 || libp) ;
09039 }
09040 
09041 static int G__G__Proof_148_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09042 {
09043       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->remove(*(pair<TDSetElement*,TString>*) libp->para[0].ref);
09044       G__setnull(result7);
09045    return(1 || funcname || hash || result7 || libp) ;
09046 }
09047 
09048 static int G__G__Proof_148_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09049 {
09050       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->unique();
09051       G__setnull(result7);
09052    return(1 || funcname || hash || result7 || libp) ;
09053 }
09054 
09055 static int G__G__Proof_148_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09056 {
09057       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->merge(*(list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) libp->para[0].ref);
09058       G__setnull(result7);
09059    return(1 || funcname || hash || result7 || libp) ;
09060 }
09061 
09062 static int G__G__Proof_148_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09063 {
09064       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->reverse();
09065       G__setnull(result7);
09066    return(1 || funcname || hash || result7 || libp) ;
09067 }
09068 
09069 static int G__G__Proof_148_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09070 {
09071       ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) G__getstructoffset())->sort();
09072       G__setnull(result7);
09073    return(1 || funcname || hash || result7 || libp) ;
09074 }
09075 
09076 // automatic destructor
09077 typedef list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > > G__TlistlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR;
09078 static int G__G__Proof_148_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09079 {
09080    char* gvp = (char*) G__getgvp();
09081    long soff = G__getstructoffset();
09082    int n = G__getaryconstruct();
09083    //
09084    //has_a_delete: 0
09085    //has_own_delete1arg: 0
09086    //has_own_delete2arg: 0
09087    //
09088    if (!soff) {
09089      return(1);
09090    }
09091    if (n) {
09092      if (gvp == (char*)G__PVOID) {
09093        delete[] (list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) soff;
09094      } else {
09095        G__setgvp((long) G__PVOID);
09096        for (int i = n - 1; i >= 0; --i) {
09097          ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) (soff+(sizeof(list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >)*i)))->~G__TlistlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR();
09098        }
09099        G__setgvp((long)gvp);
09100      }
09101    } else {
09102      if (gvp == (char*)G__PVOID) {
09103        delete (list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) soff;
09104      } else {
09105        G__setgvp((long) G__PVOID);
09106        ((list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*) (soff))->~G__TlistlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR();
09107        G__setgvp((long)gvp);
09108      }
09109    }
09110    G__setnull(result7);
09111    return(1 || funcname || hash || result7 || libp) ;
09112 }
09113 
09114 
09115 /* TProofServ */
09116 static int G__G__Proof_153_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09117 {
09118    TProofServ* p = NULL;
09119    char* gvp = (char*) G__getgvp();
09120    switch (libp->paran) {
09121    case 3:
09122      //m: 3
09123      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09124        p = new TProofServ(
09125 (Int_t*) G__int(libp->para[0]), (char**) G__int(libp->para[1])
09126 , (FILE*) G__int(libp->para[2]));
09127      } else {
09128        p = new((void*) gvp) TProofServ(
09129 (Int_t*) G__int(libp->para[0]), (char**) G__int(libp->para[1])
09130 , (FILE*) G__int(libp->para[2]));
09131      }
09132      break;
09133    case 2:
09134      //m: 2
09135      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09136        p = new TProofServ((Int_t*) G__int(libp->para[0]), (char**) G__int(libp->para[1]));
09137      } else {
09138        p = new((void*) gvp) TProofServ((Int_t*) G__int(libp->para[0]), (char**) G__int(libp->para[1]));
09139      }
09140      break;
09141    }
09142    result7->obj.i = (long) p;
09143    result7->ref = (long) p;
09144    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofServ));
09145    return(1 || funcname || hash || result7 || libp) ;
09146 }
09147 
09148 static int G__G__Proof_153_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09149 {
09150       G__letint(result7, 105, (long) ((TProofServ*) G__getstructoffset())->CreateServer());
09151    return(1 || funcname || hash || result7 || libp) ;
09152 }
09153 
09154 static int G__G__Proof_153_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09155 {
09156       G__letint(result7, 85, (long) ((const TProofServ*) G__getstructoffset())->GetProof());
09157    return(1 || funcname || hash || result7 || libp) ;
09158 }
09159 
09160 static int G__G__Proof_153_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09161 {
09162       G__letint(result7, 67, (long) ((const TProofServ*) G__getstructoffset())->GetService());
09163    return(1 || funcname || hash || result7 || libp) ;
09164 }
09165 
09166 static int G__G__Proof_153_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09167 {
09168       G__letint(result7, 67, (long) ((const TProofServ*) G__getstructoffset())->GetConfDir());
09169    return(1 || funcname || hash || result7 || libp) ;
09170 }
09171 
09172 static int G__G__Proof_153_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09173 {
09174       G__letint(result7, 67, (long) ((const TProofServ*) G__getstructoffset())->GetConfFile());
09175    return(1 || funcname || hash || result7 || libp) ;
09176 }
09177 
09178 static int G__G__Proof_153_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09179 {
09180       G__letint(result7, 67, (long) ((const TProofServ*) G__getstructoffset())->GetUser());
09181    return(1 || funcname || hash || result7 || libp) ;
09182 }
09183 
09184 static int G__G__Proof_153_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09185 {
09186       G__letint(result7, 67, (long) ((const TProofServ*) G__getstructoffset())->GetGroup());
09187    return(1 || funcname || hash || result7 || libp) ;
09188 }
09189 
09190 static int G__G__Proof_153_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09191 {
09192       G__letint(result7, 67, (long) ((const TProofServ*) G__getstructoffset())->GetWorkDir());
09193    return(1 || funcname || hash || result7 || libp) ;
09194 }
09195 
09196 static int G__G__Proof_153_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09197 {
09198       G__letint(result7, 67, (long) ((const TProofServ*) G__getstructoffset())->GetImage());
09199    return(1 || funcname || hash || result7 || libp) ;
09200 }
09201 
09202 static int G__G__Proof_153_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09203 {
09204       G__letint(result7, 67, (long) ((const TProofServ*) G__getstructoffset())->GetSessionTag());
09205    return(1 || funcname || hash || result7 || libp) ;
09206 }
09207 
09208 static int G__G__Proof_153_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09209 {
09210       G__letint(result7, 67, (long) ((const TProofServ*) G__getstructoffset())->GetSessionDir());
09211    return(1 || funcname || hash || result7 || libp) ;
09212 }
09213 
09214 static int G__G__Proof_153_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09215 {
09216       G__letint(result7, 67, (long) ((const TProofServ*) G__getstructoffset())->GetPackageDir());
09217    return(1 || funcname || hash || result7 || libp) ;
09218 }
09219 
09220 static int G__G__Proof_153_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09221 {
09222       G__letint(result7, 67, (long) ((const TProofServ*) G__getstructoffset())->GetDataDir());
09223    return(1 || funcname || hash || result7 || libp) ;
09224 }
09225 
09226 static int G__G__Proof_153_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09227 {
09228       G__letint(result7, 105, (long) ((const TProofServ*) G__getstructoffset())->GetProtocol());
09229    return(1 || funcname || hash || result7 || libp) ;
09230 }
09231 
09232 static int G__G__Proof_153_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09233 {
09234       G__letint(result7, 67, (long) ((const TProofServ*) G__getstructoffset())->GetOrdinal());
09235    return(1 || funcname || hash || result7 || libp) ;
09236 }
09237 
09238 static int G__G__Proof_153_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09239 {
09240       G__letint(result7, 105, (long) ((const TProofServ*) G__getstructoffset())->GetGroupId());
09241    return(1 || funcname || hash || result7 || libp) ;
09242 }
09243 
09244 static int G__G__Proof_153_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09245 {
09246       G__letint(result7, 105, (long) ((const TProofServ*) G__getstructoffset())->GetGroupSize());
09247    return(1 || funcname || hash || result7 || libp) ;
09248 }
09249 
09250 static int G__G__Proof_153_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09251 {
09252       G__letint(result7, 105, (long) ((const TProofServ*) G__getstructoffset())->GetLogLevel());
09253    return(1 || funcname || hash || result7 || libp) ;
09254 }
09255 
09256 static int G__G__Proof_153_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09257 {
09258       G__letint(result7, 85, (long) ((const TProofServ*) G__getstructoffset())->GetSocket());
09259    return(1 || funcname || hash || result7 || libp) ;
09260 }
09261 
09262 static int G__G__Proof_153_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09263 {
09264       G__letdouble(result7, 102, (double) ((const TProofServ*) G__getstructoffset())->GetRealTime());
09265    return(1 || funcname || hash || result7 || libp) ;
09266 }
09267 
09268 static int G__G__Proof_153_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09269 {
09270       G__letdouble(result7, 102, (double) ((const TProofServ*) G__getstructoffset())->GetCpuTime());
09271    return(1 || funcname || hash || result7 || libp) ;
09272 }
09273 
09274 static int G__G__Proof_153_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09275 {
09276       G__letint(result7, 105, (long) ((const TProofServ*) G__getstructoffset())->GetQuerySeqNum());
09277    return(1 || funcname || hash || result7 || libp) ;
09278 }
09279 
09280 static int G__G__Proof_153_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09281 {
09282       G__letint(result7, 105, (long) ((const TProofServ*) G__getstructoffset())->GetTotSessions());
09283    return(1 || funcname || hash || result7 || libp) ;
09284 }
09285 
09286 static int G__G__Proof_153_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09287 {
09288       G__letint(result7, 105, (long) ((const TProofServ*) G__getstructoffset())->GetActSessions());
09289    return(1 || funcname || hash || result7 || libp) ;
09290 }
09291 
09292 static int G__G__Proof_153_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09293 {
09294       G__letdouble(result7, 102, (double) ((const TProofServ*) G__getstructoffset())->GetEffSessions());
09295    return(1 || funcname || hash || result7 || libp) ;
09296 }
09297 
09298 static int G__G__Proof_153_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09299 {
09300       G__letint(result7, 85, (long) ((const TProofServ*) G__getstructoffset())->GetEnabledPackages());
09301    return(1 || funcname || hash || result7 || libp) ;
09302 }
09303 
09304 static int G__G__Proof_153_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09305 {
09306       G__letint(result7, 105, (long) ((const TProofServ*) G__getstructoffset())->GetInflateFactor());
09307    return(1 || funcname || hash || result7 || libp) ;
09308 }
09309 
09310 static int G__G__Proof_153_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09311 {
09312       G__letint(result7, 108, (long) TProofServ::GetVirtMemMax());
09313    return(1 || funcname || hash || result7 || libp) ;
09314 }
09315 
09316 static int G__G__Proof_153_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09317 {
09318       G__letint(result7, 108, (long) TProofServ::GetResMemMax());
09319    return(1 || funcname || hash || result7 || libp) ;
09320 }
09321 
09322 static int G__G__Proof_153_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09323 {
09324       G__letdouble(result7, 102, (double) TProofServ::GetMemHWM());
09325    return(1 || funcname || hash || result7 || libp) ;
09326 }
09327 
09328 static int G__G__Proof_153_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09329 {
09330       G__letdouble(result7, 102, (double) TProofServ::GetMemStop());
09331    return(1 || funcname || hash || result7 || libp) ;
09332 }
09333 
09334 static int G__G__Proof_153_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09335 {
09336       G__letLonglong(result7, 110, (G__int64) ((const TProofServ*) G__getstructoffset())->GetMsgSizeHWM());
09337    return(1 || funcname || hash || result7 || libp) ;
09338 }
09339 
09340 static int G__G__Proof_153_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09341 {
09342       G__letint(result7, 67, (long) ((const TProofServ*) G__getstructoffset())->GetPrefix());
09343    return(1 || funcname || hash || result7 || libp) ;
09344 }
09345 
09346 static int G__G__Proof_153_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09347 {
09348       ((TProofServ*) G__getstructoffset())->FlushLogFile();
09349       G__setnull(result7);
09350    return(1 || funcname || hash || result7 || libp) ;
09351 }
09352 
09353 static int G__G__Proof_153_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09354 {
09355       G__letint(result7, 85, (long) ((TProofServ*) G__getstructoffset())->GetCacheLock());
09356    return(1 || funcname || hash || result7 || libp) ;
09357 }
09358 
09359 static int G__G__Proof_153_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09360 {
09361       G__letint(result7, 105, (long) ((TProofServ*) G__getstructoffset())->CopyFromCache((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
09362    return(1 || funcname || hash || result7 || libp) ;
09363 }
09364 
09365 static int G__G__Proof_153_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09366 {
09367    switch (libp->paran) {
09368    case 2:
09369       G__letint(result7, 105, (long) ((TProofServ*) G__getstructoffset())->CopyToCache((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
09370       break;
09371    case 1:
09372       G__letint(result7, 105, (long) ((TProofServ*) G__getstructoffset())->CopyToCache((const char*) G__int(libp->para[0])));
09373       break;
09374    }
09375    return(1 || funcname || hash || result7 || libp) ;
09376 }
09377 
09378 static int G__G__Proof_153_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09379 {
09380    switch (libp->paran) {
09381    case 3:
09382       G__letint(result7, 105, (long) ((TProofServ*) G__getstructoffset())->GetWorkers((TList*) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])
09383 , (Bool_t) G__int(libp->para[2])));
09384       break;
09385    case 2:
09386       G__letint(result7, 105, (long) ((TProofServ*) G__getstructoffset())->GetWorkers((TList*) G__int(libp->para[0]), *(Int_t*) G__Intref(&libp->para[1])));
09387       break;
09388    }
09389    return(1 || funcname || hash || result7 || libp) ;
09390 }
09391 
09392 static int G__G__Proof_153_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09393 {
09394       G__letint(result7, 105, (long) ((TProofServ*) G__getstructoffset())->HandleSocketInput((TMessage*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
09395    return(1 || funcname || hash || result7 || libp) ;
09396 }
09397 
09398 static int G__G__Proof_153_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09399 {
09400       ((TProofServ*) G__getstructoffset())->HandleSocketInput();
09401       G__setnull(result7);
09402    return(1 || funcname || hash || result7 || libp) ;
09403 }
09404 
09405 static int G__G__Proof_153_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09406 {
09407       ((TProofServ*) G__getstructoffset())->HandleUrgentData();
09408       G__setnull(result7);
09409    return(1 || funcname || hash || result7 || libp) ;
09410 }
09411 
09412 static int G__G__Proof_153_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09413 {
09414       ((TProofServ*) G__getstructoffset())->HandleSigPipe();
09415       G__setnull(result7);
09416    return(1 || funcname || hash || result7 || libp) ;
09417 }
09418 
09419 static int G__G__Proof_153_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09420 {
09421       ((TProofServ*) G__getstructoffset())->HandleTermination();
09422       G__setnull(result7);
09423    return(1 || funcname || hash || result7 || libp) ;
09424 }
09425 
09426 static int G__G__Proof_153_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09427 {
09428       ((TProofServ*) G__getstructoffset())->Interrupt();
09429       G__setnull(result7);
09430    return(1 || funcname || hash || result7 || libp) ;
09431 }
09432 
09433 static int G__G__Proof_153_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09434 {
09435       G__letint(result7, 103, (long) ((const TProofServ*) G__getstructoffset())->IsEndMaster());
09436    return(1 || funcname || hash || result7 || libp) ;
09437 }
09438 
09439 static int G__G__Proof_153_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09440 {
09441       G__letint(result7, 103, (long) ((const TProofServ*) G__getstructoffset())->IsMaster());
09442    return(1 || funcname || hash || result7 || libp) ;
09443 }
09444 
09445 static int G__G__Proof_153_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09446 {
09447       G__letint(result7, 103, (long) ((const TProofServ*) G__getstructoffset())->IsParallel());
09448    return(1 || funcname || hash || result7 || libp) ;
09449 }
09450 
09451 static int G__G__Proof_153_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09452 {
09453       G__letint(result7, 103, (long) ((const TProofServ*) G__getstructoffset())->IsTopMaster());
09454    return(1 || funcname || hash || result7 || libp) ;
09455 }
09456 
09457 static int G__G__Proof_153_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09458 {
09459       ((TProofServ*) G__getstructoffset())->RestartComputeTime();
09460       G__setnull(result7);
09461    return(1 || funcname || hash || result7 || libp) ;
09462 }
09463 
09464 static int G__G__Proof_153_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09465 {
09466       G__letint(result7, 85, (long) ((TProofServ*) G__getstructoffset())->Get((const char*) G__int(libp->para[0])));
09467    return(1 || funcname || hash || result7 || libp) ;
09468 }
09469 
09470 static int G__G__Proof_153_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09471 {
09472    switch (libp->paran) {
09473    case 1:
09474       G__letint(result7, 85, (long) ((TProofServ*) G__getstructoffset())->GetNextPacket((Long64_t) G__Longlong(libp->para[0])));
09475       break;
09476    case 0:
09477       G__letint(result7, 85, (long) ((TProofServ*) G__getstructoffset())->GetNextPacket());
09478       break;
09479    }
09480    return(1 || funcname || hash || result7 || libp) ;
09481 }
09482 
09483 static int G__G__Proof_153_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09484 {
09485       ((TProofServ*) G__getstructoffset())->ReleaseWorker((const char*) G__int(libp->para[0]));
09486       G__setnull(result7);
09487    return(1 || funcname || hash || result7 || libp) ;
09488 }
09489 
09490 static int G__G__Proof_153_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09491 {
09492       ((TProofServ*) G__getstructoffset())->Reset((const char*) G__int(libp->para[0]));
09493       G__setnull(result7);
09494    return(1 || funcname || hash || result7 || libp) ;
09495 }
09496 
09497 static int G__G__Proof_153_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09498 {
09499       G__letint(result7, 105, (long) ((TProofServ*) G__getstructoffset())->ReceiveFile((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
09500 , (Long64_t) G__Longlong(libp->para[2])));
09501    return(1 || funcname || hash || result7 || libp) ;
09502 }
09503 
09504 static int G__G__Proof_153_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09505 {
09506    switch (libp->paran) {
09507    case 2:
09508       G__letint(result7, 105, (long) ((TProofServ*) G__getstructoffset())->SendAsynMessage((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
09509       break;
09510    case 1:
09511       G__letint(result7, 105, (long) ((TProofServ*) G__getstructoffset())->SendAsynMessage((const char*) G__int(libp->para[0])));
09512       break;
09513    }
09514    return(1 || funcname || hash || result7 || libp) ;
09515 }
09516 
09517 static int G__G__Proof_153_0_99(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09518 {
09519    switch (libp->paran) {
09520    case 3:
09521       ((TProofServ*) G__getstructoffset())->SendLogFile((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
09522 , (Int_t) G__int(libp->para[2]));
09523       G__setnull(result7);
09524       break;
09525    case 2:
09526       ((TProofServ*) G__getstructoffset())->SendLogFile((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
09527       G__setnull(result7);
09528       break;
09529    case 1:
09530       ((TProofServ*) G__getstructoffset())->SendLogFile((Int_t) G__int(libp->para[0]));
09531       G__setnull(result7);
09532       break;
09533    case 0:
09534       ((TProofServ*) G__getstructoffset())->SendLogFile();
09535       G__setnull(result7);
09536       break;
09537    }
09538    return(1 || funcname || hash || result7 || libp) ;
09539 }
09540 
09541 static int G__G__Proof_153_0_100(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09542 {
09543       ((TProofServ*) G__getstructoffset())->SendStatistics();
09544       G__setnull(result7);
09545    return(1 || funcname || hash || result7 || libp) ;
09546 }
09547 
09548 static int G__G__Proof_153_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09549 {
09550    switch (libp->paran) {
09551    case 1:
09552       ((TProofServ*) G__getstructoffset())->SendParallel((Bool_t) G__int(libp->para[0]));
09553       G__setnull(result7);
09554       break;
09555    case 0:
09556       ((TProofServ*) G__getstructoffset())->SendParallel();
09557       G__setnull(result7);
09558       break;
09559    }
09560    return(1 || funcname || hash || result7 || libp) ;
09561 }
09562 
09563 static int G__G__Proof_153_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09564 {
09565    switch (libp->paran) {
09566    case 1:
09567       G__letint(result7, 105, (long) ((TProofServ*) G__getstructoffset())->UpdateSessionStatus((Int_t) G__int(libp->para[0])));
09568       break;
09569    case 0:
09570       G__letint(result7, 105, (long) ((TProofServ*) G__getstructoffset())->UpdateSessionStatus());
09571       break;
09572    }
09573    return(1 || funcname || hash || result7 || libp) ;
09574 }
09575 
09576 static int G__G__Proof_153_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09577 {
09578       ((TProofServ*) G__getstructoffset())->DisableTimeout();
09579       G__setnull(result7);
09580    return(1 || funcname || hash || result7 || libp) ;
09581 }
09582 
09583 static int G__G__Proof_153_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09584 {
09585       ((TProofServ*) G__getstructoffset())->EnableTimeout();
09586       G__setnull(result7);
09587    return(1 || funcname || hash || result7 || libp) ;
09588 }
09589 
09590 static int G__G__Proof_153_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09591 {
09592    switch (libp->paran) {
09593    case 1:
09594       ((TProofServ*) G__getstructoffset())->LogToMaster((Bool_t) G__int(libp->para[0]));
09595       G__setnull(result7);
09596       break;
09597    case 0:
09598       ((TProofServ*) G__getstructoffset())->LogToMaster();
09599       G__setnull(result7);
09600       break;
09601    }
09602    return(1 || funcname || hash || result7 || libp) ;
09603 }
09604 
09605 static int G__G__Proof_153_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09606 {
09607       G__letint(result7, 69, (long) TProofServ::SetErrorHandlerFile((FILE*) G__int(libp->para[0])));
09608    return(1 || funcname || hash || result7 || libp) ;
09609 }
09610 
09611 static int G__G__Proof_153_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09612 {
09613       TProofServ::ErrorHandler((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
09614 , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
09615       G__setnull(result7);
09616    return(1 || funcname || hash || result7 || libp) ;
09617 }
09618 
09619 static int G__G__Proof_153_0_109(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09620 {
09621    switch (libp->paran) {
09622    case 2:
09623       TProofServ::ResolveKeywords(*(TString*) libp->para[0].ref, (const char*) G__int(libp->para[1]));
09624       G__setnull(result7);
09625       break;
09626    case 1:
09627       TProofServ::ResolveKeywords(*(TString*) libp->para[0].ref);
09628       G__setnull(result7);
09629       break;
09630    }
09631    return(1 || funcname || hash || result7 || libp) ;
09632 }
09633 
09634 static int G__G__Proof_153_0_110(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09635 {
09636       TProofServ::SetLastMsg((const char*) G__int(libp->para[0]));
09637       G__setnull(result7);
09638    return(1 || funcname || hash || result7 || libp) ;
09639 }
09640 
09641 static int G__G__Proof_153_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09642 {
09643       G__letint(result7, 103, (long) TProofServ::IsActive());
09644    return(1 || funcname || hash || result7 || libp) ;
09645 }
09646 
09647 static int G__G__Proof_153_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09648 {
09649       G__letint(result7, 85, (long) TProofServ::This());
09650    return(1 || funcname || hash || result7 || libp) ;
09651 }
09652 
09653 static int G__G__Proof_153_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09654 {
09655       G__letint(result7, 85, (long) TProofServ::Class());
09656    return(1 || funcname || hash || result7 || libp) ;
09657 }
09658 
09659 static int G__G__Proof_153_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09660 {
09661       G__letint(result7, 67, (long) TProofServ::Class_Name());
09662    return(1 || funcname || hash || result7 || libp) ;
09663 }
09664 
09665 static int G__G__Proof_153_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09666 {
09667       G__letint(result7, 115, (long) TProofServ::Class_Version());
09668    return(1 || funcname || hash || result7 || libp) ;
09669 }
09670 
09671 static int G__G__Proof_153_0_116(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09672 {
09673       TProofServ::Dictionary();
09674       G__setnull(result7);
09675    return(1 || funcname || hash || result7 || libp) ;
09676 }
09677 
09678 static int G__G__Proof_153_0_120(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09679 {
09680       ((TProofServ*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09681       G__setnull(result7);
09682    return(1 || funcname || hash || result7 || libp) ;
09683 }
09684 
09685 static int G__G__Proof_153_0_121(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09686 {
09687       G__letint(result7, 67, (long) TProofServ::DeclFileName());
09688    return(1 || funcname || hash || result7 || libp) ;
09689 }
09690 
09691 static int G__G__Proof_153_0_122(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09692 {
09693       G__letint(result7, 105, (long) TProofServ::ImplFileLine());
09694    return(1 || funcname || hash || result7 || libp) ;
09695 }
09696 
09697 static int G__G__Proof_153_0_123(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09698 {
09699       G__letint(result7, 67, (long) TProofServ::ImplFileName());
09700    return(1 || funcname || hash || result7 || libp) ;
09701 }
09702 
09703 static int G__G__Proof_153_0_124(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09704 {
09705       G__letint(result7, 105, (long) TProofServ::DeclFileLine());
09706    return(1 || funcname || hash || result7 || libp) ;
09707 }
09708 
09709 // automatic destructor
09710 typedef TProofServ G__TTProofServ;
09711 static int G__G__Proof_153_0_125(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09712 {
09713    char* gvp = (char*) G__getgvp();
09714    long soff = G__getstructoffset();
09715    int n = G__getaryconstruct();
09716    //
09717    //has_a_delete: 1
09718    //has_own_delete1arg: 0
09719    //has_own_delete2arg: 0
09720    //
09721    if (!soff) {
09722      return(1);
09723    }
09724    if (n) {
09725      if (gvp == (char*)G__PVOID) {
09726        delete[] (TProofServ*) soff;
09727      } else {
09728        G__setgvp((long) G__PVOID);
09729        for (int i = n - 1; i >= 0; --i) {
09730          ((TProofServ*) (soff+(sizeof(TProofServ)*i)))->~G__TTProofServ();
09731        }
09732        G__setgvp((long)gvp);
09733      }
09734    } else {
09735      if (gvp == (char*)G__PVOID) {
09736        delete (TProofServ*) soff;
09737      } else {
09738        G__setgvp((long) G__PVOID);
09739        ((TProofServ*) (soff))->~G__TTProofServ();
09740        G__setgvp((long)gvp);
09741      }
09742    }
09743    G__setnull(result7);
09744    return(1 || funcname || hash || result7 || libp) ;
09745 }
09746 
09747 
09748 /* TDSetProxy */
09749 static int G__G__Proof_154_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09750 {
09751    TDSetProxy* p = NULL;
09752    char* gvp = (char*) G__getgvp();
09753    int n = G__getaryconstruct();
09754    if (n) {
09755      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09756        p = new TDSetProxy[n];
09757      } else {
09758        p = new((void*) gvp) TDSetProxy[n];
09759      }
09760    } else {
09761      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09762        p = new TDSetProxy;
09763      } else {
09764        p = new((void*) gvp) TDSetProxy;
09765      }
09766    }
09767    result7->obj.i = (long) p;
09768    result7->ref = (long) p;
09769    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TDSetProxy));
09770    return(1 || funcname || hash || result7 || libp) ;
09771 }
09772 
09773 static int G__G__Proof_154_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09774 {
09775    TDSetProxy* p = NULL;
09776    char* gvp = (char*) G__getgvp();
09777    switch (libp->paran) {
09778    case 3:
09779      //m: 3
09780      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09781        p = new TDSetProxy(
09782 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09783 , (const char*) G__int(libp->para[2]));
09784      } else {
09785        p = new((void*) gvp) TDSetProxy(
09786 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09787 , (const char*) G__int(libp->para[2]));
09788      }
09789      break;
09790    case 2:
09791      //m: 2
09792      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09793        p = new TDSetProxy((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
09794      } else {
09795        p = new((void*) gvp) TDSetProxy((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
09796      }
09797      break;
09798    case 1:
09799      //m: 1
09800      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09801        p = new TDSetProxy((const char*) G__int(libp->para[0]));
09802      } else {
09803        p = new((void*) gvp) TDSetProxy((const char*) G__int(libp->para[0]));
09804      }
09805      break;
09806    }
09807    result7->obj.i = (long) p;
09808    result7->ref = (long) p;
09809    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TDSetProxy));
09810    return(1 || funcname || hash || result7 || libp) ;
09811 }
09812 
09813 static int G__G__Proof_154_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09814 {
09815       ((TDSetProxy*) G__getstructoffset())->SetProofServ((TProofServ*) G__int(libp->para[0]));
09816       G__setnull(result7);
09817    return(1 || funcname || hash || result7 || libp) ;
09818 }
09819 
09820 static int G__G__Proof_154_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09821 {
09822       G__letint(result7, 85, (long) TDSetProxy::Class());
09823    return(1 || funcname || hash || result7 || libp) ;
09824 }
09825 
09826 static int G__G__Proof_154_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09827 {
09828       G__letint(result7, 67, (long) TDSetProxy::Class_Name());
09829    return(1 || funcname || hash || result7 || libp) ;
09830 }
09831 
09832 static int G__G__Proof_154_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09833 {
09834       G__letint(result7, 115, (long) TDSetProxy::Class_Version());
09835    return(1 || funcname || hash || result7 || libp) ;
09836 }
09837 
09838 static int G__G__Proof_154_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09839 {
09840       TDSetProxy::Dictionary();
09841       G__setnull(result7);
09842    return(1 || funcname || hash || result7 || libp) ;
09843 }
09844 
09845 static int G__G__Proof_154_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09846 {
09847       ((TDSetProxy*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
09848       G__setnull(result7);
09849    return(1 || funcname || hash || result7 || libp) ;
09850 }
09851 
09852 static int G__G__Proof_154_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09853 {
09854       G__letint(result7, 67, (long) TDSetProxy::DeclFileName());
09855    return(1 || funcname || hash || result7 || libp) ;
09856 }
09857 
09858 static int G__G__Proof_154_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09859 {
09860       G__letint(result7, 105, (long) TDSetProxy::ImplFileLine());
09861    return(1 || funcname || hash || result7 || libp) ;
09862 }
09863 
09864 static int G__G__Proof_154_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09865 {
09866       G__letint(result7, 67, (long) TDSetProxy::ImplFileName());
09867    return(1 || funcname || hash || result7 || libp) ;
09868 }
09869 
09870 static int G__G__Proof_154_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09871 {
09872       G__letint(result7, 105, (long) TDSetProxy::DeclFileLine());
09873    return(1 || funcname || hash || result7 || libp) ;
09874 }
09875 
09876 // automatic destructor
09877 typedef TDSetProxy G__TTDSetProxy;
09878 static int G__G__Proof_154_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09879 {
09880    char* gvp = (char*) G__getgvp();
09881    long soff = G__getstructoffset();
09882    int n = G__getaryconstruct();
09883    //
09884    //has_a_delete: 1
09885    //has_own_delete1arg: 0
09886    //has_own_delete2arg: 0
09887    //
09888    if (!soff) {
09889      return(1);
09890    }
09891    if (n) {
09892      if (gvp == (char*)G__PVOID) {
09893        delete[] (TDSetProxy*) soff;
09894      } else {
09895        G__setgvp((long) G__PVOID);
09896        for (int i = n - 1; i >= 0; --i) {
09897          ((TDSetProxy*) (soff+(sizeof(TDSetProxy)*i)))->~G__TTDSetProxy();
09898        }
09899        G__setgvp((long)gvp);
09900      }
09901    } else {
09902      if (gvp == (char*)G__PVOID) {
09903        delete (TDSetProxy*) soff;
09904      } else {
09905        G__setgvp((long) G__PVOID);
09906        ((TDSetProxy*) (soff))->~G__TTDSetProxy();
09907        G__setgvp((long)gvp);
09908      }
09909    }
09910    G__setnull(result7);
09911    return(1 || funcname || hash || result7 || libp) ;
09912 }
09913 
09914 
09915 /* TProofDesc */
09916 static int G__G__Proof_263_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
09917 {
09918    TProofDesc* p = NULL;
09919    char* gvp = (char*) G__getgvp();
09920    switch (libp->paran) {
09921    case 7:
09922      //m: 7
09923      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09924        p = new TProofDesc(
09925 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09926 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09927 , (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
09928 , (TProof*) G__int(libp->para[6]));
09929      } else {
09930        p = new((void*) gvp) TProofDesc(
09931 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09932 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09933 , (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5])
09934 , (TProof*) G__int(libp->para[6]));
09935      }
09936      break;
09937    case 6:
09938      //m: 6
09939      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09940        p = new TProofDesc(
09941 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09942 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09943 , (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
09944      } else {
09945        p = new((void*) gvp) TProofDesc(
09946 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09947 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09948 , (Int_t) G__int(libp->para[4]), (Int_t) G__int(libp->para[5]));
09949      }
09950      break;
09951    case 5:
09952      //m: 5
09953      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09954        p = new TProofDesc(
09955 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09956 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09957 , (Int_t) G__int(libp->para[4]));
09958      } else {
09959        p = new((void*) gvp) TProofDesc(
09960 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09961 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
09962 , (Int_t) G__int(libp->para[4]));
09963      }
09964      break;
09965    case 4:
09966      //m: 4
09967      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09968        p = new TProofDesc(
09969 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09970 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
09971      } else {
09972        p = new((void*) gvp) TProofDesc(
09973 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09974 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
09975      }
09976      break;
09977    case 3:
09978      //m: 3
09979      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09980        p = new TProofDesc(
09981 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09982 , (const char*) G__int(libp->para[2]));
09983      } else {
09984        p = new((void*) gvp) TProofDesc(
09985 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
09986 , (const char*) G__int(libp->para[2]));
09987      }
09988      break;
09989    case 2:
09990      //m: 2
09991      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
09992        p = new TProofDesc((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
09993      } else {
09994        p = new((void*) gvp) TProofDesc((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
09995      }
09996      break;
09997    case 1:
09998      //m: 1
09999      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10000        p = new TProofDesc((const char*) G__int(libp->para[0]));
10001      } else {
10002        p = new((void*) gvp) TProofDesc((const char*) G__int(libp->para[0]));
10003      }
10004      break;
10005    case 0:
10006      int n = G__getaryconstruct();
10007      if (n) {
10008        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10009          p = new TProofDesc[n];
10010        } else {
10011          p = new((void*) gvp) TProofDesc[n];
10012        }
10013      } else {
10014        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10015          p = new TProofDesc;
10016        } else {
10017          p = new((void*) gvp) TProofDesc;
10018        }
10019      }
10020      break;
10021    }
10022    result7->obj.i = (long) p;
10023    result7->ref = (long) p;
10024    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofDesc));
10025    return(1 || funcname || hash || result7 || libp) ;
10026 }
10027 
10028 static int G__G__Proof_263_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10029 {
10030       G__letint(result7, 105, (long) ((const TProofDesc*) G__getstructoffset())->GetLocalId());
10031    return(1 || funcname || hash || result7 || libp) ;
10032 }
10033 
10034 static int G__G__Proof_263_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10035 {
10036       G__letint(result7, 85, (long) ((const TProofDesc*) G__getstructoffset())->GetProof());
10037    return(1 || funcname || hash || result7 || libp) ;
10038 }
10039 
10040 static int G__G__Proof_263_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10041 {
10042       G__letint(result7, 105, (long) ((const TProofDesc*) G__getstructoffset())->GetRemoteId());
10043    return(1 || funcname || hash || result7 || libp) ;
10044 }
10045 
10046 static int G__G__Proof_263_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10047 {
10048       G__letint(result7, 105, (long) ((const TProofDesc*) G__getstructoffset())->GetStatus());
10049    return(1 || funcname || hash || result7 || libp) ;
10050 }
10051 
10052 static int G__G__Proof_263_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10053 {
10054       G__letint(result7, 67, (long) ((const TProofDesc*) G__getstructoffset())->GetUrl());
10055    return(1 || funcname || hash || result7 || libp) ;
10056 }
10057 
10058 static int G__G__Proof_263_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10059 {
10060       G__letint(result7, 103, (long) ((const TProofDesc*) G__getstructoffset())->IsIdle());
10061    return(1 || funcname || hash || result7 || libp) ;
10062 }
10063 
10064 static int G__G__Proof_263_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10065 {
10066       G__letint(result7, 103, (long) ((const TProofDesc*) G__getstructoffset())->IsRunning());
10067    return(1 || funcname || hash || result7 || libp) ;
10068 }
10069 
10070 static int G__G__Proof_263_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10071 {
10072       G__letint(result7, 103, (long) ((const TProofDesc*) G__getstructoffset())->IsShuttingDown());
10073    return(1 || funcname || hash || result7 || libp) ;
10074 }
10075 
10076 static int G__G__Proof_263_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10077 {
10078       G__letint(result7, 103, (long) ((const TProofDesc*) G__getstructoffset())->MatchId((Int_t) G__int(libp->para[0])));
10079    return(1 || funcname || hash || result7 || libp) ;
10080 }
10081 
10082 static int G__G__Proof_263_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10083 {
10084       ((TProofDesc*) G__getstructoffset())->SetStatus((Int_t) G__int(libp->para[0]));
10085       G__setnull(result7);
10086    return(1 || funcname || hash || result7 || libp) ;
10087 }
10088 
10089 static int G__G__Proof_263_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10090 {
10091       ((TProofDesc*) G__getstructoffset())->SetProof((TProof*) G__int(libp->para[0]));
10092       G__setnull(result7);
10093    return(1 || funcname || hash || result7 || libp) ;
10094 }
10095 
10096 static int G__G__Proof_263_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10097 {
10098       ((TProofDesc*) G__getstructoffset())->SetRemoteId((Int_t) G__int(libp->para[0]));
10099       G__setnull(result7);
10100    return(1 || funcname || hash || result7 || libp) ;
10101 }
10102 
10103 static int G__G__Proof_263_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10104 {
10105       G__letint(result7, 85, (long) TProofDesc::Class());
10106    return(1 || funcname || hash || result7 || libp) ;
10107 }
10108 
10109 static int G__G__Proof_263_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10110 {
10111       G__letint(result7, 67, (long) TProofDesc::Class_Name());
10112    return(1 || funcname || hash || result7 || libp) ;
10113 }
10114 
10115 static int G__G__Proof_263_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10116 {
10117       G__letint(result7, 115, (long) TProofDesc::Class_Version());
10118    return(1 || funcname || hash || result7 || libp) ;
10119 }
10120 
10121 static int G__G__Proof_263_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10122 {
10123       TProofDesc::Dictionary();
10124       G__setnull(result7);
10125    return(1 || funcname || hash || result7 || libp) ;
10126 }
10127 
10128 static int G__G__Proof_263_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10129 {
10130       ((TProofDesc*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10131       G__setnull(result7);
10132    return(1 || funcname || hash || result7 || libp) ;
10133 }
10134 
10135 static int G__G__Proof_263_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10136 {
10137       G__letint(result7, 67, (long) TProofDesc::DeclFileName());
10138    return(1 || funcname || hash || result7 || libp) ;
10139 }
10140 
10141 static int G__G__Proof_263_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10142 {
10143       G__letint(result7, 105, (long) TProofDesc::ImplFileLine());
10144    return(1 || funcname || hash || result7 || libp) ;
10145 }
10146 
10147 static int G__G__Proof_263_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10148 {
10149       G__letint(result7, 67, (long) TProofDesc::ImplFileName());
10150    return(1 || funcname || hash || result7 || libp) ;
10151 }
10152 
10153 static int G__G__Proof_263_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10154 {
10155       G__letint(result7, 105, (long) TProofDesc::DeclFileLine());
10156    return(1 || funcname || hash || result7 || libp) ;
10157 }
10158 
10159 // automatic destructor
10160 typedef TProofDesc G__TTProofDesc;
10161 static int G__G__Proof_263_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10162 {
10163    char* gvp = (char*) G__getgvp();
10164    long soff = G__getstructoffset();
10165    int n = G__getaryconstruct();
10166    //
10167    //has_a_delete: 1
10168    //has_own_delete1arg: 0
10169    //has_own_delete2arg: 0
10170    //
10171    if (!soff) {
10172      return(1);
10173    }
10174    if (n) {
10175      if (gvp == (char*)G__PVOID) {
10176        delete[] (TProofDesc*) soff;
10177      } else {
10178        G__setgvp((long) G__PVOID);
10179        for (int i = n - 1; i >= 0; --i) {
10180          ((TProofDesc*) (soff+(sizeof(TProofDesc)*i)))->~G__TTProofDesc();
10181        }
10182        G__setgvp((long)gvp);
10183      }
10184    } else {
10185      if (gvp == (char*)G__PVOID) {
10186        delete (TProofDesc*) soff;
10187      } else {
10188        G__setgvp((long) G__PVOID);
10189        ((TProofDesc*) (soff))->~G__TTProofDesc();
10190        G__setgvp((long)gvp);
10191      }
10192    }
10193    G__setnull(result7);
10194    return(1 || funcname || hash || result7 || libp) ;
10195 }
10196 
10197 
10198 /* TProofLog */
10199 static int G__G__Proof_264_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10200 {
10201    TProofLog* p = NULL;
10202    char* gvp = (char*) G__getgvp();
10203    //m: 3
10204    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10205      p = new TProofLog(
10206 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10207 , (TProofMgr*) G__int(libp->para[2]));
10208    } else {
10209      p = new((void*) gvp) TProofLog(
10210 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10211 , (TProofMgr*) G__int(libp->para[2]));
10212    }
10213    result7->obj.i = (long) p;
10214    result7->ref = (long) p;
10215    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofLog));
10216    return(1 || funcname || hash || result7 || libp) ;
10217 }
10218 
10219 static int G__G__Proof_264_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10220 {
10221    switch (libp->paran) {
10222    case 3:
10223       ((TProofLog*) G__getstructoffset())->Display((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10224 , (Int_t) G__int(libp->para[2]));
10225       G__setnull(result7);
10226       break;
10227    case 2:
10228       ((TProofLog*) G__getstructoffset())->Display((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
10229       G__setnull(result7);
10230       break;
10231    case 1:
10232       ((TProofLog*) G__getstructoffset())->Display((const char*) G__int(libp->para[0]));
10233       G__setnull(result7);
10234       break;
10235    case 0:
10236       ((TProofLog*) G__getstructoffset())->Display();
10237       G__setnull(result7);
10238       break;
10239    }
10240    return(1 || funcname || hash || result7 || libp) ;
10241 }
10242 
10243 static int G__G__Proof_264_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10244 {
10245       G__letint(result7, 85, (long) ((const TProofLog*) G__getstructoffset())->GetListOfLogs());
10246    return(1 || funcname || hash || result7 || libp) ;
10247 }
10248 
10249 static int G__G__Proof_264_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10250 {
10251    switch (libp->paran) {
10252    case 2:
10253       G__letint(result7, 105, (long) ((TProofLog*) G__getstructoffset())->Grep((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
10254       break;
10255    case 1:
10256       G__letint(result7, 105, (long) ((TProofLog*) G__getstructoffset())->Grep((const char*) G__int(libp->para[0])));
10257       break;
10258    }
10259    return(1 || funcname || hash || result7 || libp) ;
10260 }
10261 
10262 static int G__G__Proof_264_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10263 {
10264       ((TProofLog*) G__getstructoffset())->Prt((const char*) G__int(libp->para[0]));
10265       G__setnull(result7);
10266    return(1 || funcname || hash || result7 || libp) ;
10267 }
10268 
10269 static int G__G__Proof_264_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10270 {
10271    switch (libp->paran) {
10272    case 4:
10273       G__letint(result7, 105, (long) ((TProofLog*) G__getstructoffset())->Retrieve((const char*) G__int(libp->para[0]), (TProofLog::ERetrieveOpt) G__int(libp->para[1])
10274 , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])));
10275       break;
10276    case 3:
10277       G__letint(result7, 105, (long) ((TProofLog*) G__getstructoffset())->Retrieve((const char*) G__int(libp->para[0]), (TProofLog::ERetrieveOpt) G__int(libp->para[1])
10278 , (const char*) G__int(libp->para[2])));
10279       break;
10280    case 2:
10281       G__letint(result7, 105, (long) ((TProofLog*) G__getstructoffset())->Retrieve((const char*) G__int(libp->para[0]), (TProofLog::ERetrieveOpt) G__int(libp->para[1])));
10282       break;
10283    case 1:
10284       G__letint(result7, 105, (long) ((TProofLog*) G__getstructoffset())->Retrieve((const char*) G__int(libp->para[0])));
10285       break;
10286    case 0:
10287       G__letint(result7, 105, (long) ((TProofLog*) G__getstructoffset())->Retrieve());
10288       break;
10289    }
10290    return(1 || funcname || hash || result7 || libp) ;
10291 }
10292 
10293 static int G__G__Proof_264_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10294 {
10295    switch (libp->paran) {
10296    case 3:
10297       G__letint(result7, 105, (long) ((TProofLog*) G__getstructoffset())->Save((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10298 , (Option_t*) G__int(libp->para[2])));
10299       break;
10300    case 2:
10301       G__letint(result7, 105, (long) ((TProofLog*) G__getstructoffset())->Save((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
10302       break;
10303    case 1:
10304       G__letint(result7, 105, (long) ((TProofLog*) G__getstructoffset())->Save((const char*) G__int(libp->para[0])));
10305       break;
10306    case 0:
10307       G__letint(result7, 105, (long) ((TProofLog*) G__getstructoffset())->Save());
10308       break;
10309    }
10310    return(1 || funcname || hash || result7 || libp) ;
10311 }
10312 
10313 static int G__G__Proof_264_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10314 {
10315       {
10316          TDatime* pobj;
10317          TDatime xobj = ((TProofLog*) G__getstructoffset())->StartTime();
10318          pobj = new TDatime(xobj);
10319          result7->obj.i = (long) ((void*) pobj);
10320          result7->ref = result7->obj.i;
10321          G__store_tempobject(*result7);
10322       }
10323    return(1 || funcname || hash || result7 || libp) ;
10324 }
10325 
10326 static int G__G__Proof_264_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10327 {
10328    switch (libp->paran) {
10329    case 1:
10330       ((TProofLog*) G__getstructoffset())->SetLogToBox((Bool_t) G__int(libp->para[0]));
10331       G__setnull(result7);
10332       break;
10333    case 0:
10334       ((TProofLog*) G__getstructoffset())->SetLogToBox();
10335       G__setnull(result7);
10336       break;
10337    }
10338    return(1 || funcname || hash || result7 || libp) ;
10339 }
10340 
10341 static int G__G__Proof_264_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10342 {
10343       G__letint(result7, 103, (long) ((TProofLog*) G__getstructoffset())->LogToBox());
10344    return(1 || funcname || hash || result7 || libp) ;
10345 }
10346 
10347 static int G__G__Proof_264_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10348 {
10349       TProofLog::SetMaxTransferSize((Long64_t) G__Longlong(libp->para[0]));
10350       G__setnull(result7);
10351    return(1 || funcname || hash || result7 || libp) ;
10352 }
10353 
10354 static int G__G__Proof_264_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10355 {
10356       G__letint(result7, 85, (long) TProofLog::Class());
10357    return(1 || funcname || hash || result7 || libp) ;
10358 }
10359 
10360 static int G__G__Proof_264_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10361 {
10362       G__letint(result7, 67, (long) TProofLog::Class_Name());
10363    return(1 || funcname || hash || result7 || libp) ;
10364 }
10365 
10366 static int G__G__Proof_264_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10367 {
10368       G__letint(result7, 115, (long) TProofLog::Class_Version());
10369    return(1 || funcname || hash || result7 || libp) ;
10370 }
10371 
10372 static int G__G__Proof_264_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10373 {
10374       TProofLog::Dictionary();
10375       G__setnull(result7);
10376    return(1 || funcname || hash || result7 || libp) ;
10377 }
10378 
10379 static int G__G__Proof_264_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10380 {
10381       ((TProofLog*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
10382       G__setnull(result7);
10383    return(1 || funcname || hash || result7 || libp) ;
10384 }
10385 
10386 static int G__G__Proof_264_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10387 {
10388       G__letint(result7, 67, (long) TProofLog::DeclFileName());
10389    return(1 || funcname || hash || result7 || libp) ;
10390 }
10391 
10392 static int G__G__Proof_264_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10393 {
10394       G__letint(result7, 105, (long) TProofLog::ImplFileLine());
10395    return(1 || funcname || hash || result7 || libp) ;
10396 }
10397 
10398 static int G__G__Proof_264_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10399 {
10400       G__letint(result7, 67, (long) TProofLog::ImplFileName());
10401    return(1 || funcname || hash || result7 || libp) ;
10402 }
10403 
10404 static int G__G__Proof_264_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10405 {
10406       G__letint(result7, 105, (long) TProofLog::DeclFileLine());
10407    return(1 || funcname || hash || result7 || libp) ;
10408 }
10409 
10410 // automatic destructor
10411 typedef TProofLog G__TTProofLog;
10412 static int G__G__Proof_264_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10413 {
10414    char* gvp = (char*) G__getgvp();
10415    long soff = G__getstructoffset();
10416    int n = G__getaryconstruct();
10417    //
10418    //has_a_delete: 1
10419    //has_own_delete1arg: 0
10420    //has_own_delete2arg: 0
10421    //
10422    if (!soff) {
10423      return(1);
10424    }
10425    if (n) {
10426      if (gvp == (char*)G__PVOID) {
10427        delete[] (TProofLog*) soff;
10428      } else {
10429        G__setgvp((long) G__PVOID);
10430        for (int i = n - 1; i >= 0; --i) {
10431          ((TProofLog*) (soff+(sizeof(TProofLog)*i)))->~G__TTProofLog();
10432        }
10433        G__setgvp((long)gvp);
10434      }
10435    } else {
10436      if (gvp == (char*)G__PVOID) {
10437        delete (TProofLog*) soff;
10438      } else {
10439        G__setgvp((long) G__PVOID);
10440        ((TProofLog*) (soff))->~G__TTProofLog();
10441        G__setgvp((long)gvp);
10442      }
10443    }
10444    G__setnull(result7);
10445    return(1 || funcname || hash || result7 || libp) ;
10446 }
10447 
10448 
10449 /* TProofMgr */
10450 static int G__G__Proof_265_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10451 {
10452    TProofMgr* p = NULL;
10453    char* gvp = (char*) G__getgvp();
10454    switch (libp->paran) {
10455    case 3:
10456      //m: 3
10457      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10458        p = new TProofMgr(
10459 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10460 , (const char*) G__int(libp->para[2]));
10461      } else {
10462        p = new((void*) gvp) TProofMgr(
10463 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10464 , (const char*) G__int(libp->para[2]));
10465      }
10466      break;
10467    case 2:
10468      //m: 2
10469      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10470        p = new TProofMgr((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
10471      } else {
10472        p = new((void*) gvp) TProofMgr((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
10473      }
10474      break;
10475    case 1:
10476      //m: 1
10477      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
10478        p = new TProofMgr((const char*) G__int(libp->para[0]));
10479      } else {
10480        p = new((void*) gvp) TProofMgr((const char*) G__int(libp->para[0]));
10481      }
10482      break;
10483    }
10484    result7->obj.i = (long) p;
10485    result7->ref = (long) p;
10486    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofMgr));
10487    return(1 || funcname || hash || result7 || libp) ;
10488 }
10489 
10490 static int G__G__Proof_265_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10491 {
10492       G__letint(result7, 103, (long) ((const TProofMgr*) G__getstructoffset())->IsLite());
10493    return(1 || funcname || hash || result7 || libp) ;
10494 }
10495 
10496 static int G__G__Proof_265_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10497 {
10498       G__letint(result7, 103, (long) ((const TProofMgr*) G__getstructoffset())->IsProofd());
10499    return(1 || funcname || hash || result7 || libp) ;
10500 }
10501 
10502 static int G__G__Proof_265_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10503 {
10504       G__letint(result7, 103, (long) ((const TProofMgr*) G__getstructoffset())->IsValid());
10505    return(1 || funcname || hash || result7 || libp) ;
10506 }
10507 
10508 static int G__G__Proof_265_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10509 {
10510       ((TProofMgr*) G__getstructoffset())->SetInvalid();
10511       G__setnull(result7);
10512    return(1 || funcname || hash || result7 || libp) ;
10513 }
10514 
10515 static int G__G__Proof_265_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10516 {
10517    switch (libp->paran) {
10518    case 2:
10519       G__letint(result7, 85, (long) ((TProofMgr*) G__getstructoffset())->AttachSession((Int_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
10520       break;
10521    case 1:
10522       G__letint(result7, 85, (long) ((TProofMgr*) G__getstructoffset())->AttachSession((Int_t) G__int(libp->para[0])));
10523       break;
10524    }
10525    return(1 || funcname || hash || result7 || libp) ;
10526 }
10527 
10528 static int G__G__Proof_265_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10529 {
10530    switch (libp->paran) {
10531    case 2:
10532       G__letint(result7, 85, (long) ((TProofMgr*) G__getstructoffset())->AttachSession((TProofDesc*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
10533       break;
10534    case 1:
10535       G__letint(result7, 85, (long) ((TProofMgr*) G__getstructoffset())->AttachSession((TProofDesc*) G__int(libp->para[0])));
10536       break;
10537    }
10538    return(1 || funcname || hash || result7 || libp) ;
10539 }
10540 
10541 static int G__G__Proof_265_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10542 {
10543    switch (libp->paran) {
10544    case 3:
10545       G__letint(result7, 85, (long) ((TProofMgr*) G__getstructoffset())->CreateSession((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10546 , (Int_t) G__int(libp->para[2])));
10547       break;
10548    case 2:
10549       G__letint(result7, 85, (long) ((TProofMgr*) G__getstructoffset())->CreateSession((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
10550       break;
10551    case 1:
10552       G__letint(result7, 85, (long) ((TProofMgr*) G__getstructoffset())->CreateSession((const char*) G__int(libp->para[0])));
10553       break;
10554    case 0:
10555       G__letint(result7, 85, (long) ((TProofMgr*) G__getstructoffset())->CreateSession());
10556       break;
10557    }
10558    return(1 || funcname || hash || result7 || libp) ;
10559 }
10560 
10561 static int G__G__Proof_265_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10562 {
10563    switch (libp->paran) {
10564    case 2:
10565       ((TProofMgr*) G__getstructoffset())->DetachSession((Int_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
10566       G__setnull(result7);
10567       break;
10568    case 1:
10569       ((TProofMgr*) G__getstructoffset())->DetachSession((Int_t) G__int(libp->para[0]));
10570       G__setnull(result7);
10571       break;
10572    }
10573    return(1 || funcname || hash || result7 || libp) ;
10574 }
10575 
10576 static int G__G__Proof_265_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10577 {
10578    switch (libp->paran) {
10579    case 2:
10580       ((TProofMgr*) G__getstructoffset())->DetachSession((TProof*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
10581       G__setnull(result7);
10582       break;
10583    case 1:
10584       ((TProofMgr*) G__getstructoffset())->DetachSession((TProof*) G__int(libp->para[0]));
10585       G__setnull(result7);
10586       break;
10587    }
10588    return(1 || funcname || hash || result7 || libp) ;
10589 }
10590 
10591 static int G__G__Proof_265_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10592 {
10593       ((TProofMgr*) G__getstructoffset())->DiscardSession((TProof*) G__int(libp->para[0]));
10594       G__setnull(result7);
10595    return(1 || funcname || hash || result7 || libp) ;
10596 }
10597 
10598 static int G__G__Proof_265_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10599 {
10600       G__letint(result7, 85, (long) ((TProofMgr*) G__getstructoffset())->GetProofDesc((Int_t) G__int(libp->para[0])));
10601    return(1 || funcname || hash || result7 || libp) ;
10602 }
10603 
10604 static int G__G__Proof_265_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10605 {
10606       G__letint(result7, 85, (long) ((TProofMgr*) G__getstructoffset())->GetProofDesc((TProof*) G__int(libp->para[0])));
10607    return(1 || funcname || hash || result7 || libp) ;
10608 }
10609 
10610 static int G__G__Proof_265_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10611 {
10612       G__letint(result7, 105, (long) ((const TProofMgr*) G__getstructoffset())->GetRemoteProtocol());
10613    return(1 || funcname || hash || result7 || libp) ;
10614 }
10615 
10616 static int G__G__Proof_265_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10617 {
10618    switch (libp->paran) {
10619    case 3:
10620       G__letint(result7, 85, (long) ((TProofMgr*) G__getstructoffset())->GetSessionLogs((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10621 , (const char*) G__int(libp->para[2])));
10622       break;
10623    case 2:
10624       G__letint(result7, 85, (long) ((TProofMgr*) G__getstructoffset())->GetSessionLogs((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
10625       break;
10626    case 1:
10627       G__letint(result7, 85, (long) ((TProofMgr*) G__getstructoffset())->GetSessionLogs((Int_t) G__int(libp->para[0])));
10628       break;
10629    case 0:
10630       G__letint(result7, 85, (long) ((TProofMgr*) G__getstructoffset())->GetSessionLogs());
10631       break;
10632    }
10633    return(1 || funcname || hash || result7 || libp) ;
10634 }
10635 
10636 static int G__G__Proof_265_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10637 {
10638       G__letint(result7, 67, (long) ((TProofMgr*) G__getstructoffset())->GetUrl());
10639    return(1 || funcname || hash || result7 || libp) ;
10640 }
10641 
10642 static int G__G__Proof_265_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10643 {
10644       G__letint(result7, 103, (long) ((TProofMgr*) G__getstructoffset())->MatchUrl((const char*) G__int(libp->para[0])));
10645    return(1 || funcname || hash || result7 || libp) ;
10646 }
10647 
10648 static int G__G__Proof_265_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10649 {
10650    switch (libp->paran) {
10651    case 1:
10652       G__letint(result7, 85, (long) ((TProofMgr*) G__getstructoffset())->QuerySessions((Option_t*) G__int(libp->para[0])));
10653       break;
10654    case 0:
10655       G__letint(result7, 85, (long) ((TProofMgr*) G__getstructoffset())->QuerySessions());
10656       break;
10657    }
10658    return(1 || funcname || hash || result7 || libp) ;
10659 }
10660 
10661 static int G__G__Proof_265_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10662 {
10663       G__letint(result7, 85, (long) ((TProofMgr*) G__getstructoffset())->ReadBuffer((const char*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
10664 , (Int_t) G__int(libp->para[2])));
10665    return(1 || funcname || hash || result7 || libp) ;
10666 }
10667 
10668 static int G__G__Proof_265_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10669 {
10670       G__letint(result7, 85, (long) ((TProofMgr*) G__getstructoffset())->ReadBuffer((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
10671    return(1 || funcname || hash || result7 || libp) ;
10672 }
10673 
10674 static int G__G__Proof_265_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10675 {
10676    switch (libp->paran) {
10677    case 2:
10678       G__letint(result7, 105, (long) ((TProofMgr*) G__getstructoffset())->Reset((Bool_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
10679       break;
10680    case 1:
10681       G__letint(result7, 105, (long) ((TProofMgr*) G__getstructoffset())->Reset((Bool_t) G__int(libp->para[0])));
10682       break;
10683    case 0:
10684       G__letint(result7, 105, (long) ((TProofMgr*) G__getstructoffset())->Reset());
10685       break;
10686    }
10687    return(1 || funcname || hash || result7 || libp) ;
10688 }
10689 
10690 static int G__G__Proof_265_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10691 {
10692       ((TProofMgr*) G__getstructoffset())->ShowWorkers();
10693       G__setnull(result7);
10694    return(1 || funcname || hash || result7 || libp) ;
10695 }
10696 
10697 static int G__G__Proof_265_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10698 {
10699    switch (libp->paran) {
10700    case 2:
10701       G__letint(result7, 105, (long) ((TProofMgr*) G__getstructoffset())->SendMsgToUsers((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
10702       break;
10703    case 1:
10704       G__letint(result7, 105, (long) ((TProofMgr*) G__getstructoffset())->SendMsgToUsers((const char*) G__int(libp->para[0])));
10705       break;
10706    }
10707    return(1 || funcname || hash || result7 || libp) ;
10708 }
10709 
10710 static int G__G__Proof_265_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10711 {
10712    switch (libp->paran) {
10713    case 1:
10714       ((TProofMgr*) G__getstructoffset())->SetAlias((const char*) G__int(libp->para[0]));
10715       G__setnull(result7);
10716       break;
10717    case 0:
10718       ((TProofMgr*) G__getstructoffset())->SetAlias();
10719       G__setnull(result7);
10720       break;
10721    }
10722    return(1 || funcname || hash || result7 || libp) ;
10723 }
10724 
10725 static int G__G__Proof_265_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10726 {
10727       ((TProofMgr*) G__getstructoffset())->SetROOTVersion((const char*) G__int(libp->para[0]));
10728       G__setnull(result7);
10729    return(1 || funcname || hash || result7 || libp) ;
10730 }
10731 
10732 static int G__G__Proof_265_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10733 {
10734       ((TProofMgr*) G__getstructoffset())->ShowROOTVersions();
10735       G__setnull(result7);
10736    return(1 || funcname || hash || result7 || libp) ;
10737 }
10738 
10739 static int G__G__Proof_265_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10740 {
10741       ((TProofMgr*) G__getstructoffset())->ShutdownSession((Int_t) G__int(libp->para[0]));
10742       G__setnull(result7);
10743    return(1 || funcname || hash || result7 || libp) ;
10744 }
10745 
10746 static int G__G__Proof_265_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10747 {
10748       ((TProofMgr*) G__getstructoffset())->ShutdownSession((TProof*) G__int(libp->para[0]));
10749       G__setnull(result7);
10750    return(1 || funcname || hash || result7 || libp) ;
10751 }
10752 
10753 static int G__G__Proof_265_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10754 {
10755    switch (libp->paran) {
10756    case 3:
10757       G__letint(result7, 105, (long) ((TProofMgr*) G__getstructoffset())->Cp((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10758 , (const char*) G__int(libp->para[2])));
10759       break;
10760    case 2:
10761       G__letint(result7, 105, (long) ((TProofMgr*) G__getstructoffset())->Cp((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
10762       break;
10763    case 1:
10764       G__letint(result7, 105, (long) ((TProofMgr*) G__getstructoffset())->Cp((const char*) G__int(libp->para[0])));
10765       break;
10766    }
10767    return(1 || funcname || hash || result7 || libp) ;
10768 }
10769 
10770 static int G__G__Proof_265_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10771 {
10772    switch (libp->paran) {
10773    case 3:
10774       ((TProofMgr*) G__getstructoffset())->Find((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10775 , (const char*) G__int(libp->para[2]));
10776       G__setnull(result7);
10777       break;
10778    case 2:
10779       ((TProofMgr*) G__getstructoffset())->Find((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
10780       G__setnull(result7);
10781       break;
10782    case 1:
10783       ((TProofMgr*) G__getstructoffset())->Find((const char*) G__int(libp->para[0]));
10784       G__setnull(result7);
10785       break;
10786    case 0:
10787       ((TProofMgr*) G__getstructoffset())->Find();
10788       G__setnull(result7);
10789       break;
10790    }
10791    return(1 || funcname || hash || result7 || libp) ;
10792 }
10793 
10794 static int G__G__Proof_265_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10795 {
10796    switch (libp->paran) {
10797    case 3:
10798       ((TProofMgr*) G__getstructoffset())->Grep((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10799 , (const char*) G__int(libp->para[2]));
10800       G__setnull(result7);
10801       break;
10802    case 2:
10803       ((TProofMgr*) G__getstructoffset())->Grep((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
10804       G__setnull(result7);
10805       break;
10806    case 1:
10807       ((TProofMgr*) G__getstructoffset())->Grep((const char*) G__int(libp->para[0]));
10808       G__setnull(result7);
10809       break;
10810    }
10811    return(1 || funcname || hash || result7 || libp) ;
10812 }
10813 
10814 static int G__G__Proof_265_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10815 {
10816    switch (libp->paran) {
10817    case 3:
10818       ((TProofMgr*) G__getstructoffset())->Ls((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10819 , (const char*) G__int(libp->para[2]));
10820       G__setnull(result7);
10821       break;
10822    case 2:
10823       ((TProofMgr*) G__getstructoffset())->Ls((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
10824       G__setnull(result7);
10825       break;
10826    case 1:
10827       ((TProofMgr*) G__getstructoffset())->Ls((const char*) G__int(libp->para[0]));
10828       G__setnull(result7);
10829       break;
10830    case 0:
10831       ((TProofMgr*) G__getstructoffset())->Ls();
10832       G__setnull(result7);
10833       break;
10834    }
10835    return(1 || funcname || hash || result7 || libp) ;
10836 }
10837 
10838 static int G__G__Proof_265_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10839 {
10840    switch (libp->paran) {
10841    case 3:
10842       ((TProofMgr*) G__getstructoffset())->More((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10843 , (const char*) G__int(libp->para[2]));
10844       G__setnull(result7);
10845       break;
10846    case 2:
10847       ((TProofMgr*) G__getstructoffset())->More((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
10848       G__setnull(result7);
10849       break;
10850    case 1:
10851       ((TProofMgr*) G__getstructoffset())->More((const char*) G__int(libp->para[0]));
10852       G__setnull(result7);
10853       break;
10854    }
10855    return(1 || funcname || hash || result7 || libp) ;
10856 }
10857 
10858 static int G__G__Proof_265_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10859 {
10860    switch (libp->paran) {
10861    case 3:
10862       G__letint(result7, 105, (long) ((TProofMgr*) G__getstructoffset())->Rm((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10863 , (const char*) G__int(libp->para[2])));
10864       break;
10865    case 2:
10866       G__letint(result7, 105, (long) ((TProofMgr*) G__getstructoffset())->Rm((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
10867       break;
10868    case 1:
10869       G__letint(result7, 105, (long) ((TProofMgr*) G__getstructoffset())->Rm((const char*) G__int(libp->para[0])));
10870       break;
10871    }
10872    return(1 || funcname || hash || result7 || libp) ;
10873 }
10874 
10875 static int G__G__Proof_265_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10876 {
10877    switch (libp->paran) {
10878    case 3:
10879       ((TProofMgr*) G__getstructoffset())->Tail((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10880 , (const char*) G__int(libp->para[2]));
10881       G__setnull(result7);
10882       break;
10883    case 2:
10884       ((TProofMgr*) G__getstructoffset())->Tail((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
10885       G__setnull(result7);
10886       break;
10887    case 1:
10888       ((TProofMgr*) G__getstructoffset())->Tail((const char*) G__int(libp->para[0]));
10889       G__setnull(result7);
10890       break;
10891    }
10892    return(1 || funcname || hash || result7 || libp) ;
10893 }
10894 
10895 static int G__G__Proof_265_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10896 {
10897    switch (libp->paran) {
10898    case 3:
10899       G__letint(result7, 105, (long) ((TProofMgr*) G__getstructoffset())->Md5sum((const char*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
10900 , (const char*) G__int(libp->para[2])));
10901       break;
10902    case 2:
10903       G__letint(result7, 105, (long) ((TProofMgr*) G__getstructoffset())->Md5sum((const char*) G__int(libp->para[0]), *(TString*) libp->para[1].ref));
10904       break;
10905    }
10906    return(1 || funcname || hash || result7 || libp) ;
10907 }
10908 
10909 static int G__G__Proof_265_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10910 {
10911    switch (libp->paran) {
10912    case 3:
10913       G__letint(result7, 105, (long) ((TProofMgr*) G__getstructoffset())->Stat((const char*) G__int(libp->para[0]), *(FileStat_t*) libp->para[1].ref
10914 , (const char*) G__int(libp->para[2])));
10915       break;
10916    case 2:
10917       G__letint(result7, 105, (long) ((TProofMgr*) G__getstructoffset())->Stat((const char*) G__int(libp->para[0]), *(FileStat_t*) libp->para[1].ref));
10918       break;
10919    }
10920    return(1 || funcname || hash || result7 || libp) ;
10921 }
10922 
10923 static int G__G__Proof_265_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10924 {
10925    switch (libp->paran) {
10926    case 3:
10927       G__letint(result7, 105, (long) ((TProofMgr*) G__getstructoffset())->GetFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10928 , (const char*) G__int(libp->para[2])));
10929       break;
10930    case 2:
10931       G__letint(result7, 105, (long) ((TProofMgr*) G__getstructoffset())->GetFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
10932       break;
10933    }
10934    return(1 || funcname || hash || result7 || libp) ;
10935 }
10936 
10937 static int G__G__Proof_265_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10938 {
10939    switch (libp->paran) {
10940    case 3:
10941       G__letint(result7, 105, (long) ((TProofMgr*) G__getstructoffset())->PutFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
10942 , (const char*) G__int(libp->para[2])));
10943       break;
10944    case 2:
10945       G__letint(result7, 105, (long) ((TProofMgr*) G__getstructoffset())->PutFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
10946       break;
10947    }
10948    return(1 || funcname || hash || result7 || libp) ;
10949 }
10950 
10951 static int G__G__Proof_265_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10952 {
10953       G__letint(result7, 85, (long) TProofMgr::GetListOfManagers());
10954    return(1 || funcname || hash || result7 || libp) ;
10955 }
10956 
10957 static int G__G__Proof_265_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10958 {
10959       TProofMgr::SetTXProofMgrHook((TProofMgr_t) G__int(libp->para[0]));
10960       G__setnull(result7);
10961    return(1 || funcname || hash || result7 || libp) ;
10962 }
10963 
10964 static int G__G__Proof_265_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10965 {
10966    switch (libp->paran) {
10967    case 4:
10968       G__letint(result7, 85, (long) TProofMgr::Create((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10969 , (const char*) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])));
10970       break;
10971    case 3:
10972       G__letint(result7, 85, (long) TProofMgr::Create((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
10973 , (const char*) G__int(libp->para[2])));
10974       break;
10975    case 2:
10976       G__letint(result7, 85, (long) TProofMgr::Create((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
10977       break;
10978    case 1:
10979       G__letint(result7, 85, (long) TProofMgr::Create((const char*) G__int(libp->para[0])));
10980       break;
10981    }
10982    return(1 || funcname || hash || result7 || libp) ;
10983 }
10984 
10985 static int G__G__Proof_265_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10986 {
10987       G__letint(result7, 85, (long) TProofMgr::Class());
10988    return(1 || funcname || hash || result7 || libp) ;
10989 }
10990 
10991 static int G__G__Proof_265_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10992 {
10993       G__letint(result7, 67, (long) TProofMgr::Class_Name());
10994    return(1 || funcname || hash || result7 || libp) ;
10995 }
10996 
10997 static int G__G__Proof_265_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
10998 {
10999       G__letint(result7, 115, (long) TProofMgr::Class_Version());
11000    return(1 || funcname || hash || result7 || libp) ;
11001 }
11002 
11003 static int G__G__Proof_265_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11004 {
11005       TProofMgr::Dictionary();
11006       G__setnull(result7);
11007    return(1 || funcname || hash || result7 || libp) ;
11008 }
11009 
11010 static int G__G__Proof_265_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11011 {
11012       ((TProofMgr*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11013       G__setnull(result7);
11014    return(1 || funcname || hash || result7 || libp) ;
11015 }
11016 
11017 static int G__G__Proof_265_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11018 {
11019       G__letint(result7, 67, (long) TProofMgr::DeclFileName());
11020    return(1 || funcname || hash || result7 || libp) ;
11021 }
11022 
11023 static int G__G__Proof_265_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11024 {
11025       G__letint(result7, 105, (long) TProofMgr::ImplFileLine());
11026    return(1 || funcname || hash || result7 || libp) ;
11027 }
11028 
11029 static int G__G__Proof_265_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11030 {
11031       G__letint(result7, 67, (long) TProofMgr::ImplFileName());
11032    return(1 || funcname || hash || result7 || libp) ;
11033 }
11034 
11035 static int G__G__Proof_265_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11036 {
11037       G__letint(result7, 105, (long) TProofMgr::DeclFileLine());
11038    return(1 || funcname || hash || result7 || libp) ;
11039 }
11040 
11041 // automatic destructor
11042 typedef TProofMgr G__TTProofMgr;
11043 static int G__G__Proof_265_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11044 {
11045    char* gvp = (char*) G__getgvp();
11046    long soff = G__getstructoffset();
11047    int n = G__getaryconstruct();
11048    //
11049    //has_a_delete: 1
11050    //has_own_delete1arg: 0
11051    //has_own_delete2arg: 0
11052    //
11053    if (!soff) {
11054      return(1);
11055    }
11056    if (n) {
11057      if (gvp == (char*)G__PVOID) {
11058        delete[] (TProofMgr*) soff;
11059      } else {
11060        G__setgvp((long) G__PVOID);
11061        for (int i = n - 1; i >= 0; --i) {
11062          ((TProofMgr*) (soff+(sizeof(TProofMgr)*i)))->~G__TTProofMgr();
11063        }
11064        G__setgvp((long)gvp);
11065      }
11066    } else {
11067      if (gvp == (char*)G__PVOID) {
11068        delete (TProofMgr*) soff;
11069      } else {
11070        G__setgvp((long) G__PVOID);
11071        ((TProofMgr*) (soff))->~G__TTProofMgr();
11072        G__setgvp((long)gvp);
11073      }
11074    }
11075    G__setnull(result7);
11076    return(1 || funcname || hash || result7 || libp) ;
11077 }
11078 
11079 
11080 /* TProofDebug */
11081 // automatic default constructor
11082 static int G__G__Proof_268_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11083 {
11084    TProofDebug *p;
11085    char* gvp = (char*) G__getgvp();
11086    int n = G__getaryconstruct();
11087    if (n) {
11088      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11089        p = new TProofDebug[n];
11090      } else {
11091        p = new((void*) gvp) TProofDebug[n];
11092      }
11093    } else {
11094      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
11095        p = new TProofDebug;
11096      } else {
11097        p = new((void*) gvp) TProofDebug;
11098      }
11099    }
11100    result7->obj.i = (long) p;
11101    result7->ref = (long) p;
11102    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofDebug));
11103    return(1 || funcname || hash || result7 || libp) ;
11104 }
11105 
11106 // automatic copy constructor
11107 static int G__G__Proof_268_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11108 
11109 {
11110    TProofDebug* p;
11111    void* tmp = (void*) G__int(libp->para[0]);
11112    p = new TProofDebug(*(TProofDebug*) tmp);
11113    result7->obj.i = (long) p;
11114    result7->ref = (long) p;
11115    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofDebug));
11116    return(1 || funcname || hash || result7 || libp) ;
11117 }
11118 
11119 // automatic destructor
11120 typedef TProofDebug G__TTProofDebug;
11121 static int G__G__Proof_268_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11122 {
11123    char* gvp = (char*) G__getgvp();
11124    long soff = G__getstructoffset();
11125    int n = G__getaryconstruct();
11126    //
11127    //has_a_delete: 0
11128    //has_own_delete1arg: 0
11129    //has_own_delete2arg: 0
11130    //
11131    if (!soff) {
11132      return(1);
11133    }
11134    if (n) {
11135      if (gvp == (char*)G__PVOID) {
11136        delete[] (TProofDebug*) soff;
11137      } else {
11138        G__setgvp((long) G__PVOID);
11139        for (int i = n - 1; i >= 0; --i) {
11140          ((TProofDebug*) (soff+(sizeof(TProofDebug)*i)))->~G__TTProofDebug();
11141        }
11142        G__setgvp((long)gvp);
11143      }
11144    } else {
11145      if (gvp == (char*)G__PVOID) {
11146        delete (TProofDebug*) soff;
11147      } else {
11148        G__setgvp((long) G__PVOID);
11149        ((TProofDebug*) (soff))->~G__TTProofDebug();
11150        G__setgvp((long)gvp);
11151      }
11152    }
11153    G__setnull(result7);
11154    return(1 || funcname || hash || result7 || libp) ;
11155 }
11156 
11157 // automatic assignment operator
11158 static int G__G__Proof_268_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11159 {
11160    TProofDebug* dest = (TProofDebug*) G__getstructoffset();
11161    *dest = *(TProofDebug*) libp->para[0].ref;
11162    const TProofDebug& obj = *dest;
11163    result7->ref = (long) (&obj);
11164    result7->obj.i = (long) (&obj);
11165    return(1 || funcname || hash || result7 || libp) ;
11166 }
11167 
11168 
11169 /* TVirtualProofPlayer */
11170 static int G__G__Proof_291_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11171 {
11172    switch (libp->paran) {
11173    case 5:
11174       G__letLonglong(result7, 110, (G__int64) ((TVirtualProofPlayer*) G__getstructoffset())->Process((TDSet*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11175 , (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
11176 , (Long64_t) G__Longlong(libp->para[4])));
11177       break;
11178    case 4:
11179       G__letLonglong(result7, 110, (G__int64) ((TVirtualProofPlayer*) G__getstructoffset())->Process((TDSet*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11180 , (Option_t*) G__int(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
11181       break;
11182    case 3:
11183       G__letLonglong(result7, 110, (G__int64) ((TVirtualProofPlayer*) G__getstructoffset())->Process((TDSet*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11184 , (Option_t*) G__int(libp->para[2])));
11185       break;
11186    case 2:
11187       G__letLonglong(result7, 110, (G__int64) ((TVirtualProofPlayer*) G__getstructoffset())->Process((TDSet*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
11188       break;
11189    }
11190    return(1 || funcname || hash || result7 || libp) ;
11191 }
11192 
11193 static int G__G__Proof_291_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11194 {
11195    switch (libp->paran) {
11196    case 2:
11197       G__letLonglong(result7, 110, (G__int64) ((TVirtualProofPlayer*) G__getstructoffset())->Finalize((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
11198       break;
11199    case 1:
11200       G__letLonglong(result7, 110, (G__int64) ((TVirtualProofPlayer*) G__getstructoffset())->Finalize((Bool_t) G__int(libp->para[0])));
11201       break;
11202    case 0:
11203       G__letLonglong(result7, 110, (G__int64) ((TVirtualProofPlayer*) G__getstructoffset())->Finalize());
11204       break;
11205    }
11206    return(1 || funcname || hash || result7 || libp) ;
11207 }
11208 
11209 static int G__G__Proof_291_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11210 {
11211       G__letLonglong(result7, 110, (G__int64) ((TVirtualProofPlayer*) G__getstructoffset())->Finalize((TQueryResult*) G__int(libp->para[0])));
11212    return(1 || funcname || hash || result7 || libp) ;
11213 }
11214 
11215 static int G__G__Proof_291_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11216 {
11217    switch (libp->paran) {
11218    case 6:
11219       G__letLonglong(result7, 110, (G__int64) ((TVirtualProofPlayer*) G__getstructoffset())->DrawSelect((TDSet*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11220 , (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])
11221 , (Long64_t) G__Longlong(libp->para[4]), (Long64_t) G__Longlong(libp->para[5])));
11222       break;
11223    case 5:
11224       G__letLonglong(result7, 110, (G__int64) ((TVirtualProofPlayer*) G__getstructoffset())->DrawSelect((TDSet*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11225 , (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])
11226 , (Long64_t) G__Longlong(libp->para[4])));
11227       break;
11228    case 4:
11229       G__letLonglong(result7, 110, (G__int64) ((TVirtualProofPlayer*) G__getstructoffset())->DrawSelect((TDSet*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11230 , (const char*) G__int(libp->para[2]), (Option_t*) G__int(libp->para[3])));
11231       break;
11232    case 3:
11233       G__letLonglong(result7, 110, (G__int64) ((TVirtualProofPlayer*) G__getstructoffset())->DrawSelect((TDSet*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11234 , (const char*) G__int(libp->para[2])));
11235       break;
11236    }
11237    return(1 || funcname || hash || result7 || libp) ;
11238 }
11239 
11240 static int G__G__Proof_291_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11241 {
11242       G__letint(result7, 105, (long) ((TVirtualProofPlayer*) G__getstructoffset())->GetDrawArgs((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
11243 , (Option_t*) G__int(libp->para[2]), *(TString*) libp->para[3].ref
11244 , *(TString*) libp->para[4].ref));
11245    return(1 || funcname || hash || result7 || libp) ;
11246 }
11247 
11248 static int G__G__Proof_291_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11249 {
11250       ((TVirtualProofPlayer*) G__getstructoffset())->HandleGetTreeHeader((TMessage*) G__int(libp->para[0]));
11251       G__setnull(result7);
11252    return(1 || funcname || hash || result7 || libp) ;
11253 }
11254 
11255 static int G__G__Proof_291_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11256 {
11257       ((TVirtualProofPlayer*) G__getstructoffset())->HandleRecvHisto((TMessage*) G__int(libp->para[0]));
11258       G__setnull(result7);
11259    return(1 || funcname || hash || result7 || libp) ;
11260 }
11261 
11262 static int G__G__Proof_291_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11263 {
11264    switch (libp->paran) {
11265    case 2:
11266       ((TVirtualProofPlayer*) G__getstructoffset())->StopProcess((Bool_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
11267       G__setnull(result7);
11268       break;
11269    case 1:
11270       ((TVirtualProofPlayer*) G__getstructoffset())->StopProcess((Bool_t) G__int(libp->para[0]));
11271       G__setnull(result7);
11272       break;
11273    }
11274    return(1 || funcname || hash || result7 || libp) ;
11275 }
11276 
11277 static int G__G__Proof_291_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11278 {
11279       ((TVirtualProofPlayer*) G__getstructoffset())->AddInput((TObject*) G__int(libp->para[0]));
11280       G__setnull(result7);
11281    return(1 || funcname || hash || result7 || libp) ;
11282 }
11283 
11284 static int G__G__Proof_291_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11285 {
11286       ((TVirtualProofPlayer*) G__getstructoffset())->ClearInput();
11287       G__setnull(result7);
11288    return(1 || funcname || hash || result7 || libp) ;
11289 }
11290 
11291 static int G__G__Proof_291_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11292 {
11293       G__letint(result7, 85, (long) ((const TVirtualProofPlayer*) G__getstructoffset())->GetOutput((const char*) G__int(libp->para[0])));
11294    return(1 || funcname || hash || result7 || libp) ;
11295 }
11296 
11297 static int G__G__Proof_291_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11298 {
11299       G__letint(result7, 85, (long) ((const TVirtualProofPlayer*) G__getstructoffset())->GetOutputList());
11300    return(1 || funcname || hash || result7 || libp) ;
11301 }
11302 
11303 static int G__G__Proof_291_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11304 {
11305       G__letint(result7, 85, (long) ((const TVirtualProofPlayer*) G__getstructoffset())->GetInputList());
11306    return(1 || funcname || hash || result7 || libp) ;
11307 }
11308 
11309 static int G__G__Proof_291_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11310 {
11311       G__letint(result7, 85, (long) ((const TVirtualProofPlayer*) G__getstructoffset())->GetListOfResults());
11312    return(1 || funcname || hash || result7 || libp) ;
11313 }
11314 
11315 static int G__G__Proof_291_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11316 {
11317       ((TVirtualProofPlayer*) G__getstructoffset())->AddQueryResult((TQueryResult*) G__int(libp->para[0]));
11318       G__setnull(result7);
11319    return(1 || funcname || hash || result7 || libp) ;
11320 }
11321 
11322 static int G__G__Proof_291_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11323 {
11324       G__letint(result7, 85, (long) ((const TVirtualProofPlayer*) G__getstructoffset())->GetCurrentQuery());
11325    return(1 || funcname || hash || result7 || libp) ;
11326 }
11327 
11328 static int G__G__Proof_291_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11329 {
11330       G__letint(result7, 85, (long) ((TVirtualProofPlayer*) G__getstructoffset())->GetQueryResult((const char*) G__int(libp->para[0])));
11331    return(1 || funcname || hash || result7 || libp) ;
11332 }
11333 
11334 static int G__G__Proof_291_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11335 {
11336       ((TVirtualProofPlayer*) G__getstructoffset())->RemoveQueryResult((const char*) G__int(libp->para[0]));
11337       G__setnull(result7);
11338    return(1 || funcname || hash || result7 || libp) ;
11339 }
11340 
11341 static int G__G__Proof_291_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11342 {
11343       ((TVirtualProofPlayer*) G__getstructoffset())->SetCurrentQuery((TQueryResult*) G__int(libp->para[0]));
11344       G__setnull(result7);
11345    return(1 || funcname || hash || result7 || libp) ;
11346 }
11347 
11348 static int G__G__Proof_291_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11349 {
11350       ((TVirtualProofPlayer*) G__getstructoffset())->SetMaxDrawQueries((Int_t) G__int(libp->para[0]));
11351       G__setnull(result7);
11352    return(1 || funcname || hash || result7 || libp) ;
11353 }
11354 
11355 static int G__G__Proof_291_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11356 {
11357       ((TVirtualProofPlayer*) G__getstructoffset())->RestorePreviousQuery();
11358       G__setnull(result7);
11359    return(1 || funcname || hash || result7 || libp) ;
11360 }
11361 
11362 static int G__G__Proof_291_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11363 {
11364       G__letint(result7, 105, (long) ((TVirtualProofPlayer*) G__getstructoffset())->AddOutputObject((TObject*) G__int(libp->para[0])));
11365    return(1 || funcname || hash || result7 || libp) ;
11366 }
11367 
11368 static int G__G__Proof_291_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11369 {
11370       ((TVirtualProofPlayer*) G__getstructoffset())->AddOutput((TList*) G__int(libp->para[0]));
11371       G__setnull(result7);
11372    return(1 || funcname || hash || result7 || libp) ;
11373 }
11374 
11375 static int G__G__Proof_291_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11376 {
11377       ((TVirtualProofPlayer*) G__getstructoffset())->StoreOutput((TList*) G__int(libp->para[0]));
11378       G__setnull(result7);
11379    return(1 || funcname || hash || result7 || libp) ;
11380 }
11381 
11382 static int G__G__Proof_291_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11383 {
11384       ((TVirtualProofPlayer*) G__getstructoffset())->StoreFeedback((TObject*) G__int(libp->para[0]), (TList*) G__int(libp->para[1]));
11385       G__setnull(result7);
11386    return(1 || funcname || hash || result7 || libp) ;
11387 }
11388 
11389 static int G__G__Proof_291_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11390 {
11391       ((TVirtualProofPlayer*) G__getstructoffset())->Progress((Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
11392       G__setnull(result7);
11393    return(1 || funcname || hash || result7 || libp) ;
11394 }
11395 
11396 static int G__G__Proof_291_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11397 {
11398       ((TVirtualProofPlayer*) G__getstructoffset())->Progress((TSlave*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
11399 , (Long64_t) G__Longlong(libp->para[2]));
11400       G__setnull(result7);
11401    return(1 || funcname || hash || result7 || libp) ;
11402 }
11403 
11404 static int G__G__Proof_291_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11405 {
11406       ((TVirtualProofPlayer*) G__getstructoffset())->Progress(
11407 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
11408 , (Long64_t) G__Longlong(libp->para[2]), (Float_t) G__double(libp->para[3])
11409 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
11410 , (Float_t) G__double(libp->para[6]));
11411       G__setnull(result7);
11412    return(1 || funcname || hash || result7 || libp) ;
11413 }
11414 
11415 static int G__G__Proof_291_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11416 {
11417       ((TVirtualProofPlayer*) G__getstructoffset())->Progress(
11418 (TSlave*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
11419 , (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
11420 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
11421 , (Float_t) G__double(libp->para[6]), (Float_t) G__double(libp->para[7]));
11422       G__setnull(result7);
11423    return(1 || funcname || hash || result7 || libp) ;
11424 }
11425 
11426 static int G__G__Proof_291_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11427 {
11428       ((TVirtualProofPlayer*) G__getstructoffset())->Progress((TProofProgressInfo*) G__int(libp->para[0]));
11429       G__setnull(result7);
11430    return(1 || funcname || hash || result7 || libp) ;
11431 }
11432 
11433 static int G__G__Proof_291_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11434 {
11435       ((TVirtualProofPlayer*) G__getstructoffset())->Progress((TSlave*) G__int(libp->para[0]), (TProofProgressInfo*) G__int(libp->para[1]));
11436       G__setnull(result7);
11437    return(1 || funcname || hash || result7 || libp) ;
11438 }
11439 
11440 static int G__G__Proof_291_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11441 {
11442       ((TVirtualProofPlayer*) G__getstructoffset())->Feedback((TList*) G__int(libp->para[0]));
11443       G__setnull(result7);
11444    return(1 || funcname || hash || result7 || libp) ;
11445 }
11446 
11447 static int G__G__Proof_291_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11448 {
11449       G__letint(result7, 85, (long) ((TVirtualProofPlayer*) G__getstructoffset())->CreateDrawFeedback((TProof*) G__int(libp->para[0])));
11450    return(1 || funcname || hash || result7 || libp) ;
11451 }
11452 
11453 static int G__G__Proof_291_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11454 {
11455       ((TVirtualProofPlayer*) G__getstructoffset())->SetDrawFeedbackOption((TDrawFeedback*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
11456       G__setnull(result7);
11457    return(1 || funcname || hash || result7 || libp) ;
11458 }
11459 
11460 static int G__G__Proof_291_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11461 {
11462       ((TVirtualProofPlayer*) G__getstructoffset())->DeleteDrawFeedback((TDrawFeedback*) G__int(libp->para[0]));
11463       G__setnull(result7);
11464    return(1 || funcname || hash || result7 || libp) ;
11465 }
11466 
11467 static int G__G__Proof_291_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11468 {
11469       G__letint(result7, 85, (long) ((TVirtualProofPlayer*) G__getstructoffset())->GetNextPacket((TSlave*) G__int(libp->para[0]), (TMessage*) G__int(libp->para[1])));
11470    return(1 || funcname || hash || result7 || libp) ;
11471 }
11472 
11473 static int G__G__Proof_291_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11474 {
11475       G__letint(result7, 105, (long) ((TVirtualProofPlayer*) G__getstructoffset())->ReinitSelector((TQueryResult*) G__int(libp->para[0])));
11476    return(1 || funcname || hash || result7 || libp) ;
11477 }
11478 
11479 static int G__G__Proof_291_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11480 {
11481       ((TVirtualProofPlayer*) G__getstructoffset())->UpdateAutoBin(
11482 (const char*) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
11483 , *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
11484 , *(Double_t*) G__Doubleref(&libp->para[4]), *(Double_t*) G__Doubleref(&libp->para[5])
11485 , *(Double_t*) G__Doubleref(&libp->para[6]));
11486       G__setnull(result7);
11487    return(1 || funcname || hash || result7 || libp) ;
11488 }
11489 
11490 static int G__G__Proof_291_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11491 {
11492       ((TVirtualProofPlayer*) G__getstructoffset())->MergeOutput();
11493       G__setnull(result7);
11494    return(1 || funcname || hash || result7 || libp) ;
11495 }
11496 
11497 static int G__G__Proof_291_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11498 {
11499       G__letint(result7, 103, (long) ((const TVirtualProofPlayer*) G__getstructoffset())->IsClient());
11500    return(1 || funcname || hash || result7 || libp) ;
11501 }
11502 
11503 static int G__G__Proof_291_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11504 {
11505       G__letint(result7, 105, (long) ((const TVirtualProofPlayer*) G__getstructoffset())->GetExitStatus());
11506    return(1 || funcname || hash || result7 || libp) ;
11507 }
11508 
11509 static int G__G__Proof_291_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11510 {
11511       G__letLonglong(result7, 110, (G__int64) ((const TVirtualProofPlayer*) G__getstructoffset())->GetEventsProcessed());
11512    return(1 || funcname || hash || result7 || libp) ;
11513 }
11514 
11515 static int G__G__Proof_291_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11516 {
11517       ((TVirtualProofPlayer*) G__getstructoffset())->AddEventsProcessed((Long64_t) G__Longlong(libp->para[0]));
11518       G__setnull(result7);
11519    return(1 || funcname || hash || result7 || libp) ;
11520 }
11521 
11522 static int G__G__Proof_291_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11523 {
11524       G__letint(result7, 85, (long) ((const TVirtualProofPlayer*) G__getstructoffset())->GetProgressStatus());
11525    return(1 || funcname || hash || result7 || libp) ;
11526 }
11527 
11528 static int G__G__Proof_291_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11529 {
11530    switch (libp->paran) {
11531    case 1:
11532       ((TVirtualProofPlayer*) G__getstructoffset())->SetDispatchTimer((Bool_t) G__int(libp->para[0]));
11533       G__setnull(result7);
11534       break;
11535    case 0:
11536       ((TVirtualProofPlayer*) G__getstructoffset())->SetDispatchTimer();
11537       G__setnull(result7);
11538       break;
11539    }
11540    return(1 || funcname || hash || result7 || libp) ;
11541 }
11542 
11543 static int G__G__Proof_291_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11544 {
11545    switch (libp->paran) {
11546    case 3:
11547       ((TVirtualProofPlayer*) G__getstructoffset())->SetStopTimer((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])
11548 , (Int_t) G__int(libp->para[2]));
11549       G__setnull(result7);
11550       break;
11551    case 2:
11552       ((TVirtualProofPlayer*) G__getstructoffset())->SetStopTimer((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
11553       G__setnull(result7);
11554       break;
11555    case 1:
11556       ((TVirtualProofPlayer*) G__getstructoffset())->SetStopTimer((Bool_t) G__int(libp->para[0]));
11557       G__setnull(result7);
11558       break;
11559    case 0:
11560       ((TVirtualProofPlayer*) G__getstructoffset())->SetStopTimer();
11561       G__setnull(result7);
11562       break;
11563    }
11564    return(1 || funcname || hash || result7 || libp) ;
11565 }
11566 
11567 static int G__G__Proof_291_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11568 {
11569       ((TVirtualProofPlayer*) G__getstructoffset())->SetInitTime();
11570       G__setnull(result7);
11571    return(1 || funcname || hash || result7 || libp) ;
11572 }
11573 
11574 static int G__G__Proof_291_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11575 {
11576       G__letLonglong(result7, 110, (G__int64) ((TVirtualProofPlayer*) G__getstructoffset())->GetCacheSize());
11577    return(1 || funcname || hash || result7 || libp) ;
11578 }
11579 
11580 static int G__G__Proof_291_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11581 {
11582       G__letint(result7, 105, (long) ((TVirtualProofPlayer*) G__getstructoffset())->GetLearnEntries());
11583    return(1 || funcname || hash || result7 || libp) ;
11584 }
11585 
11586 static int G__G__Proof_291_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11587 {
11588       G__letint(result7, 85, (long) ((const TVirtualProofPlayer*) G__getstructoffset())->GetPacketizer());
11589    return(1 || funcname || hash || result7 || libp) ;
11590 }
11591 
11592 static int G__G__Proof_291_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11593 {
11594    switch (libp->paran) {
11595    case 3:
11596       G__letint(result7, 85, (long) TVirtualProofPlayer::Create((const char*) G__int(libp->para[0]), (TProof*) G__int(libp->para[1])
11597 , (TSocket*) G__int(libp->para[2])));
11598       break;
11599    case 2:
11600       G__letint(result7, 85, (long) TVirtualProofPlayer::Create((const char*) G__int(libp->para[0]), (TProof*) G__int(libp->para[1])));
11601       break;
11602    }
11603    return(1 || funcname || hash || result7 || libp) ;
11604 }
11605 
11606 static int G__G__Proof_291_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11607 {
11608       G__letint(result7, 85, (long) TVirtualProofPlayer::Class());
11609    return(1 || funcname || hash || result7 || libp) ;
11610 }
11611 
11612 static int G__G__Proof_291_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11613 {
11614       G__letint(result7, 67, (long) TVirtualProofPlayer::Class_Name());
11615    return(1 || funcname || hash || result7 || libp) ;
11616 }
11617 
11618 static int G__G__Proof_291_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11619 {
11620       G__letint(result7, 115, (long) TVirtualProofPlayer::Class_Version());
11621    return(1 || funcname || hash || result7 || libp) ;
11622 }
11623 
11624 static int G__G__Proof_291_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11625 {
11626       TVirtualProofPlayer::Dictionary();
11627       G__setnull(result7);
11628    return(1 || funcname || hash || result7 || libp) ;
11629 }
11630 
11631 static int G__G__Proof_291_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11632 {
11633       ((TVirtualProofPlayer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11634       G__setnull(result7);
11635    return(1 || funcname || hash || result7 || libp) ;
11636 }
11637 
11638 static int G__G__Proof_291_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11639 {
11640       G__letint(result7, 67, (long) TVirtualProofPlayer::DeclFileName());
11641    return(1 || funcname || hash || result7 || libp) ;
11642 }
11643 
11644 static int G__G__Proof_291_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11645 {
11646       G__letint(result7, 105, (long) TVirtualProofPlayer::ImplFileLine());
11647    return(1 || funcname || hash || result7 || libp) ;
11648 }
11649 
11650 static int G__G__Proof_291_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11651 {
11652       G__letint(result7, 67, (long) TVirtualProofPlayer::ImplFileName());
11653    return(1 || funcname || hash || result7 || libp) ;
11654 }
11655 
11656 static int G__G__Proof_291_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11657 {
11658       G__letint(result7, 105, (long) TVirtualProofPlayer::DeclFileLine());
11659    return(1 || funcname || hash || result7 || libp) ;
11660 }
11661 
11662 // automatic destructor
11663 typedef TVirtualProofPlayer G__TTVirtualProofPlayer;
11664 static int G__G__Proof_291_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11665 {
11666    char* gvp = (char*) G__getgvp();
11667    long soff = G__getstructoffset();
11668    int n = G__getaryconstruct();
11669    //
11670    //has_a_delete: 1
11671    //has_own_delete1arg: 0
11672    //has_own_delete2arg: 0
11673    //
11674    if (!soff) {
11675      return(1);
11676    }
11677    if (n) {
11678      if (gvp == (char*)G__PVOID) {
11679        delete[] (TVirtualProofPlayer*) soff;
11680      } else {
11681        G__setgvp((long) G__PVOID);
11682        for (int i = n - 1; i >= 0; --i) {
11683          ((TVirtualProofPlayer*) (soff+(sizeof(TVirtualProofPlayer)*i)))->~G__TTVirtualProofPlayer();
11684        }
11685        G__setgvp((long)gvp);
11686      }
11687    } else {
11688      if (gvp == (char*)G__PVOID) {
11689        delete (TVirtualProofPlayer*) soff;
11690      } else {
11691        G__setgvp((long) G__PVOID);
11692        ((TVirtualProofPlayer*) (soff))->~G__TTVirtualProofPlayer();
11693        G__setgvp((long)gvp);
11694      }
11695    }
11696    G__setnull(result7);
11697    return(1 || funcname || hash || result7 || libp) ;
11698 }
11699 
11700 
11701 /* TSlave */
11702 static int G__G__Proof_296_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11703 {
11704    switch (libp->paran) {
11705    case 1:
11706       ((TSlave*) G__getstructoffset())->Close((Option_t*) G__int(libp->para[0]));
11707       G__setnull(result7);
11708       break;
11709    case 0:
11710       ((TSlave*) G__getstructoffset())->Close();
11711       G__setnull(result7);
11712       break;
11713    }
11714    return(1 || funcname || hash || result7 || libp) ;
11715 }
11716 
11717 static int G__G__Proof_296_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11718 {
11719       G__letint(result7, 67, (long) ((const TSlave*) G__getstructoffset())->GetImage());
11720    return(1 || funcname || hash || result7 || libp) ;
11721 }
11722 
11723 static int G__G__Proof_296_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11724 {
11725       G__letint(result7, 67, (long) ((const TSlave*) G__getstructoffset())->GetProofWorkDir());
11726    return(1 || funcname || hash || result7 || libp) ;
11727 }
11728 
11729 static int G__G__Proof_296_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11730 {
11731       G__letint(result7, 67, (long) ((const TSlave*) G__getstructoffset())->GetWorkDir());
11732    return(1 || funcname || hash || result7 || libp) ;
11733 }
11734 
11735 static int G__G__Proof_296_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11736 {
11737       G__letint(result7, 67, (long) ((const TSlave*) G__getstructoffset())->GetUser());
11738    return(1 || funcname || hash || result7 || libp) ;
11739 }
11740 
11741 static int G__G__Proof_296_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11742 {
11743       G__letint(result7, 67, (long) ((const TSlave*) G__getstructoffset())->GetGroup());
11744    return(1 || funcname || hash || result7 || libp) ;
11745 }
11746 
11747 static int G__G__Proof_296_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11748 {
11749       G__letint(result7, 105, (long) ((const TSlave*) G__getstructoffset())->GetPort());
11750    return(1 || funcname || hash || result7 || libp) ;
11751 }
11752 
11753 static int G__G__Proof_296_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11754 {
11755       G__letint(result7, 67, (long) ((const TSlave*) G__getstructoffset())->GetOrdinal());
11756    return(1 || funcname || hash || result7 || libp) ;
11757 }
11758 
11759 static int G__G__Proof_296_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11760 {
11761       G__letint(result7, 105, (long) ((const TSlave*) G__getstructoffset())->GetPerfIdx());
11762    return(1 || funcname || hash || result7 || libp) ;
11763 }
11764 
11765 static int G__G__Proof_296_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11766 {
11767       G__letint(result7, 105, (long) ((const TSlave*) G__getstructoffset())->GetProtocol());
11768    return(1 || funcname || hash || result7 || libp) ;
11769 }
11770 
11771 static int G__G__Proof_296_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11772 {
11773       G__letint(result7, 85, (long) ((const TSlave*) G__getstructoffset())->GetSocket());
11774    return(1 || funcname || hash || result7 || libp) ;
11775 }
11776 
11777 static int G__G__Proof_296_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11778 {
11779       G__letint(result7, 85, (long) ((const TSlave*) G__getstructoffset())->GetProof());
11780    return(1 || funcname || hash || result7 || libp) ;
11781 }
11782 
11783 static int G__G__Proof_296_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11784 {
11785       G__letLonglong(result7, 110, (G__int64) ((const TSlave*) G__getstructoffset())->GetBytesRead());
11786    return(1 || funcname || hash || result7 || libp) ;
11787 }
11788 
11789 static int G__G__Proof_296_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11790 {
11791       G__letdouble(result7, 102, (double) ((const TSlave*) G__getstructoffset())->GetRealTime());
11792    return(1 || funcname || hash || result7 || libp) ;
11793 }
11794 
11795 static int G__G__Proof_296_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11796 {
11797       G__letdouble(result7, 102, (double) ((const TSlave*) G__getstructoffset())->GetCpuTime());
11798    return(1 || funcname || hash || result7 || libp) ;
11799 }
11800 
11801 static int G__G__Proof_296_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11802 {
11803       G__letint(result7, 105, (long) ((const TSlave*) G__getstructoffset())->GetSlaveType());
11804    return(1 || funcname || hash || result7 || libp) ;
11805 }
11806 
11807 static int G__G__Proof_296_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11808 {
11809       G__letint(result7, 105, (long) ((const TSlave*) G__getstructoffset())->GetStatus());
11810    return(1 || funcname || hash || result7 || libp) ;
11811 }
11812 
11813 static int G__G__Proof_296_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11814 {
11815       G__letint(result7, 105, (long) ((const TSlave*) G__getstructoffset())->GetParallel());
11816    return(1 || funcname || hash || result7 || libp) ;
11817 }
11818 
11819 static int G__G__Proof_296_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11820 {
11821       G__letint(result7, 67, (long) ((const TSlave*) G__getstructoffset())->GetMsd());
11822    return(1 || funcname || hash || result7 || libp) ;
11823 }
11824 
11825 static int G__G__Proof_296_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11826 {
11827       G__letint(result7, 67, (long) ((const TSlave*) G__getstructoffset())->GetSessionTag());
11828    return(1 || funcname || hash || result7 || libp) ;
11829 }
11830 
11831 static int G__G__Proof_296_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11832 {
11833       G__letint(result7, 85, (long) ((const TSlave*) G__getstructoffset())->GetInputHandler());
11834    return(1 || funcname || hash || result7 || libp) ;
11835 }
11836 
11837 static int G__G__Proof_296_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11838 {
11839       ((TSlave*) G__getstructoffset())->SetInputHandler((TFileHandler*) G__int(libp->para[0]));
11840       G__setnull(result7);
11841    return(1 || funcname || hash || result7 || libp) ;
11842 }
11843 
11844 static int G__G__Proof_296_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11845 {
11846       G__letint(result7, 67, (long) ((const TSlave*) G__getstructoffset())->GetArchCompiler());
11847    return(1 || funcname || hash || result7 || libp) ;
11848 }
11849 
11850 static int G__G__Proof_296_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11851 {
11852       G__letint(result7, 67, (long) ((const TSlave*) G__getstructoffset())->GetROOTVersion());
11853    return(1 || funcname || hash || result7 || libp) ;
11854 }
11855 
11856 static int G__G__Proof_296_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11857 {
11858       G__letint(result7, 103, (long) ((const TSlave*) G__getstructoffset())->IsValid());
11859    return(1 || funcname || hash || result7 || libp) ;
11860 }
11861 
11862 static int G__G__Proof_296_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11863 {
11864       G__letint(result7, 105, (long) ((TSlave*) G__getstructoffset())->SetupServ((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
11865    return(1 || funcname || hash || result7 || libp) ;
11866 }
11867 
11868 static int G__G__Proof_296_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11869 {
11870       ((TSlave*) G__getstructoffset())->SetInterruptHandler((Bool_t) G__int(libp->para[0]));
11871       G__setnull(result7);
11872    return(1 || funcname || hash || result7 || libp) ;
11873 }
11874 
11875 static int G__G__Proof_296_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11876 {
11877       ((TSlave*) G__getstructoffset())->SetArchCompiler((const char*) G__int(libp->para[0]));
11878       G__setnull(result7);
11879    return(1 || funcname || hash || result7 || libp) ;
11880 }
11881 
11882 static int G__G__Proof_296_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11883 {
11884       ((TSlave*) G__getstructoffset())->SetROOTVersion((const char*) G__int(libp->para[0]));
11885       G__setnull(result7);
11886    return(1 || funcname || hash || result7 || libp) ;
11887 }
11888 
11889 static int G__G__Proof_296_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11890 {
11891       ((TSlave*) G__getstructoffset())->SetSessionTag((const char*) G__int(libp->para[0]));
11892       G__setnull(result7);
11893    return(1 || funcname || hash || result7 || libp) ;
11894 }
11895 
11896 static int G__G__Proof_296_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11897 {
11898       TSlave::SetTXSlaveHook((TSlave_t) G__int(libp->para[0]));
11899       G__setnull(result7);
11900    return(1 || funcname || hash || result7 || libp) ;
11901 }
11902 
11903 static int G__G__Proof_296_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11904 {
11905       ((TSlave*) G__getstructoffset())->Touch();
11906       G__setnull(result7);
11907    return(1 || funcname || hash || result7 || libp) ;
11908 }
11909 
11910 static int G__G__Proof_296_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11911 {
11912       G__letint(result7, 85, (long) TSlave::Class());
11913    return(1 || funcname || hash || result7 || libp) ;
11914 }
11915 
11916 static int G__G__Proof_296_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11917 {
11918       G__letint(result7, 67, (long) TSlave::Class_Name());
11919    return(1 || funcname || hash || result7 || libp) ;
11920 }
11921 
11922 static int G__G__Proof_296_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11923 {
11924       G__letint(result7, 115, (long) TSlave::Class_Version());
11925    return(1 || funcname || hash || result7 || libp) ;
11926 }
11927 
11928 static int G__G__Proof_296_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11929 {
11930       TSlave::Dictionary();
11931       G__setnull(result7);
11932    return(1 || funcname || hash || result7 || libp) ;
11933 }
11934 
11935 static int G__G__Proof_296_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11936 {
11937       ((TSlave*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
11938       G__setnull(result7);
11939    return(1 || funcname || hash || result7 || libp) ;
11940 }
11941 
11942 static int G__G__Proof_296_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11943 {
11944       G__letint(result7, 67, (long) TSlave::DeclFileName());
11945    return(1 || funcname || hash || result7 || libp) ;
11946 }
11947 
11948 static int G__G__Proof_296_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11949 {
11950       G__letint(result7, 105, (long) TSlave::ImplFileLine());
11951    return(1 || funcname || hash || result7 || libp) ;
11952 }
11953 
11954 static int G__G__Proof_296_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11955 {
11956       G__letint(result7, 67, (long) TSlave::ImplFileName());
11957    return(1 || funcname || hash || result7 || libp) ;
11958 }
11959 
11960 static int G__G__Proof_296_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11961 {
11962       G__letint(result7, 105, (long) TSlave::DeclFileLine());
11963    return(1 || funcname || hash || result7 || libp) ;
11964 }
11965 
11966 // automatic destructor
11967 typedef TSlave G__TTSlave;
11968 static int G__G__Proof_296_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
11969 {
11970    char* gvp = (char*) G__getgvp();
11971    long soff = G__getstructoffset();
11972    int n = G__getaryconstruct();
11973    //
11974    //has_a_delete: 1
11975    //has_own_delete1arg: 0
11976    //has_own_delete2arg: 0
11977    //
11978    if (!soff) {
11979      return(1);
11980    }
11981    if (n) {
11982      if (gvp == (char*)G__PVOID) {
11983        delete[] (TSlave*) soff;
11984      } else {
11985        G__setgvp((long) G__PVOID);
11986        for (int i = n - 1; i >= 0; --i) {
11987          ((TSlave*) (soff+(sizeof(TSlave)*i)))->~G__TTSlave();
11988        }
11989        G__setgvp((long)gvp);
11990      }
11991    } else {
11992      if (gvp == (char*)G__PVOID) {
11993        delete (TSlave*) soff;
11994      } else {
11995        G__setgvp((long) G__PVOID);
11996        ((TSlave*) (soff))->~G__TTSlave();
11997        G__setgvp((long)gvp);
11998      }
11999    }
12000    G__setnull(result7);
12001    return(1 || funcname || hash || result7 || libp) ;
12002 }
12003 
12004 
12005 /* TProofProgressInfo */
12006 static int G__G__Proof_299_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12007 {
12008    TProofProgressInfo* p = NULL;
12009    char* gvp = (char*) G__getgvp();
12010    switch (libp->paran) {
12011    case 10:
12012      //m: 10
12013      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12014        p = new TProofProgressInfo(
12015 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
12016 , (Long64_t) G__Longlong(libp->para[2]), (Float_t) G__double(libp->para[3])
12017 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
12018 , (Float_t) G__double(libp->para[6]), (Int_t) G__int(libp->para[7])
12019 , (Int_t) G__int(libp->para[8]), (Float_t) G__double(libp->para[9]));
12020      } else {
12021        p = new((void*) gvp) TProofProgressInfo(
12022 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
12023 , (Long64_t) G__Longlong(libp->para[2]), (Float_t) G__double(libp->para[3])
12024 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
12025 , (Float_t) G__double(libp->para[6]), (Int_t) G__int(libp->para[7])
12026 , (Int_t) G__int(libp->para[8]), (Float_t) G__double(libp->para[9]));
12027      }
12028      break;
12029    case 9:
12030      //m: 9
12031      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12032        p = new TProofProgressInfo(
12033 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
12034 , (Long64_t) G__Longlong(libp->para[2]), (Float_t) G__double(libp->para[3])
12035 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
12036 , (Float_t) G__double(libp->para[6]), (Int_t) G__int(libp->para[7])
12037 , (Int_t) G__int(libp->para[8]));
12038      } else {
12039        p = new((void*) gvp) TProofProgressInfo(
12040 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
12041 , (Long64_t) G__Longlong(libp->para[2]), (Float_t) G__double(libp->para[3])
12042 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
12043 , (Float_t) G__double(libp->para[6]), (Int_t) G__int(libp->para[7])
12044 , (Int_t) G__int(libp->para[8]));
12045      }
12046      break;
12047    case 8:
12048      //m: 8
12049      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12050        p = new TProofProgressInfo(
12051 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
12052 , (Long64_t) G__Longlong(libp->para[2]), (Float_t) G__double(libp->para[3])
12053 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
12054 , (Float_t) G__double(libp->para[6]), (Int_t) G__int(libp->para[7]));
12055      } else {
12056        p = new((void*) gvp) TProofProgressInfo(
12057 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
12058 , (Long64_t) G__Longlong(libp->para[2]), (Float_t) G__double(libp->para[3])
12059 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
12060 , (Float_t) G__double(libp->para[6]), (Int_t) G__int(libp->para[7]));
12061      }
12062      break;
12063    case 7:
12064      //m: 7
12065      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12066        p = new TProofProgressInfo(
12067 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
12068 , (Long64_t) G__Longlong(libp->para[2]), (Float_t) G__double(libp->para[3])
12069 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
12070 , (Float_t) G__double(libp->para[6]));
12071      } else {
12072        p = new((void*) gvp) TProofProgressInfo(
12073 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
12074 , (Long64_t) G__Longlong(libp->para[2]), (Float_t) G__double(libp->para[3])
12075 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5])
12076 , (Float_t) G__double(libp->para[6]));
12077      }
12078      break;
12079    case 6:
12080      //m: 6
12081      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12082        p = new TProofProgressInfo(
12083 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
12084 , (Long64_t) G__Longlong(libp->para[2]), (Float_t) G__double(libp->para[3])
12085 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5]));
12086      } else {
12087        p = new((void*) gvp) TProofProgressInfo(
12088 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
12089 , (Long64_t) G__Longlong(libp->para[2]), (Float_t) G__double(libp->para[3])
12090 , (Float_t) G__double(libp->para[4]), (Float_t) G__double(libp->para[5]));
12091      }
12092      break;
12093    case 5:
12094      //m: 5
12095      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12096        p = new TProofProgressInfo(
12097 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
12098 , (Long64_t) G__Longlong(libp->para[2]), (Float_t) G__double(libp->para[3])
12099 , (Float_t) G__double(libp->para[4]));
12100      } else {
12101        p = new((void*) gvp) TProofProgressInfo(
12102 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
12103 , (Long64_t) G__Longlong(libp->para[2]), (Float_t) G__double(libp->para[3])
12104 , (Float_t) G__double(libp->para[4]));
12105      }
12106      break;
12107    case 4:
12108      //m: 4
12109      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12110        p = new TProofProgressInfo(
12111 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
12112 , (Long64_t) G__Longlong(libp->para[2]), (Float_t) G__double(libp->para[3]));
12113      } else {
12114        p = new((void*) gvp) TProofProgressInfo(
12115 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
12116 , (Long64_t) G__Longlong(libp->para[2]), (Float_t) G__double(libp->para[3]));
12117      }
12118      break;
12119    case 3:
12120      //m: 3
12121      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12122        p = new TProofProgressInfo(
12123 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
12124 , (Long64_t) G__Longlong(libp->para[2]));
12125      } else {
12126        p = new((void*) gvp) TProofProgressInfo(
12127 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
12128 , (Long64_t) G__Longlong(libp->para[2]));
12129      }
12130      break;
12131    case 2:
12132      //m: 2
12133      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12134        p = new TProofProgressInfo((Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
12135      } else {
12136        p = new((void*) gvp) TProofProgressInfo((Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
12137      }
12138      break;
12139    case 1:
12140      //m: 1
12141      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12142        p = new TProofProgressInfo((Long64_t) G__Longlong(libp->para[0]));
12143      } else {
12144        p = new((void*) gvp) TProofProgressInfo((Long64_t) G__Longlong(libp->para[0]));
12145      }
12146      break;
12147    case 0:
12148      int n = G__getaryconstruct();
12149      if (n) {
12150        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12151          p = new TProofProgressInfo[n];
12152        } else {
12153          p = new((void*) gvp) TProofProgressInfo[n];
12154        }
12155      } else {
12156        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12157          p = new TProofProgressInfo;
12158        } else {
12159          p = new((void*) gvp) TProofProgressInfo;
12160        }
12161      }
12162      break;
12163    }
12164    result7->obj.i = (long) p;
12165    result7->ref = (long) p;
12166    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofProgressInfo));
12167    return(1 || funcname || hash || result7 || libp) ;
12168 }
12169 
12170 static int G__G__Proof_299_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12171 {
12172       G__letint(result7, 85, (long) TProofProgressInfo::Class());
12173    return(1 || funcname || hash || result7 || libp) ;
12174 }
12175 
12176 static int G__G__Proof_299_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12177 {
12178       G__letint(result7, 67, (long) TProofProgressInfo::Class_Name());
12179    return(1 || funcname || hash || result7 || libp) ;
12180 }
12181 
12182 static int G__G__Proof_299_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12183 {
12184       G__letint(result7, 115, (long) TProofProgressInfo::Class_Version());
12185    return(1 || funcname || hash || result7 || libp) ;
12186 }
12187 
12188 static int G__G__Proof_299_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12189 {
12190       TProofProgressInfo::Dictionary();
12191       G__setnull(result7);
12192    return(1 || funcname || hash || result7 || libp) ;
12193 }
12194 
12195 static int G__G__Proof_299_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12196 {
12197       ((TProofProgressInfo*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
12198       G__setnull(result7);
12199    return(1 || funcname || hash || result7 || libp) ;
12200 }
12201 
12202 static int G__G__Proof_299_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12203 {
12204       G__letint(result7, 67, (long) TProofProgressInfo::DeclFileName());
12205    return(1 || funcname || hash || result7 || libp) ;
12206 }
12207 
12208 static int G__G__Proof_299_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12209 {
12210       G__letint(result7, 105, (long) TProofProgressInfo::ImplFileLine());
12211    return(1 || funcname || hash || result7 || libp) ;
12212 }
12213 
12214 static int G__G__Proof_299_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12215 {
12216       G__letint(result7, 67, (long) TProofProgressInfo::ImplFileName());
12217    return(1 || funcname || hash || result7 || libp) ;
12218 }
12219 
12220 static int G__G__Proof_299_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12221 {
12222       G__letint(result7, 105, (long) TProofProgressInfo::DeclFileLine());
12223    return(1 || funcname || hash || result7 || libp) ;
12224 }
12225 
12226 // automatic copy constructor
12227 static int G__G__Proof_299_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12228 
12229 {
12230    TProofProgressInfo* p;
12231    void* tmp = (void*) G__int(libp->para[0]);
12232    p = new TProofProgressInfo(*(TProofProgressInfo*) tmp);
12233    result7->obj.i = (long) p;
12234    result7->ref = (long) p;
12235    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofProgressInfo));
12236    return(1 || funcname || hash || result7 || libp) ;
12237 }
12238 
12239 // automatic destructor
12240 typedef TProofProgressInfo G__TTProofProgressInfo;
12241 static int G__G__Proof_299_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12242 {
12243    char* gvp = (char*) G__getgvp();
12244    long soff = G__getstructoffset();
12245    int n = G__getaryconstruct();
12246    //
12247    //has_a_delete: 1
12248    //has_own_delete1arg: 0
12249    //has_own_delete2arg: 0
12250    //
12251    if (!soff) {
12252      return(1);
12253    }
12254    if (n) {
12255      if (gvp == (char*)G__PVOID) {
12256        delete[] (TProofProgressInfo*) soff;
12257      } else {
12258        G__setgvp((long) G__PVOID);
12259        for (int i = n - 1; i >= 0; --i) {
12260          ((TProofProgressInfo*) (soff+(sizeof(TProofProgressInfo)*i)))->~G__TTProofProgressInfo();
12261        }
12262        G__setgvp((long)gvp);
12263      }
12264    } else {
12265      if (gvp == (char*)G__PVOID) {
12266        delete (TProofProgressInfo*) soff;
12267      } else {
12268        G__setgvp((long) G__PVOID);
12269        ((TProofProgressInfo*) (soff))->~G__TTProofProgressInfo();
12270        G__setgvp((long)gvp);
12271      }
12272    }
12273    G__setnull(result7);
12274    return(1 || funcname || hash || result7 || libp) ;
12275 }
12276 
12277 // automatic assignment operator
12278 static int G__G__Proof_299_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12279 {
12280    TProofProgressInfo* dest = (TProofProgressInfo*) G__getstructoffset();
12281    *dest = *(TProofProgressInfo*) libp->para[0].ref;
12282    const TProofProgressInfo& obj = *dest;
12283    result7->ref = (long) (&obj);
12284    result7->obj.i = (long) (&obj);
12285    return(1 || funcname || hash || result7 || libp) ;
12286 }
12287 
12288 
12289 /* TSlaveInfo */
12290 static int G__G__Proof_300_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12291 {
12292    TSlaveInfo* p = NULL;
12293    char* gvp = (char*) G__getgvp();
12294    switch (libp->paran) {
12295    case 5:
12296      //m: 5
12297      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12298        p = new TSlaveInfo(
12299 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
12300 , (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
12301 , (const char*) G__int(libp->para[4]));
12302      } else {
12303        p = new((void*) gvp) TSlaveInfo(
12304 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
12305 , (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
12306 , (const char*) G__int(libp->para[4]));
12307      }
12308      break;
12309    case 4:
12310      //m: 4
12311      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12312        p = new TSlaveInfo(
12313 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
12314 , (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
12315      } else {
12316        p = new((void*) gvp) TSlaveInfo(
12317 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
12318 , (Int_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
12319      }
12320      break;
12321    case 3:
12322      //m: 3
12323      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12324        p = new TSlaveInfo(
12325 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
12326 , (Int_t) G__int(libp->para[2]));
12327      } else {
12328        p = new((void*) gvp) TSlaveInfo(
12329 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
12330 , (Int_t) G__int(libp->para[2]));
12331      }
12332      break;
12333    case 2:
12334      //m: 2
12335      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12336        p = new TSlaveInfo((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
12337      } else {
12338        p = new((void*) gvp) TSlaveInfo((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
12339      }
12340      break;
12341    case 1:
12342      //m: 1
12343      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12344        p = new TSlaveInfo((const char*) G__int(libp->para[0]));
12345      } else {
12346        p = new((void*) gvp) TSlaveInfo((const char*) G__int(libp->para[0]));
12347      }
12348      break;
12349    case 0:
12350      int n = G__getaryconstruct();
12351      if (n) {
12352        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12353          p = new TSlaveInfo[n];
12354        } else {
12355          p = new((void*) gvp) TSlaveInfo[n];
12356        }
12357      } else {
12358        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12359          p = new TSlaveInfo;
12360        } else {
12361          p = new((void*) gvp) TSlaveInfo;
12362        }
12363      }
12364      break;
12365    }
12366    result7->obj.i = (long) p;
12367    result7->ref = (long) p;
12368    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TSlaveInfo));
12369    return(1 || funcname || hash || result7 || libp) ;
12370 }
12371 
12372 static int G__G__Proof_300_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12373 {
12374       G__letint(result7, 67, (long) ((const TSlaveInfo*) G__getstructoffset())->GetDataDir());
12375    return(1 || funcname || hash || result7 || libp) ;
12376 }
12377 
12378 static int G__G__Proof_300_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12379 {
12380       G__letint(result7, 67, (long) ((const TSlaveInfo*) G__getstructoffset())->GetMsd());
12381    return(1 || funcname || hash || result7 || libp) ;
12382 }
12383 
12384 static int G__G__Proof_300_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12385 {
12386       G__letint(result7, 67, (long) ((const TSlaveInfo*) G__getstructoffset())->GetOrdinal());
12387    return(1 || funcname || hash || result7 || libp) ;
12388 }
12389 
12390 static int G__G__Proof_300_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12391 {
12392       {
12393          const SysInfo_t* pobj;
12394          const SysInfo_t xobj = ((const TSlaveInfo*) G__getstructoffset())->GetSysInfo();
12395          pobj = new SysInfo_t(xobj);
12396          result7->obj.i = (long) ((void*) pobj);
12397          result7->ref = result7->obj.i;
12398          G__store_tempobject(*result7);
12399       }
12400    return(1 || funcname || hash || result7 || libp) ;
12401 }
12402 
12403 static int G__G__Proof_300_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12404 {
12405       ((TSlaveInfo*) G__getstructoffset())->SetStatus((TSlaveInfo::ESlaveStatus) G__int(libp->para[0]));
12406       G__setnull(result7);
12407    return(1 || funcname || hash || result7 || libp) ;
12408 }
12409 
12410 static int G__G__Proof_300_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12411 {
12412       ((TSlaveInfo*) G__getstructoffset())->SetSysInfo(*((SysInfo_t*) G__int(libp->para[0])));
12413       G__setnull(result7);
12414    return(1 || funcname || hash || result7 || libp) ;
12415 }
12416 
12417 static int G__G__Proof_300_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12418 {
12419       G__letint(result7, 85, (long) TSlaveInfo::Class());
12420    return(1 || funcname || hash || result7 || libp) ;
12421 }
12422 
12423 static int G__G__Proof_300_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12424 {
12425       G__letint(result7, 67, (long) TSlaveInfo::Class_Name());
12426    return(1 || funcname || hash || result7 || libp) ;
12427 }
12428 
12429 static int G__G__Proof_300_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12430 {
12431       G__letint(result7, 115, (long) TSlaveInfo::Class_Version());
12432    return(1 || funcname || hash || result7 || libp) ;
12433 }
12434 
12435 static int G__G__Proof_300_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12436 {
12437       TSlaveInfo::Dictionary();
12438       G__setnull(result7);
12439    return(1 || funcname || hash || result7 || libp) ;
12440 }
12441 
12442 static int G__G__Proof_300_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12443 {
12444       ((TSlaveInfo*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
12445       G__setnull(result7);
12446    return(1 || funcname || hash || result7 || libp) ;
12447 }
12448 
12449 static int G__G__Proof_300_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12450 {
12451       G__letint(result7, 67, (long) TSlaveInfo::DeclFileName());
12452    return(1 || funcname || hash || result7 || libp) ;
12453 }
12454 
12455 static int G__G__Proof_300_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12456 {
12457       G__letint(result7, 105, (long) TSlaveInfo::ImplFileLine());
12458    return(1 || funcname || hash || result7 || libp) ;
12459 }
12460 
12461 static int G__G__Proof_300_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12462 {
12463       G__letint(result7, 67, (long) TSlaveInfo::ImplFileName());
12464    return(1 || funcname || hash || result7 || libp) ;
12465 }
12466 
12467 static int G__G__Proof_300_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12468 {
12469       G__letint(result7, 105, (long) TSlaveInfo::DeclFileLine());
12470    return(1 || funcname || hash || result7 || libp) ;
12471 }
12472 
12473 // automatic copy constructor
12474 static int G__G__Proof_300_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12475 
12476 {
12477    TSlaveInfo* p;
12478    void* tmp = (void*) G__int(libp->para[0]);
12479    p = new TSlaveInfo(*(TSlaveInfo*) tmp);
12480    result7->obj.i = (long) p;
12481    result7->ref = (long) p;
12482    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TSlaveInfo));
12483    return(1 || funcname || hash || result7 || libp) ;
12484 }
12485 
12486 // automatic destructor
12487 typedef TSlaveInfo G__TTSlaveInfo;
12488 static int G__G__Proof_300_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12489 {
12490    char* gvp = (char*) G__getgvp();
12491    long soff = G__getstructoffset();
12492    int n = G__getaryconstruct();
12493    //
12494    //has_a_delete: 1
12495    //has_own_delete1arg: 0
12496    //has_own_delete2arg: 0
12497    //
12498    if (!soff) {
12499      return(1);
12500    }
12501    if (n) {
12502      if (gvp == (char*)G__PVOID) {
12503        delete[] (TSlaveInfo*) soff;
12504      } else {
12505        G__setgvp((long) G__PVOID);
12506        for (int i = n - 1; i >= 0; --i) {
12507          ((TSlaveInfo*) (soff+(sizeof(TSlaveInfo)*i)))->~G__TTSlaveInfo();
12508        }
12509        G__setgvp((long)gvp);
12510      }
12511    } else {
12512      if (gvp == (char*)G__PVOID) {
12513        delete (TSlaveInfo*) soff;
12514      } else {
12515        G__setgvp((long) G__PVOID);
12516        ((TSlaveInfo*) (soff))->~G__TTSlaveInfo();
12517        G__setgvp((long)gvp);
12518      }
12519    }
12520    G__setnull(result7);
12521    return(1 || funcname || hash || result7 || libp) ;
12522 }
12523 
12524 // automatic assignment operator
12525 static int G__G__Proof_300_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12526 {
12527    TSlaveInfo* dest = (TSlaveInfo*) G__getstructoffset();
12528    *dest = *(TSlaveInfo*) libp->para[0].ref;
12529    const TSlaveInfo& obj = *dest;
12530    result7->ref = (long) (&obj);
12531    result7->obj.i = (long) (&obj);
12532    return(1 || funcname || hash || result7 || libp) ;
12533 }
12534 
12535 
12536 /* TMergerInfo */
12537 static int G__G__Proof_302_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12538 {
12539    TMergerInfo* p = NULL;
12540    char* gvp = (char*) G__getgvp();
12541    //m: 3
12542    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12543      p = new TMergerInfo(
12544 (TSlave*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
12545 , (Int_t) G__int(libp->para[2]));
12546    } else {
12547      p = new((void*) gvp) TMergerInfo(
12548 (TSlave*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
12549 , (Int_t) G__int(libp->para[2]));
12550    }
12551    result7->obj.i = (long) p;
12552    result7->ref = (long) p;
12553    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TMergerInfo));
12554    return(1 || funcname || hash || result7 || libp) ;
12555 }
12556 
12557 static int G__G__Proof_302_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12558 {
12559       ((TMergerInfo*) G__getstructoffset())->AddWorker((TSlave*) G__int(libp->para[0]));
12560       G__setnull(result7);
12561    return(1 || funcname || hash || result7 || libp) ;
12562 }
12563 
12564 static int G__G__Proof_302_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12565 {
12566       G__letint(result7, 85, (long) ((TMergerInfo*) G__getstructoffset())->GetWorkers());
12567    return(1 || funcname || hash || result7 || libp) ;
12568 }
12569 
12570 static int G__G__Proof_302_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12571 {
12572       G__letint(result7, 85, (long) ((TMergerInfo*) G__getstructoffset())->GetMerger());
12573    return(1 || funcname || hash || result7 || libp) ;
12574 }
12575 
12576 static int G__G__Proof_302_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12577 {
12578       G__letint(result7, 105, (long) ((TMergerInfo*) G__getstructoffset())->GetPort());
12579    return(1 || funcname || hash || result7 || libp) ;
12580 }
12581 
12582 static int G__G__Proof_302_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12583 {
12584       G__letint(result7, 105, (long) ((TMergerInfo*) G__getstructoffset())->GetWorkersToMerge());
12585    return(1 || funcname || hash || result7 || libp) ;
12586 }
12587 
12588 static int G__G__Proof_302_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12589 {
12590       G__letint(result7, 105, (long) ((TMergerInfo*) G__getstructoffset())->GetMergedWorkers());
12591    return(1 || funcname || hash || result7 || libp) ;
12592 }
12593 
12594 static int G__G__Proof_302_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12595 {
12596       G__letint(result7, 105, (long) ((TMergerInfo*) G__getstructoffset())->GetMergedObjects());
12597    return(1 || funcname || hash || result7 || libp) ;
12598 }
12599 
12600 static int G__G__Proof_302_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12601 {
12602       ((TMergerInfo*) G__getstructoffset())->SetMergedWorker();
12603       G__setnull(result7);
12604    return(1 || funcname || hash || result7 || libp) ;
12605 }
12606 
12607 static int G__G__Proof_302_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12608 {
12609       ((TMergerInfo*) G__getstructoffset())->AddMergedObjects((Int_t) G__int(libp->para[0]));
12610       G__setnull(result7);
12611    return(1 || funcname || hash || result7 || libp) ;
12612 }
12613 
12614 static int G__G__Proof_302_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12615 {
12616       G__letint(result7, 103, (long) ((TMergerInfo*) G__getstructoffset())->AreAllWorkersAssigned());
12617    return(1 || funcname || hash || result7 || libp) ;
12618 }
12619 
12620 static int G__G__Proof_302_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12621 {
12622       G__letint(result7, 103, (long) ((TMergerInfo*) G__getstructoffset())->AreAllWorkersMerged());
12623    return(1 || funcname || hash || result7 || libp) ;
12624 }
12625 
12626 static int G__G__Proof_302_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12627 {
12628       ((TMergerInfo*) G__getstructoffset())->Deactivate();
12629       G__setnull(result7);
12630    return(1 || funcname || hash || result7 || libp) ;
12631 }
12632 
12633 static int G__G__Proof_302_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12634 {
12635       G__letint(result7, 103, (long) ((TMergerInfo*) G__getstructoffset())->IsActive());
12636    return(1 || funcname || hash || result7 || libp) ;
12637 }
12638 
12639 static int G__G__Proof_302_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12640 {
12641       G__letint(result7, 85, (long) TMergerInfo::Class());
12642    return(1 || funcname || hash || result7 || libp) ;
12643 }
12644 
12645 static int G__G__Proof_302_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12646 {
12647       G__letint(result7, 67, (long) TMergerInfo::Class_Name());
12648    return(1 || funcname || hash || result7 || libp) ;
12649 }
12650 
12651 static int G__G__Proof_302_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12652 {
12653       G__letint(result7, 115, (long) TMergerInfo::Class_Version());
12654    return(1 || funcname || hash || result7 || libp) ;
12655 }
12656 
12657 static int G__G__Proof_302_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12658 {
12659       TMergerInfo::Dictionary();
12660       G__setnull(result7);
12661    return(1 || funcname || hash || result7 || libp) ;
12662 }
12663 
12664 static int G__G__Proof_302_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12665 {
12666       ((TMergerInfo*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
12667       G__setnull(result7);
12668    return(1 || funcname || hash || result7 || libp) ;
12669 }
12670 
12671 static int G__G__Proof_302_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12672 {
12673       G__letint(result7, 67, (long) TMergerInfo::DeclFileName());
12674    return(1 || funcname || hash || result7 || libp) ;
12675 }
12676 
12677 static int G__G__Proof_302_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12678 {
12679       G__letint(result7, 105, (long) TMergerInfo::ImplFileLine());
12680    return(1 || funcname || hash || result7 || libp) ;
12681 }
12682 
12683 static int G__G__Proof_302_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12684 {
12685       G__letint(result7, 67, (long) TMergerInfo::ImplFileName());
12686    return(1 || funcname || hash || result7 || libp) ;
12687 }
12688 
12689 static int G__G__Proof_302_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12690 {
12691       G__letint(result7, 105, (long) TMergerInfo::DeclFileLine());
12692    return(1 || funcname || hash || result7 || libp) ;
12693 }
12694 
12695 // automatic destructor
12696 typedef TMergerInfo G__TTMergerInfo;
12697 static int G__G__Proof_302_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12698 {
12699    char* gvp = (char*) G__getgvp();
12700    long soff = G__getstructoffset();
12701    int n = G__getaryconstruct();
12702    //
12703    //has_a_delete: 1
12704    //has_own_delete1arg: 0
12705    //has_own_delete2arg: 0
12706    //
12707    if (!soff) {
12708      return(1);
12709    }
12710    if (n) {
12711      if (gvp == (char*)G__PVOID) {
12712        delete[] (TMergerInfo*) soff;
12713      } else {
12714        G__setgvp((long) G__PVOID);
12715        for (int i = n - 1; i >= 0; --i) {
12716          ((TMergerInfo*) (soff+(sizeof(TMergerInfo)*i)))->~G__TTMergerInfo();
12717        }
12718        G__setgvp((long)gvp);
12719      }
12720    } else {
12721      if (gvp == (char*)G__PVOID) {
12722        delete (TMergerInfo*) soff;
12723      } else {
12724        G__setgvp((long) G__PVOID);
12725        ((TMergerInfo*) (soff))->~G__TTMergerInfo();
12726        G__setgvp((long)gvp);
12727      }
12728    }
12729    G__setnull(result7);
12730    return(1 || funcname || hash || result7 || libp) ;
12731 }
12732 
12733 
12734 /* TProofLite */
12735 static int G__G__Proof_307_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12736 {
12737    TProofLite* p = NULL;
12738    char* gvp = (char*) G__getgvp();
12739    switch (libp->paran) {
12740    case 6:
12741      //m: 6
12742      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12743        p = new TProofLite(
12744 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
12745 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
12746 , (const char*) G__int(libp->para[4]), (TProofMgr*) G__int(libp->para[5]));
12747      } else {
12748        p = new((void*) gvp) TProofLite(
12749 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
12750 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
12751 , (const char*) G__int(libp->para[4]), (TProofMgr*) G__int(libp->para[5]));
12752      }
12753      break;
12754    case 5:
12755      //m: 5
12756      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12757        p = new TProofLite(
12758 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
12759 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
12760 , (const char*) G__int(libp->para[4]));
12761      } else {
12762        p = new((void*) gvp) TProofLite(
12763 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
12764 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
12765 , (const char*) G__int(libp->para[4]));
12766      }
12767      break;
12768    case 4:
12769      //m: 4
12770      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12771        p = new TProofLite(
12772 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
12773 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
12774      } else {
12775        p = new((void*) gvp) TProofLite(
12776 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
12777 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
12778      }
12779      break;
12780    case 3:
12781      //m: 3
12782      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12783        p = new TProofLite(
12784 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
12785 , (const char*) G__int(libp->para[2]));
12786      } else {
12787        p = new((void*) gvp) TProofLite(
12788 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
12789 , (const char*) G__int(libp->para[2]));
12790      }
12791      break;
12792    case 2:
12793      //m: 2
12794      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12795        p = new TProofLite((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
12796      } else {
12797        p = new((void*) gvp) TProofLite((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
12798      }
12799      break;
12800    case 1:
12801      //m: 1
12802      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12803        p = new TProofLite((const char*) G__int(libp->para[0]));
12804      } else {
12805        p = new((void*) gvp) TProofLite((const char*) G__int(libp->para[0]));
12806      }
12807      break;
12808    }
12809    result7->obj.i = (long) p;
12810    result7->ref = (long) p;
12811    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofLite));
12812    return(1 || funcname || hash || result7 || libp) ;
12813 }
12814 
12815 static int G__G__Proof_307_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12816 {
12817       G__letint(result7, 105, (long) ((TProofLite*) G__getstructoffset())->Remove((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
12818    return(1 || funcname || hash || result7 || libp) ;
12819 }
12820 
12821 static int G__G__Proof_307_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12822 {
12823    switch (libp->paran) {
12824    case 1:
12825       G__letint(result7, 105, (long) TProofLite::GetNumberOfWorkers((const char*) G__int(libp->para[0])));
12826       break;
12827    case 0:
12828       G__letint(result7, 105, (long) TProofLite::GetNumberOfWorkers());
12829       break;
12830    }
12831    return(1 || funcname || hash || result7 || libp) ;
12832 }
12833 
12834 static int G__G__Proof_307_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12835 {
12836       G__letint(result7, 85, (long) TProofLite::Class());
12837    return(1 || funcname || hash || result7 || libp) ;
12838 }
12839 
12840 static int G__G__Proof_307_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12841 {
12842       G__letint(result7, 67, (long) TProofLite::Class_Name());
12843    return(1 || funcname || hash || result7 || libp) ;
12844 }
12845 
12846 static int G__G__Proof_307_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12847 {
12848       G__letint(result7, 115, (long) TProofLite::Class_Version());
12849    return(1 || funcname || hash || result7 || libp) ;
12850 }
12851 
12852 static int G__G__Proof_307_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12853 {
12854       TProofLite::Dictionary();
12855       G__setnull(result7);
12856    return(1 || funcname || hash || result7 || libp) ;
12857 }
12858 
12859 static int G__G__Proof_307_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12860 {
12861       ((TProofLite*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
12862       G__setnull(result7);
12863    return(1 || funcname || hash || result7 || libp) ;
12864 }
12865 
12866 static int G__G__Proof_307_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12867 {
12868       G__letint(result7, 67, (long) TProofLite::DeclFileName());
12869    return(1 || funcname || hash || result7 || libp) ;
12870 }
12871 
12872 static int G__G__Proof_307_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12873 {
12874       G__letint(result7, 105, (long) TProofLite::ImplFileLine());
12875    return(1 || funcname || hash || result7 || libp) ;
12876 }
12877 
12878 static int G__G__Proof_307_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12879 {
12880       G__letint(result7, 67, (long) TProofLite::ImplFileName());
12881    return(1 || funcname || hash || result7 || libp) ;
12882 }
12883 
12884 static int G__G__Proof_307_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12885 {
12886       G__letint(result7, 105, (long) TProofLite::DeclFileLine());
12887    return(1 || funcname || hash || result7 || libp) ;
12888 }
12889 
12890 // automatic destructor
12891 typedef TProofLite G__TTProofLite;
12892 static int G__G__Proof_307_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12893 {
12894    char* gvp = (char*) G__getgvp();
12895    long soff = G__getstructoffset();
12896    int n = G__getaryconstruct();
12897    //
12898    //has_a_delete: 1
12899    //has_own_delete1arg: 0
12900    //has_own_delete2arg: 0
12901    //
12902    if (!soff) {
12903      return(1);
12904    }
12905    if (n) {
12906      if (gvp == (char*)G__PVOID) {
12907        delete[] (TProofLite*) soff;
12908      } else {
12909        G__setgvp((long) G__PVOID);
12910        for (int i = n - 1; i >= 0; --i) {
12911          ((TProofLite*) (soff+(sizeof(TProofLite)*i)))->~G__TTProofLite();
12912        }
12913        G__setgvp((long)gvp);
12914      }
12915    } else {
12916      if (gvp == (char*)G__PVOID) {
12917        delete (TProofLite*) soff;
12918      } else {
12919        G__setgvp((long) G__PVOID);
12920        ((TProofLite*) (soff))->~G__TTProofLite();
12921        G__setgvp((long)gvp);
12922      }
12923    }
12924    G__setnull(result7);
12925    return(1 || funcname || hash || result7 || libp) ;
12926 }
12927 
12928 
12929 /* TSlaveLite */
12930 static int G__G__Proof_309_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12931 {
12932    TSlaveLite* p = NULL;
12933    char* gvp = (char*) G__getgvp();
12934    //m: 7
12935    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
12936      p = new TSlaveLite(
12937 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
12938 , (const char*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
12939 , (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
12940 , (const char*) G__int(libp->para[6]));
12941    } else {
12942      p = new((void*) gvp) TSlaveLite(
12943 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
12944 , (const char*) G__int(libp->para[2]), (TProof*) G__int(libp->para[3])
12945 , (Int_t) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
12946 , (const char*) G__int(libp->para[6]));
12947    }
12948    result7->obj.i = (long) p;
12949    result7->ref = (long) p;
12950    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TSlaveLite));
12951    return(1 || funcname || hash || result7 || libp) ;
12952 }
12953 
12954 static int G__G__Proof_309_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12955 {
12956       G__letint(result7, 85, (long) TSlaveLite::Class());
12957    return(1 || funcname || hash || result7 || libp) ;
12958 }
12959 
12960 static int G__G__Proof_309_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12961 {
12962       G__letint(result7, 67, (long) TSlaveLite::Class_Name());
12963    return(1 || funcname || hash || result7 || libp) ;
12964 }
12965 
12966 static int G__G__Proof_309_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12967 {
12968       G__letint(result7, 115, (long) TSlaveLite::Class_Version());
12969    return(1 || funcname || hash || result7 || libp) ;
12970 }
12971 
12972 static int G__G__Proof_309_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12973 {
12974       TSlaveLite::Dictionary();
12975       G__setnull(result7);
12976    return(1 || funcname || hash || result7 || libp) ;
12977 }
12978 
12979 static int G__G__Proof_309_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12980 {
12981       ((TSlaveLite*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
12982       G__setnull(result7);
12983    return(1 || funcname || hash || result7 || libp) ;
12984 }
12985 
12986 static int G__G__Proof_309_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12987 {
12988       G__letint(result7, 67, (long) TSlaveLite::DeclFileName());
12989    return(1 || funcname || hash || result7 || libp) ;
12990 }
12991 
12992 static int G__G__Proof_309_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12993 {
12994       G__letint(result7, 105, (long) TSlaveLite::ImplFileLine());
12995    return(1 || funcname || hash || result7 || libp) ;
12996 }
12997 
12998 static int G__G__Proof_309_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
12999 {
13000       G__letint(result7, 67, (long) TSlaveLite::ImplFileName());
13001    return(1 || funcname || hash || result7 || libp) ;
13002 }
13003 
13004 static int G__G__Proof_309_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13005 {
13006       G__letint(result7, 105, (long) TSlaveLite::DeclFileLine());
13007    return(1 || funcname || hash || result7 || libp) ;
13008 }
13009 
13010 // automatic destructor
13011 typedef TSlaveLite G__TTSlaveLite;
13012 static int G__G__Proof_309_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13013 {
13014    char* gvp = (char*) G__getgvp();
13015    long soff = G__getstructoffset();
13016    int n = G__getaryconstruct();
13017    //
13018    //has_a_delete: 1
13019    //has_own_delete1arg: 0
13020    //has_own_delete2arg: 0
13021    //
13022    if (!soff) {
13023      return(1);
13024    }
13025    if (n) {
13026      if (gvp == (char*)G__PVOID) {
13027        delete[] (TSlaveLite*) soff;
13028      } else {
13029        G__setgvp((long) G__PVOID);
13030        for (int i = n - 1; i >= 0; --i) {
13031          ((TSlaveLite*) (soff+(sizeof(TSlaveLite)*i)))->~G__TTSlaveLite();
13032        }
13033        G__setgvp((long)gvp);
13034      }
13035    } else {
13036      if (gvp == (char*)G__PVOID) {
13037        delete (TSlaveLite*) soff;
13038      } else {
13039        G__setgvp((long) G__PVOID);
13040        ((TSlaveLite*) (soff))->~G__TTSlaveLite();
13041        G__setgvp((long)gvp);
13042      }
13043    }
13044    G__setnull(result7);
13045    return(1 || funcname || hash || result7 || libp) ;
13046 }
13047 
13048 
13049 /* TProofCondor */
13050 static int G__G__Proof_342_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13051 {
13052    TProofCondor* p = NULL;
13053    char* gvp = (char*) G__getgvp();
13054    switch (libp->paran) {
13055    case 6:
13056      //m: 6
13057      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13058        p = new TProofCondor(
13059 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
13060 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
13061 , (const char*) G__int(libp->para[4]), (TProofMgr*) G__int(libp->para[5]));
13062      } else {
13063        p = new((void*) gvp) TProofCondor(
13064 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
13065 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
13066 , (const char*) G__int(libp->para[4]), (TProofMgr*) G__int(libp->para[5]));
13067      }
13068      break;
13069    case 5:
13070      //m: 5
13071      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13072        p = new TProofCondor(
13073 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
13074 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
13075 , (const char*) G__int(libp->para[4]));
13076      } else {
13077        p = new((void*) gvp) TProofCondor(
13078 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
13079 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
13080 , (const char*) G__int(libp->para[4]));
13081      }
13082      break;
13083    case 4:
13084      //m: 4
13085      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13086        p = new TProofCondor(
13087 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
13088 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
13089      } else {
13090        p = new((void*) gvp) TProofCondor(
13091 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
13092 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
13093      }
13094      break;
13095    case 3:
13096      //m: 3
13097      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13098        p = new TProofCondor(
13099 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
13100 , (const char*) G__int(libp->para[2]));
13101      } else {
13102        p = new((void*) gvp) TProofCondor(
13103 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
13104 , (const char*) G__int(libp->para[2]));
13105      }
13106      break;
13107    case 2:
13108      //m: 2
13109      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13110        p = new TProofCondor((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
13111      } else {
13112        p = new((void*) gvp) TProofCondor((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
13113      }
13114      break;
13115    case 1:
13116      //m: 1
13117      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13118        p = new TProofCondor((const char*) G__int(libp->para[0]));
13119      } else {
13120        p = new((void*) gvp) TProofCondor((const char*) G__int(libp->para[0]));
13121      }
13122      break;
13123    }
13124    result7->obj.i = (long) p;
13125    result7->ref = (long) p;
13126    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofCondor));
13127    return(1 || funcname || hash || result7 || libp) ;
13128 }
13129 
13130 static int G__G__Proof_342_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13131 {
13132       ((TProofCondor*) G__getstructoffset())->SetActive();
13133       G__setnull(result7);
13134    return(1 || funcname || hash || result7 || libp) ;
13135 }
13136 
13137 static int G__G__Proof_342_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13138 {
13139       G__letint(result7, 85, (long) TProofCondor::Class());
13140    return(1 || funcname || hash || result7 || libp) ;
13141 }
13142 
13143 static int G__G__Proof_342_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13144 {
13145       G__letint(result7, 67, (long) TProofCondor::Class_Name());
13146    return(1 || funcname || hash || result7 || libp) ;
13147 }
13148 
13149 static int G__G__Proof_342_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13150 {
13151       G__letint(result7, 115, (long) TProofCondor::Class_Version());
13152    return(1 || funcname || hash || result7 || libp) ;
13153 }
13154 
13155 static int G__G__Proof_342_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13156 {
13157       TProofCondor::Dictionary();
13158       G__setnull(result7);
13159    return(1 || funcname || hash || result7 || libp) ;
13160 }
13161 
13162 static int G__G__Proof_342_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13163 {
13164       ((TProofCondor*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
13165       G__setnull(result7);
13166    return(1 || funcname || hash || result7 || libp) ;
13167 }
13168 
13169 static int G__G__Proof_342_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13170 {
13171       G__letint(result7, 67, (long) TProofCondor::DeclFileName());
13172    return(1 || funcname || hash || result7 || libp) ;
13173 }
13174 
13175 static int G__G__Proof_342_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13176 {
13177       G__letint(result7, 105, (long) TProofCondor::ImplFileLine());
13178    return(1 || funcname || hash || result7 || libp) ;
13179 }
13180 
13181 static int G__G__Proof_342_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13182 {
13183       G__letint(result7, 67, (long) TProofCondor::ImplFileName());
13184    return(1 || funcname || hash || result7 || libp) ;
13185 }
13186 
13187 static int G__G__Proof_342_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13188 {
13189       G__letint(result7, 105, (long) TProofCondor::DeclFileLine());
13190    return(1 || funcname || hash || result7 || libp) ;
13191 }
13192 
13193 // automatic destructor
13194 typedef TProofCondor G__TTProofCondor;
13195 static int G__G__Proof_342_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13196 {
13197    char* gvp = (char*) G__getgvp();
13198    long soff = G__getstructoffset();
13199    int n = G__getaryconstruct();
13200    //
13201    //has_a_delete: 1
13202    //has_own_delete1arg: 0
13203    //has_own_delete2arg: 0
13204    //
13205    if (!soff) {
13206      return(1);
13207    }
13208    if (n) {
13209      if (gvp == (char*)G__PVOID) {
13210        delete[] (TProofCondor*) soff;
13211      } else {
13212        G__setgvp((long) G__PVOID);
13213        for (int i = n - 1; i >= 0; --i) {
13214          ((TProofCondor*) (soff+(sizeof(TProofCondor)*i)))->~G__TTProofCondor();
13215        }
13216        G__setgvp((long)gvp);
13217      }
13218    } else {
13219      if (gvp == (char*)G__PVOID) {
13220        delete (TProofCondor*) soff;
13221      } else {
13222        G__setgvp((long) G__PVOID);
13223        ((TProofCondor*) (soff))->~G__TTProofCondor();
13224        G__setgvp((long)gvp);
13225      }
13226    }
13227    G__setnull(result7);
13228    return(1 || funcname || hash || result7 || libp) ;
13229 }
13230 
13231 
13232 /* TQueryResultManager */
13233 static int G__G__Proof_343_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13234 {
13235    TQueryResultManager* p = NULL;
13236    char* gvp = (char*) G__getgvp();
13237    switch (libp->paran) {
13238    case 5:
13239      //m: 5
13240      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13241        p = new TQueryResultManager(
13242 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
13243 , (const char*) G__int(libp->para[2]), (TProofLockPath*) G__int(libp->para[3])
13244 , (FILE*) G__int(libp->para[4]));
13245      } else {
13246        p = new((void*) gvp) TQueryResultManager(
13247 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
13248 , (const char*) G__int(libp->para[2]), (TProofLockPath*) G__int(libp->para[3])
13249 , (FILE*) G__int(libp->para[4]));
13250      }
13251      break;
13252    case 4:
13253      //m: 4
13254      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13255        p = new TQueryResultManager(
13256 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
13257 , (const char*) G__int(libp->para[2]), (TProofLockPath*) G__int(libp->para[3]));
13258      } else {
13259        p = new((void*) gvp) TQueryResultManager(
13260 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
13261 , (const char*) G__int(libp->para[2]), (TProofLockPath*) G__int(libp->para[3]));
13262      }
13263      break;
13264    }
13265    result7->obj.i = (long) p;
13266    result7->ref = (long) p;
13267    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TQueryResultManager));
13268    return(1 || funcname || hash || result7 || libp) ;
13269 }
13270 
13271 static int G__G__Proof_343_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13272 {
13273       G__letint(result7, 67, (long) ((const TQueryResultManager*) G__getstructoffset())->QueryDir());
13274    return(1 || funcname || hash || result7 || libp) ;
13275 }
13276 
13277 static int G__G__Proof_343_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13278 {
13279       G__letint(result7, 105, (long) ((const TQueryResultManager*) G__getstructoffset())->SeqNum());
13280    return(1 || funcname || hash || result7 || libp) ;
13281 }
13282 
13283 static int G__G__Proof_343_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13284 {
13285       G__letint(result7, 105, (long) ((const TQueryResultManager*) G__getstructoffset())->DrawQueries());
13286    return(1 || funcname || hash || result7 || libp) ;
13287 }
13288 
13289 static int G__G__Proof_343_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13290 {
13291       G__letint(result7, 105, (long) ((const TQueryResultManager*) G__getstructoffset())->KeptQueries());
13292    return(1 || funcname || hash || result7 || libp) ;
13293 }
13294 
13295 static int G__G__Proof_343_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13296 {
13297       G__letint(result7, 85, (long) ((const TQueryResultManager*) G__getstructoffset())->Queries());
13298    return(1 || funcname || hash || result7 || libp) ;
13299 }
13300 
13301 static int G__G__Proof_343_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13302 {
13303       G__letint(result7, 85, (long) ((const TQueryResultManager*) G__getstructoffset())->PreviousQueries());
13304    return(1 || funcname || hash || result7 || libp) ;
13305 }
13306 
13307 static int G__G__Proof_343_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13308 {
13309       ((TQueryResultManager*) G__getstructoffset())->IncrementSeqNum();
13310       G__setnull(result7);
13311    return(1 || funcname || hash || result7 || libp) ;
13312 }
13313 
13314 static int G__G__Proof_343_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13315 {
13316       ((TQueryResultManager*) G__getstructoffset())->IncrementDrawQueries();
13317       G__setnull(result7);
13318    return(1 || funcname || hash || result7 || libp) ;
13319 }
13320 
13321 static int G__G__Proof_343_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13322 {
13323       G__letint(result7, 105, (long) ((TQueryResultManager*) G__getstructoffset())->ApplyMaxQueries((Int_t) G__int(libp->para[0])));
13324    return(1 || funcname || hash || result7 || libp) ;
13325 }
13326 
13327 static int G__G__Proof_343_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13328 {
13329       G__letint(result7, 105, (long) ((TQueryResultManager*) G__getstructoffset())->CleanupQueriesDir());
13330    return(1 || funcname || hash || result7 || libp) ;
13331 }
13332 
13333 static int G__G__Proof_343_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13334 {
13335       G__letint(result7, 103, (long) ((TQueryResultManager*) G__getstructoffset())->FinalizeQuery((TProofQueryResult*) G__int(libp->para[0]), (TProof*) G__int(libp->para[1])
13336 , (TVirtualProofPlayer*) G__int(libp->para[2])));
13337    return(1 || funcname || hash || result7 || libp) ;
13338 }
13339 
13340 static int G__G__Proof_343_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13341 {
13342       G__letdouble(result7, 102, (double) ((TQueryResultManager*) G__getstructoffset())->GetCpuTime());
13343    return(1 || funcname || hash || result7 || libp) ;
13344 }
13345 
13346 static int G__G__Proof_343_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13347 {
13348       G__letdouble(result7, 102, (double) ((TQueryResultManager*) G__getstructoffset())->GetRealTime());
13349    return(1 || funcname || hash || result7 || libp) ;
13350 }
13351 
13352 static int G__G__Proof_343_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13353 {
13354       G__letint(result7, 85, (long) ((TQueryResultManager*) G__getstructoffset())->LocateQuery(*((TString*) G__int(libp->para[0])), *(Int_t*) G__Intref(&libp->para[1])
13355 , *(TString*) libp->para[2].ref));
13356    return(1 || funcname || hash || result7 || libp) ;
13357 }
13358 
13359 static int G__G__Proof_343_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13360 {
13361    switch (libp->paran) {
13362    case 2:
13363       ((TQueryResultManager*) G__getstructoffset())->RemoveQuery((TQueryResult*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
13364       G__setnull(result7);
13365       break;
13366    case 1:
13367       ((TQueryResultManager*) G__getstructoffset())->RemoveQuery((TQueryResult*) G__int(libp->para[0]));
13368       G__setnull(result7);
13369       break;
13370    }
13371    return(1 || funcname || hash || result7 || libp) ;
13372 }
13373 
13374 static int G__G__Proof_343_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13375 {
13376    switch (libp->paran) {
13377    case 2:
13378       ((TQueryResultManager*) G__getstructoffset())->RemoveQuery((const char*) G__int(libp->para[0]), (TList*) G__int(libp->para[1]));
13379       G__setnull(result7);
13380       break;
13381    case 1:
13382       ((TQueryResultManager*) G__getstructoffset())->RemoveQuery((const char*) G__int(libp->para[0]));
13383       G__setnull(result7);
13384       break;
13385    }
13386    return(1 || funcname || hash || result7 || libp) ;
13387 }
13388 
13389 static int G__G__Proof_343_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13390 {
13391       ((TQueryResultManager*) G__getstructoffset())->ResetTime();
13392       G__setnull(result7);
13393    return(1 || funcname || hash || result7 || libp) ;
13394 }
13395 
13396 static int G__G__Proof_343_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13397 {
13398    switch (libp->paran) {
13399    case 2:
13400       ((TQueryResultManager*) G__getstructoffset())->SaveQuery((TProofQueryResult*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
13401       G__setnull(result7);
13402       break;
13403    case 1:
13404       ((TQueryResultManager*) G__getstructoffset())->SaveQuery((TProofQueryResult*) G__int(libp->para[0]));
13405       G__setnull(result7);
13406       break;
13407    }
13408    return(1 || funcname || hash || result7 || libp) ;
13409 }
13410 
13411 static int G__G__Proof_343_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13412 {
13413       ((TQueryResultManager*) G__getstructoffset())->SaveQuery((TProofQueryResult*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
13414       G__setnull(result7);
13415    return(1 || funcname || hash || result7 || libp) ;
13416 }
13417 
13418 static int G__G__Proof_343_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13419 {
13420       G__letint(result7, 105, (long) ((TQueryResultManager*) G__getstructoffset())->LockSession((const char*) G__int(libp->para[0]), (TProofLockPath**) G__int(libp->para[1])));
13421    return(1 || funcname || hash || result7 || libp) ;
13422 }
13423 
13424 static int G__G__Proof_343_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13425 {
13426       G__letint(result7, 105, (long) ((TQueryResultManager*) G__getstructoffset())->CleanupSession((const char*) G__int(libp->para[0])));
13427    return(1 || funcname || hash || result7 || libp) ;
13428 }
13429 
13430 static int G__G__Proof_343_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13431 {
13432       ((TQueryResultManager*) G__getstructoffset())->ScanPreviousQueries((const char*) G__int(libp->para[0]));
13433       G__setnull(result7);
13434    return(1 || funcname || hash || result7 || libp) ;
13435 }
13436 
13437 static int G__G__Proof_343_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13438 {
13439       G__letint(result7, 85, (long) TQueryResultManager::Class());
13440    return(1 || funcname || hash || result7 || libp) ;
13441 }
13442 
13443 static int G__G__Proof_343_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13444 {
13445       G__letint(result7, 67, (long) TQueryResultManager::Class_Name());
13446    return(1 || funcname || hash || result7 || libp) ;
13447 }
13448 
13449 static int G__G__Proof_343_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13450 {
13451       G__letint(result7, 115, (long) TQueryResultManager::Class_Version());
13452    return(1 || funcname || hash || result7 || libp) ;
13453 }
13454 
13455 static int G__G__Proof_343_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13456 {
13457       TQueryResultManager::Dictionary();
13458       G__setnull(result7);
13459    return(1 || funcname || hash || result7 || libp) ;
13460 }
13461 
13462 static int G__G__Proof_343_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13463 {
13464       ((TQueryResultManager*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
13465       G__setnull(result7);
13466    return(1 || funcname || hash || result7 || libp) ;
13467 }
13468 
13469 static int G__G__Proof_343_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13470 {
13471       G__letint(result7, 67, (long) TQueryResultManager::DeclFileName());
13472    return(1 || funcname || hash || result7 || libp) ;
13473 }
13474 
13475 static int G__G__Proof_343_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13476 {
13477       G__letint(result7, 105, (long) TQueryResultManager::ImplFileLine());
13478    return(1 || funcname || hash || result7 || libp) ;
13479 }
13480 
13481 static int G__G__Proof_343_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13482 {
13483       G__letint(result7, 67, (long) TQueryResultManager::ImplFileName());
13484    return(1 || funcname || hash || result7 || libp) ;
13485 }
13486 
13487 static int G__G__Proof_343_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13488 {
13489       G__letint(result7, 105, (long) TQueryResultManager::DeclFileLine());
13490    return(1 || funcname || hash || result7 || libp) ;
13491 }
13492 
13493 // automatic copy constructor
13494 static int G__G__Proof_343_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13495 
13496 {
13497    TQueryResultManager* p;
13498    void* tmp = (void*) G__int(libp->para[0]);
13499    p = new TQueryResultManager(*(TQueryResultManager*) tmp);
13500    result7->obj.i = (long) p;
13501    result7->ref = (long) p;
13502    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TQueryResultManager));
13503    return(1 || funcname || hash || result7 || libp) ;
13504 }
13505 
13506 // automatic destructor
13507 typedef TQueryResultManager G__TTQueryResultManager;
13508 static int G__G__Proof_343_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13509 {
13510    char* gvp = (char*) G__getgvp();
13511    long soff = G__getstructoffset();
13512    int n = G__getaryconstruct();
13513    //
13514    //has_a_delete: 1
13515    //has_own_delete1arg: 0
13516    //has_own_delete2arg: 0
13517    //
13518    if (!soff) {
13519      return(1);
13520    }
13521    if (n) {
13522      if (gvp == (char*)G__PVOID) {
13523        delete[] (TQueryResultManager*) soff;
13524      } else {
13525        G__setgvp((long) G__PVOID);
13526        for (int i = n - 1; i >= 0; --i) {
13527          ((TQueryResultManager*) (soff+(sizeof(TQueryResultManager)*i)))->~G__TTQueryResultManager();
13528        }
13529        G__setgvp((long)gvp);
13530      }
13531    } else {
13532      if (gvp == (char*)G__PVOID) {
13533        delete (TQueryResultManager*) soff;
13534      } else {
13535        G__setgvp((long) G__PVOID);
13536        ((TQueryResultManager*) (soff))->~G__TTQueryResultManager();
13537        G__setgvp((long)gvp);
13538      }
13539    }
13540    G__setnull(result7);
13541    return(1 || funcname || hash || result7 || libp) ;
13542 }
13543 
13544 // automatic assignment operator
13545 static int G__G__Proof_343_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13546 {
13547    TQueryResultManager* dest = (TQueryResultManager*) G__getstructoffset();
13548    *dest = *(TQueryResultManager*) libp->para[0].ref;
13549    const TQueryResultManager& obj = *dest;
13550    result7->ref = (long) (&obj);
13551    result7->obj.i = (long) (&obj);
13552    return(1 || funcname || hash || result7 || libp) ;
13553 }
13554 
13555 
13556 /* TProofQueryResult */
13557 static int G__G__Proof_344_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13558 {
13559    TProofQueryResult* p = NULL;
13560    char* gvp = (char*) G__getgvp();
13561    int n = G__getaryconstruct();
13562    if (n) {
13563      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13564        p = new TProofQueryResult[n];
13565      } else {
13566        p = new((void*) gvp) TProofQueryResult[n];
13567      }
13568    } else {
13569      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13570        p = new TProofQueryResult;
13571      } else {
13572        p = new((void*) gvp) TProofQueryResult;
13573      }
13574    }
13575    result7->obj.i = (long) p;
13576    result7->ref = (long) p;
13577    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofQueryResult));
13578    return(1 || funcname || hash || result7 || libp) ;
13579 }
13580 
13581 static int G__G__Proof_344_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13582 {
13583       G__letint(result7, 85, (long) TProofQueryResult::Class());
13584    return(1 || funcname || hash || result7 || libp) ;
13585 }
13586 
13587 static int G__G__Proof_344_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13588 {
13589       G__letint(result7, 67, (long) TProofQueryResult::Class_Name());
13590    return(1 || funcname || hash || result7 || libp) ;
13591 }
13592 
13593 static int G__G__Proof_344_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13594 {
13595       G__letint(result7, 115, (long) TProofQueryResult::Class_Version());
13596    return(1 || funcname || hash || result7 || libp) ;
13597 }
13598 
13599 static int G__G__Proof_344_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13600 {
13601       TProofQueryResult::Dictionary();
13602       G__setnull(result7);
13603    return(1 || funcname || hash || result7 || libp) ;
13604 }
13605 
13606 static int G__G__Proof_344_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13607 {
13608       ((TProofQueryResult*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
13609       G__setnull(result7);
13610    return(1 || funcname || hash || result7 || libp) ;
13611 }
13612 
13613 static int G__G__Proof_344_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13614 {
13615       G__letint(result7, 67, (long) TProofQueryResult::DeclFileName());
13616    return(1 || funcname || hash || result7 || libp) ;
13617 }
13618 
13619 static int G__G__Proof_344_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13620 {
13621       G__letint(result7, 105, (long) TProofQueryResult::ImplFileLine());
13622    return(1 || funcname || hash || result7 || libp) ;
13623 }
13624 
13625 static int G__G__Proof_344_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13626 {
13627       G__letint(result7, 67, (long) TProofQueryResult::ImplFileName());
13628    return(1 || funcname || hash || result7 || libp) ;
13629 }
13630 
13631 static int G__G__Proof_344_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13632 {
13633       G__letint(result7, 105, (long) TProofQueryResult::DeclFileLine());
13634    return(1 || funcname || hash || result7 || libp) ;
13635 }
13636 
13637 // automatic copy constructor
13638 static int G__G__Proof_344_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13639 
13640 {
13641    TProofQueryResult* p;
13642    void* tmp = (void*) G__int(libp->para[0]);
13643    p = new TProofQueryResult(*(TProofQueryResult*) tmp);
13644    result7->obj.i = (long) p;
13645    result7->ref = (long) p;
13646    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofQueryResult));
13647    return(1 || funcname || hash || result7 || libp) ;
13648 }
13649 
13650 // automatic destructor
13651 typedef TProofQueryResult G__TTProofQueryResult;
13652 static int G__G__Proof_344_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13653 {
13654    char* gvp = (char*) G__getgvp();
13655    long soff = G__getstructoffset();
13656    int n = G__getaryconstruct();
13657    //
13658    //has_a_delete: 1
13659    //has_own_delete1arg: 0
13660    //has_own_delete2arg: 0
13661    //
13662    if (!soff) {
13663      return(1);
13664    }
13665    if (n) {
13666      if (gvp == (char*)G__PVOID) {
13667        delete[] (TProofQueryResult*) soff;
13668      } else {
13669        G__setgvp((long) G__PVOID);
13670        for (int i = n - 1; i >= 0; --i) {
13671          ((TProofQueryResult*) (soff+(sizeof(TProofQueryResult)*i)))->~G__TTProofQueryResult();
13672        }
13673        G__setgvp((long)gvp);
13674      }
13675    } else {
13676      if (gvp == (char*)G__PVOID) {
13677        delete (TProofQueryResult*) soff;
13678      } else {
13679        G__setgvp((long) G__PVOID);
13680        ((TProofQueryResult*) (soff))->~G__TTProofQueryResult();
13681        G__setgvp((long)gvp);
13682      }
13683    }
13684    G__setnull(result7);
13685    return(1 || funcname || hash || result7 || libp) ;
13686 }
13687 
13688 // automatic assignment operator
13689 static int G__G__Proof_344_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13690 {
13691    TProofQueryResult* dest = (TProofQueryResult*) G__getstructoffset();
13692    *dest = *(TProofQueryResult*) libp->para[0].ref;
13693    const TProofQueryResult& obj = *dest;
13694    result7->ref = (long) (&obj);
13695    result7->obj.i = (long) (&obj);
13696    return(1 || funcname || hash || result7 || libp) ;
13697 }
13698 
13699 
13700 /* TProofLogElem */
13701 static int G__G__Proof_346_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13702 {
13703    TProofLogElem* p = NULL;
13704    char* gvp = (char*) G__getgvp();
13705    //m: 3
13706    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13707      p = new TProofLogElem(
13708 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
13709 , (TProofLog*) G__int(libp->para[2]));
13710    } else {
13711      p = new((void*) gvp) TProofLogElem(
13712 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
13713 , (TProofLog*) G__int(libp->para[2]));
13714    }
13715    result7->obj.i = (long) p;
13716    result7->ref = (long) p;
13717    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofLogElem));
13718    return(1 || funcname || hash || result7 || libp) ;
13719 }
13720 
13721 static int G__G__Proof_346_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13722 {
13723    switch (libp->paran) {
13724    case 2:
13725       ((TProofLogElem*) G__getstructoffset())->Display((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
13726       G__setnull(result7);
13727       break;
13728    case 1:
13729       ((TProofLogElem*) G__getstructoffset())->Display((Int_t) G__int(libp->para[0]));
13730       G__setnull(result7);
13731       break;
13732    case 0:
13733       ((TProofLogElem*) G__getstructoffset())->Display();
13734       G__setnull(result7);
13735       break;
13736    }
13737    return(1 || funcname || hash || result7 || libp) ;
13738 }
13739 
13740 static int G__G__Proof_346_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13741 {
13742       G__letint(result7, 85, (long) ((const TProofLogElem*) G__getstructoffset())->GetMacro());
13743    return(1 || funcname || hash || result7 || libp) ;
13744 }
13745 
13746 static int G__G__Proof_346_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13747 {
13748       G__letint(result7, 67, (long) ((TProofLogElem*) G__getstructoffset())->GetRole());
13749    return(1 || funcname || hash || result7 || libp) ;
13750 }
13751 
13752 static int G__G__Proof_346_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13753 {
13754    switch (libp->paran) {
13755    case 3:
13756       G__letint(result7, 105, (long) ((TProofLogElem*) G__getstructoffset())->Grep((const char*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
13757 , (Int_t) G__int(libp->para[2])));
13758       break;
13759    case 2:
13760       G__letint(result7, 105, (long) ((TProofLogElem*) G__getstructoffset())->Grep((const char*) G__int(libp->para[0]), *(TString*) libp->para[1].ref));
13761       break;
13762    }
13763    return(1 || funcname || hash || result7 || libp) ;
13764 }
13765 
13766 static int G__G__Proof_346_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13767 {
13768       G__letint(result7, 103, (long) ((const TProofLogElem*) G__getstructoffset())->IsMaster());
13769    return(1 || funcname || hash || result7 || libp) ;
13770 }
13771 
13772 static int G__G__Proof_346_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13773 {
13774       G__letint(result7, 103, (long) ((const TProofLogElem*) G__getstructoffset())->IsSubMaster());
13775    return(1 || funcname || hash || result7 || libp) ;
13776 }
13777 
13778 static int G__G__Proof_346_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13779 {
13780       G__letint(result7, 103, (long) ((const TProofLogElem*) G__getstructoffset())->IsWorker());
13781    return(1 || funcname || hash || result7 || libp) ;
13782 }
13783 
13784 static int G__G__Proof_346_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13785 {
13786       ((TProofLogElem*) G__getstructoffset())->Prt((const char*) G__int(libp->para[0]));
13787       G__setnull(result7);
13788    return(1 || funcname || hash || result7 || libp) ;
13789 }
13790 
13791 static int G__G__Proof_346_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13792 {
13793    switch (libp->paran) {
13794    case 2:
13795       G__letint(result7, 105, (long) ((TProofLogElem*) G__getstructoffset())->Retrieve((TProofLog::ERetrieveOpt) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
13796       break;
13797    case 1:
13798       G__letint(result7, 105, (long) ((TProofLogElem*) G__getstructoffset())->Retrieve((TProofLog::ERetrieveOpt) G__int(libp->para[0])));
13799       break;
13800    case 0:
13801       G__letint(result7, 105, (long) ((TProofLogElem*) G__getstructoffset())->Retrieve());
13802       break;
13803    }
13804    return(1 || funcname || hash || result7 || libp) ;
13805 }
13806 
13807 static int G__G__Proof_346_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13808 {
13809       G__letLonglong(result7, 110, (G__int64) TProofLogElem::GetMaxTransferSize());
13810    return(1 || funcname || hash || result7 || libp) ;
13811 }
13812 
13813 static int G__G__Proof_346_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13814 {
13815       TProofLogElem::SetMaxTransferSize((Long64_t) G__Longlong(libp->para[0]));
13816       G__setnull(result7);
13817    return(1 || funcname || hash || result7 || libp) ;
13818 }
13819 
13820 static int G__G__Proof_346_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13821 {
13822       G__letint(result7, 85, (long) TProofLogElem::Class());
13823    return(1 || funcname || hash || result7 || libp) ;
13824 }
13825 
13826 static int G__G__Proof_346_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13827 {
13828       G__letint(result7, 67, (long) TProofLogElem::Class_Name());
13829    return(1 || funcname || hash || result7 || libp) ;
13830 }
13831 
13832 static int G__G__Proof_346_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13833 {
13834       G__letint(result7, 115, (long) TProofLogElem::Class_Version());
13835    return(1 || funcname || hash || result7 || libp) ;
13836 }
13837 
13838 static int G__G__Proof_346_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13839 {
13840       TProofLogElem::Dictionary();
13841       G__setnull(result7);
13842    return(1 || funcname || hash || result7 || libp) ;
13843 }
13844 
13845 static int G__G__Proof_346_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13846 {
13847       ((TProofLogElem*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
13848       G__setnull(result7);
13849    return(1 || funcname || hash || result7 || libp) ;
13850 }
13851 
13852 static int G__G__Proof_346_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13853 {
13854       G__letint(result7, 67, (long) TProofLogElem::DeclFileName());
13855    return(1 || funcname || hash || result7 || libp) ;
13856 }
13857 
13858 static int G__G__Proof_346_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13859 {
13860       G__letint(result7, 105, (long) TProofLogElem::ImplFileLine());
13861    return(1 || funcname || hash || result7 || libp) ;
13862 }
13863 
13864 static int G__G__Proof_346_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13865 {
13866       G__letint(result7, 67, (long) TProofLogElem::ImplFileName());
13867    return(1 || funcname || hash || result7 || libp) ;
13868 }
13869 
13870 static int G__G__Proof_346_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13871 {
13872       G__letint(result7, 105, (long) TProofLogElem::DeclFileLine());
13873    return(1 || funcname || hash || result7 || libp) ;
13874 }
13875 
13876 // automatic copy constructor
13877 static int G__G__Proof_346_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13878 
13879 {
13880    TProofLogElem* p;
13881    void* tmp = (void*) G__int(libp->para[0]);
13882    p = new TProofLogElem(*(TProofLogElem*) tmp);
13883    result7->obj.i = (long) p;
13884    result7->ref = (long) p;
13885    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofLogElem));
13886    return(1 || funcname || hash || result7 || libp) ;
13887 }
13888 
13889 // automatic destructor
13890 typedef TProofLogElem G__TTProofLogElem;
13891 static int G__G__Proof_346_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13892 {
13893    char* gvp = (char*) G__getgvp();
13894    long soff = G__getstructoffset();
13895    int n = G__getaryconstruct();
13896    //
13897    //has_a_delete: 1
13898    //has_own_delete1arg: 0
13899    //has_own_delete2arg: 0
13900    //
13901    if (!soff) {
13902      return(1);
13903    }
13904    if (n) {
13905      if (gvp == (char*)G__PVOID) {
13906        delete[] (TProofLogElem*) soff;
13907      } else {
13908        G__setgvp((long) G__PVOID);
13909        for (int i = n - 1; i >= 0; --i) {
13910          ((TProofLogElem*) (soff+(sizeof(TProofLogElem)*i)))->~G__TTProofLogElem();
13911        }
13912        G__setgvp((long)gvp);
13913      }
13914    } else {
13915      if (gvp == (char*)G__PVOID) {
13916        delete (TProofLogElem*) soff;
13917      } else {
13918        G__setgvp((long) G__PVOID);
13919        ((TProofLogElem*) (soff))->~G__TTProofLogElem();
13920        G__setgvp((long)gvp);
13921      }
13922    }
13923    G__setnull(result7);
13924    return(1 || funcname || hash || result7 || libp) ;
13925 }
13926 
13927 // automatic assignment operator
13928 static int G__G__Proof_346_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13929 {
13930    TProofLogElem* dest = (TProofLogElem*) G__getstructoffset();
13931    *dest = *(TProofLogElem*) libp->para[0].ref;
13932    const TProofLogElem& obj = *dest;
13933    result7->ref = (long) (&obj);
13934    result7->obj.i = (long) (&obj);
13935    return(1 || funcname || hash || result7 || libp) ;
13936 }
13937 
13938 
13939 /* TProofMgrLite */
13940 static int G__G__Proof_347_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13941 {
13942    TProofMgrLite* p = NULL;
13943    char* gvp = (char*) G__getgvp();
13944    switch (libp->paran) {
13945    case 3:
13946      //m: 3
13947      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13948        p = new TProofMgrLite(
13949 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
13950 , (const char*) G__int(libp->para[2]));
13951      } else {
13952        p = new((void*) gvp) TProofMgrLite(
13953 (const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
13954 , (const char*) G__int(libp->para[2]));
13955      }
13956      break;
13957    case 2:
13958      //m: 2
13959      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13960        p = new TProofMgrLite((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
13961      } else {
13962        p = new((void*) gvp) TProofMgrLite((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
13963      }
13964      break;
13965    case 1:
13966      //m: 1
13967      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
13968        p = new TProofMgrLite((const char*) G__int(libp->para[0]));
13969      } else {
13970        p = new((void*) gvp) TProofMgrLite((const char*) G__int(libp->para[0]));
13971      }
13972      break;
13973    }
13974    result7->obj.i = (long) p;
13975    result7->ref = (long) p;
13976    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofMgrLite));
13977    return(1 || funcname || hash || result7 || libp) ;
13978 }
13979 
13980 static int G__G__Proof_347_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13981 {
13982       G__letint(result7, 85, (long) TProofMgrLite::Class());
13983    return(1 || funcname || hash || result7 || libp) ;
13984 }
13985 
13986 static int G__G__Proof_347_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13987 {
13988       G__letint(result7, 67, (long) TProofMgrLite::Class_Name());
13989    return(1 || funcname || hash || result7 || libp) ;
13990 }
13991 
13992 static int G__G__Proof_347_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13993 {
13994       G__letint(result7, 115, (long) TProofMgrLite::Class_Version());
13995    return(1 || funcname || hash || result7 || libp) ;
13996 }
13997 
13998 static int G__G__Proof_347_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
13999 {
14000       TProofMgrLite::Dictionary();
14001       G__setnull(result7);
14002    return(1 || funcname || hash || result7 || libp) ;
14003 }
14004 
14005 static int G__G__Proof_347_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14006 {
14007       ((TProofMgrLite*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
14008       G__setnull(result7);
14009    return(1 || funcname || hash || result7 || libp) ;
14010 }
14011 
14012 static int G__G__Proof_347_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14013 {
14014       G__letint(result7, 67, (long) TProofMgrLite::DeclFileName());
14015    return(1 || funcname || hash || result7 || libp) ;
14016 }
14017 
14018 static int G__G__Proof_347_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14019 {
14020       G__letint(result7, 105, (long) TProofMgrLite::ImplFileLine());
14021    return(1 || funcname || hash || result7 || libp) ;
14022 }
14023 
14024 static int G__G__Proof_347_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14025 {
14026       G__letint(result7, 67, (long) TProofMgrLite::ImplFileName());
14027    return(1 || funcname || hash || result7 || libp) ;
14028 }
14029 
14030 static int G__G__Proof_347_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14031 {
14032       G__letint(result7, 105, (long) TProofMgrLite::DeclFileLine());
14033    return(1 || funcname || hash || result7 || libp) ;
14034 }
14035 
14036 // automatic destructor
14037 typedef TProofMgrLite G__TTProofMgrLite;
14038 static int G__G__Proof_347_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14039 {
14040    char* gvp = (char*) G__getgvp();
14041    long soff = G__getstructoffset();
14042    int n = G__getaryconstruct();
14043    //
14044    //has_a_delete: 1
14045    //has_own_delete1arg: 0
14046    //has_own_delete2arg: 0
14047    //
14048    if (!soff) {
14049      return(1);
14050    }
14051    if (n) {
14052      if (gvp == (char*)G__PVOID) {
14053        delete[] (TProofMgrLite*) soff;
14054      } else {
14055        G__setgvp((long) G__PVOID);
14056        for (int i = n - 1; i >= 0; --i) {
14057          ((TProofMgrLite*) (soff+(sizeof(TProofMgrLite)*i)))->~G__TTProofMgrLite();
14058        }
14059        G__setgvp((long)gvp);
14060      }
14061    } else {
14062      if (gvp == (char*)G__PVOID) {
14063        delete (TProofMgrLite*) soff;
14064      } else {
14065        G__setgvp((long) G__PVOID);
14066        ((TProofMgrLite*) (soff))->~G__TTProofMgrLite();
14067        G__setgvp((long)gvp);
14068      }
14069    }
14070    G__setnull(result7);
14071    return(1 || funcname || hash || result7 || libp) ;
14072 }
14073 
14074 
14075 /* TProofResourcesStatic */
14076 static int G__G__Proof_350_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14077 {
14078    TProofResourcesStatic* p = NULL;
14079    char* gvp = (char*) G__getgvp();
14080    int n = G__getaryconstruct();
14081    if (n) {
14082      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14083        p = new TProofResourcesStatic[n];
14084      } else {
14085        p = new((void*) gvp) TProofResourcesStatic[n];
14086      }
14087    } else {
14088      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14089        p = new TProofResourcesStatic;
14090      } else {
14091        p = new((void*) gvp) TProofResourcesStatic;
14092      }
14093    }
14094    result7->obj.i = (long) p;
14095    result7->ref = (long) p;
14096    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofResourcesStatic));
14097    return(1 || funcname || hash || result7 || libp) ;
14098 }
14099 
14100 static int G__G__Proof_350_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14101 {
14102    TProofResourcesStatic* p = NULL;
14103    char* gvp = (char*) G__getgvp();
14104    //m: 2
14105    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14106      p = new TProofResourcesStatic((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
14107    } else {
14108      p = new((void*) gvp) TProofResourcesStatic((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
14109    }
14110    result7->obj.i = (long) p;
14111    result7->ref = (long) p;
14112    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofResourcesStatic));
14113    return(1 || funcname || hash || result7 || libp) ;
14114 }
14115 
14116 static int G__G__Proof_350_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14117 {
14118       {
14119          const TString* pobj;
14120          const TString xobj = ((const TProofResourcesStatic*) G__getstructoffset())->GetFileName();
14121          pobj = new TString(xobj);
14122          result7->obj.i = (long) ((void*) pobj);
14123          result7->ref = result7->obj.i;
14124          G__store_tempobject(*result7);
14125       }
14126    return(1 || funcname || hash || result7 || libp) ;
14127 }
14128 
14129 static int G__G__Proof_350_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14130 {
14131       G__letint(result7, 85, (long) TProofResourcesStatic::Class());
14132    return(1 || funcname || hash || result7 || libp) ;
14133 }
14134 
14135 static int G__G__Proof_350_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14136 {
14137       G__letint(result7, 67, (long) TProofResourcesStatic::Class_Name());
14138    return(1 || funcname || hash || result7 || libp) ;
14139 }
14140 
14141 static int G__G__Proof_350_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14142 {
14143       G__letint(result7, 115, (long) TProofResourcesStatic::Class_Version());
14144    return(1 || funcname || hash || result7 || libp) ;
14145 }
14146 
14147 static int G__G__Proof_350_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14148 {
14149       TProofResourcesStatic::Dictionary();
14150       G__setnull(result7);
14151    return(1 || funcname || hash || result7 || libp) ;
14152 }
14153 
14154 static int G__G__Proof_350_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14155 {
14156       ((TProofResourcesStatic*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
14157       G__setnull(result7);
14158    return(1 || funcname || hash || result7 || libp) ;
14159 }
14160 
14161 static int G__G__Proof_350_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14162 {
14163       G__letint(result7, 67, (long) TProofResourcesStatic::DeclFileName());
14164    return(1 || funcname || hash || result7 || libp) ;
14165 }
14166 
14167 static int G__G__Proof_350_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14168 {
14169       G__letint(result7, 105, (long) TProofResourcesStatic::ImplFileLine());
14170    return(1 || funcname || hash || result7 || libp) ;
14171 }
14172 
14173 static int G__G__Proof_350_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14174 {
14175       G__letint(result7, 67, (long) TProofResourcesStatic::ImplFileName());
14176    return(1 || funcname || hash || result7 || libp) ;
14177 }
14178 
14179 static int G__G__Proof_350_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14180 {
14181       G__letint(result7, 105, (long) TProofResourcesStatic::DeclFileLine());
14182    return(1 || funcname || hash || result7 || libp) ;
14183 }
14184 
14185 // automatic copy constructor
14186 static int G__G__Proof_350_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14187 
14188 {
14189    TProofResourcesStatic* p;
14190    void* tmp = (void*) G__int(libp->para[0]);
14191    p = new TProofResourcesStatic(*(TProofResourcesStatic*) tmp);
14192    result7->obj.i = (long) p;
14193    result7->ref = (long) p;
14194    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofResourcesStatic));
14195    return(1 || funcname || hash || result7 || libp) ;
14196 }
14197 
14198 // automatic destructor
14199 typedef TProofResourcesStatic G__TTProofResourcesStatic;
14200 static int G__G__Proof_350_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14201 {
14202    char* gvp = (char*) G__getgvp();
14203    long soff = G__getstructoffset();
14204    int n = G__getaryconstruct();
14205    //
14206    //has_a_delete: 1
14207    //has_own_delete1arg: 0
14208    //has_own_delete2arg: 0
14209    //
14210    if (!soff) {
14211      return(1);
14212    }
14213    if (n) {
14214      if (gvp == (char*)G__PVOID) {
14215        delete[] (TProofResourcesStatic*) soff;
14216      } else {
14217        G__setgvp((long) G__PVOID);
14218        for (int i = n - 1; i >= 0; --i) {
14219          ((TProofResourcesStatic*) (soff+(sizeof(TProofResourcesStatic)*i)))->~G__TTProofResourcesStatic();
14220        }
14221        G__setgvp((long)gvp);
14222      }
14223    } else {
14224      if (gvp == (char*)G__PVOID) {
14225        delete (TProofResourcesStatic*) soff;
14226      } else {
14227        G__setgvp((long) G__PVOID);
14228        ((TProofResourcesStatic*) (soff))->~G__TTProofResourcesStatic();
14229        G__setgvp((long)gvp);
14230      }
14231    }
14232    G__setnull(result7);
14233    return(1 || funcname || hash || result7 || libp) ;
14234 }
14235 
14236 // automatic assignment operator
14237 static int G__G__Proof_350_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14238 {
14239    TProofResourcesStatic* dest = (TProofResourcesStatic*) G__getstructoffset();
14240    *dest = *(TProofResourcesStatic*) libp->para[0].ref;
14241    const TProofResourcesStatic& obj = *dest;
14242    result7->ref = (long) (&obj);
14243    result7->obj.i = (long) (&obj);
14244    return(1 || funcname || hash || result7 || libp) ;
14245 }
14246 
14247 
14248 /* TProofNodeInfo */
14249 static int G__G__Proof_351_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14250 {
14251    TProofNodeInfo* p = NULL;
14252    char* gvp = (char*) G__getgvp();
14253    int n = G__getaryconstruct();
14254    if (n) {
14255      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14256        p = new TProofNodeInfo[n];
14257      } else {
14258        p = new((void*) gvp) TProofNodeInfo[n];
14259      }
14260    } else {
14261      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14262        p = new TProofNodeInfo;
14263      } else {
14264        p = new((void*) gvp) TProofNodeInfo;
14265      }
14266    }
14267    result7->obj.i = (long) p;
14268    result7->ref = (long) p;
14269    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfo));
14270    return(1 || funcname || hash || result7 || libp) ;
14271 }
14272 
14273 static int G__G__Proof_351_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14274 {
14275    TProofNodeInfo* p = NULL;
14276    char* gvp = (char*) G__getgvp();
14277    //m: 1
14278    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14279      p = new TProofNodeInfo((const char*) G__int(libp->para[0]));
14280    } else {
14281      p = new((void*) gvp) TProofNodeInfo((const char*) G__int(libp->para[0]));
14282    }
14283    result7->obj.i = (long) p;
14284    result7->ref = (long) p;
14285    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfo));
14286    return(1 || funcname || hash || result7 || libp) ;
14287 }
14288 
14289 static int G__G__Proof_351_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14290 {
14291    TProofNodeInfo* p = NULL;
14292    char* gvp = (char*) G__getgvp();
14293    //m: 1
14294    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14295      p = new TProofNodeInfo(*(TProofNodeInfo*) libp->para[0].ref);
14296    } else {
14297      p = new((void*) gvp) TProofNodeInfo(*(TProofNodeInfo*) libp->para[0].ref);
14298    }
14299    result7->obj.i = (long) p;
14300    result7->ref = (long) p;
14301    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfo));
14302    return(1 || funcname || hash || result7 || libp) ;
14303 }
14304 
14305 static int G__G__Proof_351_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14306 {
14307       G__letint(result7, 105, (long) ((const TProofNodeInfo*) G__getstructoffset())->GetNodeType());
14308    return(1 || funcname || hash || result7 || libp) ;
14309 }
14310 
14311 static int G__G__Proof_351_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14312 {
14313       {
14314          const TString& obj = ((const TProofNodeInfo*) G__getstructoffset())->GetNodeName();
14315          result7->ref = (long) (&obj);
14316          result7->obj.i = (long) (&obj);
14317       }
14318    return(1 || funcname || hash || result7 || libp) ;
14319 }
14320 
14321 static int G__G__Proof_351_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14322 {
14323       {
14324          const TString& obj = ((const TProofNodeInfo*) G__getstructoffset())->GetWorkDir();
14325          result7->ref = (long) (&obj);
14326          result7->obj.i = (long) (&obj);
14327       }
14328    return(1 || funcname || hash || result7 || libp) ;
14329 }
14330 
14331 static int G__G__Proof_351_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14332 {
14333       {
14334          const TString& obj = ((const TProofNodeInfo*) G__getstructoffset())->GetOrdinal();
14335          result7->ref = (long) (&obj);
14336          result7->obj.i = (long) (&obj);
14337       }
14338    return(1 || funcname || hash || result7 || libp) ;
14339 }
14340 
14341 static int G__G__Proof_351_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14342 {
14343       {
14344          const TString& obj = ((const TProofNodeInfo*) G__getstructoffset())->GetImage();
14345          result7->ref = (long) (&obj);
14346          result7->obj.i = (long) (&obj);
14347       }
14348    return(1 || funcname || hash || result7 || libp) ;
14349 }
14350 
14351 static int G__G__Proof_351_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14352 {
14353       {
14354          const TString& obj = ((const TProofNodeInfo*) G__getstructoffset())->GetId();
14355          result7->ref = (long) (&obj);
14356          result7->obj.i = (long) (&obj);
14357       }
14358    return(1 || funcname || hash || result7 || libp) ;
14359 }
14360 
14361 static int G__G__Proof_351_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14362 {
14363       {
14364          const TString& obj = ((const TProofNodeInfo*) G__getstructoffset())->GetConfig();
14365          result7->ref = (long) (&obj);
14366          result7->obj.i = (long) (&obj);
14367       }
14368    return(1 || funcname || hash || result7 || libp) ;
14369 }
14370 
14371 static int G__G__Proof_351_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14372 {
14373       {
14374          const TString& obj = ((const TProofNodeInfo*) G__getstructoffset())->GetMsd();
14375          result7->ref = (long) (&obj);
14376          result7->obj.i = (long) (&obj);
14377       }
14378    return(1 || funcname || hash || result7 || libp) ;
14379 }
14380 
14381 static int G__G__Proof_351_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14382 {
14383       G__letint(result7, 105, (long) ((const TProofNodeInfo*) G__getstructoffset())->GetPort());
14384    return(1 || funcname || hash || result7 || libp) ;
14385 }
14386 
14387 static int G__G__Proof_351_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14388 {
14389       G__letint(result7, 105, (long) ((const TProofNodeInfo*) G__getstructoffset())->GetPerfIndex());
14390    return(1 || funcname || hash || result7 || libp) ;
14391 }
14392 
14393 static int G__G__Proof_351_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14394 {
14395       ((TProofNodeInfo*) G__getstructoffset())->Assign(*(TProofNodeInfo*) libp->para[0].ref);
14396       G__setnull(result7);
14397    return(1 || funcname || hash || result7 || libp) ;
14398 }
14399 
14400 static int G__G__Proof_351_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14401 {
14402       G__letint(result7, 105, (long) TProofNodeInfo::GetNodeType(*(TString*) libp->para[0].ref));
14403    return(1 || funcname || hash || result7 || libp) ;
14404 }
14405 
14406 static int G__G__Proof_351_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14407 {
14408       G__letint(result7, 85, (long) TProofNodeInfo::Class());
14409    return(1 || funcname || hash || result7 || libp) ;
14410 }
14411 
14412 static int G__G__Proof_351_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14413 {
14414       G__letint(result7, 67, (long) TProofNodeInfo::Class_Name());
14415    return(1 || funcname || hash || result7 || libp) ;
14416 }
14417 
14418 static int G__G__Proof_351_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14419 {
14420       G__letint(result7, 115, (long) TProofNodeInfo::Class_Version());
14421    return(1 || funcname || hash || result7 || libp) ;
14422 }
14423 
14424 static int G__G__Proof_351_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14425 {
14426       TProofNodeInfo::Dictionary();
14427       G__setnull(result7);
14428    return(1 || funcname || hash || result7 || libp) ;
14429 }
14430 
14431 static int G__G__Proof_351_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14432 {
14433       ((TProofNodeInfo*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
14434       G__setnull(result7);
14435    return(1 || funcname || hash || result7 || libp) ;
14436 }
14437 
14438 static int G__G__Proof_351_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14439 {
14440       G__letint(result7, 67, (long) TProofNodeInfo::DeclFileName());
14441    return(1 || funcname || hash || result7 || libp) ;
14442 }
14443 
14444 static int G__G__Proof_351_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14445 {
14446       G__letint(result7, 105, (long) TProofNodeInfo::ImplFileLine());
14447    return(1 || funcname || hash || result7 || libp) ;
14448 }
14449 
14450 static int G__G__Proof_351_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14451 {
14452       G__letint(result7, 67, (long) TProofNodeInfo::ImplFileName());
14453    return(1 || funcname || hash || result7 || libp) ;
14454 }
14455 
14456 static int G__G__Proof_351_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14457 {
14458       G__letint(result7, 105, (long) TProofNodeInfo::DeclFileLine());
14459    return(1 || funcname || hash || result7 || libp) ;
14460 }
14461 
14462 // automatic destructor
14463 typedef TProofNodeInfo G__TTProofNodeInfo;
14464 static int G__G__Proof_351_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14465 {
14466    char* gvp = (char*) G__getgvp();
14467    long soff = G__getstructoffset();
14468    int n = G__getaryconstruct();
14469    //
14470    //has_a_delete: 1
14471    //has_own_delete1arg: 0
14472    //has_own_delete2arg: 0
14473    //
14474    if (!soff) {
14475      return(1);
14476    }
14477    if (n) {
14478      if (gvp == (char*)G__PVOID) {
14479        delete[] (TProofNodeInfo*) soff;
14480      } else {
14481        G__setgvp((long) G__PVOID);
14482        for (int i = n - 1; i >= 0; --i) {
14483          ((TProofNodeInfo*) (soff+(sizeof(TProofNodeInfo)*i)))->~G__TTProofNodeInfo();
14484        }
14485        G__setgvp((long)gvp);
14486      }
14487    } else {
14488      if (gvp == (char*)G__PVOID) {
14489        delete (TProofNodeInfo*) soff;
14490      } else {
14491        G__setgvp((long) G__PVOID);
14492        ((TProofNodeInfo*) (soff))->~G__TTProofNodeInfo();
14493        G__setgvp((long)gvp);
14494      }
14495    }
14496    G__setnull(result7);
14497    return(1 || funcname || hash || result7 || libp) ;
14498 }
14499 
14500 // automatic assignment operator
14501 static int G__G__Proof_351_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14502 {
14503    TProofNodeInfo* dest = (TProofNodeInfo*) G__getstructoffset();
14504    *dest = *(TProofNodeInfo*) libp->para[0].ref;
14505    const TProofNodeInfo& obj = *dest;
14506    result7->ref = (long) (&obj);
14507    result7->obj.i = (long) (&obj);
14508    return(1 || funcname || hash || result7 || libp) ;
14509 }
14510 
14511 
14512 /* TProofProgressStatus */
14513 static int G__G__Proof_353_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14514 {
14515    TProofProgressStatus* p = NULL;
14516    char* gvp = (char*) G__getgvp();
14517    switch (libp->paran) {
14518    case 5:
14519      //m: 5
14520      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14521        p = new TProofProgressStatus(
14522 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
14523 , (Long64_t) G__Longlong(libp->para[2]), (Double_t) G__double(libp->para[3])
14524 , (Double_t) G__double(libp->para[4]));
14525      } else {
14526        p = new((void*) gvp) TProofProgressStatus(
14527 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
14528 , (Long64_t) G__Longlong(libp->para[2]), (Double_t) G__double(libp->para[3])
14529 , (Double_t) G__double(libp->para[4]));
14530      }
14531      break;
14532    case 4:
14533      //m: 4
14534      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14535        p = new TProofProgressStatus(
14536 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
14537 , (Long64_t) G__Longlong(libp->para[2]), (Double_t) G__double(libp->para[3]));
14538      } else {
14539        p = new((void*) gvp) TProofProgressStatus(
14540 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
14541 , (Long64_t) G__Longlong(libp->para[2]), (Double_t) G__double(libp->para[3]));
14542      }
14543      break;
14544    case 3:
14545      //m: 3
14546      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14547        p = new TProofProgressStatus(
14548 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
14549 , (Long64_t) G__Longlong(libp->para[2]));
14550      } else {
14551        p = new((void*) gvp) TProofProgressStatus(
14552 (Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
14553 , (Long64_t) G__Longlong(libp->para[2]));
14554      }
14555      break;
14556    case 2:
14557      //m: 2
14558      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14559        p = new TProofProgressStatus((Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
14560      } else {
14561        p = new((void*) gvp) TProofProgressStatus((Long64_t) G__Longlong(libp->para[0]), (Long64_t) G__Longlong(libp->para[1]));
14562      }
14563      break;
14564    case 1:
14565      //m: 1
14566      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14567        p = new TProofProgressStatus((Long64_t) G__Longlong(libp->para[0]));
14568      } else {
14569        p = new((void*) gvp) TProofProgressStatus((Long64_t) G__Longlong(libp->para[0]));
14570      }
14571      break;
14572    case 0:
14573      int n = G__getaryconstruct();
14574      if (n) {
14575        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14576          p = new TProofProgressStatus[n];
14577        } else {
14578          p = new((void*) gvp) TProofProgressStatus[n];
14579        }
14580      } else {
14581        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
14582          p = new TProofProgressStatus;
14583        } else {
14584          p = new((void*) gvp) TProofProgressStatus;
14585        }
14586      }
14587      break;
14588    }
14589    result7->obj.i = (long) p;
14590    result7->ref = (long) p;
14591    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofProgressStatus));
14592    return(1 || funcname || hash || result7 || libp) ;
14593 }
14594 
14595 static int G__G__Proof_353_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14596 {
14597       ((TProofProgressStatus*) G__getstructoffset())->Reset();
14598       G__setnull(result7);
14599    return(1 || funcname || hash || result7 || libp) ;
14600 }
14601 
14602 static int G__G__Proof_353_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14603 {
14604       G__letLonglong(result7, 110, (G__int64) ((const TProofProgressStatus*) G__getstructoffset())->GetEntries());
14605    return(1 || funcname || hash || result7 || libp) ;
14606 }
14607 
14608 static int G__G__Proof_353_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14609 {
14610       G__letLonglong(result7, 110, (G__int64) ((const TProofProgressStatus*) G__getstructoffset())->GetBytesRead());
14611    return(1 || funcname || hash || result7 || libp) ;
14612 }
14613 
14614 static int G__G__Proof_353_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14615 {
14616       G__letLonglong(result7, 110, (G__int64) ((const TProofProgressStatus*) G__getstructoffset())->GetReadCalls());
14617    return(1 || funcname || hash || result7 || libp) ;
14618 }
14619 
14620 static int G__G__Proof_353_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14621 {
14622       G__letdouble(result7, 100, (double) ((const TProofProgressStatus*) G__getstructoffset())->GetLearnTime());
14623    return(1 || funcname || hash || result7 || libp) ;
14624 }
14625 
14626 static int G__G__Proof_353_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14627 {
14628       G__letdouble(result7, 100, (double) ((const TProofProgressStatus*) G__getstructoffset())->GetProcTime());
14629    return(1 || funcname || hash || result7 || libp) ;
14630 }
14631 
14632 static int G__G__Proof_353_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14633 {
14634       G__letdouble(result7, 100, (double) ((const TProofProgressStatus*) G__getstructoffset())->GetCPUTime());
14635    return(1 || funcname || hash || result7 || libp) ;
14636 }
14637 
14638 static int G__G__Proof_353_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14639 {
14640       G__letdouble(result7, 100, (double) ((const TProofProgressStatus*) G__getstructoffset())->GetLastUpdate());
14641    return(1 || funcname || hash || result7 || libp) ;
14642 }
14643 
14644 static int G__G__Proof_353_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14645 {
14646       G__letdouble(result7, 100, (double) ((const TProofProgressStatus*) G__getstructoffset())->GetRate());
14647    return(1 || funcname || hash || result7 || libp) ;
14648 }
14649 
14650 static int G__G__Proof_353_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14651 {
14652       G__letdouble(result7, 100, (double) ((const TProofProgressStatus*) G__getstructoffset())->GetCurrentRate());
14653    return(1 || funcname || hash || result7 || libp) ;
14654 }
14655 
14656 static int G__G__Proof_353_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14657 {
14658       ((TProofProgressStatus*) G__getstructoffset())->SetLastEntries((Long64_t) G__Longlong(libp->para[0]));
14659       G__setnull(result7);
14660    return(1 || funcname || hash || result7 || libp) ;
14661 }
14662 
14663 static int G__G__Proof_353_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14664 {
14665       ((TProofProgressStatus*) G__getstructoffset())->SetEntries((Long64_t) G__Longlong(libp->para[0]));
14666       G__setnull(result7);
14667    return(1 || funcname || hash || result7 || libp) ;
14668 }
14669 
14670 static int G__G__Proof_353_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14671 {
14672    switch (libp->paran) {
14673    case 1:
14674       ((TProofProgressStatus*) G__getstructoffset())->IncEntries((Long64_t) G__Longlong(libp->para[0]));
14675       G__setnull(result7);
14676       break;
14677    case 0:
14678       ((TProofProgressStatus*) G__getstructoffset())->IncEntries();
14679       G__setnull(result7);
14680       break;
14681    }
14682    return(1 || funcname || hash || result7 || libp) ;
14683 }
14684 
14685 static int G__G__Proof_353_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14686 {
14687       ((TProofProgressStatus*) G__getstructoffset())->IncBytesRead((Long64_t) G__Longlong(libp->para[0]));
14688       G__setnull(result7);
14689    return(1 || funcname || hash || result7 || libp) ;
14690 }
14691 
14692 static int G__G__Proof_353_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14693 {
14694       ((TProofProgressStatus*) G__getstructoffset())->SetBytesRead((Long64_t) G__Longlong(libp->para[0]));
14695       G__setnull(result7);
14696    return(1 || funcname || hash || result7 || libp) ;
14697 }
14698 
14699 static int G__G__Proof_353_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14700 {
14701       ((TProofProgressStatus*) G__getstructoffset())->IncReadCalls((Long64_t) G__Longlong(libp->para[0]));
14702       G__setnull(result7);
14703    return(1 || funcname || hash || result7 || libp) ;
14704 }
14705 
14706 static int G__G__Proof_353_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14707 {
14708       ((TProofProgressStatus*) G__getstructoffset())->SetReadCalls((Long64_t) G__Longlong(libp->para[0]));
14709       G__setnull(result7);
14710    return(1 || funcname || hash || result7 || libp) ;
14711 }
14712 
14713 static int G__G__Proof_353_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14714 {
14715       ((TProofProgressStatus*) G__getstructoffset())->SetLearnTime((Double_t) G__double(libp->para[0]));
14716       G__setnull(result7);
14717    return(1 || funcname || hash || result7 || libp) ;
14718 }
14719 
14720 static int G__G__Proof_353_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14721 {
14722       ((TProofProgressStatus*) G__getstructoffset())->SetLastProcTime((Double_t) G__double(libp->para[0]));
14723       G__setnull(result7);
14724    return(1 || funcname || hash || result7 || libp) ;
14725 }
14726 
14727 static int G__G__Proof_353_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14728 {
14729       ((TProofProgressStatus*) G__getstructoffset())->SetProcTime((Double_t) G__double(libp->para[0]));
14730       G__setnull(result7);
14731    return(1 || funcname || hash || result7 || libp) ;
14732 }
14733 
14734 static int G__G__Proof_353_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14735 {
14736       ((TProofProgressStatus*) G__getstructoffset())->IncProcTime((Double_t) G__double(libp->para[0]));
14737       G__setnull(result7);
14738    return(1 || funcname || hash || result7 || libp) ;
14739 }
14740 
14741 static int G__G__Proof_353_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14742 {
14743       ((TProofProgressStatus*) G__getstructoffset())->SetCPUTime((Double_t) G__double(libp->para[0]));
14744       G__setnull(result7);
14745    return(1 || funcname || hash || result7 || libp) ;
14746 }
14747 
14748 static int G__G__Proof_353_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14749 {
14750       ((TProofProgressStatus*) G__getstructoffset())->IncCPUTime((Double_t) G__double(libp->para[0]));
14751       G__setnull(result7);
14752    return(1 || funcname || hash || result7 || libp) ;
14753 }
14754 
14755 static int G__G__Proof_353_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14756 {
14757    switch (libp->paran) {
14758    case 1:
14759       ((TProofProgressStatus*) G__getstructoffset())->SetLastUpdate((Double_t) G__double(libp->para[0]));
14760       G__setnull(result7);
14761       break;
14762    case 0:
14763       ((TProofProgressStatus*) G__getstructoffset())->SetLastUpdate();
14764       G__setnull(result7);
14765       break;
14766    }
14767    return(1 || funcname || hash || result7 || libp) ;
14768 }
14769 
14770 static int G__G__Proof_353_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14771 {
14772       {
14773          TProofProgressStatus* pobj;
14774          TProofProgressStatus xobj = ((TProofProgressStatus*) G__getstructoffset())->operator-(*(TProofProgressStatus*) libp->para[0].ref);
14775          pobj = new TProofProgressStatus(xobj);
14776          result7->obj.i = (long) ((void*) pobj);
14777          result7->ref = result7->obj.i;
14778          G__store_tempobject(*result7);
14779       }
14780    return(1 || funcname || hash || result7 || libp) ;
14781 }
14782 
14783 static int G__G__Proof_353_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14784 {
14785       {
14786          const TProofProgressStatus& obj = ((TProofProgressStatus*) G__getstructoffset())->operator+=(*(TProofProgressStatus*) libp->para[0].ref);
14787          result7->ref = (long) (&obj);
14788          result7->obj.i = (long) (&obj);
14789       }
14790    return(1 || funcname || hash || result7 || libp) ;
14791 }
14792 
14793 static int G__G__Proof_353_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14794 {
14795       {
14796          const TProofProgressStatus& obj = ((TProofProgressStatus*) G__getstructoffset())->operator-=(*(TProofProgressStatus*) libp->para[0].ref);
14797          result7->ref = (long) (&obj);
14798          result7->obj.i = (long) (&obj);
14799       }
14800    return(1 || funcname || hash || result7 || libp) ;
14801 }
14802 
14803 static int G__G__Proof_353_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14804 {
14805       G__letint(result7, 85, (long) TProofProgressStatus::Class());
14806    return(1 || funcname || hash || result7 || libp) ;
14807 }
14808 
14809 static int G__G__Proof_353_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14810 {
14811       G__letint(result7, 67, (long) TProofProgressStatus::Class_Name());
14812    return(1 || funcname || hash || result7 || libp) ;
14813 }
14814 
14815 static int G__G__Proof_353_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14816 {
14817       G__letint(result7, 115, (long) TProofProgressStatus::Class_Version());
14818    return(1 || funcname || hash || result7 || libp) ;
14819 }
14820 
14821 static int G__G__Proof_353_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14822 {
14823       TProofProgressStatus::Dictionary();
14824       G__setnull(result7);
14825    return(1 || funcname || hash || result7 || libp) ;
14826 }
14827 
14828 static int G__G__Proof_353_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14829 {
14830       ((TProofProgressStatus*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
14831       G__setnull(result7);
14832    return(1 || funcname || hash || result7 || libp) ;
14833 }
14834 
14835 static int G__G__Proof_353_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14836 {
14837       G__letint(result7, 67, (long) TProofProgressStatus::DeclFileName());
14838    return(1 || funcname || hash || result7 || libp) ;
14839 }
14840 
14841 static int G__G__Proof_353_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14842 {
14843       G__letint(result7, 105, (long) TProofProgressStatus::ImplFileLine());
14844    return(1 || funcname || hash || result7 || libp) ;
14845 }
14846 
14847 static int G__G__Proof_353_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14848 {
14849       G__letint(result7, 67, (long) TProofProgressStatus::ImplFileName());
14850    return(1 || funcname || hash || result7 || libp) ;
14851 }
14852 
14853 static int G__G__Proof_353_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14854 {
14855       G__letint(result7, 105, (long) TProofProgressStatus::DeclFileLine());
14856    return(1 || funcname || hash || result7 || libp) ;
14857 }
14858 
14859 // automatic copy constructor
14860 static int G__G__Proof_353_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14861 
14862 {
14863    TProofProgressStatus* p;
14864    void* tmp = (void*) G__int(libp->para[0]);
14865    p = new TProofProgressStatus(*(TProofProgressStatus*) tmp);
14866    result7->obj.i = (long) p;
14867    result7->ref = (long) p;
14868    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofProgressStatus));
14869    return(1 || funcname || hash || result7 || libp) ;
14870 }
14871 
14872 // automatic destructor
14873 typedef TProofProgressStatus G__TTProofProgressStatus;
14874 static int G__G__Proof_353_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14875 {
14876    char* gvp = (char*) G__getgvp();
14877    long soff = G__getstructoffset();
14878    int n = G__getaryconstruct();
14879    //
14880    //has_a_delete: 1
14881    //has_own_delete1arg: 0
14882    //has_own_delete2arg: 0
14883    //
14884    if (!soff) {
14885      return(1);
14886    }
14887    if (n) {
14888      if (gvp == (char*)G__PVOID) {
14889        delete[] (TProofProgressStatus*) soff;
14890      } else {
14891        G__setgvp((long) G__PVOID);
14892        for (int i = n - 1; i >= 0; --i) {
14893          ((TProofProgressStatus*) (soff+(sizeof(TProofProgressStatus)*i)))->~G__TTProofProgressStatus();
14894        }
14895        G__setgvp((long)gvp);
14896      }
14897    } else {
14898      if (gvp == (char*)G__PVOID) {
14899        delete (TProofProgressStatus*) soff;
14900      } else {
14901        G__setgvp((long) G__PVOID);
14902        ((TProofProgressStatus*) (soff))->~G__TTProofProgressStatus();
14903        G__setgvp((long)gvp);
14904      }
14905    }
14906    G__setnull(result7);
14907    return(1 || funcname || hash || result7 || libp) ;
14908 }
14909 
14910 // automatic assignment operator
14911 static int G__G__Proof_353_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14912 {
14913    TProofProgressStatus* dest = (TProofProgressStatus*) G__getstructoffset();
14914    *dest = *(TProofProgressStatus*) libp->para[0].ref;
14915    const TProofProgressStatus& obj = *dest;
14916    result7->ref = (long) (&obj);
14917    result7->obj.i = (long) (&obj);
14918    return(1 || funcname || hash || result7 || libp) ;
14919 }
14920 
14921 
14922 /* TProofResources */
14923 static int G__G__Proof_356_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14924 {
14925       G__letint(result7, 85, (long) ((TProofResources*) G__getstructoffset())->GetMaster());
14926    return(1 || funcname || hash || result7 || libp) ;
14927 }
14928 
14929 static int G__G__Proof_356_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14930 {
14931       G__letint(result7, 85, (long) ((TProofResources*) G__getstructoffset())->GetSubmasters());
14932    return(1 || funcname || hash || result7 || libp) ;
14933 }
14934 
14935 static int G__G__Proof_356_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14936 {
14937       G__letint(result7, 85, (long) ((TProofResources*) G__getstructoffset())->GetWorkers());
14938    return(1 || funcname || hash || result7 || libp) ;
14939 }
14940 
14941 static int G__G__Proof_356_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14942 {
14943       G__letint(result7, 103, (long) ((const TProofResources*) G__getstructoffset())->IsValid());
14944    return(1 || funcname || hash || result7 || libp) ;
14945 }
14946 
14947 static int G__G__Proof_356_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14948 {
14949       G__letint(result7, 85, (long) TProofResources::Class());
14950    return(1 || funcname || hash || result7 || libp) ;
14951 }
14952 
14953 static int G__G__Proof_356_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14954 {
14955       G__letint(result7, 67, (long) TProofResources::Class_Name());
14956    return(1 || funcname || hash || result7 || libp) ;
14957 }
14958 
14959 static int G__G__Proof_356_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14960 {
14961       G__letint(result7, 115, (long) TProofResources::Class_Version());
14962    return(1 || funcname || hash || result7 || libp) ;
14963 }
14964 
14965 static int G__G__Proof_356_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14966 {
14967       TProofResources::Dictionary();
14968       G__setnull(result7);
14969    return(1 || funcname || hash || result7 || libp) ;
14970 }
14971 
14972 static int G__G__Proof_356_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14973 {
14974       ((TProofResources*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
14975       G__setnull(result7);
14976    return(1 || funcname || hash || result7 || libp) ;
14977 }
14978 
14979 static int G__G__Proof_356_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14980 {
14981       G__letint(result7, 67, (long) TProofResources::DeclFileName());
14982    return(1 || funcname || hash || result7 || libp) ;
14983 }
14984 
14985 static int G__G__Proof_356_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14986 {
14987       G__letint(result7, 105, (long) TProofResources::ImplFileLine());
14988    return(1 || funcname || hash || result7 || libp) ;
14989 }
14990 
14991 static int G__G__Proof_356_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14992 {
14993       G__letint(result7, 67, (long) TProofResources::ImplFileName());
14994    return(1 || funcname || hash || result7 || libp) ;
14995 }
14996 
14997 static int G__G__Proof_356_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
14998 {
14999       G__letint(result7, 105, (long) TProofResources::DeclFileLine());
15000    return(1 || funcname || hash || result7 || libp) ;
15001 }
15002 
15003 // automatic destructor
15004 typedef TProofResources G__TTProofResources;
15005 static int G__G__Proof_356_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15006 {
15007    char* gvp = (char*) G__getgvp();
15008    long soff = G__getstructoffset();
15009    int n = G__getaryconstruct();
15010    //
15011    //has_a_delete: 1
15012    //has_own_delete1arg: 0
15013    //has_own_delete2arg: 0
15014    //
15015    if (!soff) {
15016      return(1);
15017    }
15018    if (n) {
15019      if (gvp == (char*)G__PVOID) {
15020        delete[] (TProofResources*) soff;
15021      } else {
15022        G__setgvp((long) G__PVOID);
15023        for (int i = n - 1; i >= 0; --i) {
15024          ((TProofResources*) (soff+(sizeof(TProofResources)*i)))->~G__TTProofResources();
15025        }
15026        G__setgvp((long)gvp);
15027      }
15028    } else {
15029      if (gvp == (char*)G__PVOID) {
15030        delete (TProofResources*) soff;
15031      } else {
15032        G__setgvp((long) G__PVOID);
15033        ((TProofResources*) (soff))->~G__TTProofResources();
15034        G__setgvp((long)gvp);
15035      }
15036    }
15037    G__setnull(result7);
15038    return(1 || funcname || hash || result7 || libp) ;
15039 }
15040 
15041 // automatic assignment operator
15042 static int G__G__Proof_356_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15043 {
15044    TProofResources* dest = (TProofResources*) G__getstructoffset();
15045    *dest = *(TProofResources*) libp->para[0].ref;
15046    const TProofResources& obj = *dest;
15047    result7->ref = (long) (&obj);
15048    result7->obj.i = (long) (&obj);
15049    return(1 || funcname || hash || result7 || libp) ;
15050 }
15051 
15052 
15053 /* TProofServLite */
15054 static int G__G__Proof_368_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15055 {
15056    TProofServLite* p = NULL;
15057    char* gvp = (char*) G__getgvp();
15058    switch (libp->paran) {
15059    case 3:
15060      //m: 3
15061      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
15062        p = new TProofServLite(
15063 (Int_t*) G__int(libp->para[0]), (char**) G__int(libp->para[1])
15064 , (FILE*) G__int(libp->para[2]));
15065      } else {
15066        p = new((void*) gvp) TProofServLite(
15067 (Int_t*) G__int(libp->para[0]), (char**) G__int(libp->para[1])
15068 , (FILE*) G__int(libp->para[2]));
15069      }
15070      break;
15071    case 2:
15072      //m: 2
15073      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
15074        p = new TProofServLite((Int_t*) G__int(libp->para[0]), (char**) G__int(libp->para[1]));
15075      } else {
15076        p = new((void*) gvp) TProofServLite((Int_t*) G__int(libp->para[0]), (char**) G__int(libp->para[1]));
15077      }
15078      break;
15079    }
15080    result7->obj.i = (long) p;
15081    result7->ref = (long) p;
15082    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofServLite));
15083    return(1 || funcname || hash || result7 || libp) ;
15084 }
15085 
15086 static int G__G__Proof_368_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15087 {
15088       G__letint(result7, 85, (long) TProofServLite::Class());
15089    return(1 || funcname || hash || result7 || libp) ;
15090 }
15091 
15092 static int G__G__Proof_368_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15093 {
15094       G__letint(result7, 67, (long) TProofServLite::Class_Name());
15095    return(1 || funcname || hash || result7 || libp) ;
15096 }
15097 
15098 static int G__G__Proof_368_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15099 {
15100       G__letint(result7, 115, (long) TProofServLite::Class_Version());
15101    return(1 || funcname || hash || result7 || libp) ;
15102 }
15103 
15104 static int G__G__Proof_368_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15105 {
15106       TProofServLite::Dictionary();
15107       G__setnull(result7);
15108    return(1 || funcname || hash || result7 || libp) ;
15109 }
15110 
15111 static int G__G__Proof_368_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15112 {
15113       ((TProofServLite*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
15114       G__setnull(result7);
15115    return(1 || funcname || hash || result7 || libp) ;
15116 }
15117 
15118 static int G__G__Proof_368_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15119 {
15120       G__letint(result7, 67, (long) TProofServLite::DeclFileName());
15121    return(1 || funcname || hash || result7 || libp) ;
15122 }
15123 
15124 static int G__G__Proof_368_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15125 {
15126       G__letint(result7, 105, (long) TProofServLite::ImplFileLine());
15127    return(1 || funcname || hash || result7 || libp) ;
15128 }
15129 
15130 static int G__G__Proof_368_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15131 {
15132       G__letint(result7, 67, (long) TProofServLite::ImplFileName());
15133    return(1 || funcname || hash || result7 || libp) ;
15134 }
15135 
15136 static int G__G__Proof_368_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15137 {
15138       G__letint(result7, 105, (long) TProofServLite::DeclFileLine());
15139    return(1 || funcname || hash || result7 || libp) ;
15140 }
15141 
15142 // automatic destructor
15143 typedef TProofServLite G__TTProofServLite;
15144 static int G__G__Proof_368_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15145 {
15146    char* gvp = (char*) G__getgvp();
15147    long soff = G__getstructoffset();
15148    int n = G__getaryconstruct();
15149    //
15150    //has_a_delete: 1
15151    //has_own_delete1arg: 0
15152    //has_own_delete2arg: 0
15153    //
15154    if (!soff) {
15155      return(1);
15156    }
15157    if (n) {
15158      if (gvp == (char*)G__PVOID) {
15159        delete[] (TProofServLite*) soff;
15160      } else {
15161        G__setgvp((long) G__PVOID);
15162        for (int i = n - 1; i >= 0; --i) {
15163          ((TProofServLite*) (soff+(sizeof(TProofServLite)*i)))->~G__TTProofServLite();
15164        }
15165        G__setgvp((long)gvp);
15166      }
15167    } else {
15168      if (gvp == (char*)G__PVOID) {
15169        delete (TProofServLite*) soff;
15170      } else {
15171        G__setgvp((long) G__PVOID);
15172        ((TProofServLite*) (soff))->~G__TTProofServLite();
15173        G__setgvp((long)gvp);
15174      }
15175    }
15176    G__setnull(result7);
15177    return(1 || funcname || hash || result7 || libp) ;
15178 }
15179 
15180 
15181 /* TProofSuperMaster */
15182 static int G__G__Proof_377_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15183 {
15184    TProofSuperMaster* p = NULL;
15185    char* gvp = (char*) G__getgvp();
15186    switch (libp->paran) {
15187    case 6:
15188      //m: 6
15189      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
15190        p = new TProofSuperMaster(
15191 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
15192 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
15193 , (const char*) G__int(libp->para[4]), (TProofMgr*) G__int(libp->para[5]));
15194      } else {
15195        p = new((void*) gvp) TProofSuperMaster(
15196 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
15197 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
15198 , (const char*) G__int(libp->para[4]), (TProofMgr*) G__int(libp->para[5]));
15199      }
15200      break;
15201    case 5:
15202      //m: 5
15203      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
15204        p = new TProofSuperMaster(
15205 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
15206 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
15207 , (const char*) G__int(libp->para[4]));
15208      } else {
15209        p = new((void*) gvp) TProofSuperMaster(
15210 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
15211 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
15212 , (const char*) G__int(libp->para[4]));
15213      }
15214      break;
15215    case 4:
15216      //m: 4
15217      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
15218        p = new TProofSuperMaster(
15219 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
15220 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
15221      } else {
15222        p = new((void*) gvp) TProofSuperMaster(
15223 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
15224 , (const char*) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
15225      }
15226      break;
15227    case 3:
15228      //m: 3
15229      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
15230        p = new TProofSuperMaster(
15231 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
15232 , (const char*) G__int(libp->para[2]));
15233      } else {
15234        p = new((void*) gvp) TProofSuperMaster(
15235 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
15236 , (const char*) G__int(libp->para[2]));
15237      }
15238      break;
15239    case 2:
15240      //m: 2
15241      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
15242        p = new TProofSuperMaster((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
15243      } else {
15244        p = new((void*) gvp) TProofSuperMaster((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
15245      }
15246      break;
15247    case 1:
15248      //m: 1
15249      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
15250        p = new TProofSuperMaster((const char*) G__int(libp->para[0]));
15251      } else {
15252        p = new((void*) gvp) TProofSuperMaster((const char*) G__int(libp->para[0]));
15253      }
15254      break;
15255    }
15256    result7->obj.i = (long) p;
15257    result7->ref = (long) p;
15258    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofLN_TProofSuperMaster));
15259    return(1 || funcname || hash || result7 || libp) ;
15260 }
15261 
15262 static int G__G__Proof_377_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15263 {
15264       G__letint(result7, 85, (long) TProofSuperMaster::Class());
15265    return(1 || funcname || hash || result7 || libp) ;
15266 }
15267 
15268 static int G__G__Proof_377_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15269 {
15270       G__letint(result7, 67, (long) TProofSuperMaster::Class_Name());
15271    return(1 || funcname || hash || result7 || libp) ;
15272 }
15273 
15274 static int G__G__Proof_377_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15275 {
15276       G__letint(result7, 115, (long) TProofSuperMaster::Class_Version());
15277    return(1 || funcname || hash || result7 || libp) ;
15278 }
15279 
15280 static int G__G__Proof_377_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15281 {
15282       TProofSuperMaster::Dictionary();
15283       G__setnull(result7);
15284    return(1 || funcname || hash || result7 || libp) ;
15285 }
15286 
15287 static int G__G__Proof_377_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15288 {
15289       ((TProofSuperMaster*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
15290       G__setnull(result7);
15291    return(1 || funcname || hash || result7 || libp) ;
15292 }
15293 
15294 static int G__G__Proof_377_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15295 {
15296       G__letint(result7, 67, (long) TProofSuperMaster::DeclFileName());
15297    return(1 || funcname || hash || result7 || libp) ;
15298 }
15299 
15300 static int G__G__Proof_377_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15301 {
15302       G__letint(result7, 105, (long) TProofSuperMaster::ImplFileLine());
15303    return(1 || funcname || hash || result7 || libp) ;
15304 }
15305 
15306 static int G__G__Proof_377_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15307 {
15308       G__letint(result7, 67, (long) TProofSuperMaster::ImplFileName());
15309    return(1 || funcname || hash || result7 || libp) ;
15310 }
15311 
15312 static int G__G__Proof_377_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15313 {
15314       G__letint(result7, 105, (long) TProofSuperMaster::DeclFileLine());
15315    return(1 || funcname || hash || result7 || libp) ;
15316 }
15317 
15318 // automatic destructor
15319 typedef TProofSuperMaster G__TTProofSuperMaster;
15320 static int G__G__Proof_377_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
15321 {
15322    char* gvp = (char*) G__getgvp();
15323    long soff = G__getstructoffset();
15324    int n = G__getaryconstruct();
15325    //
15326    //has_a_delete: 1
15327    //has_own_delete1arg: 0
15328    //has_own_delete2arg: 0
15329    //
15330    if (!soff) {
15331      return(1);
15332    }
15333    if (n) {
15334      if (gvp == (char*)G__PVOID) {
15335        delete[] (TProofSuperMaster*) soff;
15336      } else {
15337        G__setgvp((long) G__PVOID);
15338        for (int i = n - 1; i >= 0; --i) {
15339          ((TProofSuperMaster*) (soff+(sizeof(TProofSuperMaster)*i)))->~G__TTProofSuperMaster();
15340        }
15341        G__setgvp((long)gvp);
15342      }
15343    } else {
15344      if (gvp == (char*)G__PVOID) {
15345        delete (TProofSuperMaster*) soff;
15346      } else {
15347        G__setgvp((long) G__PVOID);
15348        ((TProofSuperMaster*) (soff))->~G__TTProofSuperMaster();
15349        G__setgvp((long)gvp);
15350      }
15351    }
15352    G__setnull(result7);
15353    return(1 || funcname || hash || result7 || libp) ;
15354 }
15355 
15356 
15357 /* Setting up global function */
15358 
15359 /*********************************************************
15360 * Member function Stub
15361 *********************************************************/
15362 
15363 /* TCondorSlave */
15364 
15365 /* TCondor */
15366 
15367 /* TDataSetManager */
15368 
15369 /* TDataSetManagerFile */
15370 
15371 /* TDSet */
15372 
15373 /* TProof */
15374 
15375 /* TProofChain */
15376 
15377 /* TDSetElement */
15378 
15379 /* pair<TDSetElement*,TString> */
15380 
15381 /* list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > > */
15382 
15383 /* TProofServ */
15384 
15385 /* TDSetProxy */
15386 
15387 /* TProofDesc */
15388 
15389 /* TProofLog */
15390 
15391 /* TProofMgr */
15392 
15393 /* TProofDebug */
15394 
15395 /* TVirtualProofPlayer */
15396 
15397 /* TSlave */
15398 
15399 /* TProofProgressInfo */
15400 
15401 /* TSlaveInfo */
15402 
15403 /* TMergerInfo */
15404 
15405 /* TProofLite */
15406 
15407 /* TSlaveLite */
15408 
15409 /* TProofCondor */
15410 
15411 /* TQueryResultManager */
15412 
15413 /* TProofQueryResult */
15414 
15415 /* TProofLogElem */
15416 
15417 /* TProofMgrLite */
15418 
15419 /* TProofResourcesStatic */
15420 
15421 /* TProofNodeInfo */
15422 
15423 /* TProofProgressStatus */
15424 
15425 /* TProofResources */
15426 
15427 /* TProofServLite */
15428 
15429 /* TProofSuperMaster */
15430 
15431 /*********************************************************
15432 * Global function Stub
15433 *********************************************************/
15434 
15435 /*********************************************************
15436 * Get size of pointer to member function
15437 *********************************************************/
15438 class G__Sizep2memfuncG__Proof {
15439  public:
15440   G__Sizep2memfuncG__Proof(): p(&G__Sizep2memfuncG__Proof::sizep2memfunc) {}
15441     size_t sizep2memfunc() { return(sizeof(p)); }
15442   private:
15443     size_t (G__Sizep2memfuncG__Proof::*p)();
15444 };
15445 
15446 size_t G__get_sizep2memfuncG__Proof()
15447 {
15448   G__Sizep2memfuncG__Proof a;
15449   G__setsizep2memfunc((int)a.sizep2memfunc());
15450   return((size_t)a.sizep2memfunc());
15451 }
15452 
15453 
15454 /*********************************************************
15455 * virtual base class offset calculation interface
15456 *********************************************************/
15457 
15458    /* Setting up class inheritance */
15459 
15460 /*********************************************************
15461 * Inheritance information setup/
15462 *********************************************************/
15463 extern "C" void G__cpp_setup_inheritanceG__Proof() {
15464 
15465    /* Setting up class inheritance */
15466    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TCondorSlave))) {
15467      TCondorSlave *G__Lderived;
15468      G__Lderived=(TCondorSlave*)0x1000;
15469      {
15470        TObject *G__Lpbase=(TObject*)G__Lderived;
15471        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TCondorSlave),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15472      }
15473    }
15474    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TCondor))) {
15475      TCondor *G__Lderived;
15476      G__Lderived=(TCondor*)0x1000;
15477      {
15478        TObject *G__Lpbase=(TObject*)G__Lderived;
15479        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TCondor),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15480      }
15481    }
15482    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TDataSetManager))) {
15483      TDataSetManager *G__Lderived;
15484      G__Lderived=(TDataSetManager*)0x1000;
15485      {
15486        TObject *G__Lpbase=(TObject*)G__Lderived;
15487        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TDataSetManager),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15488      }
15489    }
15490    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagerFile))) {
15491      TDataSetManagerFile *G__Lderived;
15492      G__Lderived=(TDataSetManagerFile*)0x1000;
15493      {
15494        TDataSetManager *G__Lpbase=(TDataSetManager*)G__Lderived;
15495        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagerFile),G__get_linked_tagnum(&G__G__ProofLN_TDataSetManager),(long)G__Lpbase-(long)G__Lderived,1,1);
15496      }
15497      {
15498        TObject *G__Lpbase=(TObject*)G__Lderived;
15499        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagerFile),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15500      }
15501    }
15502    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TDSet))) {
15503      TDSet *G__Lderived;
15504      G__Lderived=(TDSet*)0x1000;
15505      {
15506        TNamed *G__Lpbase=(TNamed*)G__Lderived;
15507        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TDSet),G__get_linked_tagnum(&G__G__ProofLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
15508      }
15509      {
15510        TObject *G__Lpbase=(TObject*)G__Lderived;
15511        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TDSet),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15512      }
15513    }
15514    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TProof))) {
15515      TProof *G__Lderived;
15516      G__Lderived=(TProof*)0x1000;
15517      {
15518        TNamed *G__Lpbase=(TNamed*)G__Lderived;
15519        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProof),G__get_linked_tagnum(&G__G__ProofLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
15520      }
15521      {
15522        TObject *G__Lpbase=(TObject*)G__Lderived;
15523        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProof),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15524      }
15525      {
15526        TQObject *G__Lpbase=(TQObject*)G__Lderived;
15527        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProof),G__get_linked_tagnum(&G__G__ProofLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15528      }
15529    }
15530    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TProofChain))) {
15531      TProofChain *G__Lderived;
15532      G__Lderived=(TProofChain*)0x1000;
15533      {
15534        TChain *G__Lpbase=(TChain*)G__Lderived;
15535        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofChain),G__get_linked_tagnum(&G__G__ProofLN_TChain),(long)G__Lpbase-(long)G__Lderived,1,1);
15536      }
15537      {
15538        TTree *G__Lpbase=(TTree*)G__Lderived;
15539        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofChain),G__get_linked_tagnum(&G__G__ProofLN_TTree),(long)G__Lpbase-(long)G__Lderived,1,0);
15540      }
15541      {
15542        TNamed *G__Lpbase=(TNamed*)G__Lderived;
15543        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofChain),G__get_linked_tagnum(&G__G__ProofLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
15544      }
15545      {
15546        TObject *G__Lpbase=(TObject*)G__Lderived;
15547        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofChain),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15548      }
15549      {
15550        TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
15551        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofChain),G__get_linked_tagnum(&G__G__ProofLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
15552      }
15553      {
15554        TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
15555        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofChain),G__get_linked_tagnum(&G__G__ProofLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
15556      }
15557      {
15558        TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
15559        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofChain),G__get_linked_tagnum(&G__G__ProofLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
15560      }
15561    }
15562    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TTree))) {
15563      TTree *G__Lderived;
15564      G__Lderived=(TTree*)0x1000;
15565      {
15566        TNamed *G__Lpbase=(TNamed*)G__Lderived;
15567        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TTree),G__get_linked_tagnum(&G__G__ProofLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
15568      }
15569      {
15570        TObject *G__Lpbase=(TObject*)G__Lderived;
15571        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TTree),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15572      }
15573      {
15574        TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
15575        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TTree),G__get_linked_tagnum(&G__G__ProofLN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,1);
15576      }
15577      {
15578        TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
15579        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TTree),G__get_linked_tagnum(&G__G__ProofLN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,1);
15580      }
15581      {
15582        TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
15583        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TTree),G__get_linked_tagnum(&G__G__ProofLN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,1);
15584      }
15585    }
15586    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TDSetElement))) {
15587      TDSetElement *G__Lderived;
15588      G__Lderived=(TDSetElement*)0x1000;
15589      {
15590        TNamed *G__Lpbase=(TNamed*)G__Lderived;
15591        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TDSetElement),G__get_linked_tagnum(&G__G__ProofLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
15592      }
15593      {
15594        TObject *G__Lpbase=(TObject*)G__Lderived;
15595        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TDSetElement),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15596      }
15597    }
15598    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TProofServ))) {
15599      TProofServ *G__Lderived;
15600      G__Lderived=(TProofServ*)0x1000;
15601      {
15602        TApplication *G__Lpbase=(TApplication*)G__Lderived;
15603        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofServ),G__get_linked_tagnum(&G__G__ProofLN_TApplication),(long)G__Lpbase-(long)G__Lderived,1,1);
15604      }
15605      {
15606        TObject *G__Lpbase=(TObject*)G__Lderived;
15607        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofServ),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15608      }
15609      {
15610        TQObject *G__Lpbase=(TQObject*)G__Lderived;
15611        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofServ),G__get_linked_tagnum(&G__G__ProofLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15612      }
15613    }
15614    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TDSetProxy))) {
15615      TDSetProxy *G__Lderived;
15616      G__Lderived=(TDSetProxy*)0x1000;
15617      {
15618        TDSet *G__Lpbase=(TDSet*)G__Lderived;
15619        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TDSetProxy),G__get_linked_tagnum(&G__G__ProofLN_TDSet),(long)G__Lpbase-(long)G__Lderived,1,1);
15620      }
15621      {
15622        TNamed *G__Lpbase=(TNamed*)G__Lderived;
15623        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TDSetProxy),G__get_linked_tagnum(&G__G__ProofLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
15624      }
15625      {
15626        TObject *G__Lpbase=(TObject*)G__Lderived;
15627        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TDSetProxy),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15628      }
15629    }
15630    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TProofDesc))) {
15631      TProofDesc *G__Lderived;
15632      G__Lderived=(TProofDesc*)0x1000;
15633      {
15634        TNamed *G__Lpbase=(TNamed*)G__Lderived;
15635        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofDesc),G__get_linked_tagnum(&G__G__ProofLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
15636      }
15637      {
15638        TObject *G__Lpbase=(TObject*)G__Lderived;
15639        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofDesc),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15640      }
15641    }
15642    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TProofLog))) {
15643      TProofLog *G__Lderived;
15644      G__Lderived=(TProofLog*)0x1000;
15645      {
15646        TNamed *G__Lpbase=(TNamed*)G__Lderived;
15647        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofLog),G__get_linked_tagnum(&G__G__ProofLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
15648      }
15649      {
15650        TObject *G__Lpbase=(TObject*)G__Lderived;
15651        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofLog),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15652      }
15653      {
15654        TQObject *G__Lpbase=(TQObject*)G__Lderived;
15655        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofLog),G__get_linked_tagnum(&G__G__ProofLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15656      }
15657    }
15658    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TProofMgr))) {
15659      TProofMgr *G__Lderived;
15660      G__Lderived=(TProofMgr*)0x1000;
15661      {
15662        TNamed *G__Lpbase=(TNamed*)G__Lderived;
15663        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofMgr),G__get_linked_tagnum(&G__G__ProofLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
15664      }
15665      {
15666        TObject *G__Lpbase=(TObject*)G__Lderived;
15667        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofMgr),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15668      }
15669    }
15670    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TVirtualProofPlayer))) {
15671      TVirtualProofPlayer *G__Lderived;
15672      G__Lderived=(TVirtualProofPlayer*)0x1000;
15673      {
15674        TObject *G__Lpbase=(TObject*)G__Lderived;
15675        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TVirtualProofPlayer),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15676      }
15677      {
15678        TQObject *G__Lpbase=(TQObject*)G__Lderived;
15679        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TVirtualProofPlayer),G__get_linked_tagnum(&G__G__ProofLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15680      }
15681    }
15682    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TSlave))) {
15683      TSlave *G__Lderived;
15684      G__Lderived=(TSlave*)0x1000;
15685      {
15686        TObject *G__Lpbase=(TObject*)G__Lderived;
15687        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TSlave),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15688      }
15689    }
15690    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TProofProgressInfo))) {
15691      TProofProgressInfo *G__Lderived;
15692      G__Lderived=(TProofProgressInfo*)0x1000;
15693      {
15694        TObject *G__Lpbase=(TObject*)G__Lderived;
15695        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofProgressInfo),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15696      }
15697    }
15698    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TSlaveInfo))) {
15699      TSlaveInfo *G__Lderived;
15700      G__Lderived=(TSlaveInfo*)0x1000;
15701      {
15702        TObject *G__Lpbase=(TObject*)G__Lderived;
15703        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TSlaveInfo),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15704      }
15705    }
15706    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TMergerInfo))) {
15707      TMergerInfo *G__Lderived;
15708      G__Lderived=(TMergerInfo*)0x1000;
15709      {
15710        TObject *G__Lpbase=(TObject*)G__Lderived;
15711        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TMergerInfo),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15712      }
15713    }
15714    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TProofLite))) {
15715      TProofLite *G__Lderived;
15716      G__Lderived=(TProofLite*)0x1000;
15717      {
15718        TProof *G__Lpbase=(TProof*)G__Lderived;
15719        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofLite),G__get_linked_tagnum(&G__G__ProofLN_TProof),(long)G__Lpbase-(long)G__Lderived,1,1);
15720      }
15721      {
15722        TNamed *G__Lpbase=(TNamed*)G__Lderived;
15723        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofLite),G__get_linked_tagnum(&G__G__ProofLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
15724      }
15725      {
15726        TObject *G__Lpbase=(TObject*)G__Lderived;
15727        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofLite),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15728      }
15729      {
15730        TQObject *G__Lpbase=(TQObject*)G__Lderived;
15731        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofLite),G__get_linked_tagnum(&G__G__ProofLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15732      }
15733    }
15734    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TSlaveLite))) {
15735      TSlaveLite *G__Lderived;
15736      G__Lderived=(TSlaveLite*)0x1000;
15737      {
15738        TSlave *G__Lpbase=(TSlave*)G__Lderived;
15739        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TSlaveLite),G__get_linked_tagnum(&G__G__ProofLN_TSlave),(long)G__Lpbase-(long)G__Lderived,1,1);
15740      }
15741      {
15742        TObject *G__Lpbase=(TObject*)G__Lderived;
15743        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TSlaveLite),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15744      }
15745    }
15746    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TProofCondor))) {
15747      TProofCondor *G__Lderived;
15748      G__Lderived=(TProofCondor*)0x1000;
15749      {
15750        TProof *G__Lpbase=(TProof*)G__Lderived;
15751        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofCondor),G__get_linked_tagnum(&G__G__ProofLN_TProof),(long)G__Lpbase-(long)G__Lderived,1,1);
15752      }
15753      {
15754        TNamed *G__Lpbase=(TNamed*)G__Lderived;
15755        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofCondor),G__get_linked_tagnum(&G__G__ProofLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
15756      }
15757      {
15758        TObject *G__Lpbase=(TObject*)G__Lderived;
15759        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofCondor),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15760      }
15761      {
15762        TQObject *G__Lpbase=(TQObject*)G__Lderived;
15763        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofCondor),G__get_linked_tagnum(&G__G__ProofLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15764      }
15765    }
15766    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TQueryResultManager))) {
15767      TQueryResultManager *G__Lderived;
15768      G__Lderived=(TQueryResultManager*)0x1000;
15769      {
15770        TObject *G__Lpbase=(TObject*)G__Lderived;
15771        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TQueryResultManager),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15772      }
15773    }
15774    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TProofQueryResult))) {
15775      TProofQueryResult *G__Lderived;
15776      G__Lderived=(TProofQueryResult*)0x1000;
15777      {
15778        TQueryResult *G__Lpbase=(TQueryResult*)G__Lderived;
15779        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofQueryResult),G__get_linked_tagnum(&G__G__ProofLN_TQueryResult),(long)G__Lpbase-(long)G__Lderived,1,1);
15780      }
15781      {
15782        TNamed *G__Lpbase=(TNamed*)G__Lderived;
15783        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofQueryResult),G__get_linked_tagnum(&G__G__ProofLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
15784      }
15785      {
15786        TObject *G__Lpbase=(TObject*)G__Lderived;
15787        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofQueryResult),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15788      }
15789    }
15790    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TProofLogElem))) {
15791      TProofLogElem *G__Lderived;
15792      G__Lderived=(TProofLogElem*)0x1000;
15793      {
15794        TNamed *G__Lpbase=(TNamed*)G__Lderived;
15795        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofLogElem),G__get_linked_tagnum(&G__G__ProofLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
15796      }
15797      {
15798        TObject *G__Lpbase=(TObject*)G__Lderived;
15799        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofLogElem),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15800      }
15801    }
15802    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TProofMgrLite))) {
15803      TProofMgrLite *G__Lderived;
15804      G__Lderived=(TProofMgrLite*)0x1000;
15805      {
15806        TProofMgr *G__Lpbase=(TProofMgr*)G__Lderived;
15807        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofMgrLite),G__get_linked_tagnum(&G__G__ProofLN_TProofMgr),(long)G__Lpbase-(long)G__Lderived,1,1);
15808      }
15809      {
15810        TNamed *G__Lpbase=(TNamed*)G__Lderived;
15811        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofMgrLite),G__get_linked_tagnum(&G__G__ProofLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
15812      }
15813      {
15814        TObject *G__Lpbase=(TObject*)G__Lderived;
15815        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofMgrLite),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15816      }
15817    }
15818    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TProofResourcesStatic))) {
15819      TProofResourcesStatic *G__Lderived;
15820      G__Lderived=(TProofResourcesStatic*)0x1000;
15821      {
15822        TProofResources *G__Lpbase=(TProofResources*)G__Lderived;
15823        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofResourcesStatic),G__get_linked_tagnum(&G__G__ProofLN_TProofResources),(long)G__Lpbase-(long)G__Lderived,1,1);
15824      }
15825      {
15826        TObject *G__Lpbase=(TObject*)G__Lderived;
15827        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofResourcesStatic),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15828      }
15829    }
15830    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfo))) {
15831      TProofNodeInfo *G__Lderived;
15832      G__Lderived=(TProofNodeInfo*)0x1000;
15833      {
15834        TObject *G__Lpbase=(TObject*)G__Lderived;
15835        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfo),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15836      }
15837    }
15838    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TProofProgressStatus))) {
15839      TProofProgressStatus *G__Lderived;
15840      G__Lderived=(TProofProgressStatus*)0x1000;
15841      {
15842        TObject *G__Lpbase=(TObject*)G__Lderived;
15843        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofProgressStatus),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15844      }
15845    }
15846    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TProofResources))) {
15847      TProofResources *G__Lderived;
15848      G__Lderived=(TProofResources*)0x1000;
15849      {
15850        TObject *G__Lpbase=(TObject*)G__Lderived;
15851        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofResources),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15852      }
15853    }
15854    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TApplication))) {
15855      TApplication *G__Lderived;
15856      G__Lderived=(TApplication*)0x1000;
15857      {
15858        TObject *G__Lpbase=(TObject*)G__Lderived;
15859        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TApplication),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15860      }
15861      {
15862        TQObject *G__Lpbase=(TQObject*)G__Lderived;
15863        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TApplication),G__get_linked_tagnum(&G__G__ProofLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
15864      }
15865    }
15866    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TProofServLite))) {
15867      TProofServLite *G__Lderived;
15868      G__Lderived=(TProofServLite*)0x1000;
15869      {
15870        TProofServ *G__Lpbase=(TProofServ*)G__Lderived;
15871        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofServLite),G__get_linked_tagnum(&G__G__ProofLN_TProofServ),(long)G__Lpbase-(long)G__Lderived,1,1);
15872      }
15873      {
15874        TApplication *G__Lpbase=(TApplication*)G__Lderived;
15875        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofServLite),G__get_linked_tagnum(&G__G__ProofLN_TApplication),(long)G__Lpbase-(long)G__Lderived,1,0);
15876      }
15877      {
15878        TObject *G__Lpbase=(TObject*)G__Lderived;
15879        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofServLite),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15880      }
15881      {
15882        TQObject *G__Lpbase=(TQObject*)G__Lderived;
15883        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofServLite),G__get_linked_tagnum(&G__G__ProofLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15884      }
15885    }
15886    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofLN_TProofSuperMaster))) {
15887      TProofSuperMaster *G__Lderived;
15888      G__Lderived=(TProofSuperMaster*)0x1000;
15889      {
15890        TProof *G__Lpbase=(TProof*)G__Lderived;
15891        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofSuperMaster),G__get_linked_tagnum(&G__G__ProofLN_TProof),(long)G__Lpbase-(long)G__Lderived,1,1);
15892      }
15893      {
15894        TNamed *G__Lpbase=(TNamed*)G__Lderived;
15895        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofSuperMaster),G__get_linked_tagnum(&G__G__ProofLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
15896      }
15897      {
15898        TObject *G__Lpbase=(TObject*)G__Lderived;
15899        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofSuperMaster),G__get_linked_tagnum(&G__G__ProofLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15900      }
15901      {
15902        TQObject *G__Lpbase=(TQObject*)G__Lderived;
15903        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofSuperMaster),G__get_linked_tagnum(&G__G__ProofLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
15904      }
15905    }
15906 }
15907 
15908 /*********************************************************
15909 * typedef information setup/
15910 *********************************************************/
15911 extern "C" void G__cpp_setup_typetableG__Proof() {
15912 
15913    /* Setting up typedef entry */
15914    G__search_typename2("Int_t",105,-1,0,-1);
15915    G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
15916    G__search_typename2("UInt_t",104,-1,0,-1);
15917    G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
15918    G__search_typename2("Long_t",108,-1,0,-1);
15919    G__setnewtype(-1,"Signed long integer 4 bytes (long)",0);
15920    G__search_typename2("Float_t",102,-1,0,-1);
15921    G__setnewtype(-1,"Float 4 bytes (float)",0);
15922    G__search_typename2("Double_t",100,-1,0,-1);
15923    G__setnewtype(-1,"Double 8 bytes",0);
15924    G__search_typename2("Bool_t",103,-1,0,-1);
15925    G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
15926    G__search_typename2("Version_t",115,-1,0,-1);
15927    G__setnewtype(-1,"Class version identifier (short)",0);
15928    G__search_typename2("Option_t",99,-1,256,-1);
15929    G__setnewtype(-1,"Option string (const char)",0);
15930    G__search_typename2("Long64_t",110,-1,0,-1);
15931    G__setnewtype(-1,"Portable signed long integer 8 bytes",0);
15932    G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__ProofLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
15933    G__setnewtype(-1,NULL,0);
15934    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__ProofLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
15935    G__setnewtype(-1,NULL,0);
15936    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__ProofLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
15937    G__setnewtype(-1,NULL,0);
15938    G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__ProofLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
15939    G__setnewtype(-1,NULL,0);
15940    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__ProofLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
15941    G__setnewtype(-1,NULL,0);
15942    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__ProofLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
15943    G__setnewtype(-1,NULL,0);
15944    G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__ProofLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
15945    G__setnewtype(-1,NULL,0);
15946    G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__G__ProofLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
15947    G__setnewtype(-1,NULL,0);
15948    G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__G__ProofLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
15949    G__setnewtype(-1,NULL,0);
15950    G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__G__ProofLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
15951    G__setnewtype(-1,NULL,0);
15952    G__search_typename2("list<std::pair<TDSetElement*,TString> >",117,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR),0,-1);
15953    G__setnewtype(-1,NULL,0);
15954    G__search_typename2("value_type",117,G__get_linked_tagnum(&G__G__ProofLN_pairlETDSetElementmUcOTStringgR),0,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR));
15955    G__setnewtype(-1,NULL,0);
15956    G__search_typename2("allocator_type",117,G__get_linked_tagnum(&G__G__ProofLN_allocatorlEpairlETDSetElementmUcOTStringgRsPgR),0,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR));
15957    G__setnewtype(-1,NULL,0);
15958    G__search_typename2("void_pointer",89,-1,0,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR));
15959    G__setnewtype(-1,NULL,0);
15960    G__search_typename2("pointer",85,G__get_linked_tagnum(&G__G__ProofLN_pairlETDSetElementmUcOTStringgR),0,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR));
15961    G__setnewtype(-1,NULL,0);
15962    G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__G__ProofLN_pairlETDSetElementmUcOTStringgR),256,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR));
15963    G__setnewtype(-1,NULL,0);
15964    G__search_typename2("reference",117,G__get_linked_tagnum(&G__G__ProofLN_pairlETDSetElementmUcOTStringgR),1,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR));
15965    G__setnewtype(-1,NULL,0);
15966    G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__G__ProofLN_pairlETDSetElementmUcOTStringgR),257,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR));
15967    G__setnewtype(-1,NULL,0);
15968    G__search_typename2("size_type",104,-1,0,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR));
15969    G__setnewtype(-1,NULL,0);
15970    G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR));
15971    G__setnewtype(-1,NULL,0);
15972    G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR));
15973    G__setnewtype(-1,NULL,0);
15974    G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgRcLcLreverse_iterator),256,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR));
15975    G__setnewtype(-1,NULL,0);
15976    G__search_typename2("list<pair<TDSetElement*,TString> >",117,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR),0,-1);
15977    G__setnewtype(-1,NULL,0);
15978    G__search_typename2("FriendsList_t",117,G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__ProofLN_TDSetElement));
15979    G__setnewtype(-1,NULL,0);
15980    G__search_typename2("map<std::string,TObjArray*>",117,G__get_linked_tagnum(&G__G__ProofLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
15981    G__setnewtype(-1,NULL,0);
15982    G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__G__ProofLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
15983    G__setnewtype(-1,NULL,0);
15984    G__search_typename2("map<string,TObjArray*,less<string> >",117,G__get_linked_tagnum(&G__G__ProofLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
15985    G__setnewtype(-1,NULL,0);
15986    G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__G__ProofLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
15987    G__setnewtype(-1,NULL,0);
15988    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__ProofLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
15989    G__setnewtype(-1,NULL,0);
15990    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__ProofLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
15991    G__setnewtype(-1,NULL,0);
15992    G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__ProofLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
15993    G__setnewtype(-1,NULL,0);
15994    G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__G__ProofLN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
15995    G__setnewtype(-1,NULL,0);
15996    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__ProofLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofLN_vectorlETStringcOallocatorlETStringgRsPgR));
15997    G__setnewtype(-1,NULL,0);
15998    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__ProofLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofLN_vectorlETStringcOallocatorlETStringgRsPgR));
15999    G__setnewtype(-1,NULL,0);
16000    G__search_typename2("TProofMgr_t",89,-1,0,-1);
16001    G__setnewtype(-1,"TProofMgr *(*TProofMgr_t)(const char *, Int_t, const char *);",0);
16002    G__search_typename2("PrintProgress_t",89,-1,0,-1);
16003    G__setnewtype(-1,"void (*PrintProgress_t)(Long64_t tot, Long64_t proc, Float_t proctime, Long64_t bytes);",0);
16004    G__search_typename2("map<TString,MD5Mod_t>",117,G__get_linked_tagnum(&G__G__ProofLN_maplETStringcOTProofcLcLMD5Mod_tcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTProofcLcLMD5Mod_tgRsPgRsPgR),0,-1);
16005    G__setnewtype(-1,NULL,0);
16006    G__search_typename2("map<TString,TProof::MD5Mod_t>",117,G__get_linked_tagnum(&G__G__ProofLN_maplETStringcOTProofcLcLMD5Mod_tcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTProofcLcLMD5Mod_tgRsPgRsPgR),0,-1);
16007    G__setnewtype(-1,NULL,0);
16008    G__search_typename2("map<TString,TProof::MD5Mod_t,less<TString> >",117,G__get_linked_tagnum(&G__G__ProofLN_maplETStringcOTProofcLcLMD5Mod_tcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTProofcLcLMD5Mod_tgRsPgRsPgR),0,-1);
16009    G__setnewtype(-1,NULL,0);
16010    G__search_typename2("FileMap_t",117,G__get_linked_tagnum(&G__G__ProofLN_maplETStringcOTProofcLcLMD5Mod_tcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTProofcLcLMD5Mod_tgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__ProofLN_TProof));
16011    G__setnewtype(-1,NULL,0);
16012    G__search_typename2("TSlave_t",89,-1,0,-1);
16013    G__setnewtype(-1,"TSlave *(*TSlave_t)(const char *url, const char *ord, Int_t perf,",0);
16014 }
16015 
16016 /*********************************************************
16017 * Data Member information setup/
16018 *********************************************************/
16019 
16020    /* Setting up class,struct,union tag member variable */
16021 
16022    /* TCondorSlave */
16023 static void G__setup_memvarTCondorSlave(void) {
16024    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TCondorSlave));
16025    { TCondorSlave *p; p=(TCondorSlave*)0x1000; if (p) { }
16026    G__memvar_setup((void*)((long)(&p->fHostname)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,1,"fHostname=",0,(char*)NULL);
16027    G__memvar_setup((void*)((long)(&p->fPort)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fPort=",0,(char*)NULL);
16028    G__memvar_setup((void*)((long)(&p->fPerfIdx)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fPerfIdx=",0,(char*)NULL);
16029    G__memvar_setup((void*)((long)(&p->fImage)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,1,"fImage=",0,(char*)NULL);
16030    G__memvar_setup((void*)((long)(&p->fClaimID)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,1,"fClaimID=",0,(char*)NULL);
16031    G__memvar_setup((void*)((long)(&p->fOrdinal)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,1,"fOrdinal=",0,(char*)NULL);
16032    G__memvar_setup((void*)((long)(&p->fWorkDir)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,1,"fWorkDir=",0,(char*)NULL);
16033    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16034    }
16035    G__tag_memvar_reset();
16036 }
16037 
16038 
16039    /* TCondor */
16040 static void G__setup_memvarTCondor(void) {
16041    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TCondor));
16042    { TCondor *p; p=(TCondor*)0x1000; if (p) { }
16043    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TCondorcLcLEState),-1,-2,1,G__FastAllocString(2048).Format("kFree=%lldLL",(long long)TCondor::kFree).data(),0,(char*)NULL);
16044    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TCondorcLcLEState),-1,-2,1,G__FastAllocString(2048).Format("kSuspended=%lldLL",(long long)TCondor::kSuspended).data(),0,(char*)NULL);
16045    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TCondorcLcLEState),-1,-2,1,G__FastAllocString(2048).Format("kActive=%lldLL",(long long)TCondor::kActive).data(),0,(char*)NULL);
16046    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fValid=",0,"access to Condor");
16047    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fPool=",0,"the condor pool to be accessed");
16048    G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__ProofLN_TCondorcLcLEState),-1,-1,4,"fState=",0,"our claim state");
16049    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fClaims=",0,"list of claims we manage");
16050    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16051    }
16052    G__tag_memvar_reset();
16053 }
16054 
16055 
16056    /* TDataSetManager */
16057 static void G__setup_memvarTDataSetManager(void) {
16058    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TDataSetManager));
16059    { TDataSetManager *p; p=(TDataSetManager*)0x1000; if (p) { }
16060    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fGroup=",0,"Group to which the owner of this session belongs");
16061    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fUser=",0,"Owner of the session");
16062    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fCommonUser=",0,"User that stores the COMMON datasets");
16063    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fCommonGroup=",0,"Group that stores the COMMON datasets");
16064    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TUri),-1,-1,2,"fBase=",0,"Base URI used to parse dataset names");
16065    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TMap),-1,-1,2,"fGroupQuota=",0,"Group quotas (read from config file)");
16066    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TMap),-1,-1,2,"fGroupUsed=",0,"<group> --> <used bytes> (TParameter)");
16067    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TMap),-1,-1,2,"fUserUsed=",0,"<group> --> <map of users> --> <value>");
16068    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fAvgFileSize=",0,"Average file size to be used to estimate the dataset size (in MB)");
16069    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNTouchedFiles=",0,"Number of files touched in the last ScanDataSet operation");
16070    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNOpenedFiles=",0,"Number of files opened in the last ScanDataSet operation");
16071    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNDisappearedFiles=",0,"Number of files disappared in the last ScanDataSet operation");
16072    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fGroupConfigFile=",0,"Path to the group config file");
16073    G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,2,"fMTimeGroupConfig=",0,"Last modification of the group config file");
16074    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-2,2,"fgCommonDataSetTag=",0,"Name for common datasets, default: COMMON");
16075    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-2,2,"fgDataSetSrvMaps=",0,"List of TPair(TRegexp, TObjString) for mapping server coordinates");
16076    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kCheckQuota=%lldLL",(long long)TDataSetManager::kCheckQuota).data(),0,(char*)NULL);
16077    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kAllowRegister=%lldLL",(long long)TDataSetManager::kAllowRegister).data(),0,(char*)NULL);
16078    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kAllowVerify=%lldLL",(long long)TDataSetManager::kAllowVerify).data(),0,(char*)NULL);
16079    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kTrustInfo=%lldLL",(long long)TDataSetManager::kTrustInfo).data(),0,(char*)NULL);
16080    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kIsSandbox=%lldLL",(long long)TDataSetManager::kIsSandbox).data(),0,(char*)NULL);
16081    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kUseCache=%lldLL",(long long)TDataSetManager::kUseCache).data(),0,(char*)NULL);
16082    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kDoNotUseCache=%lldLL",(long long)TDataSetManager::kDoNotUseCache).data(),0,(char*)NULL);
16083    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kDebug=%lldLL",(long long)TDataSetManager::kDebug).data(),0,(char*)NULL);
16084    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kShowDefault=%lldLL",(long long)TDataSetManager::kShowDefault).data(),0,(char*)NULL);
16085    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kPrint=%lldLL",(long long)TDataSetManager::kPrint).data(),0,(char*)NULL);
16086    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kExport=%lldLL",(long long)TDataSetManager::kExport).data(),0,(char*)NULL);
16087    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kQuotaUpdate=%lldLL",(long long)TDataSetManager::kQuotaUpdate).data(),0,(char*)NULL);
16088    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kSetDefaultTree=%lldLL",(long long)TDataSetManager::kSetDefaultTree).data(),0,(char*)NULL);
16089    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kForceScan=%lldLL",(long long)TDataSetManager::kForceScan).data(),0,(char*)NULL);
16090    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kNoHeaderPrint=%lldLL",(long long)TDataSetManager::kNoHeaderPrint).data(),0,(char*)NULL);
16091    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kReopen=%lldLL",(long long)TDataSetManager::kReopen).data(),0,(char*)NULL);
16092    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kTouch=%lldLL",(long long)TDataSetManager::kTouch).data(),0,(char*)NULL);
16093    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kMaxFiles=%lldLL",(long long)TDataSetManager::kMaxFiles).data(),0,(char*)NULL);
16094    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kReadShort=%lldLL",(long long)TDataSetManager::kReadShort).data(),0,(char*)NULL);
16095    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kFileMustExist=%lldLL",(long long)TDataSetManager::kFileMustExist).data(),0,(char*)NULL);
16096    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kNoAction=%lldLL",(long long)TDataSetManager::kNoAction).data(),0,(char*)NULL);
16097    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kLocateOnly=%lldLL",(long long)TDataSetManager::kLocateOnly).data(),0,(char*)NULL);
16098    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kStageOnly=%lldLL",(long long)TDataSetManager::kStageOnly).data(),0,(char*)NULL);
16099    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kNoCacheUpdate=%lldLL",(long long)TDataSetManager::kNoCacheUpdate).data(),0,(char*)NULL);
16100    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kRefreshLs=%lldLL",(long long)TDataSetManager::kRefreshLs).data(),0,(char*)NULL);
16101    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kList=%lldLL",(long long)TDataSetManager::kList).data(),0,(char*)NULL);
16102    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kAllFiles=%lldLL",(long long)TDataSetManager::kAllFiles).data(),0,(char*)NULL);
16103    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kStagedFiles=%lldLL",(long long)TDataSetManager::kStagedFiles).data(),0,(char*)NULL);
16104    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts),-1,-2,1,G__FastAllocString(2048).Format("kNoStagedCheck=%lldLL",(long long)TDataSetManager::kNoStagedCheck).data(),0,(char*)NULL);
16105    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16106    }
16107    G__tag_memvar_reset();
16108 }
16109 
16110 
16111    /* TDataSetManagerFile */
16112 static void G__setup_memvarTDataSetManagerFile(void) {
16113    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagerFile));
16114    { TDataSetManagerFile *p; p=(TDataSetManagerFile*)0x1000; if (p) { }
16115    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fDataSetDir=",0,"Location of datasets");
16116    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fMSSUrl=",0,"URL for the Mass Storage System");
16117    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fStageOpts=",0,"Option string to be used in issuing staging requests");
16118    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fDataSetLockFile=",0,"Dataset lock file");
16119    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLockFileTimeLimit=",0,"Limit in seconds after a lock automatically expires");
16120    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fListFile=",0,"File to check repository updates");
16121    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsRemote=",0,"True if the repository is remote");
16122    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseCache=",0,"True if the cache is used for browsing remote repositories");
16123    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fLocalCacheDir=",0,"Local cache when the repository is remote");
16124    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCacheUpdatePeriod=",0,"Period for checking for new updated information");
16125    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16126    }
16127    G__tag_memvar_reset();
16128 }
16129 
16130 
16131    /* TDSet */
16132 static void G__setup_memvarTDSet(void) {
16133    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TDSet));
16134    { TDSet *p; p=(TDSet*)0x1000; if (p) { }
16135    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDSetcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kWriteV3=%lldLL",(long long)TDSet::kWriteV3).data(),0,(char*)NULL);
16136    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDSetcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kEmpty=%lldLL",(long long)TDSet::kEmpty).data(),0,(char*)NULL);
16137    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDSetcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kValidityChecked=%lldLL",(long long)TDSet::kValidityChecked).data(),0,(char*)NULL);
16138    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDSetcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kSomeInvalid=%lldLL",(long long)TDSet::kSomeInvalid).data(),0,(char*)NULL);
16139    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDSetcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kMultiDSet=%lldLL",(long long)TDSet::kMultiDSet).data(),0,(char*)NULL);
16140    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsTree=",0,"true if type is a TTree (or TTree derived)");
16141    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TObject),-1,-1,4,"fEntryList=",0,"! entry (or event) list for processing");
16142    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofChain),-1,-1,4,"fProofChain=",0,"! for browsing purposes");
16143    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fDir=",0,"name of the directory");
16144    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fType=",0,"type of objects (e.g. TTree);");
16145    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fObjName=",0,"name of objects to be analyzed (e.g. TTree name)");
16146    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_THashList),-1,-1,2,"fElements=",0,"-> list of TDSetElements (or TDSets, if in multi mode)");
16147    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TIter),-1,-1,2,"fIterator=",0,"! iterator on fElements");
16148    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TDSetElement),-1,-1,2,"fCurrent=",0,"! current element");
16149    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,2,"fSrvMaps=",0,"! list for mapping server coordinates for files");
16150    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TIter),-1,-1,2,"fSrvMapsIter=",0,"! iterator on fSrvMaps");
16151    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16152    }
16153    G__tag_memvar_reset();
16154 }
16155 
16156 
16157    /* TProof */
16158 static void G__setup_memvarTProof(void) {
16159    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TProof));
16160    { TProof *p; p=(TProof*)0x1000; if (p) { }
16161    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kUsingSessionGui=%lldLL",(long long)TProof::kUsingSessionGui).data(),0,(char*)NULL);
16162    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kNewInputData=%lldLL",(long long)TProof::kNewInputData).data(),0,(char*)NULL);
16163    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kIsClient=%lldLL",(long long)TProof::kIsClient).data(),0,(char*)NULL);
16164    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kIsMaster=%lldLL",(long long)TProof::kIsMaster).data(),0,(char*)NULL);
16165    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kIsTopMaster=%lldLL",(long long)TProof::kIsTopMaster).data(),0,(char*)NULL);
16166    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kUseProgressDialog=%lldLL",(long long)TProof::kUseProgressDialog).data(),0,(char*)NULL);
16167    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEQueryMode),-1,-2,1,G__FastAllocString(2048).Format("kSync=%lldLL",(long long)TProof::kSync).data(),0,(char*)NULL);
16168    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEQueryMode),-1,-2,1,G__FastAllocString(2048).Format("kAsync=%lldLL",(long long)TProof::kAsync).data(),0,(char*)NULL);
16169    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEUploadOpt),-1,-2,1,G__FastAllocString(2048).Format("kAppend=%lldLL",(long long)TProof::kAppend).data(),0,(char*)NULL);
16170    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEUploadOpt),-1,-2,1,G__FastAllocString(2048).Format("kOverwriteDataSet=%lldLL",(long long)TProof::kOverwriteDataSet).data(),0,(char*)NULL);
16171    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEUploadOpt),-1,-2,1,G__FastAllocString(2048).Format("kNoOverwriteDataSet=%lldLL",(long long)TProof::kNoOverwriteDataSet).data(),0,(char*)NULL);
16172    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEUploadOpt),-1,-2,1,G__FastAllocString(2048).Format("kOverwriteAllFiles=%lldLL",(long long)TProof::kOverwriteAllFiles).data(),0,(char*)NULL);
16173    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEUploadOpt),-1,-2,1,G__FastAllocString(2048).Format("kOverwriteNoFiles=%lldLL",(long long)TProof::kOverwriteNoFiles).data(),0,(char*)NULL);
16174    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEUploadOpt),-1,-2,1,G__FastAllocString(2048).Format("kAskUser=%lldLL",(long long)TProof::kAskUser).data(),0,(char*)NULL);
16175    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLERegisterOpt),-1,-2,1,G__FastAllocString(2048).Format("kFailIfExists=%lldLL",(long long)TProof::kFailIfExists).data(),0,(char*)NULL);
16176    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLERegisterOpt),-1,-2,1,G__FastAllocString(2048).Format("kOverwriteIfExists=%lldLL",(long long)TProof::kOverwriteIfExists).data(),0,(char*)NULL);
16177    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLERegisterOpt),-1,-2,1,G__FastAllocString(2048).Format("kMergeIfExists=%lldLL",(long long)TProof::kMergeIfExists).data(),0,(char*)NULL);
16178    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEUploadDataSetAnswer),-1,-2,1,G__FastAllocString(2048).Format("kError=%lldLL",(long long)TProof::kError).data(),0,(char*)NULL);
16179    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEUploadDataSetAnswer),-1,-2,1,G__FastAllocString(2048).Format("kDataSetExists=%lldLL",(long long)TProof::kDataSetExists).data(),0,(char*)NULL);
16180    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEUploadDataSetAnswer),-1,-2,1,G__FastAllocString(2048).Format("kFail=%lldLL",(long long)TProof::kFail).data(),0,(char*)NULL);
16181    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEUploadPackageOpt),-1,-2,1,G__FastAllocString(2048).Format("kUntar=%lldLL",(long long)TProof::kUntar).data(),0,(char*)NULL);
16182    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEUploadPackageOpt),-1,-2,1,G__FastAllocString(2048).Format("kRemoveOld=%lldLL",(long long)TProof::kRemoveOld).data(),0,(char*)NULL);
16183    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLERunStatus),-1,-2,1,G__FastAllocString(2048).Format("kRunning=%lldLL",(long long)TProof::kRunning).data(),0,(char*)NULL);
16184    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLERunStatus),-1,-2,1,G__FastAllocString(2048).Format("kStopped=%lldLL",(long long)TProof::kStopped).data(),0,(char*)NULL);
16185    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLERunStatus),-1,-2,1,G__FastAllocString(2048).Format("kAborted=%lldLL",(long long)TProof::kAborted).data(),0,(char*)NULL);
16186    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLESubMerger),-1,-2,1,G__FastAllocString(2048).Format("kOutputSize=%lldLL",(long long)TProof::kOutputSize).data(),0,(char*)NULL);
16187    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLESubMerger),-1,-2,1,G__FastAllocString(2048).Format("kSendOutput=%lldLL",(long long)TProof::kSendOutput).data(),0,(char*)NULL);
16188    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLESubMerger),-1,-2,1,G__FastAllocString(2048).Format("kBeMerger=%lldLL",(long long)TProof::kBeMerger).data(),0,(char*)NULL);
16189    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLESubMerger),-1,-2,1,G__FastAllocString(2048).Format("kMergerDown=%lldLL",(long long)TProof::kMergerDown).data(),0,(char*)NULL);
16190    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLESubMerger),-1,-2,1,G__FastAllocString(2048).Format("kStopMerging=%lldLL",(long long)TProof::kStopMerging).data(),0,(char*)NULL);
16191    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLESubMerger),-1,-2,1,G__FastAllocString(2048).Format("kOutputSent=%lldLL",(long long)TProof::kOutputSent).data(),0,(char*)NULL);
16192    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEUrgent),-1,-2,4,"kLocalInterrupt=-1LL",0,(char*)NULL);
16193    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEUrgent),-1,-2,4,"kPing=0LL",0,(char*)NULL);
16194    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEUrgent),-1,-2,4,"kHardInterrupt=1LL",0,(char*)NULL);
16195    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEUrgent),-1,-2,4,"kSoftInterrupt=2LL",0,(char*)NULL);
16196    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEUrgent),-1,-2,4,"kShutdownInterrupt=3LL",0,(char*)NULL);
16197    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kShowCache=1LL",0,(char*)NULL);
16198    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kClearCache=2LL",0,(char*)NULL);
16199    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kShowPackages=3LL",0,(char*)NULL);
16200    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kClearPackages=4LL",0,(char*)NULL);
16201    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kClearPackage=5LL",0,(char*)NULL);
16202    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kBuildPackage=6LL",0,(char*)NULL);
16203    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kLoadPackage=7LL",0,(char*)NULL);
16204    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kShowEnabledPackages=8LL",0,(char*)NULL);
16205    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kShowSubCache=9LL",0,(char*)NULL);
16206    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kClearSubCache=10LL",0,(char*)NULL);
16207    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kShowSubPackages=11LL",0,(char*)NULL);
16208    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kDisableSubPackages=12LL",0,(char*)NULL);
16209    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kDisableSubPackage=13LL",0,(char*)NULL);
16210    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kBuildSubPackage=14LL",0,(char*)NULL);
16211    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kUnloadPackage=15LL",0,(char*)NULL);
16212    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kDisablePackage=16LL",0,(char*)NULL);
16213    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kUnloadPackages=17LL",0,(char*)NULL);
16214    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kDisablePackages=18LL",0,(char*)NULL);
16215    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kListPackages=19LL",0,(char*)NULL);
16216    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kListEnabledPackages=20LL",0,(char*)NULL);
16217    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofCacheCommands),-1,-2,4,"kLoadMacro=21LL",0,(char*)NULL);
16218    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofDataSetCommands),-1,-2,4,"kUploadDataSet=1LL",0,(char*)NULL);
16219    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofDataSetCommands),-1,-2,4,"kCheckDataSetName=2LL",0,(char*)NULL);
16220    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofDataSetCommands),-1,-2,4,"kGetDataSets=3LL",0,(char*)NULL);
16221    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofDataSetCommands),-1,-2,4,"kRegisterDataSet=4LL",0,(char*)NULL);
16222    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofDataSetCommands),-1,-2,4,"kGetDataSet=5LL",0,(char*)NULL);
16223    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofDataSetCommands),-1,-2,4,"kVerifyDataSet=6LL",0,(char*)NULL);
16224    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofDataSetCommands),-1,-2,4,"kRemoveDataSet=7LL",0,(char*)NULL);
16225    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofDataSetCommands),-1,-2,4,"kMergeDataSet=8LL",0,(char*)NULL);
16226    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofDataSetCommands),-1,-2,4,"kShowDataSets=9LL",0,(char*)NULL);
16227    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofDataSetCommands),-1,-2,4,"kGetQuota=10LL",0,(char*)NULL);
16228    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofDataSetCommands),-1,-2,4,"kShowQuota=11LL",0,(char*)NULL);
16229    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofDataSetCommands),-1,-2,4,"kSetDefaultTreeName=12LL",0,(char*)NULL);
16230    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofDataSetCommands),-1,-2,4,"kCache=13LL",0,(char*)NULL);
16231    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLESendFileOpt),-1,-2,4,"kAscii=0LL",0,(char*)NULL);
16232    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLESendFileOpt),-1,-2,4,"kBinary=1LL",0,(char*)NULL);
16233    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLESendFileOpt),-1,-2,4,"kForce=2LL",0,(char*)NULL);
16234    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLESendFileOpt),-1,-2,4,"kForward=4LL",0,(char*)NULL);
16235    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLESendFileOpt),-1,-2,4,"kCpBin=8LL",0,(char*)NULL);
16236    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLESendFileOpt),-1,-2,4,"kCp=16LL",0,(char*)NULL);
16237    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofWrkListAction),-1,-2,4,"kActivateWorker=1LL",0,(char*)NULL);
16238    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofWrkListAction),-1,-2,4,"kDeactivateWorker=2LL",0,(char*)NULL);
16239    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEBuildPackageOpt),-1,-2,4,"kDontBuildOnClient=-2LL",0,(char*)NULL);
16240    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEBuildPackageOpt),-1,-2,4,"kBuildOnSlavesNoWait=-1LL",0,(char*)NULL);
16241    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEBuildPackageOpt),-1,-2,4,"kBuildAll=0LL",0,(char*)NULL);
16242    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEBuildPackageOpt),-1,-2,4,"kCollectBuildResults=1LL",0,(char*)NULL);
16243    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofShowQuotaOpt),-1,-2,4,"kPerGroup=1LL",0,(char*)NULL);
16244    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofShowQuotaOpt),-1,-2,4,"kPerUser=2LL",0,(char*)NULL);
16245    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofClearData),-1,-2,4,"kPurge=1LL",0,(char*)NULL);
16246    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofClearData),-1,-2,4,"kUnregistered=2LL",0,(char*)NULL);
16247    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofClearData),-1,-2,4,"kDataset=4LL",0,(char*)NULL);
16248    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEProofClearData),-1,-2,4,"kForceClear=8LL",0,(char*)NULL);
16249    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fValid=",0,"is this a valid proof object");
16250    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fMaster=",0,"master server (\"\" if a master); used in the browser");
16251    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fWorkDir=",0,"current work directory on remote servers");
16252    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fGroup=",0,"PROOF group of this user");
16253    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLogLevel=",0,"server debug logging level");
16254    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fStatus=",0,"remote return status (part of kPROOF_LOGDONE)");
16255    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCheckFileStatus=",0,"remote return status after kPROOF_CHECKFILE");
16256    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fRecvMessages=",0,"Messages received during collect not yet processed");
16257    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fSlaveInfo=",0,"!list returned by kPROOF_GETSLAVEINFO");
16258    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSendGroupView=",0,"if true send new group view");
16259    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fActiveSlaves=",0,"list of active slaves (subset of all slaves)");
16260    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fInactiveSlaves=",0,"list of inactive slaves (good but not used for processing)");
16261    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fUniqueSlaves=",0,"list of all active slaves with unique file systems");
16262    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fAllUniqueSlaves=",0,"list of all active slaves with unique file systems, including all submasters");
16263    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fNonUniqueMasters=",0,"list of all active masters with a nonunique file system");
16264    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TMonitor),-1,-1,4,"fActiveMonitor=",0,"monitor activity on all active slave sockets");
16265    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TMonitor),-1,-1,4,"fUniqueMonitor=",0,"monitor activity on all unique slave sockets");
16266    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TMonitor),-1,-1,4,"fAllUniqueMonitor=",0,"monitor activity on all unique slave sockets, including all submasters");
16267    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TMonitor),-1,-1,4,"fCurrentMonitor=",0,"currently active monitor");
16268    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fBytesRead=",0,"bytes read by all slaves during the session");
16269    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fRealTime=",0,"realtime spent by all slaves during the session");
16270    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fCpuTime=",0,"CPU time spent by all slaves during the session");
16271    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TSignalHandler),-1,-1,4,"fIntHandler=",0,"interrupt signal handler (ctrl-c)");
16272    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TPluginHandler),-1,-1,4,"fProgressDialog=",0,"progress dialog plugin");
16273    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fProgressDialogStarted=",0,"indicates if the progress dialog is up");
16274    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TVirtualProofPlayer),-1,-1,4,"fPlayer=",0,"current player");
16275    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fFeedback=",0,"list of names to be returned as feedback");
16276    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fChains=",0,"chains with this proof set");
16277    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_maplETStringcOTProofcLcLMD5Mod_tcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTProofcLcLMD5Mod_tgRsPgRsPgR),G__defined_typename("FileMap_t"),-1,4,"fFileMap=",0,"map keeping track of a file's md5 and mod time");
16278    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TDSet),-1,-1,4,"fDSet=",0,"current TDSet being validated");
16279    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNotIdle=",0,"Number of non-idle sub-nodes");
16280    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSync=",0,"true if type of currently processed query is sync");
16281    G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLERunStatus),-1,-1,4,"fRunStatus=",0,"run status");
16282    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsWaiting=",0,"true if queries have been enqueued");
16283    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fRedirLog=",0,"redirect received log info");
16284    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fLogFileName=",0,"name of the temp file for redirected logs");
16285    G__memvar_setup((void*)0,69,0,0,-1,-1,-1,4,"fLogFileW=",0,"temp file to redirect logs");
16286    G__memvar_setup((void*)0,69,0,0,-1,-1,-1,4,"fLogFileR=",0,"temp file to read redirected logs");
16287    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fLogToWindowOnly=",0,"send log to window only");
16288    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofMergePrg),-1,-1,4,"fMergePrg=",0,"Merging progress");
16289    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fWaitingSlaves=",0,"stores a TPair of the slaves's TSocket and TMessage");
16290    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fQueries=",0,"list of TProofQuery objects");
16291    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOtherQueries=",0,"number of queries in list from previous sessions");
16292    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDrawQueries=",0,"number of draw queries during this sessions");
16293    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMaxDrawQueries=",0,"max number of draw queries kept");
16294    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSeqNum=",0,"Remote sequential # of the last query submitted");
16295    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSessionID=",0,"remote ID of the session");
16296    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fEndMaster=",0,"true for a master in direct contact only with workers");
16297    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fPackageDir=",0,"package directory (used on client)");
16298    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_THashList),-1,-1,4,"fGlobalPackageDirList=",0,"list of directories containing global packages libs");
16299    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofLockPath),-1,-1,4,"fPackageLock=",0,"package lock");
16300    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fEnabledPackagesOnClient=",0,"list of packages enabled on client");
16301    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fInputData=",0,"Input data objects sent over via file");
16302    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fInputDataFile=",0,"File with input data objects");
16303    G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("PrintProgress_t"),-1,4,"fPrintProgress=",0,"Function function to display progress info in batch mode");
16304    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TVirtualMutex),-1,-1,4,"fCloseMutex=",0,"Avoid crashes in MarkBad or alike while closing");
16305    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fLoadedMacros=",0,"List of loaded macros (just file names)");
16306    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-2,4,"fgProofEnvList=",0,"List of TNameds defining environment");
16307    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMergersSet=",0,"Indicates, if the following variables have been initialized properly");
16308    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMergersCount=",0,(char*)NULL);
16309    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fWorkersToMerge=",0,"Current total number of workers, which have not been yet assigned to any merger");
16310    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLastAssignedMerger=",0,(char*)NULL);
16311    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fMergers=",0,(char*)NULL);
16312    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fFinalizationRunning=",0,(char*)NULL);
16313    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fRedirectNext=",0,(char*)NULL);
16314    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TPluginHandler),-1,-2,4,"fgLogViewer=",0,"Log dialog box plugin");
16315    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLESlaves),-1,-2,2,"kAll=0LL",0,(char*)NULL);
16316    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLESlaves),-1,-2,2,"kActive=1LL",0,(char*)NULL);
16317    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLESlaves),-1,-2,2,"kUnique=2LL",0,(char*)NULL);
16318    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLESlaves),-1,-2,2,"kAllUnique=3LL",0,(char*)NULL);
16319    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMasterServ=",0,"true if we are a master server");
16320    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TUrl),-1,-1,2,"fUrl=",0,"Url of the master");
16321    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fConfFile=",0,"file containing config information");
16322    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fConfDir=",0,"directory containing cluster config information");
16323    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fImage=",0,"master's image name");
16324    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fProtocol=",0,"remote PROOF server protocol version number");
16325    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,2,"fSlaves=",0,"list of all slave servers as in config file");
16326    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,2,"fBadSlaves=",0,"dead slaves (subset of all slaves)");
16327    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TMonitor),-1,-1,2,"fAllMonitor=",0,"monitor activity on all valid slave sockets");
16328    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDataReady=",0,"true if data is ready to be analyzed");
16329    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fBytesReady=",0,"number of bytes staged");
16330    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fTotalBytes=",0,"number of bytes to be analyzed");
16331    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,2,"fAvailablePackages=",0,"list of available packages");
16332    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,2,"fEnabledPackages=",0,"list of enabled packages");
16333    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,2,"fRunningDSets=",0,"Temporary datasets used for async running");
16334    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fCollectTimeout=",0,"Timeout for (some) collect actions");
16335    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fDataPoolUrl=",0,"default data pool entry point URL");
16336    G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofMgrcLcLEServType),-1,-1,2,"fServType=",0,"type of server: proofd, XrdProofd");
16337    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofMgr),-1,-1,2,"fManager=",0,"manager to which this session belongs (if any)");
16338    G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEQueryMode),-1,-1,2,"fQueryMode=",0,"default query mode");
16339    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fDynamicStartup=",0,"are the workers started dynamically?");
16340    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TSemaphore),-1,-2,2,"fgSemaphore=",0,"semaphore to control no of parallel startup threads");
16341    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16342    }
16343    G__tag_memvar_reset();
16344 }
16345 
16346 
16347    /* TProofChain */
16348 static void G__setup_memvarTProofChain(void) {
16349    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofChain));
16350    { TProofChain *p; p=(TProofChain*)0x1000; if (p) { }
16351    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofChaincLcLdA),-1,-2,1,G__FastAllocString(2048).Format("kOwnsChain=%lldLL",(long long)TProofChain::kOwnsChain).data(),0,(char*)NULL);
16352    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TChain),-1,-1,2,"fChain=",0,"mother chain: needed for the browsing list");
16353    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TDSet),-1,-1,2,"fSet=",0,"TDSet");
16354    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TDrawFeedback),-1,-1,2,"fDrawFeedback=",0,"feedback handler");
16355    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16356    }
16357    G__tag_memvar_reset();
16358 }
16359 
16360 
16361    /* TDSetElement */
16362 static void G__setup_memvarTDSetElement(void) {
16363    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TDSetElement));
16364    { TDSetElement *p; p=(TDSetElement*)0x1000; if (p) { }
16365    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDSetElementcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kHasBeenLookedUp=%lldLL",(long long)TDSetElement::kHasBeenLookedUp).data(),0,(char*)NULL);
16366    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDSetElementcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kWriteV3=%lldLL",(long long)TDSetElement::kWriteV3).data(),0,(char*)NULL);
16367    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDSetElementcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kEmpty=%lldLL",(long long)TDSetElement::kEmpty).data(),0,(char*)NULL);
16368    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDSetElementcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kCorrupted=%lldLL",(long long)TDSetElement::kCorrupted).data(),0,(char*)NULL);
16369    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDSetElementcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kNewRun=%lldLL",(long long)TDSetElement::kNewRun).data(),0,(char*)NULL);
16370    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TDSetElementcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kNewPacket=%lldLL",(long long)TDSetElement::kNewPacket).data(),0,(char*)NULL);
16371    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fDirectory=",0,"directory in file where to look for objects");
16372    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fFirst=",0,"first entry to process");
16373    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fNum=",0,"number of entries to process");
16374    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fMsd=",0,"mass storage domain name");
16375    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fTDSetOffset=",0,"the global offset in the TDSet of the first");
16376    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TObject),-1,-1,4,"fEntryList=",0,"entry (or event) list to be used in processing");
16377    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fValid=",0,"whether or not the input values are valid");
16378    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fEntries=",0,"total number of possible entries in file");
16379    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fFriends=",0,"friend elements");
16380    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fDataSet=",0,"Name of the dataset of which this element is part");
16381    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fAssocObjList=",0,"List of objects associated to this element");
16382    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16383    }
16384    G__tag_memvar_reset();
16385 }
16386 
16387 
16388    /* pair<TDSetElement*,TString> */
16389 static void G__setup_memvarpairlETDSetElementmUcOTStringgR(void) {
16390    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_pairlETDSetElementmUcOTStringgR));
16391    { pair<TDSetElement*,TString> *p; p=(pair<TDSetElement*,TString>*)0x1000; if (p) { }
16392    G__memvar_setup((void*)((long)(&p->first)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TDSetElement),-1,-1,1,"first=",0,(char*)NULL);
16393    G__memvar_setup((void*)((long)(&p->second)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,1,"second=",0,(char*)NULL);
16394    }
16395    G__tag_memvar_reset();
16396 }
16397 
16398 
16399    /* list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > > */
16400 static void G__setup_memvarlistlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR(void) {
16401    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR));
16402    { list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > > *p; p=(list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >*)0x1000; if (p) { }
16403    }
16404    G__tag_memvar_reset();
16405 }
16406 
16407 
16408    /* TProofServ */
16409 static void G__setup_memvarTProofServ(void) {
16410    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofServ));
16411    { TProofServ *p; p=(TProofServ*)0x1000; if (p) { }
16412    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofServcLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kHighMemory=%lldLL",(long long)TProofServ::kHighMemory).data(),0,(char*)NULL);
16413    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofServcLcLEQueryAction),-1,-2,1,G__FastAllocString(2048).Format("kQueryOK=%lldLL",(long long)TProofServ::kQueryOK).data(),0,(char*)NULL);
16414    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofServcLcLEQueryAction),-1,-2,1,G__FastAllocString(2048).Format("kQueryModify=%lldLL",(long long)TProofServ::kQueryModify).data(),0,(char*)NULL);
16415    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofServcLcLEQueryAction),-1,-2,1,G__FastAllocString(2048).Format("kQueryStop=%lldLL",(long long)TProofServ::kQueryStop).data(),0,(char*)NULL);
16416    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofServcLcLEQueryAction),-1,-2,1,G__FastAllocString(2048).Format("kQueryEnqueued=%lldLL",(long long)TProofServ::kQueryEnqueued).data(),0,(char*)NULL);
16417    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fService=",0,"service we are running, either \"proofserv\" or \"proofslave\"");
16418    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fUser=",0,"user as which we run");
16419    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fGroup=",0,"group the user belongs to");
16420    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fConfDir=",0,"directory containing cluster config information");
16421    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fConfFile=",0,"file containing config information");
16422    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fWorkDir=",0,"directory containing all proof related info");
16423    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fImage=",0,"image name of the session");
16424    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fSessionTag=",0,"tag for the server session");
16425    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fTopSessionTag=",0,"tag for the global session");
16426    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fSessionDir=",0,"directory containing session dependent files");
16427    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fPackageDir=",0,"directory containing packages and user libs");
16428    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_THashList),-1,-1,4,"fGlobalPackageDirList=",0,"list of directories containing global packages libs");
16429    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fCacheDir=",0,"directory containing cache of user files");
16430    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fQueryDir=",0,"directory containing query results and status");
16431    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fDataSetDir=",0,"directory containing info about known data sets");
16432    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fDataDir=",0,"directory containing data files produced during queries");
16433    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fAdminPath=",0,"admin path for this session");
16434    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofLockPath),-1,-1,4,"fPackageLock=",0,"package dir locker");
16435    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofLockPath),-1,-1,4,"fCacheLock=",0,"cache dir locker");
16436    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofLockPath),-1,-1,4,"fQueryLock=",0,"query dir locker");
16437    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fArchivePath=",0,"default archive path");
16438    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TSocket),-1,-1,4,"fSocket=",0,"socket connection to client");
16439    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProof),-1,-1,4,"fProof=",0,"PROOF talking to slave servers");
16440    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TVirtualProofPlayer),-1,-1,4,"fPlayer=",0,"actual player");
16441    G__memvar_setup((void*)0,69,0,0,-1,-1,-1,4,"fLogFile=",0,"log file");
16442    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLogFileDes=",0,"log file descriptor");
16443    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fEnabledPackages=",0,"list of enabled packages");
16444    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fProtocol=",0,"protocol version number");
16445    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fOrdinal=",0,"slave ordinal number");
16446    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fGroupId=",0,"slave unique id in the active slave group");
16447    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fGroupSize=",0,"size of the active slave group");
16448    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLogLevel=",0,"debug logging level");
16449    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNcmd=",0,"command history number");
16450    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fGroupPriority=",0,"priority of group the user belongs to (0 - 100)");
16451    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fEndMaster=",0,"true for a master in direct contact only with workers");
16452    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMasterServ=",0,"true if we are a master server");
16453    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fInterrupt=",0,"if true macro execution will be stopped");
16454    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fRealTime=",0,"real time spent executing commands");
16455    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fCpuTime=",0,"CPU time spent executing commands");
16456    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TStopwatch),-1,-1,4,"fLatency=",0,"measures latency of packet requests");
16457    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TStopwatch),-1,-1,4,"fCompute=",0,"measures time spend processing a packet");
16458    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fQuerySeqNum=",0,"sequential number of the current or last query");
16459    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTotSessions=",0,"Total number of PROOF sessions on the cluster ");
16460    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fActSessions=",0,"Total number of active PROOF sessions on the cluster ");
16461    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fEffSessions=",0,"Effective Number of PROOF sessions on the assigned machines");
16462    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TFileHandler),-1,-1,4,"fInputHandler=",0,"Input socket handler");
16463    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TQueryResultManager),-1,-1,4,"fQMgr=",0,"Query-result manager");
16464    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fWaitingQueries=",0,"list of TProofQueryResult waiting to be processed");
16465    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIdle=",0,"TRUE if idle");
16466    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TMutex),-1,-1,4,"fQMtx=",0,"To protect async msg queue");
16467    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fQueuedMsg=",0,"list of messages waiting to be processed");
16468    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fPrefix=",0,"Prefix identifying the node");
16469    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fRealTimeLog=",0,"TRUE if log messages should be send back in real-time");
16470    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TShutdownTimer),-1,-1,4,"fShutdownTimer=",0,"Timer used to shutdown out-of-control sessions");
16471    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TReaperTimer),-1,-1,4,"fReaperTimer=",0,"Timer used to control children state");
16472    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TIdleTOTimer),-1,-1,4,"fIdleTOTimer=",0,"Timer used to control children state");
16473    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fInflateFactor=",0,"Factor in 1/1000 to inflate the CPU time");
16474    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCompressMsg=",0,"Compression level for messages");
16475    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManager),-1,-1,4,"fDataSetManager=",0,"dataset manager");
16476    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSendLogToMaster=",0,"On workers, controls logs sending to master");
16477    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TServerSocket),-1,-1,4,"fMergingSocket=",0,"Socket used for merging outputs if submerger");
16478    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TMonitor),-1,-1,4,"fMergingMonitor=",0,"Monitor for merging sockets");
16479    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMergedWorkers=",0,"Number of workers merged");
16480    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMaxQueries=",0,"Max number of queries fully kept");
16481    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fMaxBoxSize=",0,"Max size of the sandbox");
16482    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fHWMBoxSize=",0,"High-Water-Mark on the sandbox size");
16483    G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-2,4,"fgVirtMemMax=",0,"Hard limit enforced by the system (in kB)");
16484    G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-2,4,"fgResMemMax=",0,"Hard limit on the resident memory checked");
16485    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-2,4,"fgMemHWM=",0,"Threshold fraction of max for warning and finer monitoring");
16486    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-2,4,"fgMemStop=",0,"Fraction of max for stop processing");
16487    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fMsgSizeHWM=",0,"High-Water-Mark on the size of messages with results");
16488    G__memvar_setup((void*)0,69,0,0,-1,-1,-2,4,"fgErrorHandlerFile=",0,"File where to log");
16489    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgRecursive=",0,"Keep track of recursive inputs during processing");
16490    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgLogToSysLog=",0,">0 sent to syslog too");
16491    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-2,4,"fgSysLogService=",0,"name of the syslog service (eg: proofm-0, proofw-0.67)");
16492    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-2,4,"fgSysLogEntity=",0,"logging entity (<user>:<group>)");
16493    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-2,2,"fgLastMsg=",0,"Message about status before exception");
16494    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16495    }
16496    G__tag_memvar_reset();
16497 }
16498 
16499 
16500    /* TDSetProxy */
16501 static void G__setup_memvarTDSetProxy(void) {
16502    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TDSetProxy));
16503    { TDSetProxy *p; p=(TDSetProxy*)0x1000; if (p) { }
16504    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofServ),-1,-1,4,"fServ=",0,"!");
16505    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16506    }
16507    G__tag_memvar_reset();
16508 }
16509 
16510 
16511    /* TProofDesc */
16512 static void G__setup_memvarTProofDesc(void) {
16513    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofDesc));
16514    { TProofDesc *p; p=(TProofDesc*)0x1000; if (p) { }
16515    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDesccLcLEStatus),-1,-2,1,G__FastAllocString(2048).Format("kUnknown=%lldLL",(long long)TProofDesc::kUnknown).data(),0,(char*)NULL);
16516    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDesccLcLEStatus),-1,-2,1,G__FastAllocString(2048).Format("kIdle=%lldLL",(long long)TProofDesc::kIdle).data(),0,(char*)NULL);
16517    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDesccLcLEStatus),-1,-2,1,G__FastAllocString(2048).Format("kRunning=%lldLL",(long long)TProofDesc::kRunning).data(),0,(char*)NULL);
16518    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDesccLcLEStatus),-1,-2,1,G__FastAllocString(2048).Format("kShutdown=%lldLL",(long long)TProofDesc::kShutdown).data(),0,(char*)NULL);
16519    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fLocalId=",0,"ID in the local list");
16520    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fStatus=",0,"Session status (see EStatus)");
16521    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProof),-1,-1,4,"fProof=",0,"Related instance of TProof");
16522    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fRemoteId=",0,"Remote ID assigned by the coordinator to the proofserv");
16523    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fUrl=",0,"Url of the connection");
16524    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16525    }
16526    G__tag_memvar_reset();
16527 }
16528 
16529 
16530    /* TProofLog */
16531 static void G__setup_memvarTProofLog(void) {
16532    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofLog));
16533    { TProofLog *p; p=(TProofLog*)0x1000; if (p) { }
16534    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofMgr),-1,-1,4,"fMgr=",0,"parent TProofMgr");
16535    G__memvar_setup((void*)0,89,0,0,-1,-1,-1,4,"fFILE=",0,"pointer logging file, if any");
16536    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fElem=",0,"list of TProofLogElem objects");
16537    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TDatime),-1,-1,4,"fStartTime=",0,"Time at which this session started");
16538    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofLogcLcLELogLocationBit),-1,-2,1,G__FastAllocString(2048).Format("kLogToBox=%lldLL",(long long)TProofLog::kLogToBox).data(),0,(char*)NULL);
16539    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofLogcLcLERetrieveOpt),-1,-2,1,G__FastAllocString(2048).Format("kLeading=%lldLL",(long long)TProofLog::kLeading).data(),0,(char*)NULL);
16540    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofLogcLcLERetrieveOpt),-1,-2,1,G__FastAllocString(2048).Format("kTrailing=%lldLL",(long long)TProofLog::kTrailing).data(),0,(char*)NULL);
16541    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofLogcLcLERetrieveOpt),-1,-2,1,G__FastAllocString(2048).Format("kAll=%lldLL",(long long)TProofLog::kAll).data(),0,(char*)NULL);
16542    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofLogcLcLERetrieveOpt),-1,-2,1,G__FastAllocString(2048).Format("kGrep=%lldLL",(long long)TProofLog::kGrep).data(),0,(char*)NULL);
16543    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16544    }
16545    G__tag_memvar_reset();
16546 }
16547 
16548 
16549    /* TProofMgr */
16550 static void G__setup_memvarTProofMgr(void) {
16551    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofMgr));
16552    { TProofMgr *p; p=(TProofMgr*)0x1000; if (p) { }
16553    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofMgrcLcLEServType),-1,-2,1,G__FastAllocString(2048).Format("kProofd=%lldLL",(long long)TProofMgr::kProofd).data(),0,(char*)NULL);
16554    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofMgrcLcLEServType),-1,-2,1,G__FastAllocString(2048).Format("kXProofd=%lldLL",(long long)TProofMgr::kXProofd).data(),0,(char*)NULL);
16555    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofMgrcLcLEServType),-1,-2,1,G__FastAllocString(2048).Format("kProofLite=%lldLL",(long long)TProofMgr::kProofLite).data(),0,(char*)NULL);
16556    G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("TProofMgr_t"),-2,4,"fgTXProofMgrHook=",0,"Constructor hooks for TXProofMgr");
16557    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRemoteProtocol=",0,"Protocol number run by the daemon server");
16558    G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofMgrcLcLEServType),-1,-1,2,"fServType=",0,"Type of server: old-proofd, XrdProofd");
16559    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,2,"fSessions=",0,"PROOF session managed by this server");
16560    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TUrl),-1,-1,2,"fUrl=",0,"Server URL");
16561    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TSignalHandler),-1,-1,2,"fIntHandler=",0,"Interrupt signal handler (ctrl-c)");
16562    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-2,2,"fgListOfManagers=",0,"Sub-list of TROOT::ListOfProofs for managers");
16563    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16564    }
16565    G__tag_memvar_reset();
16566 }
16567 
16568 
16569    /* TProofDebug */
16570 static void G__setup_memvarTProofDebug(void) {
16571    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofDebug));
16572    { TProofDebug *p; p=(TProofDebug*)0x1000; if (p) { }
16573    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDebugcLcLEProofDebugMask),-1,-2,1,G__FastAllocString(2048).Format("kNone=%lldLL",(long long)TProofDebug::kNone).data(),0,(char*)NULL);
16574    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDebugcLcLEProofDebugMask),-1,-2,1,G__FastAllocString(2048).Format("kPacketizer=%lldLL",(long long)TProofDebug::kPacketizer).data(),0,(char*)NULL);
16575    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDebugcLcLEProofDebugMask),-1,-2,1,G__FastAllocString(2048).Format("kLoop=%lldLL",(long long)TProofDebug::kLoop).data(),0,(char*)NULL);
16576    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDebugcLcLEProofDebugMask),-1,-2,1,G__FastAllocString(2048).Format("kSelector=%lldLL",(long long)TProofDebug::kSelector).data(),0,(char*)NULL);
16577    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDebugcLcLEProofDebugMask),-1,-2,1,G__FastAllocString(2048).Format("kOutput=%lldLL",(long long)TProofDebug::kOutput).data(),0,(char*)NULL);
16578    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDebugcLcLEProofDebugMask),-1,-2,1,G__FastAllocString(2048).Format("kInput=%lldLL",(long long)TProofDebug::kInput).data(),0,(char*)NULL);
16579    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDebugcLcLEProofDebugMask),-1,-2,1,G__FastAllocString(2048).Format("kGlobal=%lldLL",(long long)TProofDebug::kGlobal).data(),0,(char*)NULL);
16580    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDebugcLcLEProofDebugMask),-1,-2,1,G__FastAllocString(2048).Format("kPackage=%lldLL",(long long)TProofDebug::kPackage).data(),0,(char*)NULL);
16581    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDebugcLcLEProofDebugMask),-1,-2,1,G__FastAllocString(2048).Format("kFeedback=%lldLL",(long long)TProofDebug::kFeedback).data(),0,(char*)NULL);
16582    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDebugcLcLEProofDebugMask),-1,-2,1,G__FastAllocString(2048).Format("kCondor=%lldLL",(long long)TProofDebug::kCondor).data(),0,(char*)NULL);
16583    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDebugcLcLEProofDebugMask),-1,-2,1,G__FastAllocString(2048).Format("kDraw=%lldLL",(long long)TProofDebug::kDraw).data(),0,(char*)NULL);
16584    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDebugcLcLEProofDebugMask),-1,-2,1,G__FastAllocString(2048).Format("kAsyn=%lldLL",(long long)TProofDebug::kAsyn).data(),0,(char*)NULL);
16585    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDebugcLcLEProofDebugMask),-1,-2,1,G__FastAllocString(2048).Format("kCache=%lldLL",(long long)TProofDebug::kCache).data(),0,(char*)NULL);
16586    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDebugcLcLEProofDebugMask),-1,-2,1,G__FastAllocString(2048).Format("kCollect=%lldLL",(long long)TProofDebug::kCollect).data(),0,(char*)NULL);
16587    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDebugcLcLEProofDebugMask),-1,-2,1,G__FastAllocString(2048).Format("kDataset=%lldLL",(long long)TProofDebug::kDataset).data(),0,(char*)NULL);
16588    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDebugcLcLEProofDebugMask),-1,-2,1,G__FastAllocString(2048).Format("kSubmerger=%lldLL",(long long)TProofDebug::kSubmerger).data(),0,(char*)NULL);
16589    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofDebugcLcLEProofDebugMask),-1,-2,1,G__FastAllocString(2048).Format("kAll=%lldLL",(long long)TProofDebug::kAll).data(),0,(char*)NULL);
16590    }
16591    G__tag_memvar_reset();
16592 }
16593 
16594 
16595    /* TVirtualProofPlayer */
16596 static void G__setup_memvarTVirtualProofPlayer(void) {
16597    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TVirtualProofPlayer));
16598    { TVirtualProofPlayer *p; p=(TVirtualProofPlayer*)0x1000; if (p) { }
16599    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TVirtualProofPlayercLcLEExitStatus),-1,-2,1,G__FastAllocString(2048).Format("kFinished=%lldLL",(long long)TVirtualProofPlayer::kFinished).data(),0,(char*)NULL);
16600    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TVirtualProofPlayercLcLEExitStatus),-1,-2,1,G__FastAllocString(2048).Format("kStopped=%lldLL",(long long)TVirtualProofPlayer::kStopped).data(),0,(char*)NULL);
16601    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TVirtualProofPlayercLcLEExitStatus),-1,-2,1,G__FastAllocString(2048).Format("kAborted=%lldLL",(long long)TVirtualProofPlayer::kAborted).data(),0,(char*)NULL);
16602    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16603    }
16604    G__tag_memvar_reset();
16605 }
16606 
16607 
16608    /* TSlave */
16609 static void G__setup_memvarTSlave(void) {
16610    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TSlave));
16611    { TSlave *p; p=(TSlave*)0x1000; if (p) { }
16612    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TSlavecLcLESlaveType),-1,-2,1,G__FastAllocString(2048).Format("kMaster=%lldLL",(long long)TSlave::kMaster).data(),0,(char*)NULL);
16613    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TSlavecLcLESlaveType),-1,-2,1,G__FastAllocString(2048).Format("kSlave=%lldLL",(long long)TSlave::kSlave).data(),0,(char*)NULL);
16614    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TSlavecLcLESlaveStatus),-1,-2,1,G__FastAllocString(2048).Format("kInvalid=%lldLL",(long long)TSlave::kInvalid).data(),0,(char*)NULL);
16615    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TSlavecLcLESlaveStatus),-1,-2,1,G__FastAllocString(2048).Format("kActive=%lldLL",(long long)TSlave::kActive).data(),0,(char*)NULL);
16616    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TSlavecLcLESlaveStatus),-1,-2,1,G__FastAllocString(2048).Format("kInactive=%lldLL",(long long)TSlave::kInactive).data(),0,(char*)NULL);
16617    G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("TSlave_t"),-2,4,"fgTXSlaveHook=",0,(char*)NULL);
16618    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fName=",0,"slave's hostname");
16619    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fImage=",0,"slave's image name");
16620    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fProofWorkDir=",0,"base proofserv working directory (info obtained from slave)");
16621    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fWorkDir=",0,"slave's working directory (info obtained from slave)");
16622    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fUser=",0,"slave's user id");
16623    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fGroup=",0,"slave's group id");
16624    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPort=",0,"slave's port number");
16625    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fOrdinal=",0,"slave's ordinal number");
16626    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPerfIdx=",0,"relative CPU performance index");
16627    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fProtocol=",0,"slave's protocol level");
16628    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TSocket),-1,-1,2,"fSocket=",0,"socket to slave");
16629    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProof),-1,-1,2,"fProof=",0,"proof cluster to which slave belongs");
16630    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TFileHandler),-1,-1,2,"fInput=",0,"input handler related to this slave");
16631    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fBytesRead=",0,"bytes read by slave (info is obtained from slave)");
16632    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fRealTime=",0,"real time spent executing commands (info obtained from slave)");
16633    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fCpuTime=",0,"CPU time spent executing commands (info obtained from slave)");
16634    G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__ProofLN_TSlavecLcLESlaveType),-1,-1,2,"fSlaveType=",0,"type of slave (either kMaster or kSlave)");
16635    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fStatus=",0,"remote return status");
16636    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fParallel=",0,"number of active slaves");
16637    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fMsd=",0,"mass storage domain of slave");
16638    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fSessionTag=",0,"unique tag for ths worker process");
16639    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fROOTVers=",0,"ROOT version run by worker");
16640    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,2,"fArchComp=",0,"Build architecture, compiler on worker (e.g. linux-gcc345)");
16641    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16642    }
16643    G__tag_memvar_reset();
16644 }
16645 
16646 
16647    /* TProofProgressInfo */
16648 static void G__setup_memvarTProofProgressInfo(void) {
16649    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofProgressInfo));
16650    { TProofProgressInfo *p; p=(TProofProgressInfo*)0x1000; if (p) { }
16651    G__memvar_setup((void*)((long)(&p->fTotal)-(long)(p)),110,0,0,-1,G__defined_typename("Long64_t"),-1,1,"fTotal=",0,"Total number of events to process");
16652    G__memvar_setup((void*)((long)(&p->fProcessed)-(long)(p)),110,0,0,-1,G__defined_typename("Long64_t"),-1,1,"fProcessed=",0,"Number of events processed");
16653    G__memvar_setup((void*)((long)(&p->fBytesRead)-(long)(p)),110,0,0,-1,G__defined_typename("Long64_t"),-1,1,"fBytesRead=",0,"Number of bytes read");
16654    G__memvar_setup((void*)((long)(&p->fInitTime)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fInitTime=",0,"Time for initialization");
16655    G__memvar_setup((void*)((long)(&p->fProcTime)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fProcTime=",0,"Time for processing");
16656    G__memvar_setup((void*)((long)(&p->fEvtRateI)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fEvtRateI=",0,"Instantaneous event rate");
16657    G__memvar_setup((void*)((long)(&p->fMBRateI)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fMBRateI=",0,"Instantaneous byte read rate");
16658    G__memvar_setup((void*)((long)(&p->fActWorkers)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fActWorkers=",0,"Numebr of workers still active");
16659    G__memvar_setup((void*)((long)(&p->fTotSessions)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fTotSessions=",0,"Numebr of PROOF sessions running currently on the clusters");
16660    G__memvar_setup((void*)((long)(&p->fEffSessions)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fEffSessions=",0,"Number of effective sessions running on the machines allocated to this session");
16661    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16662    }
16663    G__tag_memvar_reset();
16664 }
16665 
16666 
16667    /* TSlaveInfo */
16668 static void G__setup_memvarTSlaveInfo(void) {
16669    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TSlaveInfo));
16670    { TSlaveInfo *p; p=(TSlaveInfo*)0x1000; if (p) { }
16671    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TSlaveInfocLcLESlaveStatus),-1,-2,1,G__FastAllocString(2048).Format("kActive=%lldLL",(long long)TSlaveInfo::kActive).data(),0,(char*)NULL);
16672    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TSlaveInfocLcLESlaveStatus),-1,-2,1,G__FastAllocString(2048).Format("kNotActive=%lldLL",(long long)TSlaveInfo::kNotActive).data(),0,(char*)NULL);
16673    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TSlaveInfocLcLESlaveStatus),-1,-2,1,G__FastAllocString(2048).Format("kBad=%lldLL",(long long)TSlaveInfo::kBad).data(),0,(char*)NULL);
16674    G__memvar_setup((void*)((long)(&p->fOrdinal)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,1,"fOrdinal=",0,"slave ordinal");
16675    G__memvar_setup((void*)((long)(&p->fHostName)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,1,"fHostName=",0,"hostname this slave is running on");
16676    G__memvar_setup((void*)((long)(&p->fMsd)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,1,"fMsd=",0,"mass storage domain slave is in");
16677    G__memvar_setup((void*)((long)(&p->fDataDir)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,1,"fDataDir=",0,"directory for user data");
16678    G__memvar_setup((void*)((long)(&p->fPerfIndex)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fPerfIndex=",0,"relative performance of this slave");
16679    G__memvar_setup((void*)((long)(&p->fSysInfo)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofLN_SysInfo_t),-1,-1,1,"fSysInfo=",0,"Infomation about its hardware");
16680    G__memvar_setup((void*)((long)(&p->fStatus)-(long)(p)),105,0,0,G__get_linked_tagnum(&G__G__ProofLN_TSlaveInfocLcLESlaveStatus),-1,-1,1,"fStatus=",0,"slave status");
16681    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16682    }
16683    G__tag_memvar_reset();
16684 }
16685 
16686 
16687    /* TMergerInfo */
16688 static void G__setup_memvarTMergerInfo(void) {
16689    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TMergerInfo));
16690    { TMergerInfo *p; p=(TMergerInfo*)0x1000; if (p) { }
16691    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TSlave),-1,-1,4,"fMerger=",0,"Slave that acts as merger");
16692    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPort=",0,"Port number, on which it accepts outputs from other workers");
16693    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMergedObjects=",0,"Total number of objects it must accept from other workers");
16694    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fWorkersToMerge=",0,"Number of workers that are merged on this merger");
16695    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMergedWorkers=",0,"Current number of already merged workers");
16696    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fWorkers=",0,"List of already assigned workers");
16697    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsActive=",0,"Merger state");
16698    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16699    }
16700    G__tag_memvar_reset();
16701 }
16702 
16703 
16704    /* TProofLite */
16705 static void G__setup_memvarTProofLite(void) {
16706    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofLite));
16707    { TProofLite *p; p=(TProofLite*)0x1000; if (p) { }
16708    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNWorkers=",0,"Number of workers");
16709    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fSandbox=",0,"PROOF sandbox root dir");
16710    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fCacheDir=",0,"Directory containing cache of user files");
16711    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fQueryDir=",0,"Directory containing query results and status");
16712    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fDataSetDir=",0,"Directory containing info about known data sets");
16713    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fSockPath=",0,"UNIX socket path for communication with workers");
16714    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TServerSocket),-1,-1,4,"fServSock=",0,"Server socket to accept call backs");
16715    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fForkStartup=",0,"Startup N-1 workers forking the first worker");
16716    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fVarExp=",0,"Internal variable to pass drawing options");
16717    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fSelection=",0,"Internal variable to pass drawing options");
16718    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofLockPath),-1,-1,4,"fCacheLock=",0,"Cache dir locker");
16719    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofLockPath),-1,-1,4,"fQueryLock=",0,"Query dir locker");
16720    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TQueryResultManager),-1,-1,4,"fQMgr=",0,"Query-result manager");
16721    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TDataSetManager),-1,-1,4,"fDataSetManager=",0,"Dataset manager");
16722    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgWrksMax=",0,"Max number of workers");
16723    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16724    }
16725    G__tag_memvar_reset();
16726 }
16727 
16728 
16729    /* TSlaveLite */
16730 static void G__setup_memvarTSlaveLite(void) {
16731    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TSlaveLite));
16732    { TSlaveLite *p; p=(TSlaveLite*)0x1000; if (p) { }
16733    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fValid=",0,(char*)NULL);
16734    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TSignalHandler),-1,-1,4,"fIntHandler=",0,"interrupt signal handler (ctrl-c)");
16735    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16736    }
16737    G__tag_memvar_reset();
16738 }
16739 
16740 
16741    /* TProofCondor */
16742 static void G__setup_memvarTProofCondor(void) {
16743    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofCondor));
16744    { TProofCondor *p; p=(TProofCondor*)0x1000; if (p) { }
16745    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TCondor),-1,-1,4,"fCondor=",0,"proxy for our Condor pool");
16746    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TTimer),-1,-1,4,"fTimer=",0,"timer for delayed Condor COD suspend");
16747    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16748    }
16749    G__tag_memvar_reset();
16750 }
16751 
16752 
16753    /* TQueryResultManager */
16754 static void G__setup_memvarTQueryResultManager(void) {
16755    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TQueryResultManager));
16756    { TQueryResultManager *p; p=(TQueryResultManager*)0x1000; if (p) { }
16757    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fQueryDir=",0,"directory containing query results and status");
16758    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fSessionTag=",0,"tag for the session");
16759    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fSessionDir=",0,"directory containing session dependent files");
16760    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSeqNum=",0,"sequential number of last processed query");
16761    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDrawQueries=",0,"number of draw queries processed");
16762    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fKeptQueries=",0,"number of queries fully in memory and in dir");
16763    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fQueries=",0,"list of TProofQueryResult objects");
16764    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fPreviousQueries=",0,"list of TProofQueryResult objects from previous sections");
16765    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofLockPath),-1,-1,4,"fLock=",0,"dir locker");
16766    G__memvar_setup((void*)0,69,0,0,-1,-1,-1,4,"fLogFile=",0,"log file");
16767    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TStopwatch),-1,-1,4,"fCompute=",0,"measures time spend processing a query on the master");
16768    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16769    }
16770    G__tag_memvar_reset();
16771 }
16772 
16773 
16774    /* TProofQueryResult */
16775 static void G__setup_memvarTProofQueryResult(void) {
16776    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofQueryResult));
16777    { TProofQueryResult *p; p=(TProofQueryResult*)0x1000; if (p) { }
16778    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fStartLog=",0,"log file offset at start");
16779    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16780    }
16781    G__tag_memvar_reset();
16782 }
16783 
16784 
16785    /* TProofLogElem */
16786 static void G__setup_memvarTProofLogElem(void) {
16787    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofLogElem));
16788    { TProofLogElem *p; p=(TProofLogElem*)0x1000; if (p) { }
16789    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofLog),-1,-1,4,"fLogger=",0,"parent TProofLog");
16790    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TMacro),-1,-1,4,"fMacro=",0,"container for the log lines");
16791    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fSize=",0,"best knowledge of the log file size");
16792    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fFrom=",0,"starting offset of the current content");
16793    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fTo=",0,"end offset of the current content");
16794    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fRole=",0,"role (master-submaster-worker)");
16795    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-2,4,"fgMaxTransferSize=",0,(char*)NULL);
16796    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16797    }
16798    G__tag_memvar_reset();
16799 }
16800 
16801 
16802    /* TProofMgrLite */
16803 static void G__setup_memvarTProofMgrLite(void) {
16804    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofMgrLite));
16805    { TProofMgrLite *p; p=(TProofMgrLite*)0x1000; if (p) { }
16806    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16807    }
16808    G__tag_memvar_reset();
16809 }
16810 
16811 
16812    /* TProofResourcesStatic */
16813 static void G__setup_memvarTProofResourcesStatic(void) {
16814    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofResourcesStatic));
16815    { TProofResourcesStatic *p; p=(TProofResourcesStatic*)0x1000; if (p) { }
16816    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofResourcesStaticcLcLEInfoType),-1,-2,1,G__FastAllocString(2048).Format("kNodeType=%lldLL",(long long)TProofResourcesStatic::kNodeType).data(),0,(char*)NULL);
16817    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofResourcesStaticcLcLEInfoType),-1,-2,1,G__FastAllocString(2048).Format("kOption=%lldLL",(long long)TProofResourcesStatic::kOption).data(),0,(char*)NULL);
16818    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofResourcesStaticcLcLEInfoType),-1,-2,1,G__FastAllocString(2048).Format("kHost=%lldLL",(long long)TProofResourcesStatic::kHost).data(),0,(char*)NULL);
16819    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfo),-1,-1,4,"fMaster=",0,"Master node info");
16820    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fSubmasterList=",0,"Node info list with all submasters");
16821    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TList),-1,-1,4,"fWorkerList=",0,"Node info list with all workers");
16822    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fFoundMaster=",0,"kTRUE if config file has master info");
16823    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fFileName=",0,"Config file name");
16824    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16825    }
16826    G__tag_memvar_reset();
16827 }
16828 
16829 
16830    /* TProofNodeInfo */
16831 static void G__setup_memvarTProofNodeInfo(void) {
16832    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfo));
16833    { TProofNodeInfo *p; p=(TProofNodeInfo*)0x1000; if (p) { }
16834    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfocLcLENodeType),-1,-2,1,G__FastAllocString(2048).Format("kMaster=%lldLL",(long long)TProofNodeInfo::kMaster).data(),0,(char*)NULL);
16835    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfocLcLENodeType),-1,-2,1,G__FastAllocString(2048).Format("kSubMaster=%lldLL",(long long)TProofNodeInfo::kSubMaster).data(),0,(char*)NULL);
16836    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfocLcLENodeType),-1,-2,1,G__FastAllocString(2048).Format("kWorker=%lldLL",(long long)TProofNodeInfo::kWorker).data(),0,(char*)NULL);
16837    G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfocLcLENodeType),-1,-1,4,"fNodeType=",0,"Distinction between master, submaster and worker");
16838    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fNodeName=",0,"Name of the node");
16839    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fWorkDir=",0,"Working directory");
16840    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fOrdinal=",0,"Worker ordinal number");
16841    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fImage=",0,"File system image");
16842    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fId=",0,"Id number");
16843    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fConfig=",0,"Configuration file name [for submasters]");
16844    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fMsd=",0,"Msd value [for submasters]");
16845    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPort=",0,"Port number");
16846    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPerfIndex=",0,"Performance index");
16847    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16848    }
16849    G__tag_memvar_reset();
16850 }
16851 
16852 
16853    /* TProofProgressStatus */
16854 static void G__setup_memvarTProofProgressStatus(void) {
16855    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofProgressStatus));
16856    { TProofProgressStatus *p; p=(TProofProgressStatus*)0x1000; if (p) { }
16857    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fLastEntries=",0,"Last chunck");
16858    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fEntries=",0,(char*)NULL);
16859    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fBytesRead=",0,(char*)NULL);
16860    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fReadCalls=",0,(char*)NULL);
16861    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLearnTime=",0,"the time spent in learning phase");
16862    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLastProcTime=",0,"the wallclock time of the last addition");
16863    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fProcTime=",0,"the wallclock time");
16864    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCPUTime=",0,(char*)NULL);
16865    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLastUpdate=",0,"Timestamp of last change");
16866    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16867    }
16868    G__tag_memvar_reset();
16869 }
16870 
16871 
16872    /* TProofResources */
16873 static void G__setup_memvarTProofResources(void) {
16874    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofResources));
16875    { TProofResources *p; p=(TProofResources*)0x1000; if (p) { }
16876    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fValid=",0,"kTRUE if resource information was processed correctly");
16877    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16878    }
16879    G__tag_memvar_reset();
16880 }
16881 
16882 
16883    /* TProofServLite */
16884 static void G__setup_memvarTProofServLite(void) {
16885    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofServLite));
16886    { TProofServLite *p; p=(TProofServLite*)0x1000; if (p) { }
16887    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofServLiteInterruptHandler),-1,-1,4,"fInterruptHandler=",0,(char*)NULL);
16888    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofLN_TString),-1,-1,4,"fSockPath=",0,"unix socket path");
16889    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTerminated=",0,"true if Terminate() has been already called");
16890    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16891    }
16892    G__tag_memvar_reset();
16893 }
16894 
16895 
16896    /* TProofSuperMaster */
16897 static void G__setup_memvarTProofSuperMaster(void) {
16898    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofSuperMaster));
16899    { TProofSuperMaster *p; p=(TProofSuperMaster*)0x1000; if (p) { }
16900    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
16901    }
16902    G__tag_memvar_reset();
16903 }
16904 
16905 extern "C" void G__cpp_setup_memvarG__Proof() {
16906 }
16907 /***********************************************************
16908 ************************************************************
16909 ************************************************************
16910 ************************************************************
16911 ************************************************************
16912 ************************************************************
16913 ************************************************************
16914 ***********************************************************/
16915 
16916 /*********************************************************
16917 * Member function information setup for each class
16918 *********************************************************/
16919 static void G__setup_memfuncTCondorSlave(void) {
16920    /* TCondorSlave */
16921    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TCondorSlave));
16922    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);
16923    G__memfunc_setup("Class",502,G__G__Proof_110_0_2, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TCondorSlave::Class) ), 0);
16924    G__memfunc_setup("Class_Name",982,G__G__Proof_110_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCondorSlave::Class_Name) ), 0);
16925    G__memfunc_setup("Class_Version",1339,G__G__Proof_110_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TCondorSlave::Class_Version) ), 0);
16926    G__memfunc_setup("Dictionary",1046,G__G__Proof_110_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCondorSlave::Dictionary) ), 0);
16927    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16928    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
16929    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
16930    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_110_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
16931    G__memfunc_setup("DeclFileName",1145,G__G__Proof_110_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCondorSlave::DeclFileName) ), 0);
16932    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_110_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCondorSlave::ImplFileLine) ), 0);
16933    G__memfunc_setup("ImplFileName",1171,G__G__Proof_110_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCondorSlave::ImplFileName) ), 0);
16934    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_110_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCondorSlave::DeclFileLine) ), 0);
16935    // automatic default constructor
16936    G__memfunc_setup("TCondorSlave", 1204, G__G__Proof_110_0_14, (int) ('i'), G__get_linked_tagnum(&G__G__ProofLN_TCondorSlave), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16937    // automatic copy constructor
16938    G__memfunc_setup("TCondorSlave", 1204, G__G__Proof_110_0_15, (int) ('i'), G__get_linked_tagnum(&G__G__ProofLN_TCondorSlave), -1, 0, 1, 1, 1, 0, "u 'TCondorSlave' - 11 - -", (char*) NULL, (void*) NULL, 0);
16939    // automatic destructor
16940    G__memfunc_setup("~TCondorSlave", 1330, G__G__Proof_110_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
16941    // automatic assignment operator
16942    G__memfunc_setup("operator=", 937, G__G__Proof_110_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__ProofLN_TCondorSlave), -1, 1, 1, 1, 1, 0, "u 'TCondorSlave' - 11 - -", (char*) NULL, (void*) NULL, 0);
16943    G__tag_memfunc_reset();
16944 }
16945 
16946 static void G__setup_memfuncTCondor(void) {
16947    /* TCondor */
16948    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TCondor));
16949    G__memfunc_setup("ClaimVM",649,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TCondorSlave), -1, 0, 2, 1, 2, 0, 
16950 "C - - 10 - vm C - - 10 - cmd", (char*)NULL, (void*) NULL, 0);
16951    G__memfunc_setup("TCondor",697,G__G__Proof_111_0_2, 105, G__get_linked_tagnum(&G__G__ProofLN_TCondor), -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' pool", (char*)NULL, (void*) NULL, 0);
16952    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);
16953    G__memfunc_setup("IsValid",684,G__G__Proof_111_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16954    G__memfunc_setup("GetVirtualMachines",1839,G__G__Proof_111_0_5, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16955    G__memfunc_setup("Claim",486,G__G__Proof_111_0_6, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 2, 1, 1, 0, 
16956 "i - 'Int_t' 0 - n C - - 10 - cmd", (char*)NULL, (void*) NULL, 0);
16957    G__memfunc_setup("Claim",486,G__G__Proof_111_0_7, 85, G__get_linked_tagnum(&G__G__ProofLN_TCondorSlave), -1, 0, 2, 1, 1, 0, 
16958 "C - - 10 - vmname C - - 10 - cmd", (char*)NULL, (void*) NULL, 0);
16959    G__memfunc_setup("SetState",813,G__G__Proof_111_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "i 'TCondor::EState' - 0 - state", (char*)NULL, (void*) NULL, 0);
16960    G__memfunc_setup("GetState",801,G__G__Proof_111_0_9, 105, G__get_linked_tagnum(&G__G__ProofLN_TCondorcLcLEState), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
16961    G__memfunc_setup("Suspend",738,G__G__Proof_111_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16962    G__memfunc_setup("Resume",625,G__G__Proof_111_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16963    G__memfunc_setup("Release",705,G__G__Proof_111_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
16964    G__memfunc_setup("GetVmInfo",879,G__G__Proof_111_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 8, 
16965 "C - - 10 - vm u 'TString' - 1 - image "
16966 "i - 'Int_t' 1 - perfidx", (char*)NULL, (void*) NULL, 0);
16967    G__memfunc_setup("GetImage",771,G__G__Proof_111_0_14, 117, G__get_linked_tagnum(&G__G__ProofLN_TString), -1, 0, 1, 1, 1, 8, "C - - 10 - host", (char*)NULL, (void*) NULL, 0);
16968    G__memfunc_setup("Class",502,G__G__Proof_111_0_15, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TCondor::Class) ), 0);
16969    G__memfunc_setup("Class_Name",982,G__G__Proof_111_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCondor::Class_Name) ), 0);
16970    G__memfunc_setup("Class_Version",1339,G__G__Proof_111_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TCondor::Class_Version) ), 0);
16971    G__memfunc_setup("Dictionary",1046,G__G__Proof_111_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TCondor::Dictionary) ), 0);
16972    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
16973    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
16974    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
16975    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_111_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
16976    G__memfunc_setup("DeclFileName",1145,G__G__Proof_111_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCondor::DeclFileName) ), 0);
16977    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_111_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCondor::ImplFileLine) ), 0);
16978    G__memfunc_setup("ImplFileName",1171,G__G__Proof_111_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TCondor::ImplFileName) ), 0);
16979    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_111_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TCondor::DeclFileLine) ), 0);
16980    // automatic copy constructor
16981    G__memfunc_setup("TCondor", 697, G__G__Proof_111_0_27, (int) ('i'), G__get_linked_tagnum(&G__G__ProofLN_TCondor), -1, 0, 1, 1, 1, 0, "u 'TCondor' - 11 - -", (char*) NULL, (void*) NULL, 0);
16982    // automatic destructor
16983    G__memfunc_setup("~TCondor", 823, G__G__Proof_111_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
16984    // automatic assignment operator
16985    G__memfunc_setup("operator=", 937, G__G__Proof_111_0_29, (int) ('u'), G__get_linked_tagnum(&G__G__ProofLN_TCondor), -1, 1, 1, 1, 1, 0, "u 'TCondor' - 11 - -", (char*) NULL, (void*) NULL, 0);
16986    G__tag_memfunc_reset();
16987 }
16988 
16989 static void G__setup_memfuncTDataSetManager(void) {
16990    /* TDataSetManager */
16991    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TDataSetManager));
16992    G__memfunc_setup("TDataSetManager",1461,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofLN_TDataSetManager), -1, 0, 1, 1, 4, 0, "u 'TDataSetManager' - 11 - -", "not implemented", (void*) NULL, 0);
16993    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__ProofLN_TDataSetManager), -1, 1, 1, 1, 4, 0, "u 'TDataSetManager' - 11 - -", "not implemented", (void*) NULL, 0);
16994    G__memfunc_setup("GetGroupUsedMap",1500,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TMap), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
16995    G__memfunc_setup("GetUserUsedMap",1390,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TMap), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
16996    G__memfunc_setup("GetNTouchedFiles",1581,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
16997    G__memfunc_setup("GetNOpenedFiles",1468,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
16998    G__memfunc_setup("GetNDisapparedFiles",1886,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
16999    G__memfunc_setup("GetQuota",810,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
17000 "C - - 10 - group C - - 10 - user "
17001 "C - - 10 - dsName U 'TFileCollection' - 0 - dataset", (char*)NULL, (void*) NULL, 0);
17002    G__memfunc_setup("PrintDataSet",1203,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
17003 "U 'TFileCollection' - 0 - fc i - 'Int_t' 0 '0' popt", (char*)NULL, (void*) NULL, 0);
17004    G__memfunc_setup("PrintUsedSpace",1418,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
17005    G__memfunc_setup("ReadGroupConfig",1503,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "C - - 10 '0' cf", (char*)NULL, (void*) NULL, 0);
17006    G__memfunc_setup("UpdateUsedSpace",1504,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
17007    G__memfunc_setup("ToBytes",714,(G__InterfaceMethod) NULL, 110, -1, G__defined_typename("Long64_t"), 0, 1, 3, 2, 0, "C - - 10 '0' size", (char*)NULL, (void*) NULL, 0);
17008    G__memfunc_setup("TDataSetManager",1461,G__G__Proof_132_0_14, 105, G__get_linked_tagnum(&G__G__ProofLN_TDataSetManager), -1, 0, 3, 1, 1, 0, 
17009 "C - - 10 '0' group C - - 10 '0' user "
17010 "C - - 10 '0' options", (char*)NULL, (void*) NULL, 0);
17011    G__memfunc_setup("ClearCache",955,G__G__Proof_132_0_15, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - uri", (char*)NULL, (void*) NULL, 1);
17012    G__memfunc_setup("GetAvgFileSize",1369,G__G__Proof_132_0_16, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
17013    G__memfunc_setup("GetDataSet",966,G__G__Proof_132_0_17, 85, G__get_linked_tagnum(&G__G__ProofLN_TFileCollection), -1, 0, 2, 1, 1, 0, 
17014 "C - - 10 - uri C - - 10 '0' server", (char*)NULL, (void*) NULL, 1);
17015    G__memfunc_setup("GetDataSets",1081,G__G__Proof_132_0_18, 85, G__get_linked_tagnum(&G__G__ProofLN_TMap), -1, 0, 2, 1, 1, 0, 
17016 "C - - 10 - uri h - 'UInt_t' 0 'TDataSetManager::kExport' -", (char*)NULL, (void*) NULL, 1);
17017    G__memfunc_setup("GetSubDataSets",1379,G__G__Proof_132_0_19, 85, G__get_linked_tagnum(&G__G__ProofLN_TMap), -1, 0, 2, 1, 1, 0, 
17018 "C - - 10 - uri C - - 10 - excludeservers", (char*)NULL, (void*) NULL, 1);
17019    G__memfunc_setup("GetGroupQuota",1335,G__G__Proof_132_0_20, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "C - - 10 - group", (char*)NULL, (void*) NULL, 1);
17020    G__memfunc_setup("GetGroupQuotaMap",1621,G__G__Proof_132_0_21, 85, G__get_linked_tagnum(&G__G__ProofLN_TMap), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17021    G__memfunc_setup("GetGroupUsed",1214,G__G__Proof_132_0_22, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "C - - 10 - group", (char*)NULL, (void*) NULL, 1);
17022    G__memfunc_setup("ExistsDataSet",1318,G__G__Proof_132_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - uri", (char*)NULL, (void*) NULL, 1);
17023    G__memfunc_setup("MonitorUsedSpace",1637,G__G__Proof_132_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TVirtualMonitoringWriter' - 0 - monitoring", (char*)NULL, (void*) NULL, 1);
17024    G__memfunc_setup("NotifyUpdate",1244,G__G__Proof_132_0_25, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
17025 "C - - 10 '0' group C - - 10 '0' user "
17026 "C - - 10 '0' dspath l - 'Long_t' 0 '0' mtime "
17027 "C - - 10 '0' checksum", (char*)NULL, (void*) NULL, 1);
17028    G__memfunc_setup("ParseUri",811,G__G__Proof_132_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 7, 1, 1, 0, 
17029 "C - - 10 - uri U 'TString' - 0 '0' dsGroup "
17030 "U 'TString' - 0 '0' dsUser U 'TString' - 0 '0' dsName "
17031 "U 'TString' - 0 '0' dsTree g - 'Bool_t' 0 'kFALSE' onlyCurrent "
17032 "g - 'Bool_t' 0 'kFALSE' wildcards", (char*)NULL, (void*) NULL, 0);
17033    G__memfunc_setup("ParseInitOpts",1333,G__G__Proof_132_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - opts", (char*)NULL, (void*) NULL, 1);
17034    G__memfunc_setup("RemoveDataSet",1300,G__G__Proof_132_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - uri", (char*)NULL, (void*) NULL, 1);
17035    G__memfunc_setup("RegisterDataSet",1515,G__G__Proof_132_0_29, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
17036 "C - - 10 - uri U 'TFileCollection' - 0 - dataSet "
17037 "C - - 10 - opt", (char*)NULL, (void*) NULL, 1);
17038    G__memfunc_setup("ScanDataSet",1067,G__G__Proof_132_0_30, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17039 "C - - 10 - uri C - - 10 - opt", (char*)NULL, (void*) NULL, 0);
17040    G__memfunc_setup("ScanDataSet",1067,G__G__Proof_132_0_31, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17041 "C - - 10 - uri h - 'UInt_t' 0 'kReopen|kDebug' option", (char*)NULL, (void*) NULL, 1);
17042    G__memfunc_setup("SetScanCounters",1540,G__G__Proof_132_0_32, 121, -1, -1, 0, 3, 1, 1, 0, 
17043 "i - 'Int_t' 0 '-1' t i - 'Int_t' 0 '-1' o "
17044 "i - 'Int_t' 0 '-1' d", (char*)NULL, (void*) NULL, 0);
17045    G__memfunc_setup("ShowCache",885,G__G__Proof_132_0_33, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - uri", (char*)NULL, (void*) NULL, 1);
17046    G__memfunc_setup("ShowQuota",939,G__G__Proof_132_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - opt", (char*)NULL, (void*) NULL, 1);
17047    G__memfunc_setup("ShowDataSets",1210,G__G__Proof_132_0_35, 121, -1, -1, 0, 2, 1, 1, 0, 
17048 "C - - 10 '\"*\"' uri C - - 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
17049    G__memfunc_setup("CreateUri",900,G__G__Proof_132_0_36, 117, G__get_linked_tagnum(&G__G__ProofLN_TString), -1, 0, 4, 3, 1, 0, 
17050 "C - - 10 '0' dsGroup C - - 10 '0' dsUser "
17051 "C - - 10 '0' dsName C - - 10 '0' dsTree", (char*)NULL, (void*) G__func2void( (TString (*)(const char*, const char*, const char*, const char*))(&TDataSetManager::CreateUri) ), 0);
17052    G__memfunc_setup("CheckDataSetSrvMaps",1872,G__G__Proof_132_0_37, 103, -1, G__defined_typename("Bool_t"), 0, 3, 3, 1, 0, 
17053 "U 'TUrl' - 0 - furl u 'TString' - 1 - fn "
17054 "U 'TList' - 0 '0' srvmaplist", (char*)NULL, (void*) G__func2void( (Bool_t (*)(TUrl*, TString&, TList*))(&TDataSetManager::CheckDataSetSrvMaps) ), 0);
17055    G__memfunc_setup("GetDataSetSrvMaps",1682,G__G__Proof_132_0_38, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TList* (*)())(&TDataSetManager::GetDataSetSrvMaps) ), 0);
17056    G__memfunc_setup("ParseDataSetSrvMaps",1901,G__G__Proof_132_0_39, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 1, 3, 1, 0, "u 'TString' - 11 - srvmaps", (char*)NULL, (void*) G__func2void( (TList* (*)(const TString&))(&TDataSetManager::ParseDataSetSrvMaps) ), 0);
17057    G__memfunc_setup("ScanDataSet",1067,G__G__Proof_132_0_40, 105, -1, G__defined_typename("Int_t"), 0, 13, 3, 1, 0, 
17058 "U 'TFileCollection' - 0 - dataset i - 'Int_t' 0 - fopt "
17059 "i - 'Int_t' 0 '0' sopt i - 'Int_t' 0 '0' ropt "
17060 "g - 'Bool_t' 0 'kFALSE' dbg I - 'Int_t' 0 '0' touched "
17061 "I - 'Int_t' 0 '0' opened I - 'Int_t' 0 '0' disappeared "
17062 "U 'TList' - 0 '0' flist n - 'Long64_t' 0 '-1' avgsz "
17063 "C - - 10 '0' mss i - 'Int_t' 0 '-1' maxfiles "
17064 "C - - 10 '0' stageopts", (char*)NULL, (void*) G__func2void( (Int_t (*)(TFileCollection*, Int_t, Int_t, Int_t, Bool_t, Int_t*, Int_t*, Int_t*, TList*, Long64_t, const char*, Int_t, const char*))(&TDataSetManager::ScanDataSet) ), 0);
17065    G__memfunc_setup("ScanFile",773,G__G__Proof_132_0_41, 105, -1, G__defined_typename("Int_t"), 0, 2, 3, 1, 0, 
17066 "U 'TFileInfo' - 0 - fileinfo g - 'Bool_t' 0 - notify", (char*)NULL, (void*) G__func2void( (Int_t (*)(TFileInfo*, Bool_t))(&TDataSetManager::ScanFile) ), 0);
17067    G__memfunc_setup("FillMetaData",1160,G__G__Proof_132_0_42, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 1, 0, 
17068 "U 'TFileInfo' - 0 - fi U 'TDirectory' - 0 - d "
17069 "C - - 10 '\"/\"' rdir", (char*)NULL, (void*) G__func2void( (Int_t (*)(TFileInfo*, TDirectory*, const char*))(&TDataSetManager::FillMetaData) ), 0);
17070    G__memfunc_setup("Class",502,G__G__Proof_132_0_43, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDataSetManager::Class) ), 0);
17071    G__memfunc_setup("Class_Name",982,G__G__Proof_132_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDataSetManager::Class_Name) ), 0);
17072    G__memfunc_setup("Class_Version",1339,G__G__Proof_132_0_45, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDataSetManager::Class_Version) ), 0);
17073    G__memfunc_setup("Dictionary",1046,G__G__Proof_132_0_46, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDataSetManager::Dictionary) ), 0);
17074    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
17075    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
17076    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
17077    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_132_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
17078    G__memfunc_setup("DeclFileName",1145,G__G__Proof_132_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDataSetManager::DeclFileName) ), 0);
17079    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_132_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDataSetManager::ImplFileLine) ), 0);
17080    G__memfunc_setup("ImplFileName",1171,G__G__Proof_132_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDataSetManager::ImplFileName) ), 0);
17081    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_132_0_54, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDataSetManager::DeclFileLine) ), 0);
17082    // automatic destructor
17083    G__memfunc_setup("~TDataSetManager", 1587, G__G__Proof_132_0_55, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
17084    G__tag_memfunc_reset();
17085 }
17086 
17087 static void G__setup_memfuncTDataSetManagerFile(void) {
17088    /* TDataSetManagerFile */
17089    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagerFile));
17090    G__memfunc_setup("InitLocalCache",1363,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
17091    G__memfunc_setup("CheckLocalCache",1437,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 4, 0, 
17092 "C - - 10 - group C - - 10 - user "
17093 "C - - 10 '\"ls\"' dsName h - 'UInt_t' 0 '0' option", (char*)NULL, (void*) NULL, 0);
17094    G__memfunc_setup("GetDataSetPath",1363,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 3, 1, 2, 1, 
17095 "C - - 10 - group C - - 10 - user "
17096 "C - - 10 - dsName", (char*)NULL, (void*) NULL, 0);
17097    G__memfunc_setup("GetDataSetPath",1363,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 5, 1, 2, 1, 
17098 "C - - 10 - group C - - 10 - user "
17099 "C - - 10 - dsName u 'TString' - 1 - md5path "
17100 "g - 'Bool_t' 0 'kFALSE' local", (char*)NULL, (void*) NULL, 0);
17101    G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
17102    G__memfunc_setup("BrowseDataSets",1419,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 5, 1, 2, 0, 
17103 "C - - 10 - group C - - 10 - user "
17104 "C - - 10 - dsName h - 'UInt_t' 0 - option "
17105 "U 'TObject' - 0 - target", (char*)NULL, (void*) NULL, 0);
17106    G__memfunc_setup("RemoveDataSet",1300,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 2, 0, 
17107 "C - - 10 - group C - - 10 - user "
17108 "C - - 10 - dsName", (char*)NULL, (void*) NULL, 0);
17109    G__memfunc_setup("ExistsDataSet",1318,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 2, 0, 
17110 "C - - 10 - group C - - 10 - user "
17111 "C - - 10 - dsName", (char*)NULL, (void*) NULL, 0);
17112    G__memfunc_setup("ScanDataSet",1067,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 2, 0, 
17113 "C - - 10 - group C - - 10 - user "
17114 "C - - 10 - dsName h - 'UInt_t' 0 'kReopen|kDebug' option", (char*)NULL, (void*) NULL, 0);
17115    G__memfunc_setup("ChecksumDataSet",1497,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 0, 
17116 "C - - 10 - path C - - 10 - md5path "
17117 "u 'TString' - 1 - checksum", (char*)NULL, (void*) NULL, 0);
17118    G__memfunc_setup("CreateLsFile",1171,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 2, 0, 
17119 "C - - 10 - group C - - 10 - user "
17120 "l - 'Long_t' 1 - mtime u 'TString' - 1 - checksum", (char*)NULL, (void*) NULL, 0);
17121    G__memfunc_setup("FillLsDataSet",1260,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 2, 0, 
17122 "C - - 10 - group C - - 10 - user "
17123 "C - - 10 - dsName U 'TList' - 0 - out "
17124 "h - 'UInt_t' 0 - option", (char*)NULL, (void*) NULL, 0);
17125    G__memfunc_setup("UpdateUsedSpace",1504,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
17126    G__memfunc_setup("TDataSetManagerFile",1845,G__G__Proof_135_0_14, 105, G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagerFile), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17127    G__memfunc_setup("TDataSetManagerFile",1845,G__G__Proof_135_0_15, 105, G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagerFile), -1, 0, 3, 1, 1, 0, 
17128 "C - - 10 - group C - - 10 - user "
17129 "C - - 10 - ins", (char*)NULL, (void*) NULL, 0);
17130    G__memfunc_setup("TDataSetManagerFile",1845,G__G__Proof_135_0_16, 105, G__get_linked_tagnum(&G__G__ProofLN_TDataSetManagerFile), -1, 0, 1, 1, 1, 0, "C - - 10 - ins", (char*)NULL, (void*) NULL, 0);
17131    G__memfunc_setup("ParseInitOpts",1333,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - opts", (char*)NULL, (void*) NULL, 1);
17132    G__memfunc_setup("ClearCache",955,G__G__Proof_135_0_18, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 '0' uri", (char*)NULL, (void*) NULL, 1);
17133    G__memfunc_setup("GetDataSet",966,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TFileCollection), -1, 0, 2, 1, 1, 0, 
17134 "C - - 10 - uri C - - 10 '0' srv", (char*)NULL, (void*) NULL, 1);
17135    G__memfunc_setup("GetDataSets",1081,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TMap), -1, 0, 2, 1, 1, 0, 
17136 "C - - 10 - uri h - 'UInt_t' 0 'TDataSetManager::kExport' option", (char*)NULL, (void*) NULL, 1);
17137    G__memfunc_setup("ExistsDataSet",1318,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - uri", (char*)NULL, (void*) NULL, 1);
17138    G__memfunc_setup("RemoveDataSet",1300,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - uri", (char*)NULL, (void*) NULL, 1);
17139    G__memfunc_setup("RegisterDataSet",1515,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
17140 "C - - 10 - uri U 'TFileCollection' - 0 - dataSet "
17141 "C - - 10 - opt", (char*)NULL, (void*) NULL, 1);
17142    G__memfunc_setup("ScanDataSet",1067,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17143 "C - - 10 - uri h - 'UInt_t' 0 'kReopen|kDebug' option", (char*)NULL, (void*) NULL, 1);
17144    G__memfunc_setup("NotifyUpdate",1244,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
17145 "C - - 10 - group C - - 10 - user "
17146 "C - - 10 - dspath l - 'Long_t' 0 - mtime "
17147 "C - - 10 '0' checksum", (char*)NULL, (void*) NULL, 1);
17148    G__memfunc_setup("ShowCache",885,G__G__Proof_135_0_26, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 '0' uri", (char*)NULL, (void*) NULL, 1);
17149    G__memfunc_setup("GetDataSet",966,G__G__Proof_135_0_27, 85, G__get_linked_tagnum(&G__G__ProofLN_TFileCollection), -1, 0, 5, 1, 1, 0, 
17150 "C - - 10 - group C - - 10 - user "
17151 "C - - 10 - dsName h - 'UInt_t' 0 '0' option "
17152 "U 'TMD5' - 2 '0' checksum", (char*)NULL, (void*) NULL, 0);
17153    G__memfunc_setup("GetDataSets",1081,G__G__Proof_135_0_28, 85, G__get_linked_tagnum(&G__G__ProofLN_TMap), -1, 0, 4, 1, 1, 0, 
17154 "C - - 10 - group C - - 10 - user "
17155 "C - - 10 '0' dsName h - 'UInt_t' 0 '0' option", (char*)NULL, (void*) NULL, 0);
17156    G__memfunc_setup("GetMSSUrl",838,G__G__Proof_135_0_29, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
17157    G__memfunc_setup("GetStageOpts",1210,G__G__Proof_135_0_30, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
17158    G__memfunc_setup("WriteDataSet",1201,G__G__Proof_135_0_31, 105, -1, G__defined_typename("Int_t"), 0, 6, 1, 1, 0, 
17159 "C - - 10 - group C - - 10 - user "
17160 "C - - 10 - dsName U 'TFileCollection' - 0 - dataset "
17161 "h - 'UInt_t' 0 '0' option U 'TMD5' - 0 '0' checksum", (char*)NULL, (void*) NULL, 0);
17162    G__memfunc_setup("Class",502,G__G__Proof_135_0_32, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDataSetManagerFile::Class) ), 0);
17163    G__memfunc_setup("Class_Name",982,G__G__Proof_135_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDataSetManagerFile::Class_Name) ), 0);
17164    G__memfunc_setup("Class_Version",1339,G__G__Proof_135_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDataSetManagerFile::Class_Version) ), 0);
17165    G__memfunc_setup("Dictionary",1046,G__G__Proof_135_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDataSetManagerFile::Dictionary) ), 0);
17166    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
17167    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
17168    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
17169    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_135_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
17170    G__memfunc_setup("DeclFileName",1145,G__G__Proof_135_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDataSetManagerFile::DeclFileName) ), 0);
17171    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_135_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDataSetManagerFile::ImplFileLine) ), 0);
17172    G__memfunc_setup("ImplFileName",1171,G__G__Proof_135_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDataSetManagerFile::ImplFileName) ), 0);
17173    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_135_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDataSetManagerFile::DeclFileLine) ), 0);
17174    // automatic destructor
17175    G__memfunc_setup("~TDataSetManagerFile", 1971, G__G__Proof_135_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
17176    G__tag_memfunc_reset();
17177 }
17178 
17179 static void G__setup_memfuncTDSet(void) {
17180    /* TDSet */
17181    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TDSet));
17182    G__memfunc_setup("SplitEntryList",1466,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", "Split entry list between elements", (void*) NULL, 0);
17183    G__memfunc_setup("TDSet",452,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofLN_TDSet), -1, 0, 1, 1, 4, 0, "u 'TDSet' - 11 - -", "not implemented", (void*) NULL, 0);
17184    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TDSet' - 11 - -", "not implemented", (void*) NULL, 0);
17185    G__memfunc_setup("TDSet",452,G__G__Proof_138_0_4, 105, G__get_linked_tagnum(&G__G__ProofLN_TDSet), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17186    G__memfunc_setup("TDSet",452,G__G__Proof_138_0_5, 105, G__get_linked_tagnum(&G__G__ProofLN_TDSet), -1, 0, 4, 1, 1, 0, 
17187 "C - - 10 - name C - - 10 '\"*\"' objname "
17188 "C - - 10 '\"/\"' dir C - - 10 '0' type", (char*)NULL, (void*) NULL, 0);
17189    G__memfunc_setup("TDSet",452,G__G__Proof_138_0_6, 105, G__get_linked_tagnum(&G__G__ProofLN_TDSet), -1, 0, 2, 1, 1, 0, 
17190 "u 'TChain' - 11 - chain g - 'Bool_t' 0 'kTRUE' withfriends", (char*)NULL, (void*) NULL, 0);
17191    G__memfunc_setup("Add",265,G__G__Proof_138_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 6, 1, 1, 0, 
17192 "C - - 10 - file C - - 10 '0' objname "
17193 "C - - 10 '0' dir n - 'Long64_t' 0 '0' first "
17194 "n - 'Long64_t' 0 '-1' num C - - 10 '0' msd", (char*)NULL, (void*) NULL, 1);
17195    G__memfunc_setup("Add",265,G__G__Proof_138_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TDSet' - 0 - set", (char*)NULL, (void*) NULL, 1);
17196    G__memfunc_setup("Add",265,G__G__Proof_138_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 0, 
17197 "U 'TCollection' - 0 - fileinfo C - - 10 '0' meta "
17198 "g - 'Bool_t' 0 'kFALSE' availableOnly U 'TCollection' - 0 '0' badlist", (char*)NULL, (void*) NULL, 1);
17199    G__memfunc_setup("Add",265,G__G__Proof_138_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
17200 "U 'TFileInfo' - 0 - fileinfo C - - 10 '0' meta", (char*)NULL, (void*) NULL, 1);
17201    G__memfunc_setup("AddFriend",865,G__G__Proof_138_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
17202 "U 'TDSet' - 0 - friendset C - - 10 - alias", (char*)NULL, (void*) NULL, 1);
17203    G__memfunc_setup("Process",735,G__G__Proof_138_0_12, 110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
17204 "C - - 10 - selector C - 'Option_t' 10 '\"\"' option "
17205 "n - 'Long64_t' 0 '-1' nentries n - 'Long64_t' 0 '0' firstentry "
17206 "U 'TObject' - 0 '0' enl", "*MENU*", (void*) NULL, 1);
17207    G__memfunc_setup("Draw",398,G__G__Proof_138_0_13, 110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
17208 "C - - 10 - varexp C - - 10 - selection "
17209 "C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
17210 "n - 'Long64_t' 0 '0' firstentry", "*MENU*", (void*) NULL, 1);
17211    G__memfunc_setup("Draw",398,G__G__Proof_138_0_14, 110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
17212 "C - - 10 - varexp u 'TCut' - 11 - selection "
17213 "C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
17214 "n - 'Long64_t' 0 '0' firstentry", "*MENU*", (void*) NULL, 1);
17215    G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
17216    G__memfunc_setup("ExportFileList",1438,G__G__Proof_138_0_16, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17217 "C - - 10 - filepath C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
17218    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);
17219    G__memfunc_setup("SetObjName",968,G__G__Proof_138_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - objname", (char*)NULL, (void*) NULL, 0);
17220    G__memfunc_setup("SetDirectory",1249,G__G__Proof_138_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - dir", (char*)NULL, (void*) NULL, 0);
17221    G__memfunc_setup("IsTree",588,G__G__Proof_138_0_20, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17222    G__memfunc_setup("IsValid",684,G__G__Proof_138_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17223    G__memfunc_setup("ElementsValid",1325,G__G__Proof_138_0_22, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17224    G__memfunc_setup("GetType",706,G__G__Proof_138_0_23, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
17225    G__memfunc_setup("GetObjName",956,G__G__Proof_138_0_24, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
17226    G__memfunc_setup("GetDirectory",1237,G__G__Proof_138_0_25, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
17227    G__memfunc_setup("GetListOfElements",1710,G__G__Proof_138_0_26, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17228    G__memfunc_setup("GetNumOfFiles",1272,G__G__Proof_138_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17229    G__memfunc_setup("Remove",622,G__G__Proof_138_0_28, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17230 "U 'TDSetElement' - 0 - elem g - 'Bool_t' 0 'kTRUE' deleteElem", (char*)NULL, (void*) NULL, 0);
17231    G__memfunc_setup("Reset",515,G__G__Proof_138_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17232    G__memfunc_setup("Next",415,G__G__Proof_138_0_30, 85, G__get_linked_tagnum(&G__G__ProofLN_TDSetElement), -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 '-1' totalEntries", (char*)NULL, (void*) NULL, 1);
17233    G__memfunc_setup("Current",739,G__G__Proof_138_0_31, 85, G__get_linked_tagnum(&G__G__ProofLN_TDSetElement), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17234    G__memfunc_setup("GetEntries",1018,G__G__Proof_138_0_32, 110, -1, G__defined_typename("Long64_t"), 0, 4, 3, 1, 0, 
17235 "g - 'Bool_t' 0 - isTree C - - 10 - filename "
17236 "C - - 10 - path u 'TString' - 1 - objname", (char*)NULL, (void*) G__func2void( (Long64_t (*)(Bool_t, const char*, const char*, TString&))(&TDSet::GetEntries) ), 0);
17237    G__memfunc_setup("AddInput",793,G__G__Proof_138_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
17238    G__memfunc_setup("ClearInput",1015,G__G__Proof_138_0_34, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17239    G__memfunc_setup("GetOutput",945,G__G__Proof_138_0_35, 85, G__get_linked_tagnum(&G__G__ProofLN_TObject), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
17240    G__memfunc_setup("GetOutputList",1357,G__G__Proof_138_0_36, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17241    G__memfunc_setup("StartViewer",1152,G__G__Proof_138_0_37, 121, -1, -1, 0, 0, 1, 1, 0, "", "*MENU*", (void*) NULL, 1);
17242    G__memfunc_setup("GetTreeHeader",1273,G__G__Proof_138_0_38, 85, G__get_linked_tagnum(&G__G__ProofLN_TTree), -1, 0, 1, 1, 1, 0, "U 'TProof' - 0 - proof", (char*)NULL, (void*) NULL, 1);
17243    G__memfunc_setup("SetEntryList",1242,G__G__Proof_138_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - aList", (char*)NULL, (void*) NULL, 1);
17244    G__memfunc_setup("GetEntryList",1230,G__G__Proof_138_0_40, 85, G__get_linked_tagnum(&G__G__ProofLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17245    G__memfunc_setup("Validate",810,G__G__Proof_138_0_41, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17246    G__memfunc_setup("Validate",810,G__G__Proof_138_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDSet' - 0 - dset", (char*)NULL, (void*) NULL, 0);
17247    G__memfunc_setup("Lookup",634,G__G__Proof_138_0_43, 121, -1, -1, 0, 2, 1, 1, 0, 
17248 "g - 'Bool_t' 0 'kFALSE' removeMissing U 'TList' - 2 '0' missingFiles", (char*)NULL, (void*) NULL, 0);
17249    G__memfunc_setup("SetLookedUp",1103,G__G__Proof_138_0_44, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17250    G__memfunc_setup("SetSrvMaps",1016,G__G__Proof_138_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 '0' srvmaps", (char*)NULL, (void*) NULL, 0);
17251    G__memfunc_setup("SetWriteV3",960,G__G__Proof_138_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 0);
17252    G__memfunc_setup("Class",502,G__G__Proof_138_0_47, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDSet::Class) ), 0);
17253    G__memfunc_setup("Class_Name",982,G__G__Proof_138_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDSet::Class_Name) ), 0);
17254    G__memfunc_setup("Class_Version",1339,G__G__Proof_138_0_49, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDSet::Class_Version) ), 0);
17255    G__memfunc_setup("Dictionary",1046,G__G__Proof_138_0_50, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDSet::Dictionary) ), 0);
17256    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
17257    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
17258    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
17259    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_138_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
17260    G__memfunc_setup("DeclFileName",1145,G__G__Proof_138_0_55, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDSet::DeclFileName) ), 0);
17261    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_138_0_56, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDSet::ImplFileLine) ), 0);
17262    G__memfunc_setup("ImplFileName",1171,G__G__Proof_138_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDSet::ImplFileName) ), 0);
17263    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_138_0_58, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDSet::DeclFileLine) ), 0);
17264    // automatic destructor
17265    G__memfunc_setup("~TDSet", 578, G__G__Proof_138_0_59, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
17266    G__tag_memfunc_reset();
17267 }
17268 
17269 static void G__setup_memfuncTProof(void) {
17270    /* TProof */
17271    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TProof));
17272    G__memfunc_setup("TProof",602,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofLN_TProof), -1, 0, 1, 1, 4, 0, "u 'TProof' - 11 - -", "not implemented", (void*) NULL, 0);
17273    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TProof' - 11 - -", "idem", (void*) NULL, 0);
17274    G__memfunc_setup("CleanGDirectory",1503,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TList' - 0 - ol", (char*)NULL, (void*) NULL, 0);
17275    G__memfunc_setup("Exec",389,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
17276 "C - - 10 - cmd i 'TProof::ESlaves' - 0 - list "
17277 "g - 'Bool_t' 0 - plusMaster", (char*)NULL, (void*) NULL, 0);
17278    G__memfunc_setup("SendCommand",1097,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
17279 "C - - 10 - cmd i 'TProof::ESlaves' - 0 'kActive' list", (char*)NULL, (void*) NULL, 0);
17280    G__memfunc_setup("SendCurrentState",1646,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "i 'TProof::ESlaves' - 0 'kActive' list", (char*)NULL, (void*) NULL, 0);
17281    G__memfunc_setup("CheckFile",862,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 4, 0, 
17282 "C - - 10 - file U 'TSlave' - 0 - sl "
17283 "l - 'Long_t' 0 - modtime i - 'Int_t' 0 '(kCp|kCpBin)' cpopt", (char*)NULL, (void*) NULL, 0);
17284    G__memfunc_setup("SendObject",993,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
17285 "U 'TObject' - 10 - obj i 'TProof::ESlaves' - 0 'kActive' list", (char*)NULL, (void*) NULL, 0);
17286    G__memfunc_setup("SendGroupView",1330,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
17287    G__memfunc_setup("SendInitialState",1621,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
17288    G__memfunc_setup("SendPrint",919,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
17289    G__memfunc_setup("Ping",398,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "i 'TProof::ESlaves' - 0 - list", (char*)NULL, (void*) NULL, 0);
17290    G__memfunc_setup("Interrupt",973,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
17291 "i 'TProof::EUrgent' - 0 - type i 'TProof::ESlaves' - 0 'kActive' list", (char*)NULL, (void*) NULL, 0);
17292    G__memfunc_setup("AskStatistics",1354,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
17293    G__memfunc_setup("AskParallel",1100,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
17294    G__memfunc_setup("GoParallel",995,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
17295 "i - 'Int_t' 0 - nodes g - 'Bool_t' 0 'kFALSE' accept "
17296 "g - 'Bool_t' 0 'kFALSE' random", (char*)NULL, (void*) NULL, 0);
17297    G__memfunc_setup("SetParallelSilent",1736,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
17298 "i - 'Int_t' 0 - nodes g - 'Bool_t' 0 'kFALSE' random", (char*)NULL, (void*) NULL, 0);
17299    G__memfunc_setup("RecvLogFile",1074,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
17300 "U 'TSocket' - 0 - s i - 'Int_t' 0 - size", (char*)NULL, (void*) NULL, 0);
17301    G__memfunc_setup("NotifyLogMsg",1218,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
17302 "C - - 10 - msg C - - 10 '\"\\n\"' sfx", (char*)NULL, (void*) NULL, 0);
17303    G__memfunc_setup("BuildPackage",1180,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
17304 "C - - 10 - package i 'TProof::EBuildPackageOpt' - 0 'kBuildAll' opt", (char*)NULL, (void*) NULL, 0);
17305    G__memfunc_setup("BuildPackageOnClient",1976,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
17306 "C - - 10 - package i - 'Int_t' 0 '0' opt "
17307 "U 'TString' - 0 '0' path", (char*)NULL, (void*) NULL, 0);
17308    G__memfunc_setup("LoadPackage",1068,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
17309 "C - - 10 - package g - 'Bool_t' 0 'kFALSE' notOnClient "
17310 "U 'TList' - 0 '0' loadopts", (char*)NULL, (void*) NULL, 0);
17311    G__memfunc_setup("LoadPackageOnClient",1864,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
17312 "C - - 10 - package U 'TList' - 0 '0' loadopts", (char*)NULL, (void*) NULL, 0);
17313    G__memfunc_setup("UnloadPackage",1295,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "C - - 10 - package", (char*)NULL, (void*) NULL, 0);
17314    G__memfunc_setup("UnloadPackageOnClient",2091,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "C - - 10 - package", (char*)NULL, (void*) NULL, 0);
17315    G__memfunc_setup("UnloadPackages",1410,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
17316    G__memfunc_setup("UploadPackageOnClient",2093,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
17317 "C - - 10 - package i 'TProof::EUploadPackageOpt' - 0 - opt "
17318 "U 'TMD5' - 0 - md5", (char*)NULL, (void*) NULL, 0);
17319    G__memfunc_setup("DisablePackage",1376,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "C - - 10 - package", (char*)NULL, (void*) NULL, 0);
17320    G__memfunc_setup("DisablePackageOnClient",2172,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "C - - 10 - package", (char*)NULL, (void*) NULL, 0);
17321    G__memfunc_setup("DisablePackages",1491,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
17322    G__memfunc_setup("Activate",817,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TList' - 0 '0' slaves", (char*)NULL, (void*) NULL, 0);
17323    G__memfunc_setup("Broadcast",915,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
17324 "u 'TMessage' - 11 - mess U 'TList' - 0 - slaves", (char*)NULL, (void*) NULL, 0);
17325    G__memfunc_setup("Broadcast",915,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
17326 "u 'TMessage' - 11 - mess i 'TProof::ESlaves' - 0 'kActive' list", (char*)NULL, (void*) NULL, 0);
17327    G__memfunc_setup("Broadcast",915,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
17328 "C - - 10 - mess i - 'Int_t' 0 - kind "
17329 "U 'TList' - 0 - slaves", (char*)NULL, (void*) NULL, 0);
17330    G__memfunc_setup("Broadcast",915,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
17331 "C - - 10 - mess i - 'Int_t' 0 'kMESS_STRING' kind "
17332 "i 'TProof::ESlaves' - 0 'kActive' list", (char*)NULL, (void*) NULL, 0);
17333    G__memfunc_setup("Broadcast",915,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
17334 "i - 'Int_t' 0 - kind U 'TList' - 0 - slaves", (char*)NULL, (void*) NULL, 0);
17335    G__memfunc_setup("Broadcast",915,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
17336 "i - 'Int_t' 0 - kind i 'TProof::ESlaves' - 0 'kActive' list", (char*)NULL, (void*) NULL, 0);
17337    G__memfunc_setup("BroadcastFile",1299,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 4, 0, 
17338 "C - - 10 - file i - 'Int_t' 0 - opt "
17339 "C - - 10 - rfile U 'TList' - 0 - wrks", (char*)NULL, (void*) NULL, 0);
17340    G__memfunc_setup("BroadcastFile",1299,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 4, 0, 
17341 "C - - 10 - file i - 'Int_t' 0 - opt "
17342 "C - - 10 '0' rfile i 'TProof::ESlaves' - 0 'kAllUnique' list", (char*)NULL, (void*) NULL, 0);
17343    G__memfunc_setup("BroadcastGroupPriority",2306,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
17344 "C - - 10 - grp i - 'Int_t' 0 - priority "
17345 "i 'TProof::ESlaves' - 0 'kAllUnique' list", (char*)NULL, (void*) NULL, 0);
17346    G__memfunc_setup("BroadcastGroupPriority",2306,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
17347 "C - - 10 - grp i - 'Int_t' 0 - priority "
17348 "U 'TList' - 0 - workers", (char*)NULL, (void*) NULL, 0);
17349    G__memfunc_setup("BroadcastObject",1514,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
17350 "U 'TObject' - 10 - obj i - 'Int_t' 0 - kind "
17351 "U 'TList' - 0 - slaves", (char*)NULL, (void*) NULL, 0);
17352    G__memfunc_setup("BroadcastObject",1514,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
17353 "U 'TObject' - 10 - obj i - 'Int_t' 0 'kMESS_OBJECT' kind "
17354 "i 'TProof::ESlaves' - 0 'kActive' list", (char*)NULL, (void*) NULL, 0);
17355    G__memfunc_setup("BroadcastRaw",1213,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
17356 "Y - - 10 - buffer i - 'Int_t' 0 - length "
17357 "U 'TList' - 0 - slaves", (char*)NULL, (void*) NULL, 0);
17358    G__memfunc_setup("BroadcastRaw",1213,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
17359 "Y - - 10 - buffer i - 'Int_t' 0 - length "
17360 "i 'TProof::ESlaves' - 0 'kActive' list", (char*)NULL, (void*) NULL, 0);
17361    G__memfunc_setup("Collect",710,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 4, 0, 
17362 "U 'TSlave' - 10 - sl l - 'Long_t' 0 '-1' timeout "
17363 "i - 'Int_t' 0 '-1' endtype g - 'Bool_t' 0 'kFALSE' deactonfail", (char*)NULL, (void*) NULL, 0);
17364    G__memfunc_setup("Collect",710,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 4, 0, 
17365 "U 'TMonitor' - 0 - mon l - 'Long_t' 0 '-1' timeout "
17366 "i - 'Int_t' 0 '-1' endtype g - 'Bool_t' 0 'kFALSE' deactonfail", (char*)NULL, (void*) NULL, 0);
17367    G__memfunc_setup("CollectInputFrom",1642,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
17368 "U 'TSocket' - 0 - s i - 'Int_t' 0 '-1' endtype "
17369 "g - 'Bool_t' 0 'kFALSE' deactonfail", (char*)NULL, (void*) NULL, 0);
17370    G__memfunc_setup("HandleInputMessage",1825,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
17371 "U 'TSlave' - 0 - wrk U 'TMessage' - 0 - m "
17372 "g - 'Bool_t' 0 'kFALSE' deactonfail", (char*)NULL, (void*) NULL, 0);
17373    G__memfunc_setup("HandleSubmerger",1528,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
17374 "U 'TMessage' - 0 - mess U 'TSlave' - 0 - sl", (char*)NULL, (void*) NULL, 0);
17375    G__memfunc_setup("SetMonitor",1044,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
17376 "U 'TMonitor' - 0 '0' mon g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 0);
17377    G__memfunc_setup("ReleaseMonitor",1449,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TMonitor' - 0 - mon", (char*)NULL, (void*) NULL, 0);
17378    G__memfunc_setup("FindUniqueSlaves",1638,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
17379    G__memfunc_setup("FindSlave",892,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TSlave), -1, 0, 1, 1, 4, 8, "U 'TSocket' - 0 - s", (char*)NULL, (void*) NULL, 0);
17380    G__memfunc_setup("GetListOfSlaves",1503,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
17381    G__memfunc_setup("GetListOfInactiveSlaves",2322,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
17382    G__memfunc_setup("GetListOfUniqueSlaves",2134,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
17383    G__memfunc_setup("GetListOfBadSlaves",1766,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
17384    G__memfunc_setup("GetNumberOfSlaves",1708,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
17385    G__memfunc_setup("GetNumberOfActiveSlaves",2312,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
17386    G__memfunc_setup("GetNumberOfInactiveSlaves",2527,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
17387    G__memfunc_setup("GetNumberOfUniqueSlaves",2339,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
17388    G__memfunc_setup("GetNumberOfBadSlaves",1971,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
17389    G__memfunc_setup("IsEndMaster",1087,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
17390    G__memfunc_setup("ModifyWorkerLists",1777,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
17391 "C - - 10 - ord g - 'Bool_t' 0 - add", (char*)NULL, (void*) NULL, 0);
17392    G__memfunc_setup("IsSync",601,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
17393    G__memfunc_setup("InterruptCurrentMonitor",2456,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
17394    G__memfunc_setup("SetRunStatus",1253,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i 'TProof::ERunStatus' - 0 - rst", (char*)NULL, (void*) NULL, 0);
17395    G__memfunc_setup("MarkBad",658,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
17396 "U 'TSlave' - 0 - wrk C - - 10 '0' reason", (char*)NULL, (void*) NULL, 0);
17397    G__memfunc_setup("MarkBad",658,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
17398 "U 'TSocket' - 0 - s C - - 10 '0' reason", (char*)NULL, (void*) NULL, 0);
17399    G__memfunc_setup("TerminateWorker",1571,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TSlave' - 0 - wrk", (char*)NULL, (void*) NULL, 0);
17400    G__memfunc_setup("TerminateWorker",1571,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "C - - 10 - ord", (char*)NULL, (void*) NULL, 0);
17401    G__memfunc_setup("ActivateAsyncInput",1855,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
17402    G__memfunc_setup("DeActivateAsyncInput",2024,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
17403    G__memfunc_setup("GetQueryReference",1733,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
17404 "i - 'Int_t' 0 - qry u 'TString' - 1 - ref", (char*)NULL, (void*) NULL, 0);
17405    G__memfunc_setup("PrintProgress",1378,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
17406 "n - 'Long64_t' 0 - total n - 'Long64_t' 0 - processed "
17407 "f - 'Float_t' 0 '-1.' procTime n - 'Long64_t' 0 '-1' bytesread", (char*)NULL, (void*) NULL, 0);
17408    G__memfunc_setup("CreateMerger",1206,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 0, 
17409 "U 'TSlave' - 0 - sl i - 'Int_t' 0 - port", (char*)NULL, (void*) NULL, 0);
17410    G__memfunc_setup("RedirectWorker",1452,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
17411 "U 'TSocket' - 0 - s U 'TSlave' - 0 - sl "
17412 "i - 'Int_t' 0 - output_size", (char*)NULL, (void*) NULL, 0);
17413    G__memfunc_setup("GetActiveMergersCount",2138,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
17414    G__memfunc_setup("FindNextFreeMerger",1796,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
17415    G__memfunc_setup("ResetMergers",1240,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
17416    G__memfunc_setup("AskForOutput",1239,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TSlave' - 0 - sl", (char*)NULL, (void*) NULL, 0);
17417    G__memfunc_setup("FinalizationDone",1646,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
17418    G__memfunc_setup("ResetMergePrg",1308,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
17419    G__memfunc_setup("ParseConfigField",1589,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "C - - 10 - config", (char*)NULL, (void*) NULL, 0);
17420    G__memfunc_setup("Prompt",642,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "C - - 10 - p", (char*)NULL, (void*) NULL, 0);
17421    G__memfunc_setup("ClearDataProgress",1718,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
17422 "i - 'Int_t' 0 - r i - 'Int_t' 0 - t", (char*)NULL, (void*) NULL, 0);
17423    G__memfunc_setup("GetDataSetSrvMaps",1682,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 1, 3, 4, 0, "u 'TString' - 11 - srvmaps", (char*)NULL, (void*) NULL, 0);
17424    G__memfunc_setup("TProof",602,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofLN_TProof), -1, 0, 0, 1, 2, 0, "", "For derived classes to use", (void*) NULL, 0);
17425    G__memfunc_setup("InitMembers",1119,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
17426    G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 2, 0, 
17427 "C - - 10 - masterurl C - - 10 - conffile "
17428 "C - - 10 - confdir i - 'Int_t' 0 - loglevel "
17429 "C - - 10 '0' alias", (char*)NULL, (void*) NULL, 0);
17430    G__memfunc_setup("StartSlaves",1148,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kFALSE' attach", (char*)NULL, (void*) NULL, 1);
17431    G__memfunc_setup("AddWorkers",1014,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "U 'TList' - 0 - wrks", (char*)NULL, (void*) NULL, 0);
17432    G__memfunc_setup("RemoveWorkers",1371,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "U 'TList' - 0 - wrks", (char*)NULL, (void*) NULL, 0);
17433    G__memfunc_setup("SetPlayer",921,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TVirtualProofPlayer' - 0 - player", (char*)NULL, (void*) NULL, 0);
17434    G__memfunc_setup("GetPlayer",909,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TVirtualProofPlayer), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
17435    G__memfunc_setup("MakePlayer",1003,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TVirtualProofPlayer), -1, 0, 2, 1, 2, 0, 
17436 "C - - 10 '0' player U 'TSocket' - 0 '0' s", (char*)NULL, (void*) NULL, 1);
17437    G__memfunc_setup("UpdateDialog",1203,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
17438    G__memfunc_setup("HandleLibIncPath",1546,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
17439 "C - - 10 - what g - 'Bool_t' 0 - add "
17440 "C - - 10 - dirs", (char*)NULL, (void*) NULL, 0);
17441    G__memfunc_setup("GetListOfActiveSlaves",2107,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
17442    G__memfunc_setup("CreateSlave",1103,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TSlave), -1, 0, 5, 1, 2, 0, 
17443 "C - - 10 - url C - - 10 - ord "
17444 "i - 'Int_t' 0 - perf C - - 10 - image "
17445 "C - - 10 - workdir", (char*)NULL, (void*) NULL, 0);
17446    G__memfunc_setup("CreateSubmaster",1546,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TSlave), -1, 0, 4, 1, 2, 0, 
17447 "C - - 10 - url C - - 10 - ord "
17448 "C - - 10 - image C - - 10 - msd", (char*)NULL, (void*) NULL, 0);
17449    G__memfunc_setup("SaveWorkerInfo",1429,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
17450    G__memfunc_setup("Collect",710,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 2, 0, 
17451 "i 'TProof::ESlaves' - 0 'kActive' list l - 'Long_t' 0 '-1' timeout "
17452 "i - 'Int_t' 0 '-1' endtype g - 'Bool_t' 0 'kFALSE' deactonfail", (char*)NULL, (void*) NULL, 0);
17453    G__memfunc_setup("Collect",710,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 2, 0, 
17454 "U 'TList' - 0 - slaves l - 'Long_t' 0 '-1' timeout "
17455 "i - 'Int_t' 0 '-1' endtype g - 'Bool_t' 0 'kFALSE' deactonfail", (char*)NULL, (void*) NULL, 0);
17456    G__memfunc_setup("SetDSet",668,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TDSet' - 0 - dset", (char*)NULL, (void*) NULL, 0);
17457    G__memfunc_setup("ValidateDSet",1178,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TDSet' - 0 - dset", (char*)NULL, (void*) NULL, 1);
17458    G__memfunc_setup("GetProgressDialog",1733,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TPluginHandler), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
17459    G__memfunc_setup("AssertPath",1023,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
17460 "C - - 10 - path g - 'Bool_t' 0 - writable", (char*)NULL, (void*) NULL, 0);
17461    G__memfunc_setup("PrepareInputDataFile",2009,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TString' - 1 - dataFile", (char*)NULL, (void*) NULL, 0);
17462    G__memfunc_setup("SendInputDataFile",1684,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
17463    G__memfunc_setup("SendFile",778,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 2, 0, 
17464 "C - - 10 - file i - 'Int_t' 0 '(kBinary|kForward|kCp|kCpBin)' opt "
17465 "C - - 10 '0' rfile U 'TSlave' - 0 '0' sl", (char*)NULL, (void*) NULL, 0);
17466    G__memfunc_setup("SlaveStartupThread",1862,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 1, 3, 2, 0, "Y - - 0 - arg", (char*)NULL, (void*) NULL, 0);
17467    G__memfunc_setup("AssertDataSet",1304,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 4, 3, 2, 0, 
17468 "U 'TDSet' - 0 - dset U 'TList' - 0 - input "
17469 "U 'TDataSetManager' - 0 - mgr u 'TString' - 1 - emsg", (char*)NULL, (void*) NULL, 0);
17470    G__memfunc_setup("GetInputData",1194,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 2, 0, 
17471 "U 'TList' - 0 - input C - - 10 - cachedir "
17472 "u 'TString' - 1 - emsg", (char*)NULL, (void*) NULL, 0);
17473    G__memfunc_setup("SaveInputData",1305,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 2, 0, 
17474 "U 'TQueryResult' - 0 - qr C - - 10 - cachedir "
17475 "u 'TString' - 1 - emsg", (char*)NULL, (void*) NULL, 0);
17476    G__memfunc_setup("SendInputData",1300,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 2, 0, 
17477 "U 'TQueryResult' - 0 - qr U 'TProof' - 0 - p "
17478 "u 'TString' - 1 - emsg", (char*)NULL, (void*) NULL, 0);
17479    G__memfunc_setup("GetFileInCmd",1131,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 3, 2, 0, 
17480 "C - - 10 - cmd u 'TString' - 1 - fn", (char*)NULL, (void*) NULL, 0);
17481    G__memfunc_setup("SystemCmd",921,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 2, 0, 
17482 "C - - 10 - cmd i - 'Int_t' 0 - fdout", (char*)NULL, (void*) NULL, 0);
17483    G__memfunc_setup("TProof",602,G__G__Proof_142_0_120, 105, G__get_linked_tagnum(&G__G__ProofLN_TProof), -1, 0, 6, 1, 1, 0, 
17484 "C - - 10 - masterurl C - - 10 'kPROOF_ConfFile' conffile "
17485 "C - - 10 'kPROOF_ConfDir' confdir i - 'Int_t' 0 '0' loglevel "
17486 "C - - 10 '0' alias U 'TProofMgr' - 0 '0' mgr", (char*)NULL, (void*) NULL, 0);
17487    G__memfunc_setup("cd",199,G__G__Proof_142_0_121, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' id", (char*)NULL, (void*) NULL, 0);
17488    G__memfunc_setup("Ping",398,G__G__Proof_142_0_122, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17489    G__memfunc_setup("Touch",515,G__G__Proof_142_0_123, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17490    G__memfunc_setup("Exec",389,G__G__Proof_142_0_124, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17491 "C - - 10 - cmd g - 'Bool_t' 0 'kFALSE' plusMaster", (char*)NULL, (void*) NULL, 0);
17492    G__memfunc_setup("Process",735,G__G__Proof_142_0_125, 110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
17493 "U 'TDSet' - 0 - dset C - - 10 - selector "
17494 "C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
17495 "n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
17496    G__memfunc_setup("Process",735,G__G__Proof_142_0_126, 110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
17497 "U 'TFileCollection' - 0 - fc C - - 10 - selector "
17498 "C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
17499 "n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
17500    G__memfunc_setup("Process",735,G__G__Proof_142_0_127, 110, -1, G__defined_typename("Long64_t"), 0, 6, 1, 1, 0, 
17501 "C - - 10 - dsetname C - - 10 - selector "
17502 "C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
17503 "n - 'Long64_t' 0 '0' firstentry U 'TObject' - 0 '0' enl", (char*)NULL, (void*) NULL, 1);
17504    G__memfunc_setup("Process",735,G__G__Proof_142_0_128, 110, -1, G__defined_typename("Long64_t"), 0, 3, 1, 1, 0, 
17505 "C - - 10 - selector n - 'Long64_t' 0 - nentries "
17506 "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
17507    G__memfunc_setup("DrawSelect",1006,G__G__Proof_142_0_129, 110, -1, G__defined_typename("Long64_t"), 0, 6, 1, 1, 0, 
17508 "U 'TDSet' - 0 - dset C - - 10 - varexp "
17509 "C - - 10 '\"\"' selection C - 'Option_t' 10 '\"\"' option "
17510 "n - 'Long64_t' 0 '-1' nentries n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
17511    G__memfunc_setup("DrawSelect",1006,G__G__Proof_142_0_130, 110, -1, G__defined_typename("Long64_t"), 0, 7, 1, 1, 0, 
17512 "C - - 10 - dsetname C - - 10 - varexp "
17513 "C - - 10 '\"\"' selection C - 'Option_t' 10 '\"\"' option "
17514 "n - 'Long64_t' 0 '-1' nentries n - 'Long64_t' 0 '0' firstentry "
17515 "U 'TObject' - 0 '0' enl", (char*)NULL, (void*) NULL, 0);
17516    G__memfunc_setup("Archive",706,G__G__Proof_142_0_131, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17517 "i - 'Int_t' 0 - query C - - 10 - url", (char*)NULL, (void*) NULL, 0);
17518    G__memfunc_setup("Archive",706,G__G__Proof_142_0_132, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17519 "C - - 10 - queryref C - - 10 '0' url", (char*)NULL, (void*) NULL, 0);
17520    G__memfunc_setup("CleanupSession",1452,G__G__Proof_142_0_133, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - sessiontag", (char*)NULL, (void*) NULL, 0);
17521    G__memfunc_setup("Finalize",818,G__G__Proof_142_0_134, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
17522 "i - 'Int_t' 0 '-1' query g - 'Bool_t' 0 'kFALSE' force", (char*)NULL, (void*) NULL, 0);
17523    G__memfunc_setup("Finalize",818,G__G__Proof_142_0_135, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
17524 "C - - 10 - queryref g - 'Bool_t' 0 'kFALSE' force", (char*)NULL, (void*) NULL, 0);
17525    G__memfunc_setup("Remove",622,G__G__Proof_142_0_136, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17526 "i - 'Int_t' 0 - query g - 'Bool_t' 0 'kFALSE' all", (char*)NULL, (void*) NULL, 0);
17527    G__memfunc_setup("Remove",622,G__G__Proof_142_0_137, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17528 "C - - 10 - queryref g - 'Bool_t' 0 'kFALSE' all", (char*)NULL, (void*) NULL, 0);
17529    G__memfunc_setup("Retrieve",838,G__G__Proof_142_0_138, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17530 "i - 'Int_t' 0 - query C - - 10 '0' path", (char*)NULL, (void*) NULL, 0);
17531    G__memfunc_setup("Retrieve",838,G__G__Proof_142_0_139, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17532 "C - - 10 - queryref C - - 10 '0' path", (char*)NULL, (void*) NULL, 0);
17533    G__memfunc_setup("DisableGoAsyn",1285,G__G__Proof_142_0_140, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17534    G__memfunc_setup("GoAsynchronous",1474,G__G__Proof_142_0_141, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17535    G__memfunc_setup("StopProcess",1157,G__G__Proof_142_0_142, 121, -1, -1, 0, 2, 1, 1, 0, 
17536 "g - 'Bool_t' 0 - abort i - 'Int_t' 0 '-1' timeout", (char*)NULL, (void*) NULL, 0);
17537    G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
17538    G__memfunc_setup("SetParallel",1113,G__G__Proof_142_0_144, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17539 "i - 'Int_t' 0 '9999' nodes g - 'Bool_t' 0 'kFALSE' random", (char*)NULL, (void*) NULL, 0);
17540    G__memfunc_setup("SetLogLevel",1094,G__G__Proof_142_0_145, 121, -1, -1, 0, 2, 1, 1, 0, 
17541 "i - 'Int_t' 0 - level h - 'UInt_t' 0 'TProofDebug::kAll' mask", (char*)NULL, (void*) NULL, 0);
17542    G__memfunc_setup("Close",502,G__G__Proof_142_0_146, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
17543    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);
17544    G__memfunc_setup("ShowCache",885,G__G__Proof_142_0_148, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' all", (char*)NULL, (void*) NULL, 1);
17545    G__memfunc_setup("ClearCache",955,G__G__Proof_142_0_149, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '0' file", (char*)NULL, (void*) NULL, 1);
17546    G__memfunc_setup("GetListOfPackages",1680,G__G__Proof_142_0_150, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17547    G__memfunc_setup("GetListOfEnabledPackages",2363,G__G__Proof_142_0_151, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17548    G__memfunc_setup("ShowPackages",1216,G__G__Proof_142_0_152, 121, -1, -1, 0, 2, 1, 1, 0, 
17549 "g - 'Bool_t' 0 'kFALSE' all g - 'Bool_t' 0 'kFALSE' redirlog", (char*)NULL, (void*) NULL, 0);
17550    G__memfunc_setup("ShowEnabledPackages",1899,G__G__Proof_142_0_153, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' all", (char*)NULL, (void*) NULL, 0);
17551    G__memfunc_setup("ClearPackages",1286,G__G__Proof_142_0_154, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17552    G__memfunc_setup("ClearPackage",1171,G__G__Proof_142_0_155, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - package", (char*)NULL, (void*) NULL, 0);
17553    G__memfunc_setup("DownloadPackage",1508,G__G__Proof_142_0_156, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17554 "C - - 10 - par C - - 10 '0' dstdir", (char*)NULL, (void*) NULL, 0);
17555    G__memfunc_setup("EnablePackage",1267,G__G__Proof_142_0_157, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17556 "C - - 10 - package g - 'Bool_t' 0 'kFALSE' notOnClient", (char*)NULL, (void*) NULL, 0);
17557    G__memfunc_setup("EnablePackage",1267,G__G__Proof_142_0_158, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
17558 "C - - 10 - package C - - 10 - loadopts "
17559 "g - 'Bool_t' 0 'kFALSE' notOnClient", (char*)NULL, (void*) NULL, 0);
17560    G__memfunc_setup("EnablePackage",1267,G__G__Proof_142_0_159, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
17561 "C - - 10 - package U 'TList' - 0 - loadopts "
17562 "g - 'Bool_t' 0 'kFALSE' notOnClient", (char*)NULL, (void*) NULL, 0);
17563    G__memfunc_setup("UploadPackage",1297,G__G__Proof_142_0_160, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17564 "C - - 10 - par i 'TProof::EUploadPackageOpt' - 0 'kUntar' opt", (char*)NULL, (void*) NULL, 0);
17565    G__memfunc_setup("Load",384,G__G__Proof_142_0_161, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
17566 "C - - 10 - macro g - 'Bool_t' 0 'kFALSE' notOnClient "
17567 "g - 'Bool_t' 0 'kTRUE' uniqueOnly U 'TList' - 0 '0' wrks", (char*)NULL, (void*) NULL, 1);
17568    G__memfunc_setup("AddDynamicPath",1371,G__G__Proof_142_0_162, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
17569 "C - - 10 - libpath g - 'Bool_t' 0 'kFALSE' onClient "
17570 "U 'TList' - 0 '0' wrks", (char*)NULL, (void*) NULL, 0);
17571    G__memfunc_setup("AddIncludePath",1370,G__G__Proof_142_0_163, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
17572 "C - - 10 - incpath g - 'Bool_t' 0 'kFALSE' onClient "
17573 "U 'TList' - 0 '0' wrks", (char*)NULL, (void*) NULL, 0);
17574    G__memfunc_setup("RemoveDynamicPath",1728,G__G__Proof_142_0_164, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17575 "C - - 10 - libpath g - 'Bool_t' 0 'kFALSE' onClient", (char*)NULL, (void*) NULL, 0);
17576    G__memfunc_setup("RemoveIncludePath",1727,G__G__Proof_142_0_165, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17577 "C - - 10 - incpath g - 'Bool_t' 0 'kFALSE' onClient", (char*)NULL, (void*) NULL, 0);
17578    G__memfunc_setup("UploadDataSet",1291,G__G__Proof_142_0_166, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
17579 "C - - 10 - dataset U 'TList' - 0 - files "
17580 "C - - 10 '0' dest i - 'Int_t' 0 'kAskUser' opt "
17581 "U 'TList' - 0 '0' skippedFiles", (char*)NULL, (void*) NULL, 0);
17582    G__memfunc_setup("UploadDataSet",1291,G__G__Proof_142_0_167, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
17583 "C - - 10 - dataset C - - 10 - files "
17584 "C - - 10 '0' dest i - 'Int_t' 0 'kAskUser' opt "
17585 "U 'TList' - 0 '0' skippedFiles", (char*)NULL, (void*) NULL, 0);
17586    G__memfunc_setup("UploadDataSetFromFile",2079,G__G__Proof_142_0_168, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
17587 "C - - 10 - dataset C - - 10 - file "
17588 "C - - 10 '0' dest i - 'Int_t' 0 'kAskUser' opt "
17589 "U 'TList' - 0 '0' skippedFiles", (char*)NULL, (void*) NULL, 0);
17590    G__memfunc_setup("RegisterDataSet",1515,G__G__Proof_142_0_169, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
17591 "C - - 10 - name U 'TFileCollection' - 0 - dataset "
17592 "C - - 10 '\"\"' optStr", (char*)NULL, (void*) NULL, 1);
17593    G__memfunc_setup("GetDataSets",1081,G__G__Proof_142_0_170, 85, G__get_linked_tagnum(&G__G__ProofLN_TMap), -1, 0, 2, 1, 1, 0, 
17594 "C - - 10 '\"\"' uri C - - 10 '\"\"' optStr", (char*)NULL, (void*) NULL, 1);
17595    G__memfunc_setup("ShowDataSets",1210,G__G__Proof_142_0_171, 121, -1, -1, 0, 2, 1, 1, 0, 
17596 "C - - 10 '\"\"' uri C - - 10 '\"\"' optStr", (char*)NULL, (void*) NULL, 1);
17597    G__memfunc_setup("GetDataSetQuota",1488,G__G__Proof_142_0_172, 85, G__get_linked_tagnum(&G__G__ProofLN_TMap), -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' optStr", (char*)NULL, (void*) NULL, 0);
17598    G__memfunc_setup("ShowDataSetQuota",1617,G__G__Proof_142_0_173, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '0' opt", (char*)NULL, (void*) NULL, 0);
17599    G__memfunc_setup("ExistsDataSet",1318,G__G__Proof_142_0_174, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - dataset", (char*)NULL, (void*) NULL, 1);
17600    G__memfunc_setup("ShowDataSet",1095,G__G__Proof_142_0_175, 121, -1, -1, 0, 2, 1, 1, 0, 
17601 "C - - 10 '\"\"' dataset C - - 10 '\"M\"' opt", (char*)NULL, (void*) NULL, 0);
17602    G__memfunc_setup("RemoveDataSet",1300,G__G__Proof_142_0_176, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17603 "C - - 10 - dataset C - - 10 '\"\"' optStr", (char*)NULL, (void*) NULL, 1);
17604    G__memfunc_setup("VerifyDataSet",1307,G__G__Proof_142_0_177, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17605 "C - - 10 - dataset C - - 10 '\"\"' optStr", (char*)NULL, (void*) NULL, 1);
17606    G__memfunc_setup("GetDataSet",966,G__G__Proof_142_0_178, 85, G__get_linked_tagnum(&G__G__ProofLN_TFileCollection), -1, 0, 2, 1, 1, 0, 
17607 "C - - 10 - dataset C - - 10 '\"\"' optStr", (char*)NULL, (void*) NULL, 1);
17608    G__memfunc_setup("FindDataSets",1178,G__G__Proof_142_0_179, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 2, 1, 1, 0, 
17609 "C - - 10 - searchString C - - 10 '\"\"' optStr", (char*)NULL, (void*) NULL, 0);
17610    G__memfunc_setup("SetDataSetTreeName",1763,G__G__Proof_142_0_180, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
17611 "C - - 10 - dataset C - - 10 - treename", (char*)NULL, (void*) NULL, 1);
17612    G__memfunc_setup("ShowDataSetCache",1563,G__G__Proof_142_0_181, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '0' dataset", (char*)NULL, (void*) NULL, 1);
17613    G__memfunc_setup("ClearDataSetCache",1633,G__G__Proof_142_0_182, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '0' dataset", (char*)NULL, (void*) NULL, 1);
17614    G__memfunc_setup("ShowData",795,G__G__Proof_142_0_183, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17615    G__memfunc_setup("ClearData",865,G__G__Proof_142_0_184, 121, -1, -1, 0, 2, 1, 1, 0, 
17616 "h - 'UInt_t' 0 'kUnregistered' what C - - 10 '0' dsname", (char*)NULL, (void*) NULL, 0);
17617    G__memfunc_setup("GetMaster",908,G__G__Proof_142_0_185, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
17618    G__memfunc_setup("GetConfDir",965,G__G__Proof_142_0_186, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
17619    G__memfunc_setup("GetConfFile",1062,G__G__Proof_142_0_187, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
17620    G__memfunc_setup("GetUser",703,G__G__Proof_142_0_188, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
17621    G__memfunc_setup("GetGroup",813,G__G__Proof_142_0_189, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
17622    G__memfunc_setup("GetWorkDir",994,G__G__Proof_142_0_190, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
17623    G__memfunc_setup("GetSessionTag",1312,G__G__Proof_142_0_191, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
17624    G__memfunc_setup("GetImage",771,G__G__Proof_142_0_192, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
17625    G__memfunc_setup("GetUrl",595,G__G__Proof_142_0_193, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
17626    G__memfunc_setup("GetPort",709,G__G__Proof_142_0_194, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17627    G__memfunc_setup("GetRemoteProtocol",1758,G__G__Proof_142_0_195, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17628    G__memfunc_setup("GetClientProtocol",1745,G__G__Proof_142_0_196, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17629    G__memfunc_setup("GetStatus",932,G__G__Proof_142_0_197, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17630    G__memfunc_setup("GetLogLevel",1082,G__G__Proof_142_0_198, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17631    G__memfunc_setup("GetParallel",1101,G__G__Proof_142_0_199, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17632    G__memfunc_setup("GetSeqNum",889,G__G__Proof_142_0_200, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17633    G__memfunc_setup("GetSessionID",1169,G__G__Proof_142_0_201, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17634    G__memfunc_setup("GetListOfSlaveInfos",1899,G__G__Proof_142_0_202, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17635    G__memfunc_setup("UseDynamicStartup",1765,G__G__Proof_142_0_203, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17636    G__memfunc_setup("GetQueryMode",1211,G__G__Proof_142_0_204, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLEQueryMode), -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '0' mode", (char*)NULL, (void*) NULL, 0);
17637    G__memfunc_setup("SetQueryMode",1223,G__G__Proof_142_0_205, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TProof::EQueryMode' - 0 - mode", (char*)NULL, (void*) NULL, 0);
17638    G__memfunc_setup("SetRealTimeLog",1377,G__G__Proof_142_0_206, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 0);
17639    G__memfunc_setup("GetStatistics",1355,G__G__Proof_142_0_207, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' verbose", (char*)NULL, (void*) NULL, 0);
17640    G__memfunc_setup("GetBytesRead",1187,G__G__Proof_142_0_208, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17641    G__memfunc_setup("GetRealTime",1075,G__G__Proof_142_0_209, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17642    G__memfunc_setup("GetCpuTime",983,G__G__Proof_142_0_210, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17643    G__memfunc_setup("IsLite",586,G__G__Proof_142_0_211, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17644    G__memfunc_setup("IsProofd",806,G__G__Proof_142_0_212, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17645    G__memfunc_setup("IsFolder",792,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
17646    G__memfunc_setup("IsMaster",808,G__G__Proof_142_0_214, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17647    G__memfunc_setup("IsValid",684,G__G__Proof_142_0_215, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17648    G__memfunc_setup("IsParallel",1001,G__G__Proof_142_0_216, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17649    G__memfunc_setup("IsIdle",570,G__G__Proof_142_0_217, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17650    G__memfunc_setup("IsWaiting",911,G__G__Proof_142_0_218, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17651    G__memfunc_setup("GetRunStatus",1241,G__G__Proof_142_0_219, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofcLcLERunStatus), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17652    G__memfunc_setup("GetLoadedMacros",1486,G__G__Proof_142_0_220, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17653    G__memfunc_setup("SetParameter",1229,G__G__Proof_142_0_221, 121, -1, -1, 0, 2, 1, 1, 0, 
17654 "C - - 10 - par C - - 10 - value", (char*)NULL, (void*) NULL, 0);
17655    G__memfunc_setup("SetParameter",1229,G__G__Proof_142_0_222, 121, -1, -1, 0, 2, 1, 1, 0, 
17656 "C - - 10 - par i - 'Int_t' 0 - value", (char*)NULL, (void*) NULL, 0);
17657    G__memfunc_setup("SetParameter",1229,G__G__Proof_142_0_223, 121, -1, -1, 0, 2, 1, 1, 0, 
17658 "C - - 10 - par l - 'Long_t' 0 - value", (char*)NULL, (void*) NULL, 0);
17659    G__memfunc_setup("SetParameter",1229,G__G__Proof_142_0_224, 121, -1, -1, 0, 2, 1, 1, 0, 
17660 "C - - 10 - par n - 'Long64_t' 0 - value", (char*)NULL, (void*) NULL, 0);
17661    G__memfunc_setup("SetParameter",1229,G__G__Proof_142_0_225, 121, -1, -1, 0, 2, 1, 1, 0, 
17662 "C - - 10 - par d - 'Double_t' 0 - value", (char*)NULL, (void*) NULL, 0);
17663    G__memfunc_setup("GetParameter",1217,G__G__Proof_142_0_226, 85, G__get_linked_tagnum(&G__G__ProofLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - par", (char*)NULL, (void*) NULL, 0);
17664    G__memfunc_setup("DeleteParameters",1639,G__G__Proof_142_0_227, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - wildcard", (char*)NULL, (void*) NULL, 0);
17665    G__memfunc_setup("ShowParameters",1461,G__G__Proof_142_0_228, 121, -1, -1, 0, 1, 1, 1, 8, "C - - 10 '\"PROOF_*\"' wildcard", (char*)NULL, (void*) NULL, 0);
17666    G__memfunc_setup("AddInput",793,G__G__Proof_142_0_229, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
17667    G__memfunc_setup("ClearInput",1015,G__G__Proof_142_0_230, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17668    G__memfunc_setup("GetInputList",1228,G__G__Proof_142_0_231, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17669    G__memfunc_setup("GetOutput",945,G__G__Proof_142_0_232, 85, G__get_linked_tagnum(&G__G__ProofLN_TObject), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
17670    G__memfunc_setup("GetOutputList",1357,G__G__Proof_142_0_233, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17671    G__memfunc_setup("ShowMissingFiles",1646,G__G__Proof_142_0_234, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TQueryResult' - 0 '0' qr", (char*)NULL, (void*) NULL, 0);
17672    G__memfunc_setup("GetMissingFiles",1517,G__G__Proof_142_0_235, 85, G__get_linked_tagnum(&G__G__ProofLN_TFileCollection), -1, 0, 1, 1, 1, 0, "U 'TQueryResult' - 0 '0' qr", (char*)NULL, (void*) NULL, 0);
17673    G__memfunc_setup("AddInputData",1171,G__G__Proof_142_0_236, 121, -1, -1, 0, 2, 1, 1, 0, 
17674 "U 'TObject' - 0 - obj g - 'Bool_t' 0 'kFALSE' push", (char*)NULL, (void*) NULL, 0);
17675    G__memfunc_setup("SetInputDataFile",1590,G__G__Proof_142_0_237, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - datafile", (char*)NULL, (void*) NULL, 0);
17676    G__memfunc_setup("ClearInputData",1393,G__G__Proof_142_0_238, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 '0' obj", (char*)NULL, (void*) NULL, 0);
17677    G__memfunc_setup("ClearInputData",1393,G__G__Proof_142_0_239, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
17678    G__memfunc_setup("AddFeedback",1038,G__G__Proof_142_0_240, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
17679    G__memfunc_setup("RemoveFeedback",1395,G__G__Proof_142_0_241, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
17680    G__memfunc_setup("ClearFeedback",1260,G__G__Proof_142_0_242, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17681    G__memfunc_setup("ShowFeedback",1190,G__G__Proof_142_0_243, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17682    G__memfunc_setup("GetFeedbackList",1473,G__G__Proof_142_0_244, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17683    G__memfunc_setup("GetListOfQueries",1615,G__G__Proof_142_0_245, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
17684    G__memfunc_setup("GetNumberOfQueries",1820,G__G__Proof_142_0_246, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17685    G__memfunc_setup("GetNumberOfDrawQueries",2218,G__G__Proof_142_0_247, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17686    G__memfunc_setup("GetQueryResults",1576,G__G__Proof_142_0_248, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17687    G__memfunc_setup("GetQueryResult",1461,G__G__Proof_142_0_249, 85, G__get_linked_tagnum(&G__G__ProofLN_TQueryResult), -1, 0, 1, 1, 1, 0, "C - - 10 '0' ref", (char*)NULL, (void*) NULL, 0);
17688    G__memfunc_setup("GetMaxQueries",1316,G__G__Proof_142_0_250, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17689    G__memfunc_setup("SetMaxDrawQueries",1726,G__G__Proof_142_0_251, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 0);
17690    G__memfunc_setup("ShowQueries",1151,G__G__Proof_142_0_252, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
17691    G__memfunc_setup("IsDataReady",1067,G__G__Proof_142_0_253, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
17692 "n - 'Long64_t' 1 - totalbytes n - 'Long64_t' 1 - bytesready", (char*)NULL, (void*) NULL, 0);
17693    G__memfunc_setup("SetActive",904,G__G__Proof_142_0_254, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' -", (char*)NULL, (void*) NULL, 0);
17694    G__memfunc_setup("LogMessage",999,G__G__Proof_142_0_255, 121, -1, -1, 0, 2, 1, 1, 0, 
17695 "C - - 10 - msg g - 'Bool_t' 0 - all", "*SIGNAL*", (void*) NULL, 0);
17696    G__memfunc_setup("Progress",853,G__G__Proof_142_0_256, 121, -1, -1, 0, 2, 1, 1, 0, 
17697 "n - 'Long64_t' 0 - total n - 'Long64_t' 0 - processed", "*SIGNAL*", (void*) NULL, 0);
17698    G__memfunc_setup("Progress",853,G__G__Proof_142_0_257, 121, -1, -1, 0, 7, 1, 1, 0, 
17699 "n - 'Long64_t' 0 - total n - 'Long64_t' 0 - processed "
17700 "n - 'Long64_t' 0 - bytesread f - 'Float_t' 0 - initTime "
17701 "f - 'Float_t' 0 - procTime f - 'Float_t' 0 - evtrti "
17702 "f - 'Float_t' 0 - mbrti", "*SIGNAL*", (void*) NULL, 0);
17703    G__memfunc_setup("Progress",853,G__G__Proof_142_0_258, 121, -1, -1, 0, 10, 1, 1, 0, 
17704 "n - 'Long64_t' 0 - total n - 'Long64_t' 0 - processed "
17705 "n - 'Long64_t' 0 - bytesread f - 'Float_t' 0 - initTime "
17706 "f - 'Float_t' 0 - procTime f - 'Float_t' 0 - evtrti "
17707 "f - 'Float_t' 0 - mbrti i - 'Int_t' 0 - actw "
17708 "i - 'Int_t' 0 - tses f - 'Float_t' 0 - eses", "*SIGNAL*", (void*) NULL, 0);
17709    G__memfunc_setup("Feedback",773,G__G__Proof_142_0_259, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - objs", "*SIGNAL*", (void*) NULL, 0);
17710    G__memfunc_setup("QueryResultReady",1674,G__G__Proof_142_0_260, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - ref", "*SIGNAL*", (void*) NULL, 0);
17711    G__memfunc_setup("CloseProgressDialog",1947,G__G__Proof_142_0_261, 121, -1, -1, 0, 0, 1, 1, 0, "", "*SIGNAL*", (void*) NULL, 0);
17712    G__memfunc_setup("ResetProgressDialog",1960,G__G__Proof_142_0_262, 121, -1, -1, 0, 4, 1, 1, 0, 
17713 "C - - 10 - sel i - 'Int_t' 0 - sz "
17714 "n - 'Long64_t' 0 - fst n - 'Long64_t' 0 - ent", "*SIGNAL*", (void*) NULL, 0);
17715    G__memfunc_setup("StartupMessage",1464,G__G__Proof_142_0_263, 121, -1, -1, 0, 4, 1, 1, 0, 
17716 "C - - 10 - msg g - 'Bool_t' 0 - status "
17717 "i - 'Int_t' 0 - done i - 'Int_t' 0 - total", "*SIGNAL*", (void*) NULL, 0);
17718    G__memfunc_setup("DataSetStatus",1322,G__G__Proof_142_0_264, 121, -1, -1, 0, 4, 1, 1, 0, 
17719 "C - - 10 - msg g - 'Bool_t' 0 - status "
17720 "i - 'Int_t' 0 - done i - 'Int_t' 0 - total", "*SIGNAL*", (void*) NULL, 0);
17721    G__memfunc_setup("SendDataSetStatus",1716,G__G__Proof_142_0_265, 121, -1, -1, 0, 4, 1, 1, 0, 
17722 "C - - 10 - msg h - 'UInt_t' 0 - n "
17723 "h - 'UInt_t' 0 - tot g - 'Bool_t' 0 - st", (char*)NULL, (void*) NULL, 0);
17724    G__memfunc_setup("GetLog",578,G__G__Proof_142_0_266, 121, -1, -1, 0, 2, 1, 1, 0, 
17725 "i - 'Int_t' 0 '-1' start i - 'Int_t' 0 '-1' end", (char*)NULL, (void*) NULL, 0);
17726    G__memfunc_setup("GetLastLog",982,G__G__Proof_142_0_267, 85, G__get_linked_tagnum(&G__G__ProofLN_TMacro), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17727    G__memfunc_setup("PutLog",603,G__G__Proof_142_0_268, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TQueryResult' - 0 - qr", (char*)NULL, (void*) NULL, 0);
17728    G__memfunc_setup("ShowLog",707,G__G__Proof_142_0_269, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' qry", (char*)NULL, (void*) NULL, 0);
17729    G__memfunc_setup("ShowLog",707,G__G__Proof_142_0_270, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - queryref", (char*)NULL, (void*) NULL, 0);
17730    G__memfunc_setup("SendingLogToWindow",1829,G__G__Proof_142_0_271, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17731    G__memfunc_setup("SendLogToWindow",1511,G__G__Proof_142_0_272, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - mode", (char*)NULL, (void*) NULL, 0);
17732    G__memfunc_setup("ResetProgressDialogStatus",2604,G__G__Proof_142_0_273, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17733    G__memfunc_setup("GetTreeHeader",1273,G__G__Proof_142_0_274, 85, G__get_linked_tagnum(&G__G__ProofLN_TTree), -1, 0, 1, 1, 1, 0, "U 'TDSet' - 0 - tdset", (char*)NULL, (void*) NULL, 1);
17734    G__memfunc_setup("GetOutputNames",1445,G__G__Proof_142_0_275, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17735    G__memfunc_setup("AddChain",748,G__G__Proof_142_0_276, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TChain' - 0 - chain", (char*)NULL, (void*) NULL, 0);
17736    G__memfunc_setup("RemoveChain",1105,G__G__Proof_142_0_277, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TChain' - 0 - chain", (char*)NULL, (void*) NULL, 0);
17737    G__memfunc_setup("CreateDrawFeedback",1767,G__G__Proof_142_0_278, 85, G__get_linked_tagnum(&G__G__ProofLN_TDrawFeedback), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17738    G__memfunc_setup("SetDrawFeedbackOption",2104,G__G__Proof_142_0_279, 121, -1, -1, 0, 2, 1, 1, 0, 
17739 "U 'TDrawFeedback' - 0 - f C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 0);
17740    G__memfunc_setup("DeleteDrawFeedback",1766,G__G__Proof_142_0_280, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDrawFeedback' - 0 - f", (char*)NULL, (void*) NULL, 0);
17741    G__memfunc_setup("Detach",585,G__G__Proof_142_0_281, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 0);
17742    G__memfunc_setup("SetAlias",790,G__G__Proof_142_0_282, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' alias", (char*)NULL, (void*) NULL, 1);
17743    G__memfunc_setup("GetManager",987,G__G__Proof_142_0_283, 85, G__get_linked_tagnum(&G__G__ProofLN_TProofMgr), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17744    G__memfunc_setup("SetManager",999,G__G__Proof_142_0_284, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TProofMgr' - 0 - mgr", (char*)NULL, (void*) NULL, 0);
17745    G__memfunc_setup("ActivateWorker",1451,G__G__Proof_142_0_285, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - ord", (char*)NULL, (void*) NULL, 0);
17746    G__memfunc_setup("DeactivateWorker",1652,G__G__Proof_142_0_286, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - ord", (char*)NULL, (void*) NULL, 0);
17747    G__memfunc_setup("GetDataPoolUrl",1383,G__G__Proof_142_0_287, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
17748    G__memfunc_setup("SetDataPoolUrl",1395,G__G__Proof_142_0_288, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - url", (char*)NULL, (void*) NULL, 0);
17749    G__memfunc_setup("SetPrintProgress",1678,G__G__Proof_142_0_289, 121, -1, -1, 0, 1, 1, 1, 0, "Y - 'PrintProgress_t' 0 - pp", (char*)NULL, (void*) NULL, 0);
17750    G__memfunc_setup("SetProgressDialog",1745,G__G__Proof_142_0_290, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 0);
17751    G__memfunc_setup("Open",402,G__G__Proof_142_0_291, 85, G__get_linked_tagnum(&G__G__ProofLN_TProof), -1, 0, 4, 3, 1, 0, 
17752 "C - - 10 '0' url C - - 10 '0' conffile "
17753 "C - - 10 '0' confdir i - 'Int_t' 0 '0' loglevel", (char*)NULL, (void*) G__func2void( (TProof* (*)(const char*, const char*, const char*, Int_t))(&TProof::Open) ), 0);
17754    G__memfunc_setup("LogViewer",916,G__G__Proof_142_0_292, 121, -1, -1, 0, 2, 3, 1, 0, 
17755 "C - - 10 '0' url i - 'Int_t' 0 '0' sessionidx", (char*)NULL, (void*) G__func2void( (void (*)(const char*, Int_t))(&TProof::LogViewer) ), 0);
17756    G__memfunc_setup("Mgr",294,G__G__Proof_142_0_293, 85, G__get_linked_tagnum(&G__G__ProofLN_TProofMgr), -1, 0, 1, 3, 1, 0, "C - - 10 - url", (char*)NULL, (void*) G__func2void( (TProofMgr* (*)(const char*))(&TProof::Mgr) ), 0);
17757    G__memfunc_setup("Reset",515,G__G__Proof_142_0_294, 121, -1, -1, 0, 2, 3, 1, 0, 
17758 "C - - 10 - url g - 'Bool_t' 0 'kFALSE' hard", (char*)NULL, (void*) G__func2void( (void (*)(const char*, Bool_t))(&TProof::Reset) ), 0);
17759    G__memfunc_setup("AddEnvVar",859,G__G__Proof_142_0_295, 121, -1, -1, 0, 2, 3, 1, 0, 
17760 "C - - 10 - name C - - 10 - value", (char*)NULL, (void*) G__func2void( (void (*)(const char*, const char*))(&TProof::AddEnvVar) ), 0);
17761    G__memfunc_setup("DelEnvVar",871,G__G__Proof_142_0_296, 121, -1, -1, 0, 1, 3, 1, 0, "C - - 10 - name", (char*)NULL, (void*) G__func2void( (void (*)(const char*))(&TProof::DelEnvVar) ), 0);
17762    G__memfunc_setup("GetEnvVars",997,G__G__Proof_142_0_297, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const TList* (*)())(&TProof::GetEnvVars) ), 0);
17763    G__memfunc_setup("ResetEnvVars",1224,G__G__Proof_142_0_298, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProof::ResetEnvVars) ), 0);
17764    G__memfunc_setup("GetParameter",1217,G__G__Proof_142_0_299, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 1, 0, 
17765 "U 'TCollection' - 0 - c C - - 10 - par "
17766 "u 'TString' - 1 - value", (char*)NULL, (void*) G__func2void( (Int_t (*)(TCollection*, const char*, TString&))(&TProof::GetParameter) ), 0);
17767    G__memfunc_setup("GetParameter",1217,G__G__Proof_142_0_300, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 1, 0, 
17768 "U 'TCollection' - 0 - c C - - 10 - par "
17769 "i - 'Int_t' 1 - value", (char*)NULL, (void*) G__func2void( (Int_t (*)(TCollection*, const char*, Int_t&))(&TProof::GetParameter) ), 0);
17770    G__memfunc_setup("GetParameter",1217,G__G__Proof_142_0_301, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 1, 0, 
17771 "U 'TCollection' - 0 - c C - - 10 - par "
17772 "l - 'Long_t' 1 - value", (char*)NULL, (void*) G__func2void( (Int_t (*)(TCollection*, const char*, Long_t&))(&TProof::GetParameter) ), 0);
17773    G__memfunc_setup("GetParameter",1217,G__G__Proof_142_0_302, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 1, 0, 
17774 "U 'TCollection' - 0 - c C - - 10 - par "
17775 "n - 'Long64_t' 1 - value", (char*)NULL, (void*) G__func2void( (Int_t (*)(TCollection*, const char*, Long64_t&))(&TProof::GetParameter) ), 0);
17776    G__memfunc_setup("GetParameter",1217,G__G__Proof_142_0_303, 105, -1, G__defined_typename("Int_t"), 0, 3, 3, 1, 0, 
17777 "U 'TCollection' - 0 - c C - - 10 - par "
17778 "d - 'Double_t' 1 - value", (char*)NULL, (void*) G__func2void( (Int_t (*)(TCollection*, const char*, Double_t&))(&TProof::GetParameter) ), 0);
17779    G__memfunc_setup("Class",502,G__G__Proof_142_0_304, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProof::Class) ), 0);
17780    G__memfunc_setup("Class_Name",982,G__G__Proof_142_0_305, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProof::Class_Name) ), 0);
17781    G__memfunc_setup("Class_Version",1339,G__G__Proof_142_0_306, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProof::Class_Version) ), 0);
17782    G__memfunc_setup("Dictionary",1046,G__G__Proof_142_0_307, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProof::Dictionary) ), 0);
17783    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
17784    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
17785    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
17786    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_142_0_311, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
17787    G__memfunc_setup("DeclFileName",1145,G__G__Proof_142_0_312, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProof::DeclFileName) ), 0);
17788    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_142_0_313, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProof::ImplFileLine) ), 0);
17789    G__memfunc_setup("ImplFileName",1171,G__G__Proof_142_0_314, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProof::ImplFileName) ), 0);
17790    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_142_0_315, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProof::DeclFileLine) ), 0);
17791    // automatic destructor
17792    G__memfunc_setup("~TProof", 728, G__G__Proof_142_0_316, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
17793    G__tag_memfunc_reset();
17794 }
17795 
17796 static void G__setup_memfuncTProofChain(void) {
17797    /* TProofChain */
17798    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofChain));
17799    G__memfunc_setup("FillDrawAttributes",1852,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TProof' - 0 - p", (char*)NULL, (void*) NULL, 0);
17800    G__memfunc_setup("TProofChain",1085,G__G__Proof_143_0_2, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofChain), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17801    G__memfunc_setup("TProofChain",1085,G__G__Proof_143_0_3, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofChain), -1, 0, 2, 1, 1, 0, 
17802 "U 'TChain' - 0 - chain g - 'Bool_t' 0 - gettreeheader", (char*)NULL, (void*) NULL, 0);
17803    G__memfunc_setup("TProofChain",1085,G__G__Proof_143_0_4, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofChain), -1, 0, 2, 1, 1, 0, 
17804 "U 'TDSet' - 0 - dset g - 'Bool_t' 0 - gettreeheader", (char*)NULL, (void*) NULL, 0);
17805    G__memfunc_setup("Browse",626,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TBrowser' - 0 - b", (char*)NULL, (void*) NULL, 1);
17806    G__memfunc_setup("Debug",487,G__G__Proof_143_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17807    G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
17808 "C - - 10 - varexp u 'TCut' - 11 - selection "
17809 "C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '1000000000' nentries "
17810 "n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
17811    G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
17812 "C - - 10 - varexp C - - 10 - selection "
17813 "C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '1000000000' nentries "
17814 "n - 'Long64_t' 0 '0' firstentry", "*MENU*", (void*) NULL, 1);
17815    G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
17816    G__memfunc_setup("FindBranch",975,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TBranch), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
17817    G__memfunc_setup("FindLeaf",761,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TLeaf), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
17818    G__memfunc_setup("GetBranch",878,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TBranch), -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
17819    G__memfunc_setup("GetBranchStatus",1522,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "C - - 10 - branchname", (char*)NULL, (void*) NULL, 1);
17820    G__memfunc_setup("GetEntries",1018,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
17821    G__memfunc_setup("GetEntries",1018,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "C - - 10 - sel", (char*)NULL, (void*) NULL, 1);
17822    G__memfunc_setup("GetListOfClones",1493,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17823    G__memfunc_setup("GetListOfBranches",1687,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17824    G__memfunc_setup("GetListOfLeaves",1489,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TObjArray), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17825    G__memfunc_setup("GetListOfFriends",1596,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
17826    G__memfunc_setup("GetListOfAliases",1587,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
17827    G__memfunc_setup("GetMakeClass",1172,G__G__Proof_143_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17828    G__memfunc_setup("GetPlayer",909,G__G__Proof_143_0_22, 85, G__get_linked_tagnum(&G__G__ProofLN_TVirtualTreePlayer), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17829    G__memfunc_setup("GetReadEntry",1198,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
17830    G__memfunc_setup("HasTreeHeader",1269,G__G__Proof_143_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17831    G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 4, 1, 1, 0, 
17832 "C - - 10 - filename C - 'Option_t' 10 '\"\"' option "
17833 "n - 'Long64_t' 0 '1000000000' nentries n - 'Long64_t' 0 '0' firstentry", "*MENU*", (void*) NULL, 1);
17834    G__memfunc_setup("Progress",853,G__G__Proof_143_0_26, 121, -1, -1, 0, 2, 1, 1, 0, 
17835 "n - 'Long64_t' 0 - total n - 'Long64_t' 0 - processed", (char*)NULL, (void*) NULL, 1);
17836    G__memfunc_setup("Process",735,G__G__Proof_143_0_27, 110, -1, G__defined_typename("Long64_t"), 0, 4, 1, 1, 0, 
17837 "U 'TSelector' - 0 - selector C - 'Option_t' 10 '\"\"' option "
17838 "n - 'Long64_t' 0 '1000000000' nentries n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
17839    G__memfunc_setup("SetDebug",787,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
17840 "i - 'Int_t' 0 '1' level n - 'Long64_t' 0 '0' min "
17841 "n - 'Long64_t' 0 '9999999' max", "*MENU*", (void*) NULL, 1);
17842    G__memfunc_setup("SetEventList",1226,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TEventList' - 0 - evlist", (char*)NULL, (void*) NULL, 1);
17843    G__memfunc_setup("SetEntryList",1242,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
17844 "U 'TEntryList' - 0 - enlist C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
17845    G__memfunc_setup("SetName",685,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", "*MENU*", (void*) NULL, 1);
17846    G__memfunc_setup("ConnectProof",1232,G__G__Proof_143_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17847    G__memfunc_setup("ReleaseProof",1223,G__G__Proof_143_0_33, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17848    G__memfunc_setup("Class",502,G__G__Proof_143_0_34, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofChain::Class) ), 0);
17849    G__memfunc_setup("Class_Name",982,G__G__Proof_143_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofChain::Class_Name) ), 0);
17850    G__memfunc_setup("Class_Version",1339,G__G__Proof_143_0_36, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofChain::Class_Version) ), 0);
17851    G__memfunc_setup("Dictionary",1046,G__G__Proof_143_0_37, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofChain::Dictionary) ), 0);
17852    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
17853    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
17854    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
17855    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_143_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
17856    G__memfunc_setup("DeclFileName",1145,G__G__Proof_143_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofChain::DeclFileName) ), 0);
17857    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_143_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofChain::ImplFileLine) ), 0);
17858    G__memfunc_setup("ImplFileName",1171,G__G__Proof_143_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofChain::ImplFileName) ), 0);
17859    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_143_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofChain::DeclFileLine) ), 0);
17860    // automatic destructor
17861    G__memfunc_setup("~TProofChain", 1211, G__G__Proof_143_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
17862    G__tag_memfunc_reset();
17863 }
17864 
17865 static void G__setup_memfuncTDSetElement(void) {
17866    /* TDSetElement */
17867    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TDSetElement));
17868    G__memfunc_setup("HasBeenLookedUp",1465,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
17869    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__ProofLN_TDSetElement), -1, 1, 1, 1, 4, 0, "u 'TDSetElement' - 11 - -", "Not implemented", (void*) NULL, 0);
17870    G__memfunc_setup("TDSetElement",1166,G__G__Proof_145_0_3, 105, G__get_linked_tagnum(&G__G__ProofLN_TDSetElement), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17871    G__memfunc_setup("TDSetElement",1166,G__G__Proof_145_0_4, 105, G__get_linked_tagnum(&G__G__ProofLN_TDSetElement), -1, 0, 7, 1, 1, 0, 
17872 "C - - 10 - file C - - 10 '0' objname "
17873 "C - - 10 '0' dir n - 'Long64_t' 0 '0' first "
17874 "n - 'Long64_t' 0 '-1' num C - - 10 '0' msd "
17875 "C - - 10 '0' dataset", (char*)NULL, (void*) NULL, 0);
17876    G__memfunc_setup("TDSetElement",1166,G__G__Proof_145_0_5, 105, G__get_linked_tagnum(&G__G__ProofLN_TDSetElement), -1, 0, 1, 1, 1, 0, "u 'TDSetElement' - 11 - elem", (char*)NULL, (void*) NULL, 0);
17877    G__memfunc_setup("GetListOfFriends",1596,G__G__Proof_145_0_6, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
17878    G__memfunc_setup("AddFriend",865,G__G__Proof_145_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
17879 "U 'TDSetElement' - 0 - friendElement C - - 10 - alias", (char*)NULL, (void*) NULL, 1);
17880    G__memfunc_setup("DeleteFriends",1310,G__G__Proof_145_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
17881    G__memfunc_setup("GetFileName",1057,G__G__Proof_145_0_9, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
17882    G__memfunc_setup("GetFirst",808,G__G__Proof_145_0_10, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17883    G__memfunc_setup("SetFirst",820,G__G__Proof_145_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - first", (char*)NULL, (void*) NULL, 0);
17884    G__memfunc_setup("GetNum",592,G__G__Proof_145_0_12, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17885    G__memfunc_setup("GetEntries",1018,G__G__Proof_145_0_13, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
17886 "g - 'Bool_t' 0 'kTRUE' istree g - 'Bool_t' 0 'kTRUE' openfile", (char*)NULL, (void*) NULL, 0);
17887    G__memfunc_setup("SetEntries",1030,G__G__Proof_145_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - ent", (char*)NULL, (void*) NULL, 0);
17888    G__memfunc_setup("GetMsd",580,G__G__Proof_145_0_15, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
17889    G__memfunc_setup("SetNum",604,G__G__Proof_145_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - num", (char*)NULL, (void*) NULL, 0);
17890    G__memfunc_setup("GetValid",784,G__G__Proof_145_0_17, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17891    G__memfunc_setup("GetObjName",956,G__G__Proof_145_0_18, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
17892    G__memfunc_setup("GetDirectory",1237,G__G__Proof_145_0_19, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
17893    G__memfunc_setup("GetDataSet",966,G__G__Proof_145_0_20, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
17894    G__memfunc_setup("SetDataSet",978,G__G__Proof_145_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - dataset", (char*)NULL, (void*) NULL, 0);
17895    G__memfunc_setup("AddAssocObj",1053,G__G__Proof_145_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - assocobj", (char*)NULL, (void*) NULL, 0);
17896    G__memfunc_setup("GetListOfAssocObjs",1784,G__G__Proof_145_0_23, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17897    G__memfunc_setup("GetAssocObj",1076,G__G__Proof_145_0_24, 85, G__get_linked_tagnum(&G__G__ProofLN_TObject), -1, 0, 2, 1, 1, 0, 
17898 "n - 'Long64_t' 0 - i g - 'Bool_t' 0 'kFALSE' isentry", (char*)NULL, (void*) NULL, 0);
17899    G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' options", (char*)NULL, (void*) NULL, 1);
17900    G__memfunc_setup("GetTDSetOffset",1355,G__G__Proof_145_0_26, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17901    G__memfunc_setup("SetTDSetOffset",1367,G__G__Proof_145_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - offset", (char*)NULL, (void*) NULL, 0);
17902    G__memfunc_setup("SetEntryList",1242,G__G__Proof_145_0_28, 121, -1, -1, 0, 3, 1, 1, 0, 
17903 "U 'TObject' - 0 - aList n - 'Long64_t' 0 '-1' first "
17904 "n - 'Long64_t' 0 '-1' num", (char*)NULL, (void*) NULL, 0);
17905    G__memfunc_setup("GetEntryList",1230,G__G__Proof_145_0_29, 85, G__get_linked_tagnum(&G__G__ProofLN_TObject), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17906    G__memfunc_setup("Validate",810,G__G__Proof_145_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - isTree", (char*)NULL, (void*) NULL, 0);
17907    G__memfunc_setup("Validate",810,G__G__Proof_145_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDSetElement' - 0 - elem", (char*)NULL, (void*) NULL, 0);
17908    G__memfunc_setup("Invalidate",1025,G__G__Proof_145_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17909    G__memfunc_setup("SetValid",796,G__G__Proof_145_0_33, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17910    G__memfunc_setup("Compare",711,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
17911    G__memfunc_setup("IsSortable",1016,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
17912    G__memfunc_setup("Lookup",634,G__G__Proof_145_0_36, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' force", (char*)NULL, (void*) NULL, 0);
17913    G__memfunc_setup("SetLookedUp",1103,G__G__Proof_145_0_37, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17914    G__memfunc_setup("GetFileInfo",1068,G__G__Proof_145_0_38, 85, G__get_linked_tagnum(&G__G__ProofLN_TFileInfo), -1, 0, 1, 1, 1, 0, "C - - 10 '\"TTree\"' type", (char*)NULL, (void*) NULL, 0);
17915    G__memfunc_setup("MergeElement",1210,G__G__Proof_145_0_39, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TDSetElement' - 0 - elem", (char*)NULL, (void*) NULL, 0);
17916    G__memfunc_setup("Class",502,G__G__Proof_145_0_40, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDSetElement::Class) ), 0);
17917    G__memfunc_setup("Class_Name",982,G__G__Proof_145_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDSetElement::Class_Name) ), 0);
17918    G__memfunc_setup("Class_Version",1339,G__G__Proof_145_0_42, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDSetElement::Class_Version) ), 0);
17919    G__memfunc_setup("Dictionary",1046,G__G__Proof_145_0_43, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDSetElement::Dictionary) ), 0);
17920    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
17921    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
17922    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
17923    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_145_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
17924    G__memfunc_setup("DeclFileName",1145,G__G__Proof_145_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDSetElement::DeclFileName) ), 0);
17925    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_145_0_49, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDSetElement::ImplFileLine) ), 0);
17926    G__memfunc_setup("ImplFileName",1171,G__G__Proof_145_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDSetElement::ImplFileName) ), 0);
17927    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_145_0_51, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDSetElement::DeclFileLine) ), 0);
17928    // automatic destructor
17929    G__memfunc_setup("~TDSetElement", 1292, G__G__Proof_145_0_52, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
17930    G__tag_memfunc_reset();
17931 }
17932 
17933 static void G__setup_memfuncpairlETDSetElementmUcOTStringgR(void) {
17934    /* pair<TDSetElement*,TString> */
17935    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_pairlETDSetElementmUcOTStringgR));
17936    G__memfunc_setup("pair<TDSetElement*,TString>",2517,G__G__Proof_146_0_1, 105, G__get_linked_tagnum(&G__G__ProofLN_pairlETDSetElementmUcOTStringgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17937    G__memfunc_setup("pair<TDSetElement*,TString>",2517,G__G__Proof_146_0_2, 105, G__get_linked_tagnum(&G__G__ProofLN_pairlETDSetElementmUcOTStringgR), -1, 0, 2, 1, 1, 0, 
17938 "U 'TDSetElement' - 41 - a u 'TString' - 11 - b", (char*)NULL, (void*) NULL, 0);
17939    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__ProofLN_pairlETDSetElementmUcOTStringgR), -1, 1, 1, 1, 4, 0, "u 'pair<TDSetElement*,TString>' - 11 - x", (char*)NULL, (void*) NULL, 0);
17940    // automatic copy constructor
17941    G__memfunc_setup("pair<TDSetElement*,TString>", 2517, G__G__Proof_146_0_4, (int) ('i'), 
17942 G__get_linked_tagnum(&G__G__ProofLN_pairlETDSetElementmUcOTStringgR), -1, 0, 1, 1, 1, 0, "u 'pair<TDSetElement*,TString>' - 11 - -", (char*) NULL, (void*) NULL, 0);
17943    // automatic destructor
17944    G__memfunc_setup("~pair<TDSetElement*,TString>", 2643, G__G__Proof_146_0_5, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
17945    G__tag_memfunc_reset();
17946 }
17947 
17948 static void G__setup_memfunclistlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR(void) {
17949    /* list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > > */
17950    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR));
17951    G__memfunc_setup("list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >",6791,G__G__Proof_148_0_1, 105, G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17952    G__memfunc_setup("begin",517,G__G__Proof_148_0_2, 117, G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17953    G__memfunc_setup("end",311,G__G__Proof_148_0_3, 117, G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17954    G__memfunc_setup("rbegin",631,G__G__Proof_148_0_4, 117, G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17955    G__memfunc_setup("rend",425,G__G__Proof_148_0_5, 117, G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgRcLcLreverse_iterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17956    G__memfunc_setup("empty",559,G__G__Proof_148_0_6, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17957    G__memfunc_setup("size",443,G__G__Proof_148_0_7, 104, -1, G__defined_typename("list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17958    G__memfunc_setup("max_size",864,G__G__Proof_148_0_8, 104, -1, G__defined_typename("list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17959    G__memfunc_setup("front",553,G__G__Proof_148_0_9, 117, G__get_linked_tagnum(&G__G__ProofLN_pairlETDSetElementmUcOTStringgR), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17960    G__memfunc_setup("back",401,G__G__Proof_148_0_10, 117, G__get_linked_tagnum(&G__G__ProofLN_pairlETDSetElementmUcOTStringgR), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
17961    G__memfunc_setup("swap",443,G__G__Proof_148_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >' - 1 - x", (char*)NULL, (void*) NULL, 0);
17962    G__memfunc_setup("insert",661,G__G__Proof_148_0_12, 117, G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
17963 "u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator' - 0 - position u 'pair<TDSetElement*,TString>' - 11 - x", (char*)NULL, (void*) NULL, 0);
17964    G__memfunc_setup("insert",661,G__G__Proof_148_0_13, 121, -1, -1, 0, 3, 1, 1, 0, 
17965 "u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator' - 0 - position U 'pair<TDSetElement*,TString>' - 0 - first "
17966 "U 'pair<TDSetElement*,TString>' - 0 - last", (char*)NULL, (void*) NULL, 0);
17967    G__memfunc_setup("insert",661,G__G__Proof_148_0_14, 121, -1, -1, 0, 3, 1, 1, 0, 
17968 "u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator' - 0 - position u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator' - 0 - first "
17969 "u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
17970    G__memfunc_setup("insert",661,G__G__Proof_148_0_15, 121, -1, -1, 0, 3, 1, 1, 0, 
17971 "u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator' - 0 - position h - 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::size_type' 0 - n "
17972 "u 'pair<TDSetElement*,TString>' - 11 - x", (char*)NULL, (void*) NULL, 0);
17973    G__memfunc_setup("push_front",1096,G__G__Proof_148_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'pair<TDSetElement*,TString>' - 11 - x", (char*)NULL, (void*) NULL, 0);
17974    G__memfunc_setup("push_back",944,G__G__Proof_148_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'pair<TDSetElement*,TString>' - 11 - x", (char*)NULL, (void*) NULL, 0);
17975    G__memfunc_setup("resize",658,G__G__Proof_148_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
17976    G__memfunc_setup("resize",658,G__G__Proof_148_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
17977 "h - 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::size_type' 0 - n u 'pair<TDSetElement*,TString>' - 0 - v", (char*)NULL, (void*) NULL, 0);
17978    G__memfunc_setup("erase",528,G__G__Proof_148_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
17979    G__memfunc_setup("erase",528,G__G__Proof_148_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
17980 "u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator' - 0 - first u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
17981    G__memfunc_setup("clear",519,G__G__Proof_148_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17982    G__memfunc_setup("pop_front",983,G__G__Proof_148_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17983    G__memfunc_setup("pop_back",831,G__G__Proof_148_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
17984    G__memfunc_setup("list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >",6791,G__G__Proof_148_0_25, 105, G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR), -1, 0, 2, 1, 1, 0, 
17985 "h - 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::size_type' 0 - n u 'pair<TDSetElement*,TString>' - 11 '(pair<TDSetElement*,TString>)()' value", (char*)NULL, (void*) NULL, 0);
17986    G__memfunc_setup("list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >",6791,G__G__Proof_148_0_26, 105, G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR), -1, 0, 2, 1, 1, 0, 
17987 "U 'pair<TDSetElement*,TString>' - 10 - first U 'pair<TDSetElement*,TString>' - 10 - last", (char*)NULL, (void*) NULL, 0);
17988    G__memfunc_setup("list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >",6791,G__G__Proof_148_0_27, 105, G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR), -1, 0, 2, 1, 1, 0, 
17989 "u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator' 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::const_iterator' 10 - first u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator' 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
17990    G__memfunc_setup("list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >",6791,G__G__Proof_148_0_28, 105, G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR), -1, 0, 1, 1, 1, 0, "u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >' - 11 - x", (char*)NULL, (void*) NULL, 0);
17991    G__memfunc_setup("operator=",937,G__G__Proof_148_0_29, 117, G__get_linked_tagnum(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR), -1, 1, 1, 1, 1, 0, "u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >' - 11 - x", (char*)NULL, (void*) NULL, 0);
17992    G__memfunc_setup("splice",640,G__G__Proof_148_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
17993 "u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator' - 0 - position u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >' - 1 - x", (char*)NULL, (void*) NULL, 0);
17994    G__memfunc_setup("splice",640,G__G__Proof_148_0_31, 121, -1, -1, 0, 3, 1, 1, 0, 
17995 "u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator' - 0 - position u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >' - 1 - x "
17996 "u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator' - 0 - i", (char*)NULL, (void*) NULL, 0);
17997    G__memfunc_setup("splice",640,G__G__Proof_148_0_32, 121, -1, -1, 0, 4, 1, 1, 0, 
17998 "u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator' - 0 - position u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >' - 1 - x "
17999 "u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator' - 0 - first u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
18000    G__memfunc_setup("remove",654,G__G__Proof_148_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "u 'pair<TDSetElement*,TString>' - 11 - value", (char*)NULL, (void*) NULL, 0);
18001    G__memfunc_setup("unique",663,G__G__Proof_148_0_34, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18002    G__memfunc_setup("merge",528,G__G__Proof_148_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >' - 1 - x", (char*)NULL, (void*) NULL, 0);
18003    G__memfunc_setup("reverse",764,G__G__Proof_148_0_36, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18004    G__memfunc_setup("sort",456,G__G__Proof_148_0_37, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18005    // automatic destructor
18006    G__memfunc_setup("~list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >", 6917, G__G__Proof_148_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
18007    G__tag_memfunc_reset();
18008 }
18009 
18010 static void G__setup_memfuncTProofServ(void) {
18011    /* TProofServ */
18012    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofServ));
18013    G__memfunc_setup("RedirectOutput",1475,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
18014 "C - - 10 '0' dir C - - 10 '\"w\"' mode", (char*)NULL, (void*) NULL, 0);
18015    G__memfunc_setup("CatMotd",684,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
18016    G__memfunc_setup("UnloadPackage",1295,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "C - - 10 - package", (char*)NULL, (void*) NULL, 0);
18017    G__memfunc_setup("UnloadPackages",1410,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
18018    G__memfunc_setup("OldAuthSetup",1218,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "u 'TString' - 1 - wconf", (char*)NULL, (void*) NULL, 0);
18019    G__memfunc_setup("GetPriority",1154,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
18020    G__memfunc_setup("MakeQueryResult",1555,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TProofQueryResult), -1, 0, 7, 1, 4, 0, 
18021 "n - 'Long64_t' 0 - nentries C - - 10 - opt "
18022 "U 'TList' - 0 - inl n - 'Long64_t' 0 - first "
18023 "U 'TDSet' - 0 - dset C - - 10 - selec "
18024 "U 'TObject' - 0 - elist", (char*)NULL, (void*) NULL, 0);
18025    G__memfunc_setup("SetQueryRunning",1571,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TProofQueryResult' - 0 - pq", (char*)NULL, (void*) NULL, 0);
18026    G__memfunc_setup("SendResults",1148,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 4, 0, 
18027 "U 'TSocket' - 0 - sock U 'TList' - 0 '0' outlist "
18028 "U 'TQueryResult' - 0 '0' pq", (char*)NULL, (void*) NULL, 0);
18029    G__memfunc_setup("AcceptResults",1346,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 0, 
18030 "i - 'Int_t' 0 - connections U 'TVirtualProofPlayer' - 0 - mergerPlayer", (char*)NULL, (void*) NULL, 0);
18031    G__memfunc_setup("RegisterDataSets",1630,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
18032 "U 'TList' - 0 - in U 'TList' - 0 - out", (char*)NULL, (void*) NULL, 0);
18033    G__memfunc_setup("SetIdle",682,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "g - 'Bool_t' 0 'kTRUE' st", (char*)NULL, (void*) NULL, 0);
18034    G__memfunc_setup("IsWaiting",911,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
18035    G__memfunc_setup("WaitingQueries",1457,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
18036    G__memfunc_setup("QueueQuery",1051,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "U 'TProofQueryResult' - 0 - pq", (char*)NULL, (void*) NULL, 0);
18037    G__memfunc_setup("NextQuery",949,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TProofQueryResult), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
18038    G__memfunc_setup("CleanupWaitingQueries",2169,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
18039 "g - 'Bool_t' 0 'kTRUE' del U 'TList' - 0 '0' qls", (char*)NULL, (void*) NULL, 0);
18040    G__memfunc_setup("HandleArchive",1294,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
18041 "U 'TMessage' - 0 - mess U 'TString' - 0 '0' slb", (char*)NULL, (void*) NULL, 1);
18042    G__memfunc_setup("HandleCache",1056,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
18043 "U 'TMessage' - 0 - mess U 'TString' - 0 '0' slb", (char*)NULL, (void*) NULL, 1);
18044    G__memfunc_setup("HandleCheckFile",1450,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
18045 "U 'TMessage' - 0 - mess U 'TString' - 0 '0' slb", (char*)NULL, (void*) NULL, 1);
18046    G__memfunc_setup("HandleDataSets",1381,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
18047 "U 'TMessage' - 0 - mess U 'TString' - 0 '0' slb", (char*)NULL, (void*) NULL, 1);
18048    G__memfunc_setup("HandleSubmerger",1528,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TMessage' - 0 - mess", (char*)NULL, (void*) NULL, 1);
18049    G__memfunc_setup("HandleFork",990,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TMessage' - 0 - mess", (char*)NULL, (void*) NULL, 1);
18050    G__memfunc_setup("HandleLibIncPath",1546,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TMessage' - 0 - mess", (char*)NULL, (void*) NULL, 1);
18051    G__memfunc_setup("HandleProcess",1323,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
18052 "U 'TMessage' - 0 - mess U 'TString' - 0 '0' slb", (char*)NULL, (void*) NULL, 1);
18053    G__memfunc_setup("HandleQueryList",1534,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TMessage' - 0 - mess", (char*)NULL, (void*) NULL, 1);
18054    G__memfunc_setup("HandleRemove",1210,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
18055 "U 'TMessage' - 0 - mess U 'TString' - 0 '0' slb", (char*)NULL, (void*) NULL, 1);
18056    G__memfunc_setup("HandleRetrieve",1426,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
18057 "U 'TMessage' - 0 - mess U 'TString' - 0 '0' slb", (char*)NULL, (void*) NULL, 1);
18058    G__memfunc_setup("HandleWorkerLists",1749,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TMessage' - 0 - mess", (char*)NULL, (void*) NULL, 1);
18059    G__memfunc_setup("ProcessNext",1150,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TString' - 0 '0' slb", (char*)NULL, (void*) NULL, 1);
18060    G__memfunc_setup("Setup",529,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
18061    G__memfunc_setup("SetupCommon",1146,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
18062    G__memfunc_setup("MakePlayer",1003,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
18063    G__memfunc_setup("DeletePlayer",1216,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
18064    G__memfunc_setup("Fork",402,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
18065    G__memfunc_setup("GetSessionStatus",1672,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
18066    G__memfunc_setup("IsIdle",570,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
18067    G__memfunc_setup("UnlinkDataDir",1290,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 0);
18068    G__memfunc_setup("TProofServ",1018,G__G__Proof_153_0_39, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofServ), -1, 0, 3, 1, 1, 0, 
18069 "I - 'Int_t' 0 - argc C - - 2 - argv "
18070 "E - - 0 '0' flog", (char*)NULL, (void*) NULL, 0);
18071    G__memfunc_setup("CreateServer",1227,G__G__Proof_153_0_40, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
18072    G__memfunc_setup("GetProof",806,G__G__Proof_153_0_41, 85, G__get_linked_tagnum(&G__G__ProofLN_TProof), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18073    G__memfunc_setup("GetService",1009,G__G__Proof_153_0_42, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18074    G__memfunc_setup("GetConfDir",965,G__G__Proof_153_0_43, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18075    G__memfunc_setup("GetConfFile",1062,G__G__Proof_153_0_44, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18076    G__memfunc_setup("GetUser",703,G__G__Proof_153_0_45, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18077    G__memfunc_setup("GetGroup",813,G__G__Proof_153_0_46, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18078    G__memfunc_setup("GetWorkDir",994,G__G__Proof_153_0_47, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18079    G__memfunc_setup("GetImage",771,G__G__Proof_153_0_48, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18080    G__memfunc_setup("GetSessionTag",1312,G__G__Proof_153_0_49, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18081    G__memfunc_setup("GetSessionDir",1315,G__G__Proof_153_0_50, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18082    G__memfunc_setup("GetPackageDir",1259,G__G__Proof_153_0_51, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18083    G__memfunc_setup("GetDataDir",953,G__G__Proof_153_0_52, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18084    G__memfunc_setup("GetProtocol",1138,G__G__Proof_153_0_53, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18085    G__memfunc_setup("GetOrdinal",1001,G__G__Proof_153_0_54, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18086    G__memfunc_setup("GetGroupId",986,G__G__Proof_153_0_55, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18087    G__memfunc_setup("GetGroupSize",1224,G__G__Proof_153_0_56, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18088    G__memfunc_setup("GetLogLevel",1082,G__G__Proof_153_0_57, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18089    G__memfunc_setup("GetSocket",905,G__G__Proof_153_0_58, 85, G__get_linked_tagnum(&G__G__ProofLN_TSocket), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18090    G__memfunc_setup("GetRealTime",1075,G__G__Proof_153_0_59, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18091    G__memfunc_setup("GetCpuTime",983,G__G__Proof_153_0_60, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18092    G__memfunc_setup("GetQuerySeqNum",1423,G__G__Proof_153_0_61, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18093    G__memfunc_setup("GetTotSessions",1454,G__G__Proof_153_0_62, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18094    G__memfunc_setup("GetActSessions",1423,G__G__Proof_153_0_63, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18095    G__memfunc_setup("GetEffSessions",1416,G__G__Proof_153_0_64, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18096    G__memfunc_setup("GetOptions",1036,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
18097 "I - 'Int_t' 0 - argc C - - 2 - argv", (char*)NULL, (void*) NULL, 1);
18098    G__memfunc_setup("GetEnabledPackages",1770,G__G__Proof_153_0_66, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18099    G__memfunc_setup("GetInflateFactor",1602,G__G__Proof_153_0_67, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18100    G__memfunc_setup("GetVirtMemMax",1290,G__G__Proof_153_0_68, 108, -1, G__defined_typename("Long_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Long_t (*)())(&TProofServ::GetVirtMemMax) ), 0);
18101    G__memfunc_setup("GetResMemMax",1167,G__G__Proof_153_0_69, 108, -1, G__defined_typename("Long_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Long_t (*)())(&TProofServ::GetResMemMax) ), 0);
18102    G__memfunc_setup("GetMemHWM",811,G__G__Proof_153_0_70, 102, -1, G__defined_typename("Float_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Float_t (*)())(&TProofServ::GetMemHWM) ), 0);
18103    G__memfunc_setup("GetMemStop",997,G__G__Proof_153_0_71, 102, -1, G__defined_typename("Float_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Float_t (*)())(&TProofServ::GetMemStop) ), 0);
18104    G__memfunc_setup("GetMsgSizeHWM",1230,G__G__Proof_153_0_72, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18105    G__memfunc_setup("GetPrefix",910,G__G__Proof_153_0_73, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18106    G__memfunc_setup("FlushLogFile",1188,G__G__Proof_153_0_74, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18107    G__memfunc_setup("GetCacheLock",1149,G__G__Proof_153_0_75, 85, G__get_linked_tagnum(&G__G__ProofLN_TProofLockPath), -1, 0, 0, 1, 1, 0, "", "cache dir locker; used by TProofPlayer", (void*) NULL, 0);
18108    G__memfunc_setup("CopyFromCache",1283,G__G__Proof_153_0_76, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
18109 "C - - 10 - name g - 'Bool_t' 0 - cpbin", (char*)NULL, (void*) NULL, 0);
18110    G__memfunc_setup("CopyToCache",1074,G__G__Proof_153_0_77, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
18111 "C - - 10 - name i - 'Int_t' 0 '0' opt", (char*)NULL, (void*) NULL, 0);
18112    G__memfunc_setup("GetWorkers",1037,G__G__Proof_153_0_78, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofServcLcLEQueryAction), -1, 0, 3, 1, 1, 0, 
18113 "U 'TList' - 0 - workers i - 'Int_t' 1 - prioritychange "
18114 "g - 'Bool_t' 0 'kFALSE' resume", (char*)NULL, (void*) NULL, 1);
18115    G__memfunc_setup("HandleException",1531,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - sig", (char*)NULL, (void*) NULL, 1);
18116    G__memfunc_setup("HandleSocketInput",1733,G__G__Proof_153_0_80, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
18117 "U 'TMessage' - 0 - mess g - 'Bool_t' 0 - all", (char*)NULL, (void*) NULL, 1);
18118    G__memfunc_setup("HandleSocketInput",1733,G__G__Proof_153_0_81, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
18119    G__memfunc_setup("HandleUrgentData",1595,G__G__Proof_153_0_82, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
18120    G__memfunc_setup("HandleSigPipe",1277,G__G__Proof_153_0_83, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
18121    G__memfunc_setup("HandleTermination",1750,G__G__Proof_153_0_84, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
18122    G__memfunc_setup("Interrupt",973,G__G__Proof_153_0_85, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18123    G__memfunc_setup("IsEndMaster",1087,G__G__Proof_153_0_86, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18124    G__memfunc_setup("IsMaster",808,G__G__Proof_153_0_87, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18125    G__memfunc_setup("IsParallel",1001,G__G__Proof_153_0_88, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18126    G__memfunc_setup("IsTopMaster",1115,G__G__Proof_153_0_89, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18127    G__memfunc_setup("Run",309,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' retrn", (char*)NULL, (void*) NULL, 1);
18128    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);
18129    G__memfunc_setup("RestartComputeTime",1873,G__G__Proof_153_0_92, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18130    G__memfunc_setup("Get",288,G__G__Proof_153_0_93, 85, G__get_linked_tagnum(&G__G__ProofLN_TObject), -1, 0, 1, 1, 1, 0, "C - - 10 - namecycle", (char*)NULL, (void*) NULL, 0);
18131    G__memfunc_setup("GetNextPacket",1303,G__G__Proof_153_0_94, 85, G__get_linked_tagnum(&G__G__ProofLN_TDSetElement), -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 '-1' totalEntries", (char*)NULL, (void*) NULL, 0);
18132    G__memfunc_setup("ReleaseWorker",1339,G__G__Proof_153_0_95, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
18133    G__memfunc_setup("Reset",515,G__G__Proof_153_0_96, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - dir", (char*)NULL, (void*) NULL, 0);
18134    G__memfunc_setup("ReceiveFile",1091,G__G__Proof_153_0_97, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
18135 "C - - 10 - file g - 'Bool_t' 0 - bin "
18136 "n - 'Long64_t' 0 - size", (char*)NULL, (void*) NULL, 0);
18137    G__memfunc_setup("SendAsynMessage",1514,G__G__Proof_153_0_98, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
18138 "C - - 10 - msg g - 'Bool_t' 0 'kTRUE' lf", (char*)NULL, (void*) NULL, 1);
18139    G__memfunc_setup("SendLogFile",1068,G__G__Proof_153_0_99, 121, -1, -1, 0, 3, 1, 1, 0, 
18140 "i - 'Int_t' 0 '0' status i - 'Int_t' 0 '-1' start "
18141 "i - 'Int_t' 0 '-1' end", (char*)NULL, (void*) NULL, 1);
18142    G__memfunc_setup("SendStatistics",1461,G__G__Proof_153_0_100, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18143    G__memfunc_setup("SendParallel",1207,G__G__Proof_153_0_101, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' async", (char*)NULL, (void*) NULL, 0);
18144    G__memfunc_setup("UpdateSessionStatus",1995,G__G__Proof_153_0_102, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' xst", (char*)NULL, (void*) NULL, 0);
18145    G__memfunc_setup("DisableTimeout",1435,G__G__Proof_153_0_103, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
18146    G__memfunc_setup("EnableTimeout",1326,G__G__Proof_153_0_104, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
18147    G__memfunc_setup("Terminate",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - status", (char*)NULL, (void*) NULL, 1);
18148    G__memfunc_setup("LogToMaster",1105,G__G__Proof_153_0_106, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 0);
18149    G__memfunc_setup("SetErrorHandlerFile",1908,G__G__Proof_153_0_107, 69, -1, -1, 0, 1, 3, 1, 0, "E - - 0 - ferr", (char*)NULL, (void*) G__func2void( (FILE* (*)(FILE*))(&TProofServ::SetErrorHandlerFile) ), 0);
18150    G__memfunc_setup("ErrorHandler",1224,G__G__Proof_153_0_108, 121, -1, -1, 0, 4, 3, 1, 0, 
18151 "i - 'Int_t' 0 - level g - 'Bool_t' 0 - abort "
18152 "C - - 10 - location C - - 10 - msg", (char*)NULL, (void*) G__func2void( (void (*)(Int_t, Bool_t, const char*, const char*))(&TProofServ::ErrorHandler) ), 0);
18153    G__memfunc_setup("ResolveKeywords",1592,G__G__Proof_153_0_109, 121, -1, -1, 0, 2, 3, 1, 0, 
18154 "u 'TString' - 1 - fname C - - 10 '0' path", (char*)NULL, (void*) G__func2void( (void (*)(TString&, const char*))(&TProofServ::ResolveKeywords) ), 0);
18155    G__memfunc_setup("SetLastMsg",999,G__G__Proof_153_0_110, 121, -1, -1, 0, 1, 3, 1, 0, "C - - 10 - lastmsg", (char*)NULL, (void*) G__func2void( (void (*)(const char*))(&TProofServ::SetLastMsg) ), 0);
18156    G__memfunc_setup("IsActive",792,G__G__Proof_153_0_111, 103, -1, G__defined_typename("Bool_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Bool_t (*)())(&TProofServ::IsActive) ), 0);
18157    G__memfunc_setup("This",408,G__G__Proof_153_0_112, 85, G__get_linked_tagnum(&G__G__ProofLN_TProofServ), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TProofServ* (*)())(&TProofServ::This) ), 0);
18158    G__memfunc_setup("Class",502,G__G__Proof_153_0_113, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofServ::Class) ), 0);
18159    G__memfunc_setup("Class_Name",982,G__G__Proof_153_0_114, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofServ::Class_Name) ), 0);
18160    G__memfunc_setup("Class_Version",1339,G__G__Proof_153_0_115, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofServ::Class_Version) ), 0);
18161    G__memfunc_setup("Dictionary",1046,G__G__Proof_153_0_116, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofServ::Dictionary) ), 0);
18162    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18163    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
18164    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
18165    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_153_0_120, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
18166    G__memfunc_setup("DeclFileName",1145,G__G__Proof_153_0_121, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofServ::DeclFileName) ), 0);
18167    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_153_0_122, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofServ::ImplFileLine) ), 0);
18168    G__memfunc_setup("ImplFileName",1171,G__G__Proof_153_0_123, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofServ::ImplFileName) ), 0);
18169    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_153_0_124, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofServ::DeclFileLine) ), 0);
18170    // automatic destructor
18171    G__memfunc_setup("~TProofServ", 1144, G__G__Proof_153_0_125, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
18172    G__tag_memfunc_reset();
18173 }
18174 
18175 static void G__setup_memfuncTDSetProxy(void) {
18176    /* TDSetProxy */
18177    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TDSetProxy));
18178    G__memfunc_setup("TDSetProxy",998,G__G__Proof_154_0_1, 105, G__get_linked_tagnum(&G__G__ProofLN_TDSetProxy), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18179    G__memfunc_setup("TDSetProxy",998,G__G__Proof_154_0_2, 105, G__get_linked_tagnum(&G__G__ProofLN_TDSetProxy), -1, 0, 3, 1, 1, 0, 
18180 "C - - 10 - type C - - 10 '\"*\"' objname "
18181 "C - - 10 '\"/\"' dir", (char*)NULL, (void*) NULL, 0);
18182    G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
18183    G__memfunc_setup("Next",415,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TDSetElement), -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 '-1' totalEntries", (char*)NULL, (void*) NULL, 1);
18184    G__memfunc_setup("SetProofServ",1234,G__G__Proof_154_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TProofServ' - 0 - serv", (char*)NULL, (void*) NULL, 0);
18185    G__memfunc_setup("Class",502,G__G__Proof_154_0_6, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDSetProxy::Class) ), 0);
18186    G__memfunc_setup("Class_Name",982,G__G__Proof_154_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDSetProxy::Class_Name) ), 0);
18187    G__memfunc_setup("Class_Version",1339,G__G__Proof_154_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDSetProxy::Class_Version) ), 0);
18188    G__memfunc_setup("Dictionary",1046,G__G__Proof_154_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDSetProxy::Dictionary) ), 0);
18189    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18190    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
18191    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
18192    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_154_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
18193    G__memfunc_setup("DeclFileName",1145,G__G__Proof_154_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDSetProxy::DeclFileName) ), 0);
18194    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_154_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDSetProxy::ImplFileLine) ), 0);
18195    G__memfunc_setup("ImplFileName",1171,G__G__Proof_154_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDSetProxy::ImplFileName) ), 0);
18196    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_154_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDSetProxy::DeclFileLine) ), 0);
18197    // automatic destructor
18198    G__memfunc_setup("~TDSetProxy", 1124, G__G__Proof_154_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
18199    G__tag_memfunc_reset();
18200 }
18201 
18202 static void G__setup_memfuncTProofDesc(void) {
18203    /* TProofDesc */
18204    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofDesc));
18205    G__memfunc_setup("TProofDesc",985,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofDesc), -1, 0, 1, 1, 4, 0, "u 'TProofDesc' - 11 - -", "Not implemented", (void*) NULL, 0);
18206    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__ProofLN_TProofDesc), -1, 1, 1, 1, 4, 0, "u 'TProofDesc' - 11 - -", "Not implemented", (void*) NULL, 0);
18207    G__memfunc_setup("TProofDesc",985,G__G__Proof_263_0_3, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofDesc), -1, 0, 7, 1, 1, 0, 
18208 "C - - 10 '0' tag C - - 10 '0' alias "
18209 "C - - 10 '0' url i - 'Int_t' 0 '-1' id "
18210 "i - 'Int_t' 0 '-1' remid i - 'Int_t' 0 'kIdle' status "
18211 "U 'TProof' - 0 '0' p", (char*)NULL, (void*) NULL, 0);
18212    G__memfunc_setup("GetLocalId",952,G__G__Proof_263_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18213    G__memfunc_setup("GetProof",806,G__G__Proof_263_0_5, 85, G__get_linked_tagnum(&G__G__ProofLN_TProof), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18214    G__memfunc_setup("GetRemoteId",1081,G__G__Proof_263_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18215    G__memfunc_setup("GetStatus",932,G__G__Proof_263_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18216    G__memfunc_setup("GetUrl",595,G__G__Proof_263_0_8, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18217    G__memfunc_setup("IsIdle",570,G__G__Proof_263_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18218    G__memfunc_setup("IsRunning",925,G__G__Proof_263_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18219    G__memfunc_setup("IsShuttingDown",1450,G__G__Proof_263_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18220    G__memfunc_setup("MatchId",666,G__G__Proof_263_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
18221    G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
18222    G__memfunc_setup("SetStatus",944,G__G__Proof_263_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - st", (char*)NULL, (void*) NULL, 0);
18223    G__memfunc_setup("SetProof",818,G__G__Proof_263_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TProof' - 0 - p", (char*)NULL, (void*) NULL, 0);
18224    G__memfunc_setup("SetRemoteId",1093,G__G__Proof_263_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 0);
18225    G__memfunc_setup("Class",502,G__G__Proof_263_0_17, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofDesc::Class) ), 0);
18226    G__memfunc_setup("Class_Name",982,G__G__Proof_263_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofDesc::Class_Name) ), 0);
18227    G__memfunc_setup("Class_Version",1339,G__G__Proof_263_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofDesc::Class_Version) ), 0);
18228    G__memfunc_setup("Dictionary",1046,G__G__Proof_263_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofDesc::Dictionary) ), 0);
18229    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18230    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
18231    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
18232    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_263_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
18233    G__memfunc_setup("DeclFileName",1145,G__G__Proof_263_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofDesc::DeclFileName) ), 0);
18234    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_263_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofDesc::ImplFileLine) ), 0);
18235    G__memfunc_setup("ImplFileName",1171,G__G__Proof_263_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofDesc::ImplFileName) ), 0);
18236    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_263_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofDesc::DeclFileLine) ), 0);
18237    // automatic destructor
18238    G__memfunc_setup("~TProofDesc", 1111, G__G__Proof_263_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
18239    G__tag_memfunc_reset();
18240 }
18241 
18242 static void G__setup_memfuncTProofLog(void) {
18243    /* TProofLog */
18244    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofLog));
18245    G__memfunc_setup("Add",265,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TProofLogElem), -1, 0, 2, 1, 4, 0, 
18246 "C - - 10 - ord C - - 10 - url", (char*)NULL, (void*) NULL, 0);
18247    G__memfunc_setup("TProofLog",892,G__G__Proof_264_0_2, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofLog), -1, 0, 3, 1, 1, 0, 
18248 "C - - 10 - stag C - - 10 - url "
18249 "U 'TProofMgr' - 0 - mgr", (char*)NULL, (void*) NULL, 0);
18250    G__memfunc_setup("Display",726,G__G__Proof_264_0_3, 121, -1, -1, 0, 3, 1, 1, 0, 
18251 "C - - 10 '\"*\"' ord i - 'Int_t' 0 '-10' from "
18252 "i - 'Int_t' 0 '-1' to", (char*)NULL, (void*) NULL, 0);
18253    G__memfunc_setup("GetListOfLogs",1286,G__G__Proof_264_0_4, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18254    G__memfunc_setup("Grep",398,G__G__Proof_264_0_5, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
18255 "C - - 10 - txt i - 'Int_t' 0 '0' from", (char*)NULL, (void*) NULL, 0);
18256    G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '0' opt", (char*)NULL, (void*) NULL, 1);
18257    G__memfunc_setup("Prt",310,G__G__Proof_264_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - what", (char*)NULL, (void*) NULL, 0);
18258    G__memfunc_setup("Retrieve",838,G__G__Proof_264_0_8, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
18259 "C - - 10 '\"*\"' ord i 'TProofLog::ERetrieveOpt' - 0 'TProofLog::kTrailing' opt "
18260 "C - - 10 '0' fname C - - 10 '0' pattern", (char*)NULL, (void*) NULL, 0);
18261    G__memfunc_setup("Save",399,G__G__Proof_264_0_9, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
18262 "C - - 10 '\"*\"' ord C - - 10 '0' fname "
18263 "C - 'Option_t' 10 '\"w\"' opt", (char*)NULL, (void*) NULL, 0);
18264    G__memfunc_setup("StartTime",925,G__G__Proof_264_0_10, 117, G__get_linked_tagnum(&G__G__ProofLN_TDatime), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18265    G__memfunc_setup("SetLogToBox",1082,G__G__Proof_264_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' lgbox", (char*)NULL, (void*) NULL, 0);
18266    G__memfunc_setup("LogToBox",782,G__G__Proof_264_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18267    G__memfunc_setup("SetMaxTransferSize",1842,G__G__Proof_264_0_13, 121, -1, -1, 0, 1, 3, 1, 0, "n - 'Long64_t' 0 - maxsz", (char*)NULL, (void*) G__func2void( (void (*)(Long64_t))(&TProofLog::SetMaxTransferSize) ), 0);
18268    G__memfunc_setup("Class",502,G__G__Proof_264_0_14, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofLog::Class) ), 0);
18269    G__memfunc_setup("Class_Name",982,G__G__Proof_264_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofLog::Class_Name) ), 0);
18270    G__memfunc_setup("Class_Version",1339,G__G__Proof_264_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofLog::Class_Version) ), 0);
18271    G__memfunc_setup("Dictionary",1046,G__G__Proof_264_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofLog::Dictionary) ), 0);
18272    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18273    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
18274    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
18275    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_264_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
18276    G__memfunc_setup("DeclFileName",1145,G__G__Proof_264_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofLog::DeclFileName) ), 0);
18277    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_264_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofLog::ImplFileLine) ), 0);
18278    G__memfunc_setup("ImplFileName",1171,G__G__Proof_264_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofLog::ImplFileName) ), 0);
18279    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_264_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofLog::DeclFileLine) ), 0);
18280    // automatic destructor
18281    G__memfunc_setup("~TProofLog", 1018, G__G__Proof_264_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
18282    G__tag_memfunc_reset();
18283 }
18284 
18285 static void G__setup_memfuncTProofMgr(void) {
18286    /* TProofMgr */
18287    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofMgr));
18288    G__memfunc_setup("TProofMgr",896,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofMgr), -1, 0, 1, 1, 4, 0, "u 'TProofMgr' - 11 - -", "Not implemented", (void*) NULL, 0);
18289    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__ProofLN_TProofMgr), -1, 1, 1, 1, 4, 0, "u 'TProofMgr' - 11 - -", "Not implemented", (void*) NULL, 0);
18290    G__memfunc_setup("GetXProofMgrHook",1589,(G__InterfaceMethod) NULL, 89, -1, G__defined_typename("TProofMgr_t"), 0, 0, 3, 4, 0, "", (char*)NULL, (void*) NULL, 0);
18291    G__memfunc_setup("TProofMgr",896,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofMgr), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
18292    G__memfunc_setup("TProofMgr",896,G__G__Proof_265_0_5, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofMgr), -1, 0, 3, 1, 1, 0, 
18293 "C - - 10 - url i - 'Int_t' 0 '-1' loglevel "
18294 "C - - 10 '\"\"' alias", (char*)NULL, (void*) NULL, 0);
18295    G__memfunc_setup("IsLite",586,G__G__Proof_265_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18296    G__memfunc_setup("IsProofd",806,G__G__Proof_265_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18297    G__memfunc_setup("IsValid",684,G__G__Proof_265_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18298    G__memfunc_setup("SetInvalid",1011,G__G__Proof_265_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
18299    G__memfunc_setup("AttachSession",1337,G__G__Proof_265_0_10, 85, G__get_linked_tagnum(&G__G__ProofLN_TProof), -1, 0, 2, 1, 1, 0, 
18300 "i - 'Int_t' 0 - - g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
18301    G__memfunc_setup("AttachSession",1337,G__G__Proof_265_0_11, 85, G__get_linked_tagnum(&G__G__ProofLN_TProof), -1, 0, 2, 1, 1, 0, 
18302 "U 'TProofDesc' - 0 - - g - 'Bool_t' 0 'kFALSE' -", (char*)NULL, (void*) NULL, 1);
18303    G__memfunc_setup("CreateSession",1336,G__G__Proof_265_0_12, 85, G__get_linked_tagnum(&G__G__ProofLN_TProof), -1, 0, 3, 1, 1, 0, 
18304 "C - - 10 '0' - C - - 10 '0' - "
18305 "i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 1);
18306    G__memfunc_setup("DetachSession",1325,G__G__Proof_265_0_13, 121, -1, -1, 0, 2, 1, 1, 0, 
18307 "i - 'Int_t' 0 - - C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
18308    G__memfunc_setup("DetachSession",1325,G__G__Proof_265_0_14, 121, -1, -1, 0, 2, 1, 1, 0, 
18309 "U 'TProof' - 0 - - C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
18310    G__memfunc_setup("DiscardSession",1438,G__G__Proof_265_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TProof' - 0 - p", (char*)NULL, (void*) NULL, 1);
18311    G__memfunc_setup("GetProofDesc",1189,G__G__Proof_265_0_16, 85, G__get_linked_tagnum(&G__G__ProofLN_TProofDesc), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
18312    G__memfunc_setup("GetProofDesc",1189,G__G__Proof_265_0_17, 85, G__get_linked_tagnum(&G__G__ProofLN_TProofDesc), -1, 0, 1, 1, 1, 0, "U 'TProof' - 0 - p", (char*)NULL, (void*) NULL, 1);
18313    G__memfunc_setup("GetRemoteProtocol",1758,G__G__Proof_265_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18314    G__memfunc_setup("GetSessionLogs",1433,G__G__Proof_265_0_19, 85, G__get_linked_tagnum(&G__G__ProofLN_TProofLog), -1, 0, 3, 1, 1, 0, 
18315 "i - 'Int_t' 0 '0' - C - - 10 '0' - "
18316 "C - - 10 '\"-v \\\"| SvcMsg\\\"\"' -", (char*)NULL, (void*) NULL, 1);
18317    G__memfunc_setup("GetUrl",595,G__G__Proof_265_0_20, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
18318    G__memfunc_setup("MatchUrl",800,G__G__Proof_265_0_21, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - url", (char*)NULL, (void*) NULL, 1);
18319    G__memfunc_setup("QuerySessions",1389,G__G__Proof_265_0_22, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"S\"' opt", (char*)NULL, (void*) NULL, 1);
18320    G__memfunc_setup("ReadBuffer",982,G__G__Proof_265_0_23, 85, G__get_linked_tagnum(&G__G__ProofLN_TObjString), -1, 0, 3, 1, 1, 0, 
18321 "C - - 10 - - n - 'Long64_t' 0 - - "
18322 "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
18323    G__memfunc_setup("ReadBuffer",982,G__G__Proof_265_0_24, 85, G__get_linked_tagnum(&G__G__ProofLN_TObjString), -1, 0, 2, 1, 1, 0, 
18324 "C - - 10 - - C - - 10 - -", (char*)NULL, (void*) NULL, 1);
18325    G__memfunc_setup("Reset",515,G__G__Proof_265_0_25, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
18326 "g - 'Bool_t' 0 'kFALSE' hard C - - 10 '0' usr", (char*)NULL, (void*) NULL, 1);
18327    G__memfunc_setup("ShowWorkers",1166,G__G__Proof_265_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
18328    G__memfunc_setup("SendMsgToUsers",1414,G__G__Proof_265_0_27, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
18329 "C - - 10 - - C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
18330    G__memfunc_setup("SetAlias",790,G__G__Proof_265_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '\"\"' alias", (char*)NULL, (void*) NULL, 1);
18331    G__memfunc_setup("SetROOTVersion",1366,G__G__Proof_265_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
18332    G__memfunc_setup("ShowROOTVersions",1598,G__G__Proof_265_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
18333    G__memfunc_setup("ShutdownSession",1600,G__G__Proof_265_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - id", (char*)NULL, (void*) NULL, 1);
18334    G__memfunc_setup("ShutdownSession",1600,G__G__Proof_265_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TProof' - 0 - p", (char*)NULL, (void*) NULL, 1);
18335    G__memfunc_setup("Cp",179,G__G__Proof_265_0_33, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
18336 "C - - 10 - - C - - 10 '0' - "
18337 "C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
18338    G__memfunc_setup("Find",385,G__G__Proof_265_0_34, 121, -1, -1, 0, 3, 1, 1, 0, 
18339 "C - - 10 '\"~/\"' - C - - 10 '0' - "
18340 "C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
18341    G__memfunc_setup("Grep",398,G__G__Proof_265_0_35, 121, -1, -1, 0, 3, 1, 1, 0, 
18342 "C - - 10 - - C - - 10 '0' - "
18343 "C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
18344    G__memfunc_setup("Ls",191,G__G__Proof_265_0_36, 121, -1, -1, 0, 3, 1, 1, 0, 
18345 "C - - 10 '\"~/\"' - C - - 10 '0' - "
18346 "C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
18347    G__memfunc_setup("More",403,G__G__Proof_265_0_37, 121, -1, -1, 0, 3, 1, 1, 0, 
18348 "C - - 10 - - C - - 10 '0' - "
18349 "C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
18350    G__memfunc_setup("Rm",191,G__G__Proof_265_0_38, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
18351 "C - - 10 - - C - - 10 '0' - "
18352 "C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
18353    G__memfunc_setup("Tail",394,G__G__Proof_265_0_39, 121, -1, -1, 0, 3, 1, 1, 0, 
18354 "C - - 10 - - C - - 10 '0' - "
18355 "C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
18356    G__memfunc_setup("Md5sum",571,G__G__Proof_265_0_40, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
18357 "C - - 10 - - u 'TString' - 1 - - "
18358 "C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
18359    G__memfunc_setup("Stat",412,G__G__Proof_265_0_41, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
18360 "C - - 10 - - u 'FileStat_t' - 1 - - "
18361 "C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
18362    G__memfunc_setup("GetFile",672,G__G__Proof_265_0_42, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
18363 "C - - 10 - - C - - 10 - - "
18364 "C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
18365    G__memfunc_setup("PutFile",697,G__G__Proof_265_0_43, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
18366 "C - - 10 - - C - - 10 - - "
18367 "C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
18368    G__memfunc_setup("GetListOfManagers",1695,G__G__Proof_265_0_44, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TList* (*)())(&TProofMgr::GetListOfManagers) ), 0);
18369    G__memfunc_setup("SetTXProofMgrHook",1685,G__G__Proof_265_0_45, 121, -1, -1, 0, 1, 3, 1, 0, "Y - 'TProofMgr_t' 0 - pmh", (char*)NULL, (void*) G__func2void( (void (*)(TProofMgr_t))(&TProofMgr::SetTXProofMgrHook) ), 0);
18370    G__memfunc_setup("Create",596,G__G__Proof_265_0_46, 85, G__get_linked_tagnum(&G__G__ProofLN_TProofMgr), -1, 0, 4, 3, 1, 0, 
18371 "C - - 10 - url i - 'Int_t' 0 '-1' loglevel "
18372 "C - - 10 '0' alias g - 'Bool_t' 0 'kTRUE' xpd", (char*)NULL, (void*) G__func2void( (TProofMgr* (*)(const char*, Int_t, const char*, Bool_t))(&TProofMgr::Create) ), 0);
18373    G__memfunc_setup("Class",502,G__G__Proof_265_0_47, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofMgr::Class) ), 0);
18374    G__memfunc_setup("Class_Name",982,G__G__Proof_265_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofMgr::Class_Name) ), 0);
18375    G__memfunc_setup("Class_Version",1339,G__G__Proof_265_0_49, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofMgr::Class_Version) ), 0);
18376    G__memfunc_setup("Dictionary",1046,G__G__Proof_265_0_50, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofMgr::Dictionary) ), 0);
18377    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18378    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
18379    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
18380    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_265_0_54, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
18381    G__memfunc_setup("DeclFileName",1145,G__G__Proof_265_0_55, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofMgr::DeclFileName) ), 0);
18382    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_265_0_56, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofMgr::ImplFileLine) ), 0);
18383    G__memfunc_setup("ImplFileName",1171,G__G__Proof_265_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofMgr::ImplFileName) ), 0);
18384    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_265_0_58, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofMgr::DeclFileLine) ), 0);
18385    // automatic destructor
18386    G__memfunc_setup("~TProofMgr", 1022, G__G__Proof_265_0_59, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
18387    G__tag_memfunc_reset();
18388 }
18389 
18390 static void G__setup_memfuncTProofDebug(void) {
18391    /* TProofDebug */
18392    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofDebug));
18393    // automatic default constructor
18394    G__memfunc_setup("TProofDebug", 1089, G__G__Proof_268_0_1, (int) ('i'), G__get_linked_tagnum(&G__G__ProofLN_TProofDebug), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
18395    // automatic copy constructor
18396    G__memfunc_setup("TProofDebug", 1089, G__G__Proof_268_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__ProofLN_TProofDebug), -1, 0, 1, 1, 1, 0, "u 'TProofDebug' - 11 - -", (char*) NULL, (void*) NULL, 0);
18397    // automatic destructor
18398    G__memfunc_setup("~TProofDebug", 1215, G__G__Proof_268_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
18399    // automatic assignment operator
18400    G__memfunc_setup("operator=", 937, G__G__Proof_268_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__ProofLN_TProofDebug), -1, 1, 1, 1, 1, 0, "u 'TProofDebug' - 11 - -", (char*) NULL, (void*) NULL, 0);
18401    G__tag_memfunc_reset();
18402 }
18403 
18404 static void G__setup_memfuncTVirtualProofPlayer(void) {
18405    /* TVirtualProofPlayer */
18406    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TVirtualProofPlayer));
18407    G__memfunc_setup("Process",735,G__G__Proof_291_0_2, 110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
18408 "U 'TDSet' - 0 - set C - - 10 - selector "
18409 "C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
18410 "n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 3);
18411    G__memfunc_setup("Finalize",818,G__G__Proof_291_0_3, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
18412 "g - 'Bool_t' 0 'kFALSE' force g - 'Bool_t' 0 'kFALSE' sync", (char*)NULL, (void*) NULL, 3);
18413    G__memfunc_setup("Finalize",818,G__G__Proof_291_0_4, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "U 'TQueryResult' - 0 - qr", (char*)NULL, (void*) NULL, 3);
18414    G__memfunc_setup("DrawSelect",1006,G__G__Proof_291_0_5, 110, -1, G__defined_typename("Long64_t"), 0, 6, 1, 1, 0, 
18415 "U 'TDSet' - 0 - set C - - 10 - varexp "
18416 "C - - 10 - selection C - 'Option_t' 10 '\"\"' option "
18417 "n - 'Long64_t' 0 '-1' nentries n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 3);
18418    G__memfunc_setup("GetDrawArgs",1083,G__G__Proof_291_0_6, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
18419 "C - - 10 - var C - - 10 - sel "
18420 "C - 'Option_t' 10 - opt u 'TString' - 1 - selector "
18421 "u 'TString' - 1 - objname", (char*)NULL, (void*) NULL, 3);
18422    G__memfunc_setup("HandleGetTreeHeader",1861,G__G__Proof_291_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMessage' - 0 - mess", (char*)NULL, (void*) NULL, 3);
18423    G__memfunc_setup("HandleRecvHisto",1507,G__G__Proof_291_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMessage' - 0 - mess", (char*)NULL, (void*) NULL, 3);
18424    G__memfunc_setup("StopProcess",1157,G__G__Proof_291_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
18425 "g - 'Bool_t' 0 - abort i - 'Int_t' 0 '-1' timeout", (char*)NULL, (void*) NULL, 3);
18426    G__memfunc_setup("AddInput",793,G__G__Proof_291_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - inp", (char*)NULL, (void*) NULL, 3);
18427    G__memfunc_setup("ClearInput",1015,G__G__Proof_291_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
18428    G__memfunc_setup("GetOutput",945,G__G__Proof_291_0_12, 85, G__get_linked_tagnum(&G__G__ProofLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 3);
18429    G__memfunc_setup("GetOutputList",1357,G__G__Proof_291_0_13, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
18430    G__memfunc_setup("GetInputList",1228,G__G__Proof_291_0_14, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
18431    G__memfunc_setup("GetListOfResults",1635,G__G__Proof_291_0_15, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
18432    G__memfunc_setup("AddQueryResult",1438,G__G__Proof_291_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TQueryResult' - 0 - q", (char*)NULL, (void*) NULL, 3);
18433    G__memfunc_setup("GetCurrentQuery",1561,G__G__Proof_291_0_17, 85, G__get_linked_tagnum(&G__G__ProofLN_TQueryResult), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
18434    G__memfunc_setup("GetQueryResult",1461,G__G__Proof_291_0_18, 85, G__get_linked_tagnum(&G__G__ProofLN_TQueryResult), -1, 0, 1, 1, 1, 0, "C - - 10 - ref", (char*)NULL, (void*) NULL, 3);
18435    G__memfunc_setup("RemoveQueryResult",1795,G__G__Proof_291_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - ref", (char*)NULL, (void*) NULL, 3);
18436    G__memfunc_setup("SetCurrentQuery",1573,G__G__Proof_291_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TQueryResult' - 0 - q", (char*)NULL, (void*) NULL, 3);
18437    G__memfunc_setup("SetMaxDrawQueries",1726,G__G__Proof_291_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 3);
18438    G__memfunc_setup("RestorePreviousQuery",2135,G__G__Proof_291_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
18439    G__memfunc_setup("AddOutputObject",1521,G__G__Proof_291_0_23, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 3);
18440    G__memfunc_setup("AddOutput",922,G__G__Proof_291_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - out", "Incorporate a list", (void*) NULL, 3);
18441    G__memfunc_setup("StoreOutput",1182,G__G__Proof_291_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - out", "Adopts the list", (void*) NULL, 3);
18442    G__memfunc_setup("StoreFeedback",1298,G__G__Proof_291_0_26, 121, -1, -1, 0, 2, 1, 1, 0, 
18443 "U 'TObject' - 0 - slave U 'TList' - 0 - out", "Adopts the list", (void*) NULL, 3);
18444    G__memfunc_setup("Progress",853,G__G__Proof_291_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
18445 "n - 'Long64_t' 0 - total n - 'Long64_t' 0 - processed", "*SIGNAL*", (void*) NULL, 3);
18446    G__memfunc_setup("Progress",853,G__G__Proof_291_0_28, 121, -1, -1, 0, 3, 1, 1, 0, 
18447 "U 'TSlave' - 0 - - n - 'Long64_t' 0 - total "
18448 "n - 'Long64_t' 0 - processed", (char*)NULL, (void*) NULL, 3);
18449    G__memfunc_setup("Progress",853,G__G__Proof_291_0_29, 121, -1, -1, 0, 7, 1, 1, 0, 
18450 "n - 'Long64_t' 0 - total n - 'Long64_t' 0 - processed "
18451 "n - 'Long64_t' 0 - bytesread f - 'Float_t' 0 - initTime "
18452 "f - 'Float_t' 0 - procTime f - 'Float_t' 0 - evtrti "
18453 "f - 'Float_t' 0 - mbrti", "*SIGNAL*", (void*) NULL, 3);
18454    G__memfunc_setup("Progress",853,G__G__Proof_291_0_30, 121, -1, -1, 0, 8, 1, 1, 0, 
18455 "U 'TSlave' - 0 - - n - 'Long64_t' 0 - total "
18456 "n - 'Long64_t' 0 - processed n - 'Long64_t' 0 - bytesread "
18457 "f - 'Float_t' 0 - initTime f - 'Float_t' 0 - procTime "
18458 "f - 'Float_t' 0 - evtrti f - 'Float_t' 0 - mbrti", "*SIGNAL*", (void*) NULL, 3);
18459    G__memfunc_setup("Progress",853,G__G__Proof_291_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TProofProgressInfo' - 0 - -", "*SIGNAL*", (void*) NULL, 3);
18460    G__memfunc_setup("Progress",853,G__G__Proof_291_0_32, 121, -1, -1, 0, 2, 1, 1, 0, 
18461 "U 'TSlave' - 0 - - U 'TProofProgressInfo' - 0 - -", "*SIGNAL*", (void*) NULL, 3);
18462    G__memfunc_setup("Feedback",773,G__G__Proof_291_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - objs", "*SIGNAL*", (void*) NULL, 3);
18463    G__memfunc_setup("CreateDrawFeedback",1767,G__G__Proof_291_0_34, 85, G__get_linked_tagnum(&G__G__ProofLN_TDrawFeedback), -1, 0, 1, 1, 1, 0, "U 'TProof' - 0 - p", (char*)NULL, (void*) NULL, 3);
18464    G__memfunc_setup("SetDrawFeedbackOption",2104,G__G__Proof_291_0_35, 121, -1, -1, 0, 2, 1, 1, 0, 
18465 "U 'TDrawFeedback' - 0 - f C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 3);
18466    G__memfunc_setup("DeleteDrawFeedback",1766,G__G__Proof_291_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDrawFeedback' - 0 - f", (char*)NULL, (void*) NULL, 3);
18467    G__memfunc_setup("GetNextPacket",1303,G__G__Proof_291_0_37, 85, G__get_linked_tagnum(&G__G__ProofLN_TDSetElement), -1, 0, 2, 1, 1, 0, 
18468 "U 'TSlave' - 0 - slave U 'TMessage' - 0 - r", (char*)NULL, (void*) NULL, 3);
18469    G__memfunc_setup("ReinitSelector",1452,G__G__Proof_291_0_38, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TQueryResult' - 0 - qr", (char*)NULL, (void*) NULL, 3);
18470    G__memfunc_setup("UpdateAutoBin",1301,G__G__Proof_291_0_39, 121, -1, -1, 0, 7, 1, 1, 0, 
18471 "C - - 10 - name d - 'Double_t' 1 - xmin "
18472 "d - 'Double_t' 1 - xmax d - 'Double_t' 1 - ymin "
18473 "d - 'Double_t' 1 - ymax d - 'Double_t' 1 - zmin "
18474 "d - 'Double_t' 1 - zmax", (char*)NULL, (void*) NULL, 3);
18475    G__memfunc_setup("MergeOutput",1153,G__G__Proof_291_0_40, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
18476    G__memfunc_setup("IsClient",795,G__G__Proof_291_0_41, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
18477    G__memfunc_setup("GetExitStatus",1342,G__G__Proof_291_0_42, 105, G__get_linked_tagnum(&G__G__ProofLN_TVirtualProofPlayercLcLEExitStatus), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
18478    G__memfunc_setup("GetEventsProcessed",1853,G__G__Proof_291_0_43, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
18479    G__memfunc_setup("AddEventsProcessed",1830,G__G__Proof_291_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - ev", (char*)NULL, (void*) NULL, 3);
18480    G__memfunc_setup("GetProgressStatus",1785,G__G__Proof_291_0_45, 85, G__get_linked_tagnum(&G__G__ProofLN_TProofProgressStatus), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
18481    G__memfunc_setup("SetDispatchTimer",1629,G__G__Proof_291_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 3);
18482    G__memfunc_setup("SetStopTimer",1235,G__G__Proof_291_0_47, 121, -1, -1, 0, 3, 1, 1, 0, 
18483 "g - 'Bool_t' 0 'kTRUE' on g - 'Bool_t' 0 'kFALSE' abort "
18484 "i - 'Int_t' 0 '0' timeout", (char*)NULL, (void*) NULL, 3);
18485    G__memfunc_setup("SetInitTime",1103,G__G__Proof_291_0_48, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
18486    G__memfunc_setup("GetCacheSize",1167,G__G__Proof_291_0_49, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
18487    G__memfunc_setup("GetLearnEntries",1516,G__G__Proof_291_0_50, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
18488    G__memfunc_setup("GetPacketizer",1330,G__G__Proof_291_0_51, 85, G__get_linked_tagnum(&G__G__ProofLN_TVirtualPacketizer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18489    G__memfunc_setup("Create",596,G__G__Proof_291_0_52, 85, G__get_linked_tagnum(&G__G__ProofLN_TVirtualProofPlayer), -1, 0, 3, 3, 1, 0, 
18490 "C - - 10 - player U 'TProof' - 0 - p "
18491 "U 'TSocket' - 0 '0' s", (char*)NULL, (void*) G__func2void( (TVirtualProofPlayer* (*)(const char*, TProof*, TSocket*))(&TVirtualProofPlayer::Create) ), 0);
18492    G__memfunc_setup("Class",502,G__G__Proof_291_0_53, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualProofPlayer::Class) ), 0);
18493    G__memfunc_setup("Class_Name",982,G__G__Proof_291_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualProofPlayer::Class_Name) ), 0);
18494    G__memfunc_setup("Class_Version",1339,G__G__Proof_291_0_55, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualProofPlayer::Class_Version) ), 0);
18495    G__memfunc_setup("Dictionary",1046,G__G__Proof_291_0_56, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualProofPlayer::Dictionary) ), 0);
18496    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18497    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
18498    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
18499    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_291_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
18500    G__memfunc_setup("DeclFileName",1145,G__G__Proof_291_0_61, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualProofPlayer::DeclFileName) ), 0);
18501    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_291_0_62, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualProofPlayer::ImplFileLine) ), 0);
18502    G__memfunc_setup("ImplFileName",1171,G__G__Proof_291_0_63, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualProofPlayer::ImplFileName) ), 0);
18503    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_291_0_64, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualProofPlayer::DeclFileLine) ), 0);
18504    // automatic destructor
18505    G__memfunc_setup("~TVirtualProofPlayer", 2092, G__G__Proof_291_0_65, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
18506    G__tag_memfunc_reset();
18507 }
18508 
18509 static void G__setup_memfuncTSlave(void) {
18510    /* TSlave */
18511    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TSlave));
18512    G__memfunc_setup("TSlave",591,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofLN_TSlave), -1, 0, 1, 1, 4, 0, "u 'TSlave' - 11 - s", (char*)NULL, (void*) NULL, 0);
18513    G__memfunc_setup("TSlave",591,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofLN_TSlave), -1, 0, 8, 1, 4, 0, 
18514 "C - - 10 - host C - - 10 - ord "
18515 "i - 'Int_t' 0 - perf C - - 10 - image "
18516 "U 'TProof' - 0 - proof i - 'Int_t' 0 - stype "
18517 "C - - 10 - workdir C - - 10 - msd", (char*)NULL, (void*) NULL, 0);
18518    G__memfunc_setup("OldAuthSetup",1218,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
18519 "g - 'Bool_t' 0 - master u 'TString' - 0 - wconf", (char*)NULL, (void*) NULL, 0);
18520    G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
18521 "C - - 10 - host i - 'Int_t' 0 - port "
18522 "i - 'Int_t' 0 - stype", (char*)NULL, (void*) NULL, 0);
18523    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TSlave' - 11 - -", (char*)NULL, (void*) NULL, 0);
18524    G__memfunc_setup("Create",596,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TSlave), -1, 0, 8, 3, 4, 0, 
18525 "C - - 10 - url C - - 10 - ord "
18526 "i - 'Int_t' 0 - perf C - - 10 - image "
18527 "U 'TProof' - 0 - proof i - 'Int_t' 0 - stype "
18528 "C - - 10 - workdir C - - 10 - msd", (char*)NULL, (void*) NULL, 0);
18529    G__memfunc_setup("TSlave",591,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofLN_TSlave), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
18530    G__memfunc_setup("FlushSocket",1131,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
18531    G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
18532 "U 'TSocket' - 0 - s i - 'Int_t' 0 - stype", (char*)NULL, (void*) NULL, 0);
18533    G__memfunc_setup("Interrupt",973,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 1);
18534    G__memfunc_setup("Ping",398,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
18535    G__memfunc_setup("SendCoordinator",1550,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TObjString), -1, 0, 3, 1, 2, 0, 
18536 "i - 'Int_t' 0 - kind C - - 10 '0' msg "
18537 "i - 'Int_t' 0 '0' int2", (char*)NULL, (void*) NULL, 1);
18538    G__memfunc_setup("SendGroupPriority",1785,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
18539 "C - - 10 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
18540    G__memfunc_setup("SetAlias",790,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - - 10 - alias", (char*)NULL, (void*) NULL, 1);
18541    G__memfunc_setup("SetSocket",917,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TSocket' - 0 - s", (char*)NULL, (void*) NULL, 0);
18542    G__memfunc_setup("SetStatus",944,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - st", (char*)NULL, (void*) NULL, 1);
18543    G__memfunc_setup("StopProcess",1157,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
18544 "g - 'Bool_t' 0 - abort i - 'Int_t' 0 - timeout", (char*)NULL, (void*) NULL, 1);
18545    G__memfunc_setup("Close",502,G__G__Proof_296_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
18546    G__memfunc_setup("Compare",711,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
18547    G__memfunc_setup("IsSortable",1016,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18548    G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
18549    G__memfunc_setup("GetImage",771,G__G__Proof_296_0_22, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18550    G__memfunc_setup("GetProofWorkDir",1512,G__G__Proof_296_0_23, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18551    G__memfunc_setup("GetWorkDir",994,G__G__Proof_296_0_24, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18552    G__memfunc_setup("GetUser",703,G__G__Proof_296_0_25, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18553    G__memfunc_setup("GetGroup",813,G__G__Proof_296_0_26, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18554    G__memfunc_setup("GetPort",709,G__G__Proof_296_0_27, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18555    G__memfunc_setup("GetOrdinal",1001,G__G__Proof_296_0_28, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18556    G__memfunc_setup("GetPerfIdx",978,G__G__Proof_296_0_29, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18557    G__memfunc_setup("GetProtocol",1138,G__G__Proof_296_0_30, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18558    G__memfunc_setup("GetSocket",905,G__G__Proof_296_0_31, 85, G__get_linked_tagnum(&G__G__ProofLN_TSocket), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18559    G__memfunc_setup("GetProof",806,G__G__Proof_296_0_32, 85, G__get_linked_tagnum(&G__G__ProofLN_TProof), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18560    G__memfunc_setup("GetBytesRead",1187,G__G__Proof_296_0_33, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18561    G__memfunc_setup("GetRealTime",1075,G__G__Proof_296_0_34, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18562    G__memfunc_setup("GetCpuTime",983,G__G__Proof_296_0_35, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18563    G__memfunc_setup("GetSlaveType",1213,G__G__Proof_296_0_36, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18564    G__memfunc_setup("GetStatus",932,G__G__Proof_296_0_37, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18565    G__memfunc_setup("GetParallel",1101,G__G__Proof_296_0_38, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18566    G__memfunc_setup("GetMsd",580,G__G__Proof_296_0_39, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18567    G__memfunc_setup("GetSessionTag",1312,G__G__Proof_296_0_40, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18568    G__memfunc_setup("GetInputHandler",1518,G__G__Proof_296_0_41, 85, G__get_linked_tagnum(&G__G__ProofLN_TFileHandler), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18569    G__memfunc_setup("SetInputHandler",1530,G__G__Proof_296_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TFileHandler' - 0 - ih", (char*)NULL, (void*) NULL, 0);
18570    G__memfunc_setup("GetArchCompiler",1497,G__G__Proof_296_0_43, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18571    G__memfunc_setup("GetROOTVersion",1354,G__G__Proof_296_0_44, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18572    G__memfunc_setup("IsValid",684,G__G__Proof_296_0_45, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18573    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);
18574    G__memfunc_setup("SetupServ",945,G__G__Proof_296_0_47, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
18575 "i - 'Int_t' 0 - stype C - - 10 - conffile", (char*)NULL, (void*) NULL, 1);
18576    G__memfunc_setup("SetInterruptHandler",1975,G__G__Proof_296_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
18577    G__memfunc_setup("SetArchCompiler",1509,G__G__Proof_296_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - ac", (char*)NULL, (void*) NULL, 0);
18578    G__memfunc_setup("SetROOTVersion",1366,G__G__Proof_296_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - rv", (char*)NULL, (void*) NULL, 0);
18579    G__memfunc_setup("SetSessionTag",1324,G__G__Proof_296_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - st", (char*)NULL, (void*) NULL, 0);
18580    G__memfunc_setup("SetTXSlaveHook",1380,G__G__Proof_296_0_52, 121, -1, -1, 0, 1, 3, 1, 0, "Y - 'TSlave_t' 0 - xslavehook", (char*)NULL, (void*) G__func2void( (void (*)(TSlave_t))(&TSlave::SetTXSlaveHook) ), 0);
18581    G__memfunc_setup("Touch",515,G__G__Proof_296_0_53, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
18582    G__memfunc_setup("Class",502,G__G__Proof_296_0_54, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSlave::Class) ), 0);
18583    G__memfunc_setup("Class_Name",982,G__G__Proof_296_0_55, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSlave::Class_Name) ), 0);
18584    G__memfunc_setup("Class_Version",1339,G__G__Proof_296_0_56, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSlave::Class_Version) ), 0);
18585    G__memfunc_setup("Dictionary",1046,G__G__Proof_296_0_57, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSlave::Dictionary) ), 0);
18586    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18587    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
18588    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
18589    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_296_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
18590    G__memfunc_setup("DeclFileName",1145,G__G__Proof_296_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSlave::DeclFileName) ), 0);
18591    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_296_0_63, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSlave::ImplFileLine) ), 0);
18592    G__memfunc_setup("ImplFileName",1171,G__G__Proof_296_0_64, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSlave::ImplFileName) ), 0);
18593    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_296_0_65, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSlave::DeclFileLine) ), 0);
18594    // automatic destructor
18595    G__memfunc_setup("~TSlave", 717, G__G__Proof_296_0_66, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
18596    G__tag_memfunc_reset();
18597 }
18598 
18599 static void G__setup_memfuncTProofProgressInfo(void) {
18600    /* TProofProgressInfo */
18601    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofProgressInfo));
18602    G__memfunc_setup("TProofProgressInfo",1851,G__G__Proof_299_0_1, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofProgressInfo), -1, 0, 10, 1, 1, 0, 
18603 "n - 'Long64_t' 0 '0' tot n - 'Long64_t' 0 '0' proc "
18604 "n - 'Long64_t' 0 '0' bytes f - 'Float_t' 0 '-1.' initt "
18605 "f - 'Float_t' 0 '-1.' proct f - 'Float_t' 0 '-1.' evts "
18606 "f - 'Float_t' 0 '-1.' mbs i - 'Int_t' 0 '0' actw "
18607 "i - 'Int_t' 0 '0' tsess f - 'Float_t' 0 '0.' esess", (char*)NULL, (void*) NULL, 0);
18608    G__memfunc_setup("Class",502,G__G__Proof_299_0_2, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofProgressInfo::Class) ), 0);
18609    G__memfunc_setup("Class_Name",982,G__G__Proof_299_0_3, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofProgressInfo::Class_Name) ), 0);
18610    G__memfunc_setup("Class_Version",1339,G__G__Proof_299_0_4, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofProgressInfo::Class_Version) ), 0);
18611    G__memfunc_setup("Dictionary",1046,G__G__Proof_299_0_5, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofProgressInfo::Dictionary) ), 0);
18612    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18613    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
18614    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
18615    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_299_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
18616    G__memfunc_setup("DeclFileName",1145,G__G__Proof_299_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofProgressInfo::DeclFileName) ), 0);
18617    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_299_0_11, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofProgressInfo::ImplFileLine) ), 0);
18618    G__memfunc_setup("ImplFileName",1171,G__G__Proof_299_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofProgressInfo::ImplFileName) ), 0);
18619    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_299_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofProgressInfo::DeclFileLine) ), 0);
18620    // automatic copy constructor
18621    G__memfunc_setup("TProofProgressInfo", 1851, G__G__Proof_299_0_14, (int) ('i'), G__get_linked_tagnum(&G__G__ProofLN_TProofProgressInfo), -1, 0, 1, 1, 1, 0, "u 'TProofProgressInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
18622    // automatic destructor
18623    G__memfunc_setup("~TProofProgressInfo", 1977, G__G__Proof_299_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
18624    // automatic assignment operator
18625    G__memfunc_setup("operator=", 937, G__G__Proof_299_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__ProofLN_TProofProgressInfo), -1, 1, 1, 1, 1, 0, "u 'TProofProgressInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
18626    G__tag_memfunc_reset();
18627 }
18628 
18629 static void G__setup_memfuncTSlaveInfo(void) {
18630    /* TSlaveInfo */
18631    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TSlaveInfo));
18632    G__memfunc_setup("TSlaveInfo",987,G__G__Proof_300_0_1, 105, G__get_linked_tagnum(&G__G__ProofLN_TSlaveInfo), -1, 0, 5, 1, 1, 0, 
18633 "C - - 10 '\"\"' ordinal C - - 10 '\"\"' host "
18634 "i - 'Int_t' 0 '0' perfidx C - - 10 '\"\"' msd "
18635 "C - - 10 '\"\"' datadir", (char*)NULL, (void*) NULL, 0);
18636    G__memfunc_setup("GetDataDir",953,G__G__Proof_300_0_2, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18637    G__memfunc_setup("GetMsd",580,G__G__Proof_300_0_3, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18638    G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
18639    G__memfunc_setup("GetOrdinal",1001,G__G__Proof_300_0_5, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18640    G__memfunc_setup("GetSysInfo",1003,G__G__Proof_300_0_6, 117, G__get_linked_tagnum(&G__G__ProofLN_SysInfo_t), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18641    G__memfunc_setup("SetStatus",944,G__G__Proof_300_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TSlaveInfo::ESlaveStatus' - 0 - stat", (char*)NULL, (void*) NULL, 0);
18642    G__memfunc_setup("SetSysInfo",1015,G__G__Proof_300_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'SysInfo_t' - 0 - si", (char*)NULL, (void*) NULL, 0);
18643    G__memfunc_setup("Compare",711,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "U 'TObject' - 10 - obj", (char*)NULL, (void*) NULL, 1);
18644    G__memfunc_setup("IsSortable",1016,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18645    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);
18646    G__memfunc_setup("Class",502,G__G__Proof_300_0_12, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSlaveInfo::Class) ), 0);
18647    G__memfunc_setup("Class_Name",982,G__G__Proof_300_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSlaveInfo::Class_Name) ), 0);
18648    G__memfunc_setup("Class_Version",1339,G__G__Proof_300_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSlaveInfo::Class_Version) ), 0);
18649    G__memfunc_setup("Dictionary",1046,G__G__Proof_300_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSlaveInfo::Dictionary) ), 0);
18650    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18651    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
18652    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
18653    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_300_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
18654    G__memfunc_setup("DeclFileName",1145,G__G__Proof_300_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSlaveInfo::DeclFileName) ), 0);
18655    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_300_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSlaveInfo::ImplFileLine) ), 0);
18656    G__memfunc_setup("ImplFileName",1171,G__G__Proof_300_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSlaveInfo::ImplFileName) ), 0);
18657    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_300_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSlaveInfo::DeclFileLine) ), 0);
18658    // automatic copy constructor
18659    G__memfunc_setup("TSlaveInfo", 987, G__G__Proof_300_0_24, (int) ('i'), G__get_linked_tagnum(&G__G__ProofLN_TSlaveInfo), -1, 0, 1, 1, 1, 0, "u 'TSlaveInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
18660    // automatic destructor
18661    G__memfunc_setup("~TSlaveInfo", 1113, G__G__Proof_300_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
18662    // automatic assignment operator
18663    G__memfunc_setup("operator=", 937, G__G__Proof_300_0_26, (int) ('u'), G__get_linked_tagnum(&G__G__ProofLN_TSlaveInfo), -1, 1, 1, 1, 1, 0, "u 'TSlaveInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
18664    G__tag_memfunc_reset();
18665 }
18666 
18667 static void G__setup_memfuncTMergerInfo(void) {
18668    /* TMergerInfo */
18669    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TMergerInfo));
18670    G__memfunc_setup("TMergerInfo",1090,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofLN_TMergerInfo), -1, 0, 1, 1, 4, 0, "u 'TMergerInfo' - 11 - -", "Not implemented", (void*) NULL, 0);
18671    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__ProofLN_TMergerInfo), -1, 1, 1, 1, 4, 0, "u 'TMergerInfo' - 11 - -", "Not implemented", (void*) NULL, 0);
18672    G__memfunc_setup("TMergerInfo",1090,G__G__Proof_302_0_3, 105, G__get_linked_tagnum(&G__G__ProofLN_TMergerInfo), -1, 0, 3, 1, 1, 0, 
18673 "U 'TSlave' - 0 - t i - 'Int_t' 0 - port "
18674 "i - 'Int_t' 0 - forHowManyWorkers", (char*)NULL, (void*) NULL, 0);
18675    G__memfunc_setup("AddWorker",899,G__G__Proof_302_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TSlave' - 0 - sl", (char*)NULL, (void*) NULL, 0);
18676    G__memfunc_setup("GetWorkers",1037,G__G__Proof_302_0_5, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18677    G__memfunc_setup("GetMerger",898,G__G__Proof_302_0_6, 85, G__get_linked_tagnum(&G__G__ProofLN_TSlave), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18678    G__memfunc_setup("GetPort",709,G__G__Proof_302_0_7, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18679    G__memfunc_setup("GetWorkersToMerge",1728,G__G__Proof_302_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18680    G__memfunc_setup("GetMergedWorkers",1633,G__G__Proof_302_0_9, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18681    G__memfunc_setup("GetMergedObjects",1598,G__G__Proof_302_0_10, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18682    G__memfunc_setup("SetMergedWorker",1530,G__G__Proof_302_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18683    G__memfunc_setup("AddMergedObjects",1575,G__G__Proof_302_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - objects", (char*)NULL, (void*) NULL, 0);
18684    G__memfunc_setup("AreAllWorkersAssigned",2124,G__G__Proof_302_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18685    G__memfunc_setup("AreAllWorkersMerged",1906,G__G__Proof_302_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18686    G__memfunc_setup("Deactivate",1018,G__G__Proof_302_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18687    G__memfunc_setup("IsActive",792,G__G__Proof_302_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18688    G__memfunc_setup("Class",502,G__G__Proof_302_0_17, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMergerInfo::Class) ), 0);
18689    G__memfunc_setup("Class_Name",982,G__G__Proof_302_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMergerInfo::Class_Name) ), 0);
18690    G__memfunc_setup("Class_Version",1339,G__G__Proof_302_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMergerInfo::Class_Version) ), 0);
18691    G__memfunc_setup("Dictionary",1046,G__G__Proof_302_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMergerInfo::Dictionary) ), 0);
18692    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18693    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
18694    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
18695    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_302_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
18696    G__memfunc_setup("DeclFileName",1145,G__G__Proof_302_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMergerInfo::DeclFileName) ), 0);
18697    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_302_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMergerInfo::ImplFileLine) ), 0);
18698    G__memfunc_setup("ImplFileName",1171,G__G__Proof_302_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMergerInfo::ImplFileName) ), 0);
18699    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_302_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMergerInfo::DeclFileLine) ), 0);
18700    // automatic destructor
18701    G__memfunc_setup("~TMergerInfo", 1216, G__G__Proof_302_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
18702    G__tag_memfunc_reset();
18703 }
18704 
18705 static void G__setup_memfuncTProofLite(void) {
18706    /* TProofLite */
18707    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofLite));
18708    G__memfunc_setup("TProofLite",1000,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofLite), -1, 0, 1, 1, 4, 0, "u 'TProofLite' - 11 - -", "not implemented", (void*) NULL, 0);
18709    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TProofLite' - 11 - -", "idem", (void*) NULL, 0);
18710    G__memfunc_setup("CleanupSandbox",1431,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
18711    G__memfunc_setup("CreateSandbox",1315,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
18712    G__memfunc_setup("FindUniqueSlaves",1638,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
18713    G__memfunc_setup("NotifyStartUp",1356,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
18714 "C - - 10 - action i - 'Int_t' 0 - done "
18715 "i - 'Int_t' 0 - tot", (char*)NULL, (void*) NULL, 0);
18716    G__memfunc_setup("SetProofServEnv",1531,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "C - - 10 - ord", (char*)NULL, (void*) NULL, 0);
18717    G__memfunc_setup("InitDataSetManager",1781,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
18718    G__memfunc_setup("RegisterDataSets",1630,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
18719 "U 'TList' - 0 - in U 'TList' - 0 - out", (char*)NULL, (void*) NULL, 0);
18720    G__memfunc_setup("ResolveKeywords",1592,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
18721 "u 'TString' - 1 - s C - - 10 - logfile", (char*)NULL, (void*) NULL, 0);
18722    G__memfunc_setup("SendInputDataFile",1684,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
18723    G__memfunc_setup("TProofLite",1000,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofLite), -1, 0, 0, 1, 2, 0, "", "For derived classes to use", (void*) NULL, 0);
18724    G__memfunc_setup("CreateSymLinks",1422,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "U 'TList' - 0 - files", (char*)NULL, (void*) NULL, 0);
18725    G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 2, 0, 
18726 "C - - 10 - masterurl C - - 10 - conffile "
18727 "C - - 10 - confdir i - 'Int_t' 0 - loglevel "
18728 "C - - 10 '0' alias", (char*)NULL, (void*) NULL, 0);
18729    G__memfunc_setup("MakeQueryResult",1555,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TProofQueryResult), -1, 0, 5, 1, 2, 0, 
18730 "n - 'Long64_t' 0 - nent C - - 10 - opt "
18731 "n - 'Long64_t' 0 - fst U 'TDSet' - 0 - dset "
18732 "C - - 10 - selec", (char*)NULL, (void*) NULL, 0);
18733    G__memfunc_setup("SetQueryRunning",1571,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TProofQueryResult' - 0 - pq", (char*)NULL, (void*) NULL, 0);
18734    G__memfunc_setup("SetupWorkers",1278,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
18735 "i - 'Int_t' 0 '0' opt U 'TList' - 0 '0' wrks", (char*)NULL, (void*) NULL, 0);
18736    G__memfunc_setup("CopyMacroToCache",1572,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 2, 0, 
18737 "C - - 10 - macro i - 'Int_t' 0 '0' headerRequired "
18738 "U 'TSelector' - 2 '0' selector i - 'Int_t' 0 '0' opt", (char*)NULL, (void*) NULL, 0);
18739    G__memfunc_setup("TProofLite",1000,G__G__Proof_307_0_19, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofLite), -1, 0, 6, 1, 1, 0, 
18740 "C - - 10 - masterurl C - - 10 'kPROOF_ConfFile' conffile "
18741 "C - - 10 'kPROOF_ConfDir' confdir i - 'Int_t' 0 '0' loglevel "
18742 "C - - 10 '0' alias U 'TProofMgr' - 0 '0' mgr", (char*)NULL, (void*) NULL, 0);
18743    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);
18744    G__memfunc_setup("DrawSelect",1006,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 6, 1, 1, 0, 
18745 "U 'TDSet' - 0 - dset C - - 10 - varexp "
18746 "C - - 10 '\"\"' selection C - 'Option_t' 10 '\"\"' option "
18747 "n - 'Long64_t' 0 '-1' nentries n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
18748    G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
18749 "U 'TDSet' - 0 - dset C - - 10 - sel "
18750 "C - 'Option_t' 10 '\"\"' o n - 'Long64_t' 0 '-1' nent "
18751 "n - 'Long64_t' 0 '0' fst", (char*)NULL, (void*) NULL, 1);
18752    G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
18753 "U 'TFileCollection' - 0 - fc C - - 10 - sel "
18754 "C - 'Option_t' 10 '\"\"' o n - 'Long64_t' 0 '-1' nent "
18755 "n - 'Long64_t' 0 '0' fst", (char*)NULL, (void*) NULL, 1);
18756    G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 6, 1, 1, 0, 
18757 "C - - 10 - dsname C - - 10 - sel "
18758 "C - 'Option_t' 10 '\"\"' o n - 'Long64_t' 0 '-1' nent "
18759 "n - 'Long64_t' 0 '0' fst U 'TObject' - 0 '0' enl", (char*)NULL, (void*) NULL, 1);
18760    G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 3, 1, 1, 0, 
18761 "C - - 10 - sel n - 'Long64_t' 0 - nent "
18762 "C - 'Option_t' 10 '\"\"' o", (char*)NULL, (void*) NULL, 1);
18763    G__memfunc_setup("ShowCache",885,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' all", (char*)NULL, (void*) NULL, 1);
18764    G__memfunc_setup("ClearCache",955,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '0' file", (char*)NULL, (void*) NULL, 1);
18765    G__memfunc_setup("Load",384,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
18766 "C - - 10 - macro g - 'Bool_t' 0 'kFALSE' notOnClient "
18767 "g - 'Bool_t' 0 'kTRUE' uniqueOnly U 'TList' - 0 '0' wrks", (char*)NULL, (void*) NULL, 1);
18768    G__memfunc_setup("GetListOfQueries",1615,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
18769    G__memfunc_setup("Remove",622,G__G__Proof_307_0_30, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
18770 "C - - 10 - ref g - 'Bool_t' 0 - all", (char*)NULL, (void*) NULL, 0);
18771    G__memfunc_setup("RegisterDataSet",1515,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
18772 "C - - 10 - dsName U 'TFileCollection' - 0 - ds "
18773 "C - - 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
18774    G__memfunc_setup("ExistsDataSet",1318,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - uri", (char*)NULL, (void*) NULL, 1);
18775    G__memfunc_setup("GetDataSets",1081,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TMap), -1, 0, 2, 1, 1, 0, 
18776 "C - - 10 '\"\"' uri C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
18777    G__memfunc_setup("ShowDataSets",1210,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
18778 "C - - 10 '\"\"' uri C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
18779    G__memfunc_setup("GetDataSet",966,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TFileCollection), -1, 0, 2, 1, 1, 0, 
18780 "C - - 10 - uri C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
18781    G__memfunc_setup("RemoveDataSet",1300,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
18782 "C - - 10 - uri C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
18783    G__memfunc_setup("VerifyDataSet",1307,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
18784 "C - - 10 - uri C - - 10 '0' -", (char*)NULL, (void*) NULL, 1);
18785    G__memfunc_setup("SetDataSetTreeName",1763,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
18786 "C - - 10 - dataset C - - 10 - treename", (char*)NULL, (void*) NULL, 1);
18787    G__memfunc_setup("ShowDataSetCache",1563,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '0' dataset", (char*)NULL, (void*) NULL, 1);
18788    G__memfunc_setup("ClearDataSetCache",1633,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 '0' dataset", (char*)NULL, (void*) NULL, 1);
18789    G__memfunc_setup("GetTreeHeader",1273,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TTree), -1, 0, 1, 1, 1, 0, "U 'TDSet' - 0 - tdset", (char*)NULL, (void*) NULL, 1);
18790    G__memfunc_setup("GetNumberOfWorkers",1835,G__G__Proof_307_0_42, 105, -1, G__defined_typename("Int_t"), 0, 1, 3, 1, 0, "C - - 10 '0' url", (char*)NULL, (void*) G__func2void( (Int_t (*)(const char*))(&TProofLite::GetNumberOfWorkers) ), 0);
18791    G__memfunc_setup("Class",502,G__G__Proof_307_0_43, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofLite::Class) ), 0);
18792    G__memfunc_setup("Class_Name",982,G__G__Proof_307_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofLite::Class_Name) ), 0);
18793    G__memfunc_setup("Class_Version",1339,G__G__Proof_307_0_45, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofLite::Class_Version) ), 0);
18794    G__memfunc_setup("Dictionary",1046,G__G__Proof_307_0_46, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofLite::Dictionary) ), 0);
18795    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18796    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
18797    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
18798    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_307_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
18799    G__memfunc_setup("DeclFileName",1145,G__G__Proof_307_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofLite::DeclFileName) ), 0);
18800    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_307_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofLite::ImplFileLine) ), 0);
18801    G__memfunc_setup("ImplFileName",1171,G__G__Proof_307_0_53, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofLite::ImplFileName) ), 0);
18802    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_307_0_54, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofLite::DeclFileLine) ), 0);
18803    // automatic destructor
18804    G__memfunc_setup("~TProofLite", 1126, G__G__Proof_307_0_55, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
18805    G__tag_memfunc_reset();
18806 }
18807 
18808 static void G__setup_memfuncTSlaveLite(void) {
18809    /* TSlaveLite */
18810    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TSlaveLite));
18811    G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
18812    G__memfunc_setup("TSlaveLite",989,G__G__Proof_309_0_2, 105, G__get_linked_tagnum(&G__G__ProofLN_TSlaveLite), -1, 0, 7, 1, 1, 0, 
18813 "C - - 10 - ord i - 'Int_t' 0 - perf "
18814 "C - - 10 - image U 'TProof' - 0 - proof "
18815 "i - 'Int_t' 0 - stype C - - 10 - workdir "
18816 "C - - 10 - msd", (char*)NULL, (void*) NULL, 0);
18817    G__memfunc_setup("Close",502,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' opt", (char*)NULL, (void*) NULL, 1);
18818    G__memfunc_setup("DoError",701,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 8, 
18819 "i - - 0 - level C - - 10 - location "
18820 "C - - 10 - fmt u 'va_list' - 0 - va", (char*)NULL, (void*) NULL, 1);
18821    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);
18822    G__memfunc_setup("SetupServ",945,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
18823 "i - 'Int_t' 0 - stype C - - 10 - conffile", (char*)NULL, (void*) NULL, 1);
18824    G__memfunc_setup("Class",502,G__G__Proof_309_0_7, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSlaveLite::Class) ), 0);
18825    G__memfunc_setup("Class_Name",982,G__G__Proof_309_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSlaveLite::Class_Name) ), 0);
18826    G__memfunc_setup("Class_Version",1339,G__G__Proof_309_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSlaveLite::Class_Version) ), 0);
18827    G__memfunc_setup("Dictionary",1046,G__G__Proof_309_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSlaveLite::Dictionary) ), 0);
18828    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18829    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
18830    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
18831    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_309_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
18832    G__memfunc_setup("DeclFileName",1145,G__G__Proof_309_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSlaveLite::DeclFileName) ), 0);
18833    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_309_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSlaveLite::ImplFileLine) ), 0);
18834    G__memfunc_setup("ImplFileName",1171,G__G__Proof_309_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSlaveLite::ImplFileName) ), 0);
18835    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_309_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSlaveLite::DeclFileLine) ), 0);
18836    // automatic destructor
18837    G__memfunc_setup("~TSlaveLite", 1115, G__G__Proof_309_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
18838    G__tag_memfunc_reset();
18839 }
18840 
18841 static void G__setup_memfuncTProofCondor(void) {
18842    /* TProofCondor */
18843    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofCondor));
18844    G__memfunc_setup("StartSlaves",1148,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
18845    G__memfunc_setup("GetJobAd",736,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__ProofLN_TString), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
18846    G__memfunc_setup("TProofCondor",1215,G__G__Proof_342_0_3, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofCondor), -1, 0, 6, 1, 1, 0, 
18847 "C - - 10 - masterurl C - - 10 'kPROOF_ConfFile' conffile "
18848 "C - - 10 'kPROOF_ConfDir' confdir i - 'Int_t' 0 '0' loglevel "
18849 "C - - 10 '0' alias U 'TProofMgr' - 0 '0' mgr", (char*)NULL, (void*) NULL, 0);
18850    G__memfunc_setup("SetActive",904,G__G__Proof_342_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
18851    G__memfunc_setup("SetActive",904,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - active", (char*)NULL, (void*) NULL, 1);
18852    G__memfunc_setup("Class",502,G__G__Proof_342_0_6, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofCondor::Class) ), 0);
18853    G__memfunc_setup("Class_Name",982,G__G__Proof_342_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofCondor::Class_Name) ), 0);
18854    G__memfunc_setup("Class_Version",1339,G__G__Proof_342_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofCondor::Class_Version) ), 0);
18855    G__memfunc_setup("Dictionary",1046,G__G__Proof_342_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofCondor::Dictionary) ), 0);
18856    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18857    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
18858    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
18859    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_342_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
18860    G__memfunc_setup("DeclFileName",1145,G__G__Proof_342_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofCondor::DeclFileName) ), 0);
18861    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_342_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofCondor::ImplFileLine) ), 0);
18862    G__memfunc_setup("ImplFileName",1171,G__G__Proof_342_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofCondor::ImplFileName) ), 0);
18863    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_342_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofCondor::DeclFileLine) ), 0);
18864    // automatic destructor
18865    G__memfunc_setup("~TProofCondor", 1341, G__G__Proof_342_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
18866    G__tag_memfunc_reset();
18867 }
18868 
18869 static void G__setup_memfuncTQueryResultManager(void) {
18870    /* TQueryResultManager */
18871    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TQueryResultManager));
18872    G__memfunc_setup("AddLogFile",939,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TProofQueryResult' - 0 - pq", (char*)NULL, (void*) NULL, 0);
18873    G__memfunc_setup("TQueryResultManager",1956,G__G__Proof_343_0_2, 105, G__get_linked_tagnum(&G__G__ProofLN_TQueryResultManager), -1, 0, 5, 1, 1, 0, 
18874 "C - - 10 - qdir C - - 10 - stag "
18875 "C - - 10 - sdir U 'TProofLockPath' - 0 - lck "
18876 "E - - 0 '0' logfile", (char*)NULL, (void*) NULL, 0);
18877    G__memfunc_setup("QueryDir",821,G__G__Proof_343_0_3, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
18878    G__memfunc_setup("SeqNum",601,G__G__Proof_343_0_4, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18879    G__memfunc_setup("DrawQueries",1132,G__G__Proof_343_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18880    G__memfunc_setup("KeptQueries",1138,G__G__Proof_343_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18881    G__memfunc_setup("Queries",734,G__G__Proof_343_0_7, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18882    G__memfunc_setup("PreviousQueries",1595,G__G__Proof_343_0_8, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18883    G__memfunc_setup("IncrementSeqNum",1534,G__G__Proof_343_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18884    G__memfunc_setup("IncrementDrawQueries",2065,G__G__Proof_343_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18885    G__memfunc_setup("ApplyMaxQueries",1546,G__G__Proof_343_0_11, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mxq", (char*)NULL, (void*) NULL, 0);
18886    G__memfunc_setup("CleanupQueriesDir",1733,G__G__Proof_343_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18887    G__memfunc_setup("FinalizeQuery",1352,G__G__Proof_343_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
18888 "U 'TProofQueryResult' - 0 - pq U 'TProof' - 0 - proof "
18889 "U 'TVirtualProofPlayer' - 0 - player", (char*)NULL, (void*) NULL, 0);
18890    G__memfunc_setup("GetCpuTime",983,G__G__Proof_343_0_14, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18891    G__memfunc_setup("GetRealTime",1075,G__G__Proof_343_0_15, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18892    G__memfunc_setup("LocateQuery",1134,G__G__Proof_343_0_16, 85, G__get_linked_tagnum(&G__G__ProofLN_TProofQueryResult), -1, 0, 3, 1, 1, 0, 
18893 "u 'TString' - 0 - queryref i - 'Int_t' 1 - qry "
18894 "u 'TString' - 1 - qdir", (char*)NULL, (void*) NULL, 0);
18895    G__memfunc_setup("RemoveQuery",1156,G__G__Proof_343_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
18896 "U 'TQueryResult' - 0 - qr g - 'Bool_t' 0 'kFALSE' soft", (char*)NULL, (void*) NULL, 0);
18897    G__memfunc_setup("RemoveQuery",1156,G__G__Proof_343_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
18898 "C - - 10 - queryref U 'TList' - 0 '0' otherlist", (char*)NULL, (void*) NULL, 0);
18899    G__memfunc_setup("ResetTime",914,G__G__Proof_343_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18900    G__memfunc_setup("SaveQuery",933,G__G__Proof_343_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
18901 "U 'TProofQueryResult' - 0 - qr C - - 10 '0' fout", (char*)NULL, (void*) NULL, 0);
18902    G__memfunc_setup("SaveQuery",933,G__G__Proof_343_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
18903 "U 'TProofQueryResult' - 0 - qr i - 'Int_t' 0 - mxq", (char*)NULL, (void*) NULL, 0);
18904    G__memfunc_setup("LockSession",1133,G__G__Proof_343_0_22, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
18905 "C - - 10 - sessiontag U 'TProofLockPath' - 2 - lck", (char*)NULL, (void*) NULL, 0);
18906    G__memfunc_setup("CleanupSession",1452,G__G__Proof_343_0_23, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "C - - 10 - sessiontag", (char*)NULL, (void*) NULL, 0);
18907    G__memfunc_setup("ScanPreviousQueries",1984,G__G__Proof_343_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - dir", (char*)NULL, (void*) NULL, 0);
18908    G__memfunc_setup("Class",502,G__G__Proof_343_0_25, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TQueryResultManager::Class) ), 0);
18909    G__memfunc_setup("Class_Name",982,G__G__Proof_343_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQueryResultManager::Class_Name) ), 0);
18910    G__memfunc_setup("Class_Version",1339,G__G__Proof_343_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TQueryResultManager::Class_Version) ), 0);
18911    G__memfunc_setup("Dictionary",1046,G__G__Proof_343_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TQueryResultManager::Dictionary) ), 0);
18912    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18913    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
18914    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
18915    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_343_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
18916    G__memfunc_setup("DeclFileName",1145,G__G__Proof_343_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQueryResultManager::DeclFileName) ), 0);
18917    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_343_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TQueryResultManager::ImplFileLine) ), 0);
18918    G__memfunc_setup("ImplFileName",1171,G__G__Proof_343_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TQueryResultManager::ImplFileName) ), 0);
18919    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_343_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TQueryResultManager::DeclFileLine) ), 0);
18920    // automatic copy constructor
18921    G__memfunc_setup("TQueryResultManager", 1956, G__G__Proof_343_0_37, (int) ('i'), G__get_linked_tagnum(&G__G__ProofLN_TQueryResultManager), -1, 0, 1, 1, 1, 0, "u 'TQueryResultManager' - 11 - -", (char*) NULL, (void*) NULL, 0);
18922    // automatic destructor
18923    G__memfunc_setup("~TQueryResultManager", 2082, G__G__Proof_343_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
18924    // automatic assignment operator
18925    G__memfunc_setup("operator=", 937, G__G__Proof_343_0_39, (int) ('u'), G__get_linked_tagnum(&G__G__ProofLN_TQueryResultManager), -1, 1, 1, 1, 1, 0, "u 'TQueryResultManager' - 11 - -", (char*) NULL, (void*) NULL, 0);
18926    G__tag_memfunc_reset();
18927 }
18928 
18929 static void G__setup_memfuncTProofQueryResult(void) {
18930    /* TProofQueryResult */
18931    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofQueryResult));
18932    G__memfunc_setup("TProofQueryResult",1775,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofQueryResult), -1, 0, 8, 1, 4, 0, 
18933 "i - 'Int_t' 0 - seqnum C - - 10 - opt "
18934 "U 'TList' - 0 - inlist n - 'Long64_t' 0 - entries "
18935 "n - 'Long64_t' 0 - first U 'TDSet' - 0 - dset "
18936 "C - - 10 - selec U 'TObject' - 0 '0' elist", (char*)NULL, (void*) NULL, 0);
18937    G__memfunc_setup("RecordEnd",886,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
18938 "i 'TQueryResult::EQueryStatus' - 0 - status U 'TList' - 0 '0' outlist", (char*)NULL, (void*) NULL, 1);
18939    G__memfunc_setup("SetFinalized",1218,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
18940    G__memfunc_setup("SetResultFile",1323,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "C - - 10 - rf", (char*)NULL, (void*) NULL, 0);
18941    G__memfunc_setup("SetRunning",1037,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
18942 "i - 'Int_t' 0 - startlog C - - 10 - par "
18943 "i - 'Int_t' 0 - nwrks", (char*)NULL, (void*) NULL, 0);
18944    G__memfunc_setup("TProofQueryResult",1775,G__G__Proof_344_0_6, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofQueryResult), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
18945    G__memfunc_setup("Class",502,G__G__Proof_344_0_7, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofQueryResult::Class) ), 0);
18946    G__memfunc_setup("Class_Name",982,G__G__Proof_344_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofQueryResult::Class_Name) ), 0);
18947    G__memfunc_setup("Class_Version",1339,G__G__Proof_344_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofQueryResult::Class_Version) ), 0);
18948    G__memfunc_setup("Dictionary",1046,G__G__Proof_344_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofQueryResult::Dictionary) ), 0);
18949    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18950    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
18951    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
18952    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_344_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
18953    G__memfunc_setup("DeclFileName",1145,G__G__Proof_344_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofQueryResult::DeclFileName) ), 0);
18954    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_344_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofQueryResult::ImplFileLine) ), 0);
18955    G__memfunc_setup("ImplFileName",1171,G__G__Proof_344_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofQueryResult::ImplFileName) ), 0);
18956    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_344_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofQueryResult::DeclFileLine) ), 0);
18957    // automatic copy constructor
18958    G__memfunc_setup("TProofQueryResult", 1775, G__G__Proof_344_0_19, (int) ('i'), G__get_linked_tagnum(&G__G__ProofLN_TProofQueryResult), -1, 0, 1, 1, 1, 0, "u 'TProofQueryResult' - 11 - -", (char*) NULL, (void*) NULL, 0);
18959    // automatic destructor
18960    G__memfunc_setup("~TProofQueryResult", 1901, G__G__Proof_344_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
18961    // automatic assignment operator
18962    G__memfunc_setup("operator=", 937, G__G__Proof_344_0_21, (int) ('u'), G__get_linked_tagnum(&G__G__ProofLN_TProofQueryResult), -1, 1, 1, 1, 1, 0, "u 'TProofQueryResult' - 11 - -", (char*) NULL, (void*) NULL, 0);
18963    G__tag_memfunc_reset();
18964 }
18965 
18966 static void G__setup_memfuncTProofLogElem(void) {
18967    /* TProofLogElem */
18968    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofLogElem));
18969    G__memfunc_setup("TProofLogElem",1279,G__G__Proof_346_0_1, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofLogElem), -1, 0, 3, 1, 1, 0, 
18970 "C - - 10 - ord C - - 10 - url "
18971 "U 'TProofLog' - 0 - logger", (char*)NULL, (void*) NULL, 0);
18972    G__memfunc_setup("Display",726,G__G__Proof_346_0_2, 121, -1, -1, 0, 2, 1, 1, 0, 
18973 "i - 'Int_t' 0 '0' from i - 'Int_t' 0 '-1' to", (char*)NULL, (void*) NULL, 0);
18974    G__memfunc_setup("GetMacro",786,G__G__Proof_346_0_3, 85, G__get_linked_tagnum(&G__G__ProofLN_TMacro), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18975    G__memfunc_setup("GetRole",690,G__G__Proof_346_0_4, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
18976    G__memfunc_setup("Grep",398,G__G__Proof_346_0_5, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
18977 "C - - 10 - txt u 'TString' - 1 - res "
18978 "i - 'Int_t' 0 '0' from", (char*)NULL, (void*) NULL, 0);
18979    G__memfunc_setup("IsMaster",808,G__G__Proof_346_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18980    G__memfunc_setup("IsSubMaster",1106,G__G__Proof_346_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18981    G__memfunc_setup("IsWorker",822,G__G__Proof_346_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
18982    G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '0' opt", (char*)NULL, (void*) NULL, 1);
18983    G__memfunc_setup("Prt",310,G__G__Proof_346_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - what", (char*)NULL, (void*) NULL, 0);
18984    G__memfunc_setup("Retrieve",838,G__G__Proof_346_0_11, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 1, 0, 
18985 "i 'TProofLog::ERetrieveOpt' - 0 'TProofLog::kTrailing' opt C - - 10 '0' pattern", (char*)NULL, (void*) NULL, 0);
18986    G__memfunc_setup("GetMaxTransferSize",1830,G__G__Proof_346_0_12, 110, -1, G__defined_typename("Long64_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Long64_t (*)())(&TProofLogElem::GetMaxTransferSize) ), 0);
18987    G__memfunc_setup("SetMaxTransferSize",1842,G__G__Proof_346_0_13, 121, -1, -1, 0, 1, 3, 1, 0, "n - 'Long64_t' 0 - maxsz", (char*)NULL, (void*) G__func2void( (void (*)(Long64_t))(&TProofLogElem::SetMaxTransferSize) ), 0);
18988    G__memfunc_setup("Class",502,G__G__Proof_346_0_14, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofLogElem::Class) ), 0);
18989    G__memfunc_setup("Class_Name",982,G__G__Proof_346_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofLogElem::Class_Name) ), 0);
18990    G__memfunc_setup("Class_Version",1339,G__G__Proof_346_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofLogElem::Class_Version) ), 0);
18991    G__memfunc_setup("Dictionary",1046,G__G__Proof_346_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofLogElem::Dictionary) ), 0);
18992    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
18993    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
18994    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
18995    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_346_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
18996    G__memfunc_setup("DeclFileName",1145,G__G__Proof_346_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofLogElem::DeclFileName) ), 0);
18997    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_346_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofLogElem::ImplFileLine) ), 0);
18998    G__memfunc_setup("ImplFileName",1171,G__G__Proof_346_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofLogElem::ImplFileName) ), 0);
18999    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_346_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofLogElem::DeclFileLine) ), 0);
19000    // automatic copy constructor
19001    G__memfunc_setup("TProofLogElem", 1279, G__G__Proof_346_0_26, (int) ('i'), G__get_linked_tagnum(&G__G__ProofLN_TProofLogElem), -1, 0, 1, 1, 1, 0, "u 'TProofLogElem' - 11 - -", (char*) NULL, (void*) NULL, 0);
19002    // automatic destructor
19003    G__memfunc_setup("~TProofLogElem", 1405, G__G__Proof_346_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
19004    // automatic assignment operator
19005    G__memfunc_setup("operator=", 937, G__G__Proof_346_0_28, (int) ('u'), G__get_linked_tagnum(&G__G__ProofLN_TProofLogElem), -1, 1, 1, 1, 1, 0, "u 'TProofLogElem' - 11 - -", (char*) NULL, (void*) NULL, 0);
19006    G__tag_memfunc_reset();
19007 }
19008 
19009 static void G__setup_memfuncTProofMgrLite(void) {
19010    /* TProofMgrLite */
19011    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofMgrLite));
19012    G__memfunc_setup("TProofMgrLite",1294,G__G__Proof_347_0_1, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofMgrLite), -1, 0, 3, 1, 1, 0, 
19013 "C - - 10 - url i - 'Int_t' 0 '-1' loglevel "
19014 "C - - 10 '\"\"' alias", (char*)NULL, (void*) NULL, 0);
19015    G__memfunc_setup("CreateSession",1336,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TProof), -1, 0, 3, 1, 1, 0, 
19016 "C - - 10 '0' - C - - 10 '0' - "
19017 "i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 1);
19018    G__memfunc_setup("GetSessionLogs",1433,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TProofLog), -1, 0, 3, 1, 1, 0, 
19019 "i - 'Int_t' 0 '0' ridx C - - 10 '0' stag "
19020 "C - - 10 '\"-v | SvcMsg\"' pattern", (char*)NULL, (void*) NULL, 1);
19021    G__memfunc_setup("ReadBuffer",982,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TObjString), -1, 0, 3, 1, 1, 0, 
19022 "C - - 10 - file n - 'Long64_t' 0 - ofs "
19023 "i - 'Int_t' 0 - len", (char*)NULL, (void*) NULL, 1);
19024    G__memfunc_setup("ReadBuffer",982,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TObjString), -1, 0, 2, 1, 1, 0, 
19025 "C - - 10 - file C - - 10 - pattern", (char*)NULL, (void*) NULL, 1);
19026    G__memfunc_setup("Class",502,G__G__Proof_347_0_6, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofMgrLite::Class) ), 0);
19027    G__memfunc_setup("Class_Name",982,G__G__Proof_347_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofMgrLite::Class_Name) ), 0);
19028    G__memfunc_setup("Class_Version",1339,G__G__Proof_347_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofMgrLite::Class_Version) ), 0);
19029    G__memfunc_setup("Dictionary",1046,G__G__Proof_347_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofMgrLite::Dictionary) ), 0);
19030    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
19031    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
19032    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
19033    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_347_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
19034    G__memfunc_setup("DeclFileName",1145,G__G__Proof_347_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofMgrLite::DeclFileName) ), 0);
19035    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_347_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofMgrLite::ImplFileLine) ), 0);
19036    G__memfunc_setup("ImplFileName",1171,G__G__Proof_347_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofMgrLite::ImplFileName) ), 0);
19037    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_347_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofMgrLite::DeclFileLine) ), 0);
19038    // automatic destructor
19039    G__memfunc_setup("~TProofMgrLite", 1420, G__G__Proof_347_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
19040    G__tag_memfunc_reset();
19041 }
19042 
19043 static void G__setup_memfuncTProofResourcesStatic(void) {
19044    /* TProofResourcesStatic */
19045    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofResourcesStatic));
19046    G__memfunc_setup("InitResources",1359,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
19047    G__memfunc_setup("ReadConfigFile",1362,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 0, 
19048 "C - - 10 - confDir C - - 10 - fileName", (char*)NULL, (void*) NULL, 0);
19049    G__memfunc_setup("GetInfoType",1102,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofResourcesStaticcLcLEInfoType), -1, 0, 1, 3, 4, 0, "u 'TString' - 11 - word", (char*)NULL, (void*) NULL, 0);
19050    G__memfunc_setup("SetOption",933,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 3, 4, 0, 
19051 "U 'TProofNodeInfo' - 0 - nodeinfo u 'TString' - 11 - option "
19052 "u 'TString' - 11 - value", (char*)NULL, (void*) NULL, 0);
19053    G__memfunc_setup("CreateNodeInfo",1382,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfo), -1, 0, 1, 3, 4, 0, "u 'TString' - 11 - name", (char*)NULL, (void*) NULL, 0);
19054    G__memfunc_setup("TProofResourcesStatic",2173,G__G__Proof_350_0_6, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofResourcesStatic), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
19055    G__memfunc_setup("TProofResourcesStatic",2173,G__G__Proof_350_0_7, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofResourcesStatic), -1, 0, 2, 1, 1, 0, 
19056 "C - - 10 - confDir C - - 10 - fileName", (char*)NULL, (void*) NULL, 0);
19057    G__memfunc_setup("GetMaster",908,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
19058    G__memfunc_setup("GetSubmasters",1353,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
19059    G__memfunc_setup("GetWorkers",1037,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
19060    G__memfunc_setup("GetFileName",1057,G__G__Proof_350_0_11, 117, G__get_linked_tagnum(&G__G__ProofLN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
19061    G__memfunc_setup("Class",502,G__G__Proof_350_0_12, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofResourcesStatic::Class) ), 0);
19062    G__memfunc_setup("Class_Name",982,G__G__Proof_350_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofResourcesStatic::Class_Name) ), 0);
19063    G__memfunc_setup("Class_Version",1339,G__G__Proof_350_0_14, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofResourcesStatic::Class_Version) ), 0);
19064    G__memfunc_setup("Dictionary",1046,G__G__Proof_350_0_15, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofResourcesStatic::Dictionary) ), 0);
19065    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
19066    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
19067    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
19068    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_350_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
19069    G__memfunc_setup("DeclFileName",1145,G__G__Proof_350_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofResourcesStatic::DeclFileName) ), 0);
19070    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_350_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofResourcesStatic::ImplFileLine) ), 0);
19071    G__memfunc_setup("ImplFileName",1171,G__G__Proof_350_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofResourcesStatic::ImplFileName) ), 0);
19072    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_350_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofResourcesStatic::DeclFileLine) ), 0);
19073    // automatic copy constructor
19074    G__memfunc_setup("TProofResourcesStatic", 2173, G__G__Proof_350_0_24, (int) ('i'), 
19075 G__get_linked_tagnum(&G__G__ProofLN_TProofResourcesStatic), -1, 0, 1, 1, 1, 0, "u 'TProofResourcesStatic' - 11 - -", (char*) NULL, (void*) NULL, 0);
19076    // automatic destructor
19077    G__memfunc_setup("~TProofResourcesStatic", 2299, G__G__Proof_350_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
19078    // automatic assignment operator
19079    G__memfunc_setup("operator=", 937, G__G__Proof_350_0_26, (int) ('u'), G__get_linked_tagnum(&G__G__ProofLN_TProofResourcesStatic), -1, 1, 1, 1, 1, 0, "u 'TProofResourcesStatic' - 11 - -", (char*) NULL, (void*) NULL, 0);
19080    G__tag_memfunc_reset();
19081 }
19082 
19083 static void G__setup_memfuncTProofNodeInfo(void) {
19084    /* TProofNodeInfo */
19085    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfo));
19086    G__memfunc_setup("TProofNodeInfo",1388,G__G__Proof_351_0_1, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
19087    G__memfunc_setup("TProofNodeInfo",1388,G__G__Proof_351_0_2, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfo), -1, 0, 1, 1, 1, 0, "C - - 10 - str", (char*)NULL, (void*) NULL, 0);
19088    G__memfunc_setup("TProofNodeInfo",1388,G__G__Proof_351_0_3, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfo), -1, 0, 1, 1, 1, 0, "u 'TProofNodeInfo' - 11 - nodeInfo", (char*)NULL, (void*) NULL, 0);
19089    G__memfunc_setup("GetNodeType",1096,G__G__Proof_351_0_4, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfocLcLENodeType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
19090    G__memfunc_setup("GetNodeName",1063,G__G__Proof_351_0_5, 117, G__get_linked_tagnum(&G__G__ProofLN_TString), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
19091    G__memfunc_setup("GetWorkDir",994,G__G__Proof_351_0_6, 117, G__get_linked_tagnum(&G__G__ProofLN_TString), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
19092    G__memfunc_setup("GetOrdinal",1001,G__G__Proof_351_0_7, 117, G__get_linked_tagnum(&G__G__ProofLN_TString), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
19093    G__memfunc_setup("GetImage",771,G__G__Proof_351_0_8, 117, G__get_linked_tagnum(&G__G__ProofLN_TString), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
19094    G__memfunc_setup("GetId",461,G__G__Proof_351_0_9, 117, G__get_linked_tagnum(&G__G__ProofLN_TString), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
19095    G__memfunc_setup("GetConfig",886,G__G__Proof_351_0_10, 117, G__get_linked_tagnum(&G__G__ProofLN_TString), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
19096    G__memfunc_setup("GetMsd",580,G__G__Proof_351_0_11, 117, G__get_linked_tagnum(&G__G__ProofLN_TString), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
19097    G__memfunc_setup("GetPort",709,G__G__Proof_351_0_12, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
19098    G__memfunc_setup("GetPerfIndex",1189,G__G__Proof_351_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
19099    G__memfunc_setup("Assign",613,G__G__Proof_351_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TProofNodeInfo' - 11 - n", (char*)NULL, (void*) NULL, 0);
19100    G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 - -", (char*)NULL, (void*) NULL, 1);
19101    G__memfunc_setup("GetNodeType",1096,G__G__Proof_351_0_16, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfocLcLENodeType), -1, 0, 1, 3, 1, 0, "u 'TString' - 11 - type", (char*)NULL, (void*) G__func2void( (TProofNodeInfo::ENodeType (*)(const TString&))(&TProofNodeInfo::GetNodeType) ), 0);
19102    G__memfunc_setup("Class",502,G__G__Proof_351_0_17, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofNodeInfo::Class) ), 0);
19103    G__memfunc_setup("Class_Name",982,G__G__Proof_351_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofNodeInfo::Class_Name) ), 0);
19104    G__memfunc_setup("Class_Version",1339,G__G__Proof_351_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofNodeInfo::Class_Version) ), 0);
19105    G__memfunc_setup("Dictionary",1046,G__G__Proof_351_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofNodeInfo::Dictionary) ), 0);
19106    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
19107    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
19108    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
19109    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_351_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
19110    G__memfunc_setup("DeclFileName",1145,G__G__Proof_351_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofNodeInfo::DeclFileName) ), 0);
19111    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_351_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofNodeInfo::ImplFileLine) ), 0);
19112    G__memfunc_setup("ImplFileName",1171,G__G__Proof_351_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofNodeInfo::ImplFileName) ), 0);
19113    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_351_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofNodeInfo::DeclFileLine) ), 0);
19114    // automatic destructor
19115    G__memfunc_setup("~TProofNodeInfo", 1514, G__G__Proof_351_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
19116    // automatic assignment operator
19117    G__memfunc_setup("operator=", 937, G__G__Proof_351_0_30, (int) ('u'), G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfo), -1, 1, 1, 1, 1, 0, "u 'TProofNodeInfo' - 11 - -", (char*) NULL, (void*) NULL, 0);
19118    G__tag_memfunc_reset();
19119 }
19120 
19121 static void G__setup_memfuncTProofProgressStatus(void) {
19122    /* TProofProgressStatus */
19123    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofProgressStatus));
19124    G__memfunc_setup("TProofProgressStatus",2099,G__G__Proof_353_0_1, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofProgressStatus), -1, 0, 5, 1, 1, 0, 
19125 "n - 'Long64_t' 0 '0' fEntries n - 'Long64_t' 0 '0' fBytesRead "
19126 "n - 'Long64_t' 0 '0' fReadCalls d - 'Double_t' 0 '0' fProcTime "
19127 "d - 'Double_t' 0 '0' fCPUTime", (char*)NULL, (void*) NULL, 0);
19128    G__memfunc_setup("Reset",515,G__G__Proof_353_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
19129    G__memfunc_setup("GetEntries",1018,G__G__Proof_353_0_3, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
19130    G__memfunc_setup("GetBytesRead",1187,G__G__Proof_353_0_4, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
19131    G__memfunc_setup("GetReadCalls",1163,G__G__Proof_353_0_5, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
19132    G__memfunc_setup("GetLearnTime",1185,G__G__Proof_353_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
19133    G__memfunc_setup("GetProcTime",1091,G__G__Proof_353_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
19134    G__memfunc_setup("GetCPUTime",919,G__G__Proof_353_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
19135    G__memfunc_setup("GetLastUpdate",1303,G__G__Proof_353_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
19136    G__memfunc_setup("GetRate",684,G__G__Proof_353_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
19137    G__memfunc_setup("GetCurrentRate",1423,G__G__Proof_353_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
19138    G__memfunc_setup("SetLastEntries",1434,G__G__Proof_353_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - entries", (char*)NULL, (void*) NULL, 0);
19139    G__memfunc_setup("SetEntries",1030,G__G__Proof_353_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - entries", (char*)NULL, (void*) NULL, 0);
19140    G__memfunc_setup("IncEntries",1012,G__G__Proof_353_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 '1' entries", (char*)NULL, (void*) NULL, 0);
19141    G__memfunc_setup("IncBytesRead",1181,G__G__Proof_353_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - bytesRead", (char*)NULL, (void*) NULL, 0);
19142    G__memfunc_setup("SetBytesRead",1199,G__G__Proof_353_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - bytesRead", (char*)NULL, (void*) NULL, 0);
19143    G__memfunc_setup("IncReadCalls",1157,G__G__Proof_353_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - readCalls", (char*)NULL, (void*) NULL, 0);
19144    G__memfunc_setup("SetReadCalls",1175,G__G__Proof_353_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - readCalls", (char*)NULL, (void*) NULL, 0);
19145    G__memfunc_setup("SetLearnTime",1197,G__G__Proof_353_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - learnTime", (char*)NULL, (void*) NULL, 0);
19146    G__memfunc_setup("SetLastProcTime",1507,G__G__Proof_353_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - procTime", (char*)NULL, (void*) NULL, 0);
19147    G__memfunc_setup("SetProcTime",1103,G__G__Proof_353_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - procTime", (char*)NULL, (void*) NULL, 0);
19148    G__memfunc_setup("IncProcTime",1085,G__G__Proof_353_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - procTime", (char*)NULL, (void*) NULL, 0);
19149    G__memfunc_setup("SetCPUTime",931,G__G__Proof_353_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - procTime", (char*)NULL, (void*) NULL, 0);
19150    G__memfunc_setup("IncCPUTime",913,G__G__Proof_353_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - procTime", (char*)NULL, (void*) NULL, 0);
19151    G__memfunc_setup("SetLastUpdate",1315,G__G__Proof_353_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0' updtTime", (char*)NULL, (void*) NULL, 0);
19152    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);
19153    G__memfunc_setup("operator-",921,G__G__Proof_353_0_27, 117, G__get_linked_tagnum(&G__G__ProofLN_TProofProgressStatus), -1, 0, 1, 1, 1, 0, "u 'TProofProgressStatus' - 1 - st", (char*)NULL, (void*) NULL, 0);
19154    G__memfunc_setup("operator+=",980,G__G__Proof_353_0_28, 117, G__get_linked_tagnum(&G__G__ProofLN_TProofProgressStatus), -1, 1, 1, 1, 1, 0, "u 'TProofProgressStatus' - 11 - st", (char*)NULL, (void*) NULL, 0);
19155    G__memfunc_setup("operator-=",982,G__G__Proof_353_0_29, 117, G__get_linked_tagnum(&G__G__ProofLN_TProofProgressStatus), -1, 1, 1, 1, 1, 0, "u 'TProofProgressStatus' - 11 - st", (char*)NULL, (void*) NULL, 0);
19156    G__memfunc_setup("Class",502,G__G__Proof_353_0_30, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofProgressStatus::Class) ), 0);
19157    G__memfunc_setup("Class_Name",982,G__G__Proof_353_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofProgressStatus::Class_Name) ), 0);
19158    G__memfunc_setup("Class_Version",1339,G__G__Proof_353_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofProgressStatus::Class_Version) ), 0);
19159    G__memfunc_setup("Dictionary",1046,G__G__Proof_353_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofProgressStatus::Dictionary) ), 0);
19160    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
19161    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
19162    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
19163    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_353_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
19164    G__memfunc_setup("DeclFileName",1145,G__G__Proof_353_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofProgressStatus::DeclFileName) ), 0);
19165    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_353_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofProgressStatus::ImplFileLine) ), 0);
19166    G__memfunc_setup("ImplFileName",1171,G__G__Proof_353_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofProgressStatus::ImplFileName) ), 0);
19167    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_353_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofProgressStatus::DeclFileLine) ), 0);
19168    // automatic copy constructor
19169    G__memfunc_setup("TProofProgressStatus", 2099, G__G__Proof_353_0_42, (int) ('i'), G__get_linked_tagnum(&G__G__ProofLN_TProofProgressStatus), -1, 0, 1, 1, 1, 0, "u 'TProofProgressStatus' - 11 - -", (char*) NULL, (void*) NULL, 0);
19170    // automatic destructor
19171    G__memfunc_setup("~TProofProgressStatus", 2225, G__G__Proof_353_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
19172    // automatic assignment operator
19173    G__memfunc_setup("operator=", 937, G__G__Proof_353_0_44, (int) ('u'), G__get_linked_tagnum(&G__G__ProofLN_TProofProgressStatus), -1, 1, 1, 1, 1, 0, "u 'TProofProgressStatus' - 11 - -", (char*) NULL, (void*) NULL, 0);
19174    G__tag_memfunc_reset();
19175 }
19176 
19177 static void G__setup_memfuncTProofResources(void) {
19178    /* TProofResources */
19179    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofResources));
19180    G__memfunc_setup("GetMaster",908,G__G__Proof_356_0_2, 85, G__get_linked_tagnum(&G__G__ProofLN_TProofNodeInfo), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
19181    G__memfunc_setup("GetSubmasters",1353,G__G__Proof_356_0_3, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
19182    G__memfunc_setup("GetWorkers",1037,G__G__Proof_356_0_4, 85, G__get_linked_tagnum(&G__G__ProofLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
19183    G__memfunc_setup("IsValid",684,G__G__Proof_356_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
19184    G__memfunc_setup("Class",502,G__G__Proof_356_0_6, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofResources::Class) ), 0);
19185    G__memfunc_setup("Class_Name",982,G__G__Proof_356_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofResources::Class_Name) ), 0);
19186    G__memfunc_setup("Class_Version",1339,G__G__Proof_356_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofResources::Class_Version) ), 0);
19187    G__memfunc_setup("Dictionary",1046,G__G__Proof_356_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofResources::Dictionary) ), 0);
19188    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
19189    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
19190    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
19191    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_356_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
19192    G__memfunc_setup("DeclFileName",1145,G__G__Proof_356_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofResources::DeclFileName) ), 0);
19193    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_356_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofResources::ImplFileLine) ), 0);
19194    G__memfunc_setup("ImplFileName",1171,G__G__Proof_356_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofResources::ImplFileName) ), 0);
19195    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_356_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofResources::DeclFileLine) ), 0);
19196    // automatic destructor
19197    G__memfunc_setup("~TProofResources", 1683, G__G__Proof_356_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
19198    // automatic assignment operator
19199    G__memfunc_setup("operator=", 937, G__G__Proof_356_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__ProofLN_TProofResources), -1, 1, 1, 1, 1, 0, "u 'TProofResources' - 11 - -", (char*) NULL, (void*) NULL, 0);
19200    G__tag_memfunc_reset();
19201 }
19202 
19203 static void G__setup_memfuncTProofServLite(void) {
19204    /* TProofServLite */
19205    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofServLite));
19206    G__memfunc_setup("Setup",529,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
19207    G__memfunc_setup("SetupOnFork",1120,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 0, "C - - 10 - ord", (char*)NULL, (void*) NULL, 0);
19208    G__memfunc_setup("TProofServLite",1416,G__G__Proof_368_0_3, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofServLite), -1, 0, 3, 1, 1, 0, 
19209 "I - 'Int_t' 0 - argc C - - 2 - argv "
19210 "E - - 0 '0' flog", (char*)NULL, (void*) NULL, 0);
19211    G__memfunc_setup("CreateServer",1227,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
19212    G__memfunc_setup("HandleFork",990,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TMessage' - 0 - mess", (char*)NULL, (void*) NULL, 1);
19213    G__memfunc_setup("HandleSigPipe",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
19214    G__memfunc_setup("HandleTermination",1750,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
19215    G__memfunc_setup("Terminate",937,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - status", (char*)NULL, (void*) NULL, 1);
19216    G__memfunc_setup("Class",502,G__G__Proof_368_0_9, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofServLite::Class) ), 0);
19217    G__memfunc_setup("Class_Name",982,G__G__Proof_368_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofServLite::Class_Name) ), 0);
19218    G__memfunc_setup("Class_Version",1339,G__G__Proof_368_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofServLite::Class_Version) ), 0);
19219    G__memfunc_setup("Dictionary",1046,G__G__Proof_368_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofServLite::Dictionary) ), 0);
19220    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
19221    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
19222    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
19223    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_368_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
19224    G__memfunc_setup("DeclFileName",1145,G__G__Proof_368_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofServLite::DeclFileName) ), 0);
19225    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_368_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofServLite::ImplFileLine) ), 0);
19226    G__memfunc_setup("ImplFileName",1171,G__G__Proof_368_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofServLite::ImplFileName) ), 0);
19227    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_368_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofServLite::DeclFileLine) ), 0);
19228    // automatic destructor
19229    G__memfunc_setup("~TProofServLite", 1542, G__G__Proof_368_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
19230    G__tag_memfunc_reset();
19231 }
19232 
19233 static void G__setup_memfuncTProofSuperMaster(void) {
19234    /* TProofSuperMaster */
19235    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofSuperMaster));
19236    G__memfunc_setup("StartSlaves",1148,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 1);
19237    G__memfunc_setup("ValidateDSet",1178,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TDSet' - 0 - dset", (char*)NULL, (void*) NULL, 1);
19238    G__memfunc_setup("MakePlayer",1003,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofLN_TVirtualProofPlayer), -1, 0, 2, 1, 2, 0, 
19239 "C - - 10 '0' player U 'TSocket' - 0 '0' s", (char*)NULL, (void*) NULL, 1);
19240    G__memfunc_setup("TProofSuperMaster",1749,G__G__Proof_377_0_4, 105, G__get_linked_tagnum(&G__G__ProofLN_TProofSuperMaster), -1, 0, 6, 1, 1, 0, 
19241 "C - - 10 - masterurl C - - 10 'kPROOF_ConfFile' conffile "
19242 "C - - 10 'kPROOF_ConfDir' confdir i - 'Int_t' 0 '0' loglevel "
19243 "C - - 10 '0' alias U 'TProofMgr' - 0 '0' mgr", (char*)NULL, (void*) NULL, 0);
19244    G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
19245 "U 'TDSet' - 0 - set C - - 10 - selector "
19246 "C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
19247 "n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
19248    G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
19249 "U 'TFileCollection' - 0 - fc C - - 10 - sel "
19250 "C - 'Option_t' 10 '\"\"' o n - 'Long64_t' 0 '-1' nent "
19251 "n - 'Long64_t' 0 '0' fst", (char*)NULL, (void*) NULL, 1);
19252    G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 6, 1, 1, 0, 
19253 "C - - 10 - dsname C - - 10 - sel "
19254 "C - 'Option_t' 10 '\"\"' o n - 'Long64_t' 0 '-1' nent "
19255 "n - 'Long64_t' 0 '0' fst U 'TObject' - 0 '0' enl", (char*)NULL, (void*) NULL, 1);
19256    G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 3, 1, 1, 0, 
19257 "C - - 10 - sel n - 'Long64_t' 0 - nent "
19258 "C - 'Option_t' 10 '\"\"' o", (char*)NULL, (void*) NULL, 1);
19259    G__memfunc_setup("Class",502,G__G__Proof_377_0_9, 85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofSuperMaster::Class) ), 0);
19260    G__memfunc_setup("Class_Name",982,G__G__Proof_377_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofSuperMaster::Class_Name) ), 0);
19261    G__memfunc_setup("Class_Version",1339,G__G__Proof_377_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofSuperMaster::Class_Version) ), 0);
19262    G__memfunc_setup("Dictionary",1046,G__G__Proof_377_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofSuperMaster::Dictionary) ), 0);
19263    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
19264    G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
19265    G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
19266    G__memfunc_setup("StreamerNVirtual",1656,G__G__Proof_377_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
19267    G__memfunc_setup("DeclFileName",1145,G__G__Proof_377_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofSuperMaster::DeclFileName) ), 0);
19268    G__memfunc_setup("ImplFileLine",1178,G__G__Proof_377_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofSuperMaster::ImplFileLine) ), 0);
19269    G__memfunc_setup("ImplFileName",1171,G__G__Proof_377_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofSuperMaster::ImplFileName) ), 0);
19270    G__memfunc_setup("DeclFileLine",1152,G__G__Proof_377_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofSuperMaster::DeclFileLine) ), 0);
19271    // automatic destructor
19272    G__memfunc_setup("~TProofSuperMaster", 1875, G__G__Proof_377_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
19273    G__tag_memfunc_reset();
19274 }
19275 
19276 
19277 /*********************************************************
19278 * Member function information setup
19279 *********************************************************/
19280 extern "C" void G__cpp_setup_memfuncG__Proof() {
19281 }
19282 
19283 /*********************************************************
19284 * Global variable information setup for each class
19285 *********************************************************/
19286 static void G__cpp_setup_global0() {
19287 
19288    /* Setting up global variables */
19289    G__resetplocal();
19290 
19291 }
19292 
19293 static void G__cpp_setup_global1() {
19294 }
19295 
19296 static void G__cpp_setup_global2() {
19297 }
19298 
19299 static void G__cpp_setup_global3() {
19300 }
19301 
19302 static void G__cpp_setup_global4() {
19303    G__memvar_setup((void*)(&gProofDebugMask),105,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofDebugcLcLEProofDebugMask),-1,-1,1,"gProofDebugMask=",0,(char*)NULL);
19304    G__memvar_setup((void*)(&gProofDebugLevel),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"gProofDebugLevel=",0,(char*)NULL);
19305 }
19306 
19307 static void G__cpp_setup_global5() {
19308    G__memvar_setup((void*)(&gProof),85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProof),-1,-1,1,"gProof=",0,(char*)NULL);
19309    G__memvar_setup((void*)(&gProofServ),85,0,0,G__get_linked_tagnum(&G__G__ProofLN_TProofServ),-1,-1,1,"gProofServ=",0,(char*)NULL);
19310 
19311    G__resetglobalenv();
19312 }
19313 extern "C" void G__cpp_setup_globalG__Proof() {
19314   G__cpp_setup_global0();
19315   G__cpp_setup_global1();
19316   G__cpp_setup_global2();
19317   G__cpp_setup_global3();
19318   G__cpp_setup_global4();
19319   G__cpp_setup_global5();
19320 }
19321 
19322 /*********************************************************
19323 * Global function information setup for each class
19324 *********************************************************/
19325 static void G__cpp_setup_func0() {
19326    G__lastifuncposition();
19327 
19328 }
19329 
19330 static void G__cpp_setup_func1() {
19331 }
19332 
19333 static void G__cpp_setup_func2() {
19334 }
19335 
19336 static void G__cpp_setup_func3() {
19337 }
19338 
19339 static void G__cpp_setup_func4() {
19340 }
19341 
19342 static void G__cpp_setup_func5() {
19343 
19344    G__resetifuncposition();
19345 }
19346 
19347 extern "C" void G__cpp_setup_funcG__Proof() {
19348   G__cpp_setup_func0();
19349   G__cpp_setup_func1();
19350   G__cpp_setup_func2();
19351   G__cpp_setup_func3();
19352   G__cpp_setup_func4();
19353   G__cpp_setup_func5();
19354 }
19355 
19356 /*********************************************************
19357 * Class,struct,union,enum tag information setup
19358 *********************************************************/
19359 /* Setup class/struct taginfo */
19360 G__linked_taginfo G__G__ProofLN_TClass = { "TClass" , 99 , -1 };
19361 G__linked_taginfo G__G__ProofLN_TBuffer = { "TBuffer" , 99 , -1 };
19362 G__linked_taginfo G__G__ProofLN_TDirectory = { "TDirectory" , 99 , -1 };
19363 G__linked_taginfo G__G__ProofLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
19364 G__linked_taginfo G__G__ProofLN_TObject = { "TObject" , 99 , -1 };
19365 G__linked_taginfo G__G__ProofLN_TNamed = { "TNamed" , 99 , -1 };
19366 G__linked_taginfo G__G__ProofLN_TString = { "TString" , 99 , -1 };
19367 G__linked_taginfo G__G__ProofLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
19368 G__linked_taginfo G__G__ProofLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
19369 G__linked_taginfo G__G__ProofLN_va_list = { "va_list" , 115 , -1 };
19370 G__linked_taginfo G__G__ProofLN_TList = { "TList" , 99 , -1 };
19371 G__linked_taginfo G__G__ProofLN_TBrowser = { "TBrowser" , 99 , -1 };
19372 G__linked_taginfo G__G__ProofLN_TObjArray = { "TObjArray" , 99 , -1 };
19373 G__linked_taginfo G__G__ProofLN_TTimer = { "TTimer" , 99 , -1 };
19374 G__linked_taginfo G__G__ProofLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
19375 G__linked_taginfo G__G__ProofLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
19376 G__linked_taginfo G__G__ProofLN_TVirtualMutex = { "TVirtualMutex" , 99 , -1 };
19377 G__linked_taginfo G__G__ProofLN_TCondorSlave = { "TCondorSlave" , 99 , -1 };
19378 G__linked_taginfo G__G__ProofLN_TCondor = { "TCondor" , 99 , -1 };
19379 G__linked_taginfo G__G__ProofLN_TCondorcLcLEState = { "TCondor::EState" , 101 , -1 };
19380 G__linked_taginfo G__G__ProofLN_TCollection = { "TCollection" , 99 , -1 };
19381 G__linked_taginfo G__G__ProofLN_TIter = { "TIter" , 99 , -1 };
19382 G__linked_taginfo G__G__ProofLN_TMap = { "TMap" , 99 , -1 };
19383 G__linked_taginfo G__G__ProofLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
19384 G__linked_taginfo G__G__ProofLN_TUri = { "TUri" , 99 , -1 };
19385 G__linked_taginfo G__G__ProofLN_TFileCollection = { "TFileCollection" , 99 , -1 };
19386 G__linked_taginfo G__G__ProofLN_TFileInfo = { "TFileInfo" , 99 , -1 };
19387 G__linked_taginfo G__G__ProofLN_TMD5 = { "TMD5" , 99 , -1 };
19388 G__linked_taginfo G__G__ProofLN_TUrl = { "TUrl" , 99 , -1 };
19389 G__linked_taginfo G__G__ProofLN_TVirtualMonitoringWriter = { "TVirtualMonitoringWriter" , 99 , -1 };
19390 G__linked_taginfo G__G__ProofLN_TDataSetManager = { "TDataSetManager" , 99 , -1 };
19391 G__linked_taginfo G__G__ProofLN_TDataSetManagercLcLEDataSetStatusBits = { "TDataSetManager::EDataSetStatusBits" , 101 , -1 };
19392 G__linked_taginfo G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts = { "TDataSetManager::EDataSetWorkOpts" , 101 , -1 };
19393 G__linked_taginfo G__G__ProofLN_TDataSetManagerFile = { "TDataSetManagerFile" , 99 , -1 };
19394 G__linked_taginfo G__G__ProofLN_TChain = { "TChain" , 99 , -1 };
19395 G__linked_taginfo G__G__ProofLN_TCut = { "TCut" , 99 , -1 };
19396 G__linked_taginfo G__G__ProofLN_TDSet = { "TDSet" , 99 , -1 };
19397 G__linked_taginfo G__G__ProofLN_TEventList = { "TEventList" , 99 , -1 };
19398 G__linked_taginfo G__G__ProofLN_TEntryList = { "TEntryList" , 99 , -1 };
19399 G__linked_taginfo G__G__ProofLN_THashList = { "THashList" , 99 , -1 };
19400 G__linked_taginfo G__G__ProofLN_TProof = { "TProof" , 99 , -1 };
19401 G__linked_taginfo G__G__ProofLN_TProofChain = { "TProofChain" , 99 , -1 };
19402 G__linked_taginfo G__G__ProofLN_TTree = { "TTree" , 99 , -1 };
19403 G__linked_taginfo G__G__ProofLN_TDSetElement = { "TDSetElement" , 99 , -1 };
19404 G__linked_taginfo G__G__ProofLN_pairlETDSetElementmUcOTStringgR = { "pair<TDSetElement*,TString>" , 115 , -1 };
19405 G__linked_taginfo G__G__ProofLN_allocatorlEpairlETDSetElementmUcOTStringgRsPgR = { "allocator<pair<TDSetElement*,TString> >" , 99 , -1 };
19406 G__linked_taginfo G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR = { "list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >" , 99 , -1 };
19407 G__linked_taginfo G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgRcLcLiterator = { "list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::iterator" , 99 , -1 };
19408 G__linked_taginfo G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgRcLcLreverse_iterator = { "list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >::reverse_iterator" , 99 , -1 };
19409 G__linked_taginfo G__G__ProofLN_TDSetElementcLcLEStatusBits = { "TDSetElement::EStatusBits" , 101 , -1 };
19410 G__linked_taginfo G__G__ProofLN_TDSetcLcLEStatusBits = { "TDSet::EStatusBits" , 101 , -1 };
19411 G__linked_taginfo G__G__ProofLN_TProofServ = { "TProofServ" , 99 , -1 };
19412 G__linked_taginfo G__G__ProofLN_TDSetProxy = { "TDSetProxy" , 99 , -1 };
19413 G__linked_taginfo G__G__ProofLN_TAttFill = { "TAttFill" , 99 , -1 };
19414 G__linked_taginfo G__G__ProofLN_TLeaf = { "TLeaf" , 99 , -1 };
19415 G__linked_taginfo G__G__ProofLN_TBranch = { "TBranch" , 99 , -1 };
19416 G__linked_taginfo G__G__ProofLN_TAttLine = { "TAttLine" , 99 , -1 };
19417 G__linked_taginfo G__G__ProofLN_TAttMarker = { "TAttMarker" , 99 , -1 };
19418 G__linked_taginfo G__G__ProofLN_TObjString = { "TObjString" , 99 , -1 };
19419 G__linked_taginfo G__G__ProofLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR = { "map<string,TObjArray*,less<string>,allocator<pair<const string,TObjArray*> > >" , 99 , -1 };
19420 G__linked_taginfo G__G__ProofLN_TSelector = { "TSelector" , 99 , -1 };
19421 G__linked_taginfo G__G__ProofLN_TVirtualTreePlayer = { "TVirtualTreePlayer" , 99 , -1 };
19422 G__linked_taginfo G__G__ProofLN_TDrawFeedback = { "TDrawFeedback" , 99 , -1 };
19423 G__linked_taginfo G__G__ProofLN_TProofChaincLcLdA = { "TProofChain::$" , 101 , -1 };
19424 G__linked_taginfo G__G__ProofLN_TSocket = { "TSocket" , 99 , -1 };
19425 G__linked_taginfo G__G__ProofLN_TServerSocket = { "TServerSocket" , 99 , -1 };
19426 G__linked_taginfo G__G__ProofLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
19427 G__linked_taginfo G__G__ProofLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
19428 G__linked_taginfo G__G__ProofLN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
19429 G__linked_taginfo G__G__ProofLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
19430 G__linked_taginfo G__G__ProofLN_TQObject = { "TQObject" , 99 , -1 };
19431 G__linked_taginfo G__G__ProofLN_TFileHandler = { "TFileHandler" , 99 , -1 };
19432 G__linked_taginfo G__G__ProofLN_TSignalHandler = { "TSignalHandler" , 99 , -1 };
19433 G__linked_taginfo G__G__ProofLN_FileStat_t = { "FileStat_t" , 115 , -1 };
19434 G__linked_taginfo G__G__ProofLN_SysInfo_t = { "SysInfo_t" , 115 , -1 };
19435 G__linked_taginfo G__G__ProofLN_TProofDesc = { "TProofDesc" , 99 , -1 };
19436 G__linked_taginfo G__G__ProofLN_TProofLog = { "TProofLog" , 99 , -1 };
19437 G__linked_taginfo G__G__ProofLN_TProofMgr = { "TProofMgr" , 99 , -1 };
19438 G__linked_taginfo G__G__ProofLN_TProofMgrcLcLEServType = { "TProofMgr::EServType" , 101 , -1 };
19439 G__linked_taginfo G__G__ProofLN_TProofDesccLcLEStatus = { "TProofDesc::EStatus" , 101 , -1 };
19440 G__linked_taginfo G__G__ProofLN_TProofDebug = { "TProofDebug" , 99 , -1 };
19441 G__linked_taginfo G__G__ProofLN_TProofDebugcLcLEProofDebugMask = { "TProofDebug::EProofDebugMask" , 101 , -1 };
19442 G__linked_taginfo G__G__ProofLN_TMutex = { "TMutex" , 99 , -1 };
19443 G__linked_taginfo G__G__ProofLN_TMessage = { "TMessage" , 99 , -1 };
19444 G__linked_taginfo G__G__ProofLN_TMonitor = { "TMonitor" , 99 , -1 };
19445 G__linked_taginfo G__G__ProofLN_TPluginHandler = { "TPluginHandler" , 99 , -1 };
19446 G__linked_taginfo G__G__ProofLN_TProofLockPath = { "TProofLockPath" , 99 , -1 };
19447 G__linked_taginfo G__G__ProofLN_TVirtualProofPlayer = { "TVirtualProofPlayer" , 99 , -1 };
19448 G__linked_taginfo G__G__ProofLN_TQueryResult = { "TQueryResult" , 99 , -1 };
19449 G__linked_taginfo G__G__ProofLN_TSlave = { "TSlave" , 99 , -1 };
19450 G__linked_taginfo G__G__ProofLN_TSemaphore = { "TSemaphore" , 99 , -1 };
19451 G__linked_taginfo G__G__ProofLN_TMacro = { "TMacro" , 99 , -1 };
19452 G__linked_taginfo G__G__ProofLN_TProofProgressInfo = { "TProofProgressInfo" , 99 , -1 };
19453 G__linked_taginfo G__G__ProofLN_TSlaveInfo = { "TSlaveInfo" , 99 , -1 };
19454 G__linked_taginfo G__G__ProofLN_TSlaveInfocLcLESlaveStatus = { "TSlaveInfo::ESlaveStatus" , 101 , -1 };
19455 G__linked_taginfo G__G__ProofLN_TMergerInfo = { "TMergerInfo" , 99 , -1 };
19456 G__linked_taginfo G__G__ProofLN_TProofMergePrg = { "TProofMergePrg" , 99 , -1 };
19457 G__linked_taginfo G__G__ProofLN_TProofLite = { "TProofLite" , 99 , -1 };
19458 G__linked_taginfo G__G__ProofLN_TSlaveLite = { "TSlaveLite" , 99 , -1 };
19459 G__linked_taginfo G__G__ProofLN_TVirtualPacketizer = { "TVirtualPacketizer" , 99 , -1 };
19460 G__linked_taginfo G__G__ProofLN_TProofcLcLEStatusBits = { "TProof::EStatusBits" , 101 , -1 };
19461 G__linked_taginfo G__G__ProofLN_TProofcLcLEQueryMode = { "TProof::EQueryMode" , 101 , -1 };
19462 G__linked_taginfo G__G__ProofLN_TProofcLcLEUploadOpt = { "TProof::EUploadOpt" , 101 , -1 };
19463 G__linked_taginfo G__G__ProofLN_TProofcLcLERegisterOpt = { "TProof::ERegisterOpt" , 101 , -1 };
19464 G__linked_taginfo G__G__ProofLN_TProofcLcLEUploadDataSetAnswer = { "TProof::EUploadDataSetAnswer" , 101 , -1 };
19465 G__linked_taginfo G__G__ProofLN_TProofcLcLEUploadPackageOpt = { "TProof::EUploadPackageOpt" , 101 , -1 };
19466 G__linked_taginfo G__G__ProofLN_TProofcLcLERunStatus = { "TProof::ERunStatus" , 101 , -1 };
19467 G__linked_taginfo G__G__ProofLN_TProofcLcLESubMerger = { "TProof::ESubMerger" , 101 , -1 };
19468 G__linked_taginfo G__G__ProofLN_TProofcLcLEUrgent = { "TProof::EUrgent" , 101 , -1 };
19469 G__linked_taginfo G__G__ProofLN_TProofcLcLEProofCacheCommands = { "TProof::EProofCacheCommands" , 101 , -1 };
19470 G__linked_taginfo G__G__ProofLN_TProofcLcLEProofDataSetCommands = { "TProof::EProofDataSetCommands" , 101 , -1 };
19471 G__linked_taginfo G__G__ProofLN_TProofcLcLESendFileOpt = { "TProof::ESendFileOpt" , 101 , -1 };
19472 G__linked_taginfo G__G__ProofLN_TProofcLcLEProofWrkListAction = { "TProof::EProofWrkListAction" , 101 , -1 };
19473 G__linked_taginfo G__G__ProofLN_TProofcLcLEBuildPackageOpt = { "TProof::EBuildPackageOpt" , 101 , -1 };
19474 G__linked_taginfo G__G__ProofLN_TProofcLcLEProofShowQuotaOpt = { "TProof::EProofShowQuotaOpt" , 101 , -1 };
19475 G__linked_taginfo G__G__ProofLN_TProofcLcLEProofClearData = { "TProof::EProofClearData" , 101 , -1 };
19476 G__linked_taginfo G__G__ProofLN_maplETStringcOTProofcLcLMD5Mod_tcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTProofcLcLMD5Mod_tgRsPgRsPgR = { "map<TString,TProof::MD5Mod_t,less<TString>,allocator<pair<const TString,TProof::MD5Mod_t> > >" , 99 , -1 };
19477 G__linked_taginfo G__G__ProofLN_TProofcLcLESlaves = { "TProof::ESlaves" , 101 , -1 };
19478 G__linked_taginfo G__G__ProofLN_TProofCondor = { "TProofCondor" , 99 , -1 };
19479 G__linked_taginfo G__G__ProofLN_TQueryResultManager = { "TQueryResultManager" , 99 , -1 };
19480 G__linked_taginfo G__G__ProofLN_TProofQueryResult = { "TProofQueryResult" , 99 , -1 };
19481 G__linked_taginfo G__G__ProofLN_TDatime = { "TDatime" , 99 , -1 };
19482 G__linked_taginfo G__G__ProofLN_TProofLogElem = { "TProofLogElem" , 99 , -1 };
19483 G__linked_taginfo G__G__ProofLN_TProofMgrLite = { "TProofMgrLite" , 99 , -1 };
19484 G__linked_taginfo G__G__ProofLN_TProofLogcLcLELogLocationBit = { "TProofLog::ELogLocationBit" , 101 , -1 };
19485 G__linked_taginfo G__G__ProofLN_TProofLogcLcLERetrieveOpt = { "TProofLog::ERetrieveOpt" , 101 , -1 };
19486 G__linked_taginfo G__G__ProofLN_TProofResourcesStatic = { "TProofResourcesStatic" , 99 , -1 };
19487 G__linked_taginfo G__G__ProofLN_TProofNodeInfo = { "TProofNodeInfo" , 99 , -1 };
19488 G__linked_taginfo G__G__ProofLN_TProofNodeInfocLcLENodeType = { "TProofNodeInfo::ENodeType" , 101 , -1 };
19489 G__linked_taginfo G__G__ProofLN_TProofProgressStatus = { "TProofProgressStatus" , 99 , -1 };
19490 G__linked_taginfo G__G__ProofLN_TQueryResultcLcLEQueryStatus = { "TQueryResult::EQueryStatus" , 101 , -1 };
19491 G__linked_taginfo G__G__ProofLN_TProofResources = { "TProofResources" , 99 , -1 };
19492 G__linked_taginfo G__G__ProofLN_TProofResourcesStaticcLcLEInfoType = { "TProofResourcesStatic::EInfoType" , 101 , -1 };
19493 G__linked_taginfo G__G__ProofLN_TApplication = { "TApplication" , 99 , -1 };
19494 G__linked_taginfo G__G__ProofLN_TStopwatch = { "TStopwatch" , 99 , -1 };
19495 G__linked_taginfo G__G__ProofLN_TShutdownTimer = { "TShutdownTimer" , 99 , -1 };
19496 G__linked_taginfo G__G__ProofLN_TReaperTimer = { "TReaperTimer" , 99 , -1 };
19497 G__linked_taginfo G__G__ProofLN_TIdleTOTimer = { "TIdleTOTimer" , 99 , -1 };
19498 G__linked_taginfo G__G__ProofLN_TProofServLite = { "TProofServLite" , 99 , -1 };
19499 G__linked_taginfo G__G__ProofLN_TProofServcLcLEStatusBits = { "TProofServ::EStatusBits" , 101 , -1 };
19500 G__linked_taginfo G__G__ProofLN_TProofServcLcLEQueryAction = { "TProofServ::EQueryAction" , 101 , -1 };
19501 G__linked_taginfo G__G__ProofLN_TProofServLiteInterruptHandler = { "TProofServLiteInterruptHandler" , 99 , -1 };
19502 G__linked_taginfo G__G__ProofLN_TProofSuperMaster = { "TProofSuperMaster" , 99 , -1 };
19503 G__linked_taginfo G__G__ProofLN_TSlavecLcLESlaveType = { "TSlave::ESlaveType" , 101 , -1 };
19504 G__linked_taginfo G__G__ProofLN_TSlavecLcLESlaveStatus = { "TSlave::ESlaveStatus" , 101 , -1 };
19505 G__linked_taginfo G__G__ProofLN_TVirtualProofPlayercLcLEExitStatus = { "TVirtualProofPlayer::EExitStatus" , 101 , -1 };
19506 
19507 /* Reset class/struct taginfo */
19508 extern "C" void G__cpp_reset_tagtableG__Proof() {
19509   G__G__ProofLN_TClass.tagnum = -1 ;
19510   G__G__ProofLN_TBuffer.tagnum = -1 ;
19511   G__G__ProofLN_TDirectory.tagnum = -1 ;
19512   G__G__ProofLN_TMemberInspector.tagnum = -1 ;
19513   G__G__ProofLN_TObject.tagnum = -1 ;
19514   G__G__ProofLN_TNamed.tagnum = -1 ;
19515   G__G__ProofLN_TString.tagnum = -1 ;
19516   G__G__ProofLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
19517   G__G__ProofLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
19518   G__G__ProofLN_va_list.tagnum = -1 ;
19519   G__G__ProofLN_TList.tagnum = -1 ;
19520   G__G__ProofLN_TBrowser.tagnum = -1 ;
19521   G__G__ProofLN_TObjArray.tagnum = -1 ;
19522   G__G__ProofLN_TTimer.tagnum = -1 ;
19523   G__G__ProofLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
19524   G__G__ProofLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
19525   G__G__ProofLN_TVirtualMutex.tagnum = -1 ;
19526   G__G__ProofLN_TCondorSlave.tagnum = -1 ;
19527   G__G__ProofLN_TCondor.tagnum = -1 ;
19528   G__G__ProofLN_TCondorcLcLEState.tagnum = -1 ;
19529   G__G__ProofLN_TCollection.tagnum = -1 ;
19530   G__G__ProofLN_TIter.tagnum = -1 ;
19531   G__G__ProofLN_TMap.tagnum = -1 ;
19532   G__G__ProofLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
19533   G__G__ProofLN_TUri.tagnum = -1 ;
19534   G__G__ProofLN_TFileCollection.tagnum = -1 ;
19535   G__G__ProofLN_TFileInfo.tagnum = -1 ;
19536   G__G__ProofLN_TMD5.tagnum = -1 ;
19537   G__G__ProofLN_TUrl.tagnum = -1 ;
19538   G__G__ProofLN_TVirtualMonitoringWriter.tagnum = -1 ;
19539   G__G__ProofLN_TDataSetManager.tagnum = -1 ;
19540   G__G__ProofLN_TDataSetManagercLcLEDataSetStatusBits.tagnum = -1 ;
19541   G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts.tagnum = -1 ;
19542   G__G__ProofLN_TDataSetManagerFile.tagnum = -1 ;
19543   G__G__ProofLN_TChain.tagnum = -1 ;
19544   G__G__ProofLN_TCut.tagnum = -1 ;
19545   G__G__ProofLN_TDSet.tagnum = -1 ;
19546   G__G__ProofLN_TEventList.tagnum = -1 ;
19547   G__G__ProofLN_TEntryList.tagnum = -1 ;
19548   G__G__ProofLN_THashList.tagnum = -1 ;
19549   G__G__ProofLN_TProof.tagnum = -1 ;
19550   G__G__ProofLN_TProofChain.tagnum = -1 ;
19551   G__G__ProofLN_TTree.tagnum = -1 ;
19552   G__G__ProofLN_TDSetElement.tagnum = -1 ;
19553   G__G__ProofLN_pairlETDSetElementmUcOTStringgR.tagnum = -1 ;
19554   G__G__ProofLN_allocatorlEpairlETDSetElementmUcOTStringgRsPgR.tagnum = -1 ;
19555   G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR.tagnum = -1 ;
19556   G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgRcLcLiterator.tagnum = -1 ;
19557   G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgRcLcLreverse_iterator.tagnum = -1 ;
19558   G__G__ProofLN_TDSetElementcLcLEStatusBits.tagnum = -1 ;
19559   G__G__ProofLN_TDSetcLcLEStatusBits.tagnum = -1 ;
19560   G__G__ProofLN_TProofServ.tagnum = -1 ;
19561   G__G__ProofLN_TDSetProxy.tagnum = -1 ;
19562   G__G__ProofLN_TAttFill.tagnum = -1 ;
19563   G__G__ProofLN_TLeaf.tagnum = -1 ;
19564   G__G__ProofLN_TBranch.tagnum = -1 ;
19565   G__G__ProofLN_TAttLine.tagnum = -1 ;
19566   G__G__ProofLN_TAttMarker.tagnum = -1 ;
19567   G__G__ProofLN_TObjString.tagnum = -1 ;
19568   G__G__ProofLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR.tagnum = -1 ;
19569   G__G__ProofLN_TSelector.tagnum = -1 ;
19570   G__G__ProofLN_TVirtualTreePlayer.tagnum = -1 ;
19571   G__G__ProofLN_TDrawFeedback.tagnum = -1 ;
19572   G__G__ProofLN_TProofChaincLcLdA.tagnum = -1 ;
19573   G__G__ProofLN_TSocket.tagnum = -1 ;
19574   G__G__ProofLN_TServerSocket.tagnum = -1 ;
19575   G__G__ProofLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
19576   G__G__ProofLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
19577   G__G__ProofLN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
19578   G__G__ProofLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
19579   G__G__ProofLN_TQObject.tagnum = -1 ;
19580   G__G__ProofLN_TFileHandler.tagnum = -1 ;
19581   G__G__ProofLN_TSignalHandler.tagnum = -1 ;
19582   G__G__ProofLN_FileStat_t.tagnum = -1 ;
19583   G__G__ProofLN_SysInfo_t.tagnum = -1 ;
19584   G__G__ProofLN_TProofDesc.tagnum = -1 ;
19585   G__G__ProofLN_TProofLog.tagnum = -1 ;
19586   G__G__ProofLN_TProofMgr.tagnum = -1 ;
19587   G__G__ProofLN_TProofMgrcLcLEServType.tagnum = -1 ;
19588   G__G__ProofLN_TProofDesccLcLEStatus.tagnum = -1 ;
19589   G__G__ProofLN_TProofDebug.tagnum = -1 ;
19590   G__G__ProofLN_TProofDebugcLcLEProofDebugMask.tagnum = -1 ;
19591   G__G__ProofLN_TMutex.tagnum = -1 ;
19592   G__G__ProofLN_TMessage.tagnum = -1 ;
19593   G__G__ProofLN_TMonitor.tagnum = -1 ;
19594   G__G__ProofLN_TPluginHandler.tagnum = -1 ;
19595   G__G__ProofLN_TProofLockPath.tagnum = -1 ;
19596   G__G__ProofLN_TVirtualProofPlayer.tagnum = -1 ;
19597   G__G__ProofLN_TQueryResult.tagnum = -1 ;
19598   G__G__ProofLN_TSlave.tagnum = -1 ;
19599   G__G__ProofLN_TSemaphore.tagnum = -1 ;
19600   G__G__ProofLN_TMacro.tagnum = -1 ;
19601   G__G__ProofLN_TProofProgressInfo.tagnum = -1 ;
19602   G__G__ProofLN_TSlaveInfo.tagnum = -1 ;
19603   G__G__ProofLN_TSlaveInfocLcLESlaveStatus.tagnum = -1 ;
19604   G__G__ProofLN_TMergerInfo.tagnum = -1 ;
19605   G__G__ProofLN_TProofMergePrg.tagnum = -1 ;
19606   G__G__ProofLN_TProofLite.tagnum = -1 ;
19607   G__G__ProofLN_TSlaveLite.tagnum = -1 ;
19608   G__G__ProofLN_TVirtualPacketizer.tagnum = -1 ;
19609   G__G__ProofLN_TProofcLcLEStatusBits.tagnum = -1 ;
19610   G__G__ProofLN_TProofcLcLEQueryMode.tagnum = -1 ;
19611   G__G__ProofLN_TProofcLcLEUploadOpt.tagnum = -1 ;
19612   G__G__ProofLN_TProofcLcLERegisterOpt.tagnum = -1 ;
19613   G__G__ProofLN_TProofcLcLEUploadDataSetAnswer.tagnum = -1 ;
19614   G__G__ProofLN_TProofcLcLEUploadPackageOpt.tagnum = -1 ;
19615   G__G__ProofLN_TProofcLcLERunStatus.tagnum = -1 ;
19616   G__G__ProofLN_TProofcLcLESubMerger.tagnum = -1 ;
19617   G__G__ProofLN_TProofcLcLEUrgent.tagnum = -1 ;
19618   G__G__ProofLN_TProofcLcLEProofCacheCommands.tagnum = -1 ;
19619   G__G__ProofLN_TProofcLcLEProofDataSetCommands.tagnum = -1 ;
19620   G__G__ProofLN_TProofcLcLESendFileOpt.tagnum = -1 ;
19621   G__G__ProofLN_TProofcLcLEProofWrkListAction.tagnum = -1 ;
19622   G__G__ProofLN_TProofcLcLEBuildPackageOpt.tagnum = -1 ;
19623   G__G__ProofLN_TProofcLcLEProofShowQuotaOpt.tagnum = -1 ;
19624   G__G__ProofLN_TProofcLcLEProofClearData.tagnum = -1 ;
19625   G__G__ProofLN_maplETStringcOTProofcLcLMD5Mod_tcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTProofcLcLMD5Mod_tgRsPgRsPgR.tagnum = -1 ;
19626   G__G__ProofLN_TProofcLcLESlaves.tagnum = -1 ;
19627   G__G__ProofLN_TProofCondor.tagnum = -1 ;
19628   G__G__ProofLN_TQueryResultManager.tagnum = -1 ;
19629   G__G__ProofLN_TProofQueryResult.tagnum = -1 ;
19630   G__G__ProofLN_TDatime.tagnum = -1 ;
19631   G__G__ProofLN_TProofLogElem.tagnum = -1 ;
19632   G__G__ProofLN_TProofMgrLite.tagnum = -1 ;
19633   G__G__ProofLN_TProofLogcLcLELogLocationBit.tagnum = -1 ;
19634   G__G__ProofLN_TProofLogcLcLERetrieveOpt.tagnum = -1 ;
19635   G__G__ProofLN_TProofResourcesStatic.tagnum = -1 ;
19636   G__G__ProofLN_TProofNodeInfo.tagnum = -1 ;
19637   G__G__ProofLN_TProofNodeInfocLcLENodeType.tagnum = -1 ;
19638   G__G__ProofLN_TProofProgressStatus.tagnum = -1 ;
19639   G__G__ProofLN_TQueryResultcLcLEQueryStatus.tagnum = -1 ;
19640   G__G__ProofLN_TProofResources.tagnum = -1 ;
19641   G__G__ProofLN_TProofResourcesStaticcLcLEInfoType.tagnum = -1 ;
19642   G__G__ProofLN_TApplication.tagnum = -1 ;
19643   G__G__ProofLN_TStopwatch.tagnum = -1 ;
19644   G__G__ProofLN_TShutdownTimer.tagnum = -1 ;
19645   G__G__ProofLN_TReaperTimer.tagnum = -1 ;
19646   G__G__ProofLN_TIdleTOTimer.tagnum = -1 ;
19647   G__G__ProofLN_TProofServLite.tagnum = -1 ;
19648   G__G__ProofLN_TProofServcLcLEStatusBits.tagnum = -1 ;
19649   G__G__ProofLN_TProofServcLcLEQueryAction.tagnum = -1 ;
19650   G__G__ProofLN_TProofServLiteInterruptHandler.tagnum = -1 ;
19651   G__G__ProofLN_TProofSuperMaster.tagnum = -1 ;
19652   G__G__ProofLN_TSlavecLcLESlaveType.tagnum = -1 ;
19653   G__G__ProofLN_TSlavecLcLESlaveStatus.tagnum = -1 ;
19654   G__G__ProofLN_TVirtualProofPlayercLcLEExitStatus.tagnum = -1 ;
19655 }
19656 
19657 
19658 extern "C" void G__cpp_setup_tagtableG__Proof() {
19659 
19660    /* Setting up class,struct,union tag entry */
19661    G__get_linked_tagnum_fwd(&G__G__ProofLN_TClass);
19662    G__get_linked_tagnum_fwd(&G__G__ProofLN_TBuffer);
19663    G__get_linked_tagnum_fwd(&G__G__ProofLN_TDirectory);
19664    G__get_linked_tagnum_fwd(&G__G__ProofLN_TMemberInspector);
19665    G__get_linked_tagnum_fwd(&G__G__ProofLN_TObject);
19666    G__get_linked_tagnum_fwd(&G__G__ProofLN_TNamed);
19667    G__get_linked_tagnum_fwd(&G__G__ProofLN_TString);
19668    G__get_linked_tagnum_fwd(&G__G__ProofLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
19669    G__get_linked_tagnum_fwd(&G__G__ProofLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
19670    G__get_linked_tagnum_fwd(&G__G__ProofLN_va_list);
19671    G__get_linked_tagnum_fwd(&G__G__ProofLN_TList);
19672    G__get_linked_tagnum_fwd(&G__G__ProofLN_TBrowser);
19673    G__get_linked_tagnum_fwd(&G__G__ProofLN_TObjArray);
19674    G__get_linked_tagnum_fwd(&G__G__ProofLN_TTimer);
19675    G__get_linked_tagnum_fwd(&G__G__ProofLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
19676    G__get_linked_tagnum_fwd(&G__G__ProofLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
19677    G__get_linked_tagnum_fwd(&G__G__ProofLN_TVirtualMutex);
19678    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TCondorSlave),sizeof(TCondorSlave),-1,290816,"Describes a claimed slave",G__setup_memvarTCondorSlave,G__setup_memfuncTCondorSlave);
19679    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TCondor),sizeof(TCondor),-1,292096,"Interface to the Condor System",G__setup_memvarTCondor,G__setup_memfuncTCondor);
19680    G__get_linked_tagnum_fwd(&G__G__ProofLN_TCondorcLcLEState);
19681    G__get_linked_tagnum_fwd(&G__G__ProofLN_TCollection);
19682    G__get_linked_tagnum_fwd(&G__G__ProofLN_TIter);
19683    G__get_linked_tagnum_fwd(&G__G__ProofLN_TMap);
19684    G__get_linked_tagnum_fwd(&G__G__ProofLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
19685    G__get_linked_tagnum_fwd(&G__G__ProofLN_TUri);
19686    G__get_linked_tagnum_fwd(&G__G__ProofLN_TFileCollection);
19687    G__get_linked_tagnum_fwd(&G__G__ProofLN_TFileInfo);
19688    G__get_linked_tagnum_fwd(&G__G__ProofLN_TMD5);
19689    G__get_linked_tagnum_fwd(&G__G__ProofLN_TUrl);
19690    G__get_linked_tagnum_fwd(&G__G__ProofLN_TVirtualMonitoringWriter);
19691    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TDataSetManager),sizeof(TDataSetManager),-1,32512,"Abstract data set manager class",G__setup_memvarTDataSetManager,G__setup_memfuncTDataSetManager);
19692    G__get_linked_tagnum_fwd(&G__G__ProofLN_TDataSetManagercLcLEDataSetStatusBits);
19693    G__get_linked_tagnum_fwd(&G__G__ProofLN_TDataSetManagercLcLEDataSetWorkOpts);
19694    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TDataSetManagerFile),sizeof(TDataSetManagerFile),-1,62720,"DataSet manager for files",G__setup_memvarTDataSetManagerFile,G__setup_memfuncTDataSetManagerFile);
19695    G__get_linked_tagnum_fwd(&G__G__ProofLN_TChain);
19696    G__get_linked_tagnum_fwd(&G__G__ProofLN_TCut);
19697    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TDSet),sizeof(TDSet),-1,130816,"Data set for remote processing (PROOF)",G__setup_memvarTDSet,G__setup_memfuncTDSet);
19698    G__get_linked_tagnum_fwd(&G__G__ProofLN_TEventList);
19699    G__get_linked_tagnum_fwd(&G__G__ProofLN_TEntryList);
19700    G__get_linked_tagnum_fwd(&G__G__ProofLN_THashList);
19701    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TProof),sizeof(TProof),-1,65280,"PROOF control class",G__setup_memvarTProof,G__setup_memfuncTProof);
19702    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofChain),sizeof(TProofChain),-1,324864,"TChain proxy for running chains on PROOF",G__setup_memvarTProofChain,G__setup_memfuncTProofChain);
19703    G__get_linked_tagnum_fwd(&G__G__ProofLN_TTree);
19704    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TDSetElement),sizeof(TDSetElement),-1,130816,"A TDSet element",G__setup_memvarTDSetElement,G__setup_memfuncTDSetElement);
19705    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_pairlETDSetElementmUcOTStringgR),sizeof(pair<TDSetElement*,TString>),-1,35072,(char*)NULL,G__setup_memvarpairlETDSetElementmUcOTStringgR,G__setup_memfuncpairlETDSetElementmUcOTStringgR);
19706    G__get_linked_tagnum_fwd(&G__G__ProofLN_allocatorlEpairlETDSetElementmUcOTStringgRsPgR);
19707    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR),sizeof(list<pair<TDSetElement*,TString>,allocator<pair<TDSetElement*,TString> > >),-1,36608,(char*)NULL,G__setup_memvarlistlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR,G__setup_memfunclistlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgR);
19708    G__get_linked_tagnum_fwd(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgRcLcLiterator);
19709    G__get_linked_tagnum_fwd(&G__G__ProofLN_listlEpairlETDSetElementmUcOTStringgRcOallocatorlEpairlETDSetElementmUcOTStringgRsPgRsPgRcLcLreverse_iterator);
19710    G__get_linked_tagnum_fwd(&G__G__ProofLN_TDSetElementcLcLEStatusBits);
19711    G__get_linked_tagnum_fwd(&G__G__ProofLN_TDSetcLcLEStatusBits);
19712    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofServ),sizeof(TProofServ),-1,62464,"PROOF Server Application Interface",G__setup_memvarTProofServ,G__setup_memfuncTProofServ);
19713    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TDSetProxy),sizeof(TDSetProxy),-1,323840,"TDSet proxy for use on slaves",G__setup_memvarTDSetProxy,G__setup_memfuncTDSetProxy);
19714    G__get_linked_tagnum_fwd(&G__G__ProofLN_TAttFill);
19715    G__get_linked_tagnum_fwd(&G__G__ProofLN_TLeaf);
19716    G__get_linked_tagnum_fwd(&G__G__ProofLN_TBranch);
19717    G__get_linked_tagnum_fwd(&G__G__ProofLN_TAttLine);
19718    G__get_linked_tagnum_fwd(&G__G__ProofLN_TAttMarker);
19719    G__get_linked_tagnum_fwd(&G__G__ProofLN_TObjString);
19720    G__get_linked_tagnum_fwd(&G__G__ProofLN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR);
19721    G__get_linked_tagnum_fwd(&G__G__ProofLN_TSelector);
19722    G__get_linked_tagnum_fwd(&G__G__ProofLN_TVirtualTreePlayer);
19723    G__get_linked_tagnum_fwd(&G__G__ProofLN_TDrawFeedback);
19724    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofChaincLcLdA);
19725    G__get_linked_tagnum_fwd(&G__G__ProofLN_TSocket);
19726    G__get_linked_tagnum_fwd(&G__G__ProofLN_TServerSocket);
19727    G__get_linked_tagnum_fwd(&G__G__ProofLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
19728    G__get_linked_tagnum_fwd(&G__G__ProofLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
19729    G__get_linked_tagnum_fwd(&G__G__ProofLN_vectorlETStringcOallocatorlETStringgRsPgR);
19730    G__get_linked_tagnum_fwd(&G__G__ProofLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
19731    G__get_linked_tagnum_fwd(&G__G__ProofLN_TQObject);
19732    G__get_linked_tagnum_fwd(&G__G__ProofLN_TFileHandler);
19733    G__get_linked_tagnum_fwd(&G__G__ProofLN_TSignalHandler);
19734    G__get_linked_tagnum_fwd(&G__G__ProofLN_FileStat_t);
19735    G__get_linked_tagnum_fwd(&G__G__ProofLN_SysInfo_t);
19736    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofDesc),sizeof(TProofDesc),-1,65280,"Small class describing a proof session",G__setup_memvarTProofDesc,G__setup_memfuncTProofDesc);
19737    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofLog),sizeof(TProofLog),-1,62464,"PROOF session log handler",G__setup_memvarTProofLog,G__setup_memfuncTProofLog);
19738    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofMgr),sizeof(TProofMgr),-1,65280,"Abstract PROOF manager interface",G__setup_memvarTProofMgr,G__setup_memfuncTProofMgr);
19739    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofMgrcLcLEServType);
19740    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofDesccLcLEStatus);
19741    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofDebug),sizeof(TProofDebug),-1,0,(char*)NULL,G__setup_memvarTProofDebug,G__setup_memfuncTProofDebug);
19742    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofDebugcLcLEProofDebugMask);
19743    G__get_linked_tagnum_fwd(&G__G__ProofLN_TMutex);
19744    G__get_linked_tagnum_fwd(&G__G__ProofLN_TMessage);
19745    G__get_linked_tagnum_fwd(&G__G__ProofLN_TMonitor);
19746    G__get_linked_tagnum_fwd(&G__G__ProofLN_TPluginHandler);
19747    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofLockPath);
19748    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TVirtualProofPlayer),sizeof(TVirtualProofPlayer),-1,292145,"Abstract PROOF player",G__setup_memvarTVirtualProofPlayer,G__setup_memfuncTVirtualProofPlayer);
19749    G__get_linked_tagnum_fwd(&G__G__ProofLN_TQueryResult);
19750    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TSlave),sizeof(TSlave),-1,65280,"PROOF slave server",G__setup_memvarTSlave,G__setup_memfuncTSlave);
19751    G__get_linked_tagnum_fwd(&G__G__ProofLN_TSemaphore);
19752    G__get_linked_tagnum_fwd(&G__G__ProofLN_TMacro);
19753    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofProgressInfo),sizeof(TProofProgressInfo),-1,29952,"Progress information",G__setup_memvarTProofProgressInfo,G__setup_memfuncTProofProgressInfo);
19754    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TSlaveInfo),sizeof(TSlaveInfo),-1,291072,"basic info on workers",G__setup_memvarTSlaveInfo,G__setup_memfuncTSlaveInfo);
19755    G__get_linked_tagnum_fwd(&G__G__ProofLN_TSlaveInfocLcLESlaveStatus);
19756    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TMergerInfo),sizeof(TMergerInfo),-1,65024,"Basic info on merger, i.e. worker serving as merger",G__setup_memvarTMergerInfo,G__setup_memfuncTMergerInfo);
19757    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofMergePrg);
19758    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofLite),sizeof(TProofLite),-1,65280,"PROOF-Lite control class",G__setup_memvarTProofLite,G__setup_memfuncTProofLite);
19759    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TSlaveLite),sizeof(TSlaveLite),-1,62464,"PROOF lite worker server",G__setup_memvarTSlaveLite,G__setup_memfuncTSlaveLite);
19760    G__get_linked_tagnum_fwd(&G__G__ProofLN_TVirtualPacketizer);
19761    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofcLcLEStatusBits);
19762    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofcLcLEQueryMode);
19763    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofcLcLEUploadOpt);
19764    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofcLcLERegisterOpt);
19765    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofcLcLEUploadDataSetAnswer);
19766    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofcLcLEUploadPackageOpt);
19767    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofcLcLERunStatus);
19768    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofcLcLESubMerger);
19769    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofcLcLEUrgent);
19770    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofcLcLEProofCacheCommands);
19771    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofcLcLEProofDataSetCommands);
19772    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofcLcLESendFileOpt);
19773    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofcLcLEProofWrkListAction);
19774    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofcLcLEBuildPackageOpt);
19775    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofcLcLEProofShowQuotaOpt);
19776    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofcLcLEProofClearData);
19777    G__get_linked_tagnum_fwd(&G__G__ProofLN_maplETStringcOTProofcLcLMD5Mod_tcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTProofcLcLMD5Mod_tgRsPgRsPgR);
19778    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofcLcLESlaves);
19779    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofCondor),sizeof(TProofCondor),-1,62464,"PROOF control class for slaves allocated by condor",G__setup_memvarTProofCondor,G__setup_memfuncTProofCondor);
19780    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TQueryResultManager),sizeof(TQueryResultManager),-1,324608,"PROOF query result manager",G__setup_memvarTQueryResultManager,G__setup_memfuncTQueryResultManager);
19781    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofQueryResult),sizeof(TProofQueryResult),-1,324864,"Class describing a PROOF query",G__setup_memvarTProofQueryResult,G__setup_memfuncTProofQueryResult);
19782    G__get_linked_tagnum_fwd(&G__G__ProofLN_TDatime);
19783    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofLogElem),sizeof(TProofLogElem),-1,62464,"PROOF session log element",G__setup_memvarTProofLogElem,G__setup_memfuncTProofLogElem);
19784    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofMgrLite),sizeof(TProofMgrLite),-1,62464,"XrdProofd PROOF manager interface",G__setup_memvarTProofMgrLite,G__setup_memfuncTProofMgrLite);
19785    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofLogcLcLELogLocationBit);
19786    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofLogcLcLERetrieveOpt);
19787    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofResourcesStatic),sizeof(TProofResourcesStatic),-1,62720,"Class to handle PROOF static config",G__setup_memvarTProofResourcesStatic,G__setup_memfuncTProofResourcesStatic);
19788    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofNodeInfo),sizeof(TProofNodeInfo),-1,63232,"Class describing a PROOF node",G__setup_memvarTProofNodeInfo,G__setup_memfuncTProofNodeInfo);
19789    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofNodeInfocLcLENodeType);
19790    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofProgressStatus),sizeof(TProofProgressStatus),-1,28928,"Proof progress status class",G__setup_memvarTProofProgressStatus,G__setup_memfuncTProofProgressStatus);
19791    G__get_linked_tagnum_fwd(&G__G__ProofLN_TQueryResultcLcLEQueryStatus);
19792    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofResources),sizeof(TProofResources),-1,29955,"Abstract class describing PROOF resources",G__setup_memvarTProofResources,G__setup_memfuncTProofResources);
19793    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofResourcesStaticcLcLEInfoType);
19794    G__get_linked_tagnum_fwd(&G__G__ProofLN_TApplication);
19795    G__get_linked_tagnum_fwd(&G__G__ProofLN_TStopwatch);
19796    G__get_linked_tagnum_fwd(&G__G__ProofLN_TShutdownTimer);
19797    G__get_linked_tagnum_fwd(&G__G__ProofLN_TReaperTimer);
19798    G__get_linked_tagnum_fwd(&G__G__ProofLN_TIdleTOTimer);
19799    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofServLite),sizeof(TProofServLite),-1,62464,"PROOF-Lite Server Application Interface",G__setup_memvarTProofServLite,G__setup_memfuncTProofServLite);
19800    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofServcLcLEStatusBits);
19801    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofServcLcLEQueryAction);
19802    G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofServLiteInterruptHandler);
19803    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofLN_TProofSuperMaster),sizeof(TProofSuperMaster),-1,62464,"PROOF control class for making submasters",G__setup_memvarTProofSuperMaster,G__setup_memfuncTProofSuperMaster);
19804    G__get_linked_tagnum_fwd(&G__G__ProofLN_TSlavecLcLESlaveType);
19805    G__get_linked_tagnum_fwd(&G__G__ProofLN_TSlavecLcLESlaveStatus);
19806    G__get_linked_tagnum_fwd(&G__G__ProofLN_TVirtualProofPlayercLcLEExitStatus);
19807 }
19808 extern "C" void G__cpp_setupG__Proof(void) {
19809   G__check_setup_version(30051515,"G__cpp_setupG__Proof()");
19810   G__set_cpp_environmentG__Proof();
19811   G__cpp_setup_tagtableG__Proof();
19812 
19813   G__cpp_setup_inheritanceG__Proof();
19814 
19815   G__cpp_setup_typetableG__Proof();
19816 
19817   G__cpp_setup_memvarG__Proof();
19818 
19819   G__cpp_setup_memfuncG__Proof();
19820   G__cpp_setup_globalG__Proof();
19821   G__cpp_setup_funcG__Proof();
19822 
19823    if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Proof();
19824   return;
19825 }
19826 class G__cpp_setup_initG__Proof {
19827   public:
19828     G__cpp_setup_initG__Proof() { G__add_setup_func("G__Proof",(G__incsetup)(&G__cpp_setupG__Proof)); G__call_setup_funcs(); }
19829    ~G__cpp_setup_initG__Proof() { G__remove_setup_func("G__Proof"); }
19830 };
19831 G__cpp_setup_initG__Proof G__cpp_setup_initializerG__Proof;
19832 

Generated on Tue Jul 5 14:51:35 2011 for ROOT_528-00b_version by  doxygen 1.5.1