00001
00002
00003
00004
00005
00006
00007 #define R__DICTIONARY_FILENAME proofdIproofdIsrcdIG__Proof
00008 #include "RConfig.h"
00009 #if !defined(R__ACCESS_IN_SYMBOL)
00010
00011 #define private public
00012 #define protected public
00013 #endif
00014
00015
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
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
00042 ::TDSetElement* first;
00043 ::TString second;
00044 };
00045 #endif
00046
00047 }
00048 }
00049
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
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
00081 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TCondorSlave*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00082 }
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
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
00114 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TCondor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00115 }
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
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
00149 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDataSetManager*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00150 }
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
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
00184 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDataSetManagerFile*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00185 }
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
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
00219 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDSet*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00220 }
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
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
00250 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProof*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00251 }
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
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
00285 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofChain*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00286 }
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
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
00320 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDSetElement*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00321 }
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
00333 static TGenericClassInfo *GenerateInitInstanceLocal(const pair<TDSetElement*,TString>*)
00334 {
00335
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
00355 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const pair<TDSetElement*,TString>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00356
00357
00358 static void pairlETDSetElementmUcOTStringgR_Dictionary() {
00359 ::ROOT::GenerateInitInstanceLocal((const pair<TDSetElement*,TString>*)0x0)->GetClass();
00360 }
00361
00362 }
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
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
00392 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofServ*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00393 }
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
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
00425 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDSetProxy*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00426 }
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
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
00460 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofDesc*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00461 }
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
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
00491 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofLog*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00492 }
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
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
00522 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofMgr*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00523 }
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
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
00556 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofDebug*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00557
00558
00559 static void TProofDebug_Dictionary() {
00560 ::ROOT::GenerateInitInstanceLocal((const ::TProofDebug*)0x0)->GetClass();
00561 }
00562
00563 }
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
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
00591 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TVirtualProofPlayer*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00592 }
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
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
00622 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSlave*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00623 }
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
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
00657 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofProgressInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00658 }
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
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
00690 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSlaveInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00691 }
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
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
00721 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMergerInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00722 }
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
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
00752 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofLite*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00753 }
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
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
00783 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSlaveLite*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00784 }
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
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
00814 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofCondor*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00815 }
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
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
00843 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TQueryResultManager*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00844 }
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
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
00876 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofQueryResult*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00877 }
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
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
00907 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofLogElem*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00908 }
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
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
00938 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofMgrLite*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00939 }
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
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
00973 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofResourcesStatic*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00974 }
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
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
01008 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofNodeInfo*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01009 }
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
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
01043 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofProgressStatus*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01044 }
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
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
01074 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofResources*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01075 }
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
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
01105 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofServLite*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01106 }
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
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
01136 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofSuperMaster*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01137 }
01138
01139
01140 TClass *TCondorSlave::fgIsA = 0;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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;
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
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
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
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
02236 static void streamer_TDSet(TBuffer &buf, void *obj) {
02237 ((::TDSet*)obj)->::TDSet::Streamer(buf);
02238 }
02239 }
02240
02241
02242 void TDSetElement::ShowMembers(TMemberInspector &R__insp)
02243 {
02244
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
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
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
02284 static void streamer_TDSetElement(TBuffer &buf, void *obj) {
02285 ((::TDSetElement*)obj)->::TDSetElement::Streamer(buf);
02286 }
02287 }
02288
02289
02290 void TProofChain::Streamer(TBuffer &R__b)
02291 {
02292
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
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
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
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
02333 static void directoryAutoAdd_TProofChain(void *p, TDirectory *dir) {
02334 ((::TProofChain*)p)->DirectoryAutoAdd(dir);
02335 }
02336 }
02337
02338
02339 void TProofMgr::Streamer(TBuffer &R__b)
02340 {
02341
02342
02343 TNamed::Streamer(R__b);
02344 }
02345
02346
02347 void TProofMgr::ShowMembers(TMemberInspector &R__insp)
02348 {
02349
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
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
02374 static void streamer_TProofMgr(TBuffer &buf, void *obj) {
02375 ((::TProofMgr*)obj)->::TProofMgr::Streamer(buf);
02376 }
02377 }
02378
02379
02380 void TProofMgrLite::Streamer(TBuffer &R__b)
02381 {
02382
02383
02384 TProofMgr::Streamer(R__b);
02385 }
02386
02387
02388 void TProofMgrLite::ShowMembers(TMemberInspector &R__insp)
02389 {
02390
02391 TClass *R__cl = ::TProofMgrLite::IsA();
02392 if (R__cl || R__insp.IsA()) { }
02393 TProofMgr::ShowMembers(R__insp);
02394 }
02395
02396 namespace ROOT {
02397
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
02409 static void streamer_TProofMgrLite(TBuffer &buf, void *obj) {
02410 ((::TProofMgrLite*)obj)->::TProofMgrLite::Streamer(buf);
02411 }
02412 }
02413
02414
02415 void TProofDesc::Streamer(TBuffer &R__b)
02416 {
02417
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
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
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
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
02476 static void streamer_TProofDesc(TBuffer &buf, void *obj) {
02477 ((::TProofDesc*)obj)->::TProofDesc::Streamer(buf);
02478 }
02479 }
02480
02481
02482 void TProof::Streamer(TBuffer &R__b)
02483 {
02484
02485
02486 TNamed::Streamer(R__b);
02487 TQObject::Streamer(R__b);
02488 }
02489
02490
02491 void TProof::ShowMembers(TMemberInspector &R__insp)
02492 {
02493
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
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
02611 static void streamer_TProof(TBuffer &buf, void *obj) {
02612 ((::TProof*)obj)->::TProof::Streamer(buf);
02613 }
02614 }
02615
02616
02617 void TProofCondor::Streamer(TBuffer &R__b)
02618 {
02619
02620
02621 TProof::Streamer(R__b);
02622 }
02623
02624
02625 void TProofCondor::ShowMembers(TMemberInspector &R__insp)
02626 {
02627
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
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
02648 static void streamer_TProofCondor(TBuffer &buf, void *obj) {
02649 ((::TProofCondor*)obj)->::TProofCondor::Streamer(buf);
02650 }
02651 }
02652
02653
02654 void TProofLite::Streamer(TBuffer &R__b)
02655 {
02656
02657
02658 TProof::Streamer(R__b);
02659 }
02660
02661
02662 void TProofLite::ShowMembers(TMemberInspector &R__insp)
02663 {
02664
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
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
02704 static void streamer_TProofLite(TBuffer &buf, void *obj) {
02705 ((::TProofLite*)obj)->::TProofLite::Streamer(buf);
02706 }
02707 }
02708
02709
02710 void TProofSuperMaster::Streamer(TBuffer &R__b)
02711 {
02712
02713
02714 TProof::Streamer(R__b);
02715 }
02716
02717
02718 void TProofSuperMaster::ShowMembers(TMemberInspector &R__insp)
02719 {
02720
02721 TClass *R__cl = ::TProofSuperMaster::IsA();
02722 if (R__cl || R__insp.IsA()) { }
02723 TProof::ShowMembers(R__insp);
02724 }
02725
02726 namespace ROOT {
02727
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
02739 static void streamer_TProofSuperMaster(TBuffer &buf, void *obj) {
02740 ((::TProofSuperMaster*)obj)->::TProofSuperMaster::Streamer(buf);
02741 }
02742 }
02743
02744
02745 void TSlaveInfo::Streamer(TBuffer &R__b)
02746 {
02747
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
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
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
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 }
02797
02798
02799 void TProofServ::Streamer(TBuffer &R__b)
02800 {
02801
02802
02803 TApplication::Streamer(R__b);
02804 }
02805
02806
02807 void TProofServ::ShowMembers(TMemberInspector &R__insp)
02808 {
02809
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
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
02916 static void streamer_TProofServ(TBuffer &buf, void *obj) {
02917 ((::TProofServ*)obj)->::TProofServ::Streamer(buf);
02918 }
02919 }
02920
02921
02922 void TProofServLite::Streamer(TBuffer &R__b)
02923 {
02924
02925
02926 TProofServ::Streamer(R__b);
02927 }
02928
02929
02930 void TProofServLite::ShowMembers(TMemberInspector &R__insp)
02931 {
02932
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
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
02955 static void streamer_TProofServLite(TBuffer &buf, void *obj) {
02956 ((::TProofServLite*)obj)->::TProofServLite::Streamer(buf);
02957 }
02958 }
02959
02960 namespace ROOT {
02961
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
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 }
02980
02981
02982 void TProofLog::Streamer(TBuffer &R__b)
02983 {
02984
02985
02986 TNamed::Streamer(R__b);
02987 TQObject::Streamer(R__b);
02988 }
02989
02990
02991 void TProofLog::ShowMembers(TMemberInspector &R__insp)
02992 {
02993
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
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
03018 static void streamer_TProofLog(TBuffer &buf, void *obj) {
03019 ((::TProofLog*)obj)->::TProofLog::Streamer(buf);
03020 }
03021 }
03022
03023
03024 void TProofLogElem::Streamer(TBuffer &R__b)
03025 {
03026
03027
03028 TNamed::Streamer(R__b);
03029 }
03030
03031
03032 void TProofLogElem::ShowMembers(TMemberInspector &R__insp)
03033 {
03034
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
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
03060 static void streamer_TProofLogElem(TBuffer &buf, void *obj) {
03061 ((::TProofLogElem*)obj)->::TProofLogElem::Streamer(buf);
03062 }
03063 }
03064
03065
03066 void TSlave::Streamer(TBuffer &R__b)
03067 {
03068
03069
03070 TObject::Streamer(R__b);
03071 }
03072
03073
03074 void TSlave::ShowMembers(TMemberInspector &R__insp)
03075 {
03076
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
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
03129 static void streamer_TSlave(TBuffer &buf, void *obj) {
03130 ((::TSlave*)obj)->::TSlave::Streamer(buf);
03131 }
03132 }
03133
03134
03135 void TSlaveLite::Streamer(TBuffer &R__b)
03136 {
03137
03138
03139 TSlave::Streamer(R__b);
03140 }
03141
03142
03143 void TSlaveLite::ShowMembers(TMemberInspector &R__insp)
03144 {
03145
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
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
03166 static void streamer_TSlaveLite(TBuffer &buf, void *obj) {
03167 ((::TSlaveLite*)obj)->::TSlaveLite::Streamer(buf);
03168 }
03169 }
03170
03171
03172 void TVirtualProofPlayer::Streamer(TBuffer &R__b)
03173 {
03174
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
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
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 }
03206
03207
03208 void TProofQueryResult::Streamer(TBuffer &R__b)
03209 {
03210
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
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
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
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 }
03249
03250
03251 void TQueryResultManager::Streamer(TBuffer &R__b)
03252 {
03253
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
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
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 }
03299
03300
03301 void TDSetProxy::Streamer(TBuffer &R__b)
03302 {
03303
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
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
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
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 }
03342
03343
03344 void TCondor::Streamer(TBuffer &R__b)
03345 {
03346
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
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
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
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 }
03389
03390
03391 void TCondorSlave::Streamer(TBuffer &R__b)
03392 {
03393
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
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
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
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 }
03443
03444
03445 void TProofNodeInfo::Streamer(TBuffer &R__b)
03446 {
03447
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
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
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
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
03528 static void streamer_TProofNodeInfo(TBuffer &buf, void *obj) {
03529 ((::TProofNodeInfo*)obj)->::TProofNodeInfo::Streamer(buf);
03530 }
03531 }
03532
03533
03534 void TProofResources::Streamer(TBuffer &R__b)
03535 {
03536
03537
03538 TObject::Streamer(R__b);
03539 }
03540
03541
03542 void TProofResources::ShowMembers(TMemberInspector &R__insp)
03543 {
03544
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
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
03564 static void streamer_TProofResources(TBuffer &buf, void *obj) {
03565 ((::TProofResources*)obj)->::TProofResources::Streamer(buf);
03566 }
03567 }
03568
03569
03570 void TProofResourcesStatic::Streamer(TBuffer &R__b)
03571 {
03572
03573
03574 TProofResources::Streamer(R__b);
03575 }
03576
03577
03578 void TProofResourcesStatic::ShowMembers(TMemberInspector &R__insp)
03579 {
03580
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
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
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
03612 static void streamer_TProofResourcesStatic(TBuffer &buf, void *obj) {
03613 ((::TProofResourcesStatic*)obj)->::TProofResourcesStatic::Streamer(buf);
03614 }
03615 }
03616
03617
03618 void TProofProgressStatus::Streamer(TBuffer &R__b)
03619 {
03620
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
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
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
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
03690 static void streamer_TProofProgressStatus(TBuffer &buf, void *obj) {
03691 ((::TProofProgressStatus*)obj)->::TProofProgressStatus::Streamer(buf);
03692 }
03693 }
03694
03695
03696 void TMergerInfo::Streamer(TBuffer &R__b)
03697 {
03698
03699
03700 TObject::Streamer(R__b);
03701 }
03702
03703
03704 void TMergerInfo::ShowMembers(TMemberInspector &R__insp)
03705 {
03706
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
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
03732 static void streamer_TMergerInfo(TBuffer &buf, void *obj) {
03733 ((::TMergerInfo*)obj)->::TMergerInfo::Streamer(buf);
03734 }
03735 }
03736
03737
03738 void TProofProgressInfo::Streamer(TBuffer &R__b)
03739 {
03740
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
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
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
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
03813 static void streamer_TProofProgressInfo(TBuffer &buf, void *obj) {
03814 ((::TProofProgressInfo*)obj)->::TProofProgressInfo::Streamer(buf);
03815 }
03816 }
03817
03818
03819 void TDataSetManager::Streamer(TBuffer &R__b)
03820 {
03821
03822
03823 TObject::Streamer(R__b);
03824 }
03825
03826
03827 void TDataSetManager::ShowMembers(TMemberInspector &R__insp)
03828 {
03829
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
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
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
03878 static void streamer_TDataSetManager(TBuffer &buf, void *obj) {
03879 ((::TDataSetManager*)obj)->::TDataSetManager::Streamer(buf);
03880 }
03881 }
03882
03883
03884 void TDataSetManagerFile::Streamer(TBuffer &R__b)
03885 {
03886
03887
03888 TDataSetManager::Streamer(R__b);
03889 }
03890
03891
03892 void TDataSetManagerFile::ShowMembers(TMemberInspector &R__insp)
03893 {
03894
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
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
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
03936 static void streamer_TDataSetManagerFile(TBuffer &buf, void *obj) {
03937 ((::TDataSetManagerFile*)obj)->::TDataSetManagerFile::Streamer(buf);
03938 }
03939 }
03940
03941
03942 namespace ROOT {
03943 void pairlETDSetElementmUcOTStringgR_ShowMembers(void *obj, TMemberInspector &R__insp)
03944 {
03945
03946 typedef ::ROOT::Shadow::pairlETDSetElementmUcOTStringgR ShadowClass;
03947 ShadowClass *sobj = (ShadowClass*)obj;
03948 if (sobj) { }
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
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
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 }
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
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
04008 static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const list<pair<TDSetElement*,TString> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));
04009
04010
04011 static void listlEpairlETDSetElementmUcOTStringgRsPgR_Dictionary() {
04012 ::ROOT::GenerateInitInstanceLocal((const list<pair<TDSetElement*,TString> >*)0x0)->GetClass();
04013 }
04014
04015 }
04016
04017 namespace ROOT {
04018
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
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 }
04037
04038
04039
04040
04041
04042
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
04091
04092
04093
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
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
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
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
04197
04198
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
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
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
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
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
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
04427
04428
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
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
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
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
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
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
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
05018
05019
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
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
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
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
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
05271
05272
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
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
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
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
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
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
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
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
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
05864
05865
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
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
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
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
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
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
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
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
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
07893
07894
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
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
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
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
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
08111
08112
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
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
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
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
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
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
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
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
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
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
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
08587
08588
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
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
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
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
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
08680
08681
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
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
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
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
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
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
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
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
09085
09086
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
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
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
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
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
09718
09719
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
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
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
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
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
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
09885
09886
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
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
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
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
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
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
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
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
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
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
10168
10169
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
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
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
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
10419
10420
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
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
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
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
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
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
11050
11051
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
11081
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
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
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
11128
11129
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
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
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
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
11671
11672
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
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
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
11975
11976
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
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
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
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
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
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
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
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
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
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
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
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
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
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
12248
12249
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
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
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
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
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
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
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
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
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
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
12495
12496
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
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
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
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
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
12704
12705
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
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
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
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
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
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
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
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
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
12899
12900
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
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
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
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
13019
13020
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
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
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
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
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
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
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
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
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
13202
13203
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
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
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
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
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
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
13515
13516
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
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
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
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
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
13659
13660
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
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
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
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
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
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
13898
13899
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
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
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
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
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
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
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
14045
14046
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
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
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
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
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
14207
14208
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
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
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
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
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
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
14471
14472
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
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
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
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
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
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
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
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
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
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
14881
14882
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
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
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
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
15012
15013
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
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
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
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
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
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
15151
15152
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
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
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
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
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
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
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
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
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
15327
15328
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
15358
15359
15360
15361
15362
15363
15364
15365
15366
15367
15368
15369
15370
15371
15372
15373
15374
15375
15376
15377
15378
15379
15380
15381
15382
15383
15384
15385
15386
15387
15388
15389
15390
15391
15392
15393
15394
15395
15396
15397
15398
15399
15400
15401
15402
15403
15404
15405
15406
15407
15408
15409
15410
15411
15412
15413
15414
15415
15416
15417
15418
15419
15420
15421
15422
15423
15424
15425
15426
15427
15428
15429
15430
15431
15432
15433
15434
15435
15436
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
15456
15457
15458
15459
15460
15461
15462
15463 extern "C" void G__cpp_setup_inheritanceG__Proof() {
15464
15465
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
15910
15911 extern "C" void G__cpp_setup_typetableG__Proof() {
15912
15913
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
16018
16019
16020
16021
16022
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
16918
16919 static void G__setup_memfuncTCondorSlave(void) {
16920
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
18392 G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofLN_TProofDebug));
18393
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
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
19279
19280 extern "C" void G__cpp_setup_memfuncG__Proof() {
19281 }
19282
19283
19284
19285
19286 static void G__cpp_setup_global0() {
19287
19288
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
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
19358
19359
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
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
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