ROOT_528-00b_version: proof/proofplayer/src/G_

00001 //
00002 // File generated by core/utils/src/rootcint_tmp at Wed Apr 20 13:47:35 2011
00003 
00004 // Do NOT change. Changes will be lost next time file is generated
00005 //
00006 
00007 #define R__DICTIONARY_FILENAME proofdIproofplayerdIsrcdIG__ProofPlayer
00008 #include "RConfig.h" //rootcint 4834
00009 #if !defined(R__ACCESS_IN_SYMBOL)
00010 //Break the privacy of classes -- Disabled for the moment
00011 #define private public
00012 #define protected public
00013 #endif
00014 
00015 // Since CINT ignores the std namespace, we need to do so in this file.
00016 namespace std {} using namespace std;
00017 #include "G__ProofPlayer.h"
00018 
00019 #include "TCollectionProxyInfo.h"
00020 #include "TClass.h"
00021 #include "TBuffer.h"
00022 #include "TMemberInspector.h"
00023 #include "TError.h"
00024 
00025 #ifndef G__ROOT
00026 #define G__ROOT
00027 #endif
00028 
00029 #include "RtypesImp.h"
00030 #include "TIsAProxy.h"
00031 
00032 // START OF SHADOWS
00033 
00034 namespace ROOT {
00035    namespace Shadow {
00036    } // of namespace Shadow
00037 } // of namespace ROOT
00038 // END OF SHADOWS
00039 
00040 namespace ROOT {
00041    void TDrawFeedback_ShowMembers(void *obj, TMemberInspector &R__insp);
00042    static void *new_TDrawFeedback(void *p = 0);
00043    static void *newArray_TDrawFeedback(Long_t size, void *p);
00044    static void delete_TDrawFeedback(void *p);
00045    static void deleteArray_TDrawFeedback(void *p);
00046    static void destruct_TDrawFeedback(void *p);
00047 
00048    // Function generating the singleton type initializer
00049    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TDrawFeedback*)
00050    {
00051       ::TDrawFeedback *ptr = 0;
00052       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TDrawFeedback >(0);
00053       static ::ROOT::TGenericClassInfo 
00054          instance("TDrawFeedback", ::TDrawFeedback::Class_Version(), "include/TDrawFeedback.h", 36,
00055                   typeid(::TDrawFeedback), DefineBehavior(ptr, ptr),
00056                   &::TDrawFeedback::Dictionary, isa_proxy, 4,
00057                   sizeof(::TDrawFeedback) );
00058       instance.SetNew(&new_TDrawFeedback);
00059       instance.SetNewArray(&newArray_TDrawFeedback);
00060       instance.SetDelete(&delete_TDrawFeedback);
00061       instance.SetDeleteArray(&deleteArray_TDrawFeedback);
00062       instance.SetDestructor(&destruct_TDrawFeedback);
00063       return &instance;
00064    }
00065    TGenericClassInfo *GenerateInitInstance(const ::TDrawFeedback*)
00066    {
00067       return GenerateInitInstanceLocal((::TDrawFeedback*)0);
00068    }
00069    // Static variable to force the class initialization
00070    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TDrawFeedback*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00071 } // end of namespace ROOT
00072 
00073 namespace ROOT {
00074    void TEventIter_ShowMembers(void *obj, TMemberInspector &R__insp);
00075    static void delete_TEventIter(void *p);
00076    static void deleteArray_TEventIter(void *p);
00077    static void destruct_TEventIter(void *p);
00078 
00079    // Function generating the singleton type initializer
00080    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEventIter*)
00081    {
00082       ::TEventIter *ptr = 0;
00083       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEventIter >(0);
00084       static ::ROOT::TGenericClassInfo 
00085          instance("TEventIter", ::TEventIter::Class_Version(), "include/TEventIter.h", 46,
00086                   typeid(::TEventIter), DefineBehavior(ptr, ptr),
00087                   &::TEventIter::Dictionary, isa_proxy, 4,
00088                   sizeof(::TEventIter) );
00089       instance.SetDelete(&delete_TEventIter);
00090       instance.SetDeleteArray(&deleteArray_TEventIter);
00091       instance.SetDestructor(&destruct_TEventIter);
00092       return &instance;
00093    }
00094    TGenericClassInfo *GenerateInitInstance(const ::TEventIter*)
00095    {
00096       return GenerateInitInstanceLocal((::TEventIter*)0);
00097    }
00098    // Static variable to force the class initialization
00099    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEventIter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00100 } // end of namespace ROOT
00101 
00102 namespace ROOT {
00103    void TEventIterUnit_ShowMembers(void *obj, TMemberInspector &R__insp);
00104    static void *new_TEventIterUnit(void *p = 0);
00105    static void *newArray_TEventIterUnit(Long_t size, void *p);
00106    static void delete_TEventIterUnit(void *p);
00107    static void deleteArray_TEventIterUnit(void *p);
00108    static void destruct_TEventIterUnit(void *p);
00109 
00110    // Function generating the singleton type initializer
00111    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEventIterUnit*)
00112    {
00113       ::TEventIterUnit *ptr = 0;
00114       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEventIterUnit >(0);
00115       static ::ROOT::TGenericClassInfo 
00116          instance("TEventIterUnit", ::TEventIterUnit::Class_Version(), "include/TEventIter.h", 92,
00117                   typeid(::TEventIterUnit), DefineBehavior(ptr, ptr),
00118                   &::TEventIterUnit::Dictionary, isa_proxy, 4,
00119                   sizeof(::TEventIterUnit) );
00120       instance.SetNew(&new_TEventIterUnit);
00121       instance.SetNewArray(&newArray_TEventIterUnit);
00122       instance.SetDelete(&delete_TEventIterUnit);
00123       instance.SetDeleteArray(&deleteArray_TEventIterUnit);
00124       instance.SetDestructor(&destruct_TEventIterUnit);
00125       return &instance;
00126    }
00127    TGenericClassInfo *GenerateInitInstance(const ::TEventIterUnit*)
00128    {
00129       return GenerateInitInstanceLocal((::TEventIterUnit*)0);
00130    }
00131    // Static variable to force the class initialization
00132    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEventIterUnit*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00133 } // end of namespace ROOT
00134 
00135 namespace ROOT {
00136    void TEventIterObj_ShowMembers(void *obj, TMemberInspector &R__insp);
00137    static void *new_TEventIterObj(void *p = 0);
00138    static void *newArray_TEventIterObj(Long_t size, void *p);
00139    static void delete_TEventIterObj(void *p);
00140    static void deleteArray_TEventIterObj(void *p);
00141    static void destruct_TEventIterObj(void *p);
00142 
00143    // Function generating the singleton type initializer
00144    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEventIterObj*)
00145    {
00146       ::TEventIterObj *ptr = 0;
00147       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEventIterObj >(0);
00148       static ::ROOT::TGenericClassInfo 
00149          instance("TEventIterObj", ::TEventIterObj::Class_Version(), "include/TEventIter.h", 114,
00150                   typeid(::TEventIterObj), DefineBehavior(ptr, ptr),
00151                   &::TEventIterObj::Dictionary, isa_proxy, 4,
00152                   sizeof(::TEventIterObj) );
00153       instance.SetNew(&new_TEventIterObj);
00154       instance.SetNewArray(&newArray_TEventIterObj);
00155       instance.SetDelete(&delete_TEventIterObj);
00156       instance.SetDeleteArray(&deleteArray_TEventIterObj);
00157       instance.SetDestructor(&destruct_TEventIterObj);
00158       return &instance;
00159    }
00160    TGenericClassInfo *GenerateInitInstance(const ::TEventIterObj*)
00161    {
00162       return GenerateInitInstanceLocal((::TEventIterObj*)0);
00163    }
00164    // Static variable to force the class initialization
00165    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEventIterObj*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00166 } // end of namespace ROOT
00167 
00168 namespace ROOT {
00169    void TEventIterTree_ShowMembers(void *obj, TMemberInspector &R__insp);
00170    static void *new_TEventIterTree(void *p = 0);
00171    static void *newArray_TEventIterTree(Long_t size, void *p);
00172    static void delete_TEventIterTree(void *p);
00173    static void deleteArray_TEventIterTree(void *p);
00174    static void destruct_TEventIterTree(void *p);
00175 
00176    // Function generating the singleton type initializer
00177    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TEventIterTree*)
00178    {
00179       ::TEventIterTree *ptr = 0;
00180       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TEventIterTree >(0);
00181       static ::ROOT::TGenericClassInfo 
00182          instance("TEventIterTree", ::TEventIterTree::Class_Version(), "include/TEventIter.h", 136,
00183                   typeid(::TEventIterTree), DefineBehavior(ptr, ptr),
00184                   &::TEventIterTree::Dictionary, isa_proxy, 4,
00185                   sizeof(::TEventIterTree) );
00186       instance.SetNew(&new_TEventIterTree);
00187       instance.SetNewArray(&newArray_TEventIterTree);
00188       instance.SetDelete(&delete_TEventIterTree);
00189       instance.SetDeleteArray(&deleteArray_TEventIterTree);
00190       instance.SetDestructor(&destruct_TEventIterTree);
00191       return &instance;
00192    }
00193    TGenericClassInfo *GenerateInitInstance(const ::TEventIterTree*)
00194    {
00195       return GenerateInitInstanceLocal((::TEventIterTree*)0);
00196    }
00197    // Static variable to force the class initialization
00198    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TEventIterTree*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00199 } // end of namespace ROOT
00200 
00201 namespace ROOT {
00202    void TFileMerger_ShowMembers(void *obj, TMemberInspector &R__insp);
00203    static void *new_TFileMerger(void *p = 0);
00204    static void *newArray_TFileMerger(Long_t size, void *p);
00205    static void delete_TFileMerger(void *p);
00206    static void deleteArray_TFileMerger(void *p);
00207    static void destruct_TFileMerger(void *p);
00208 
00209    // Function generating the singleton type initializer
00210    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TFileMerger*)
00211    {
00212       ::TFileMerger *ptr = 0;
00213       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TFileMerger >(0);
00214       static ::ROOT::TGenericClassInfo 
00215          instance("TFileMerger", ::TFileMerger::Class_Version(), "include/TFileMerger.h", 45,
00216                   typeid(::TFileMerger), DefineBehavior(ptr, ptr),
00217                   &::TFileMerger::Dictionary, isa_proxy, 4,
00218                   sizeof(::TFileMerger) );
00219       instance.SetNew(&new_TFileMerger);
00220       instance.SetNewArray(&newArray_TFileMerger);
00221       instance.SetDelete(&delete_TFileMerger);
00222       instance.SetDeleteArray(&deleteArray_TFileMerger);
00223       instance.SetDestructor(&destruct_TFileMerger);
00224       return &instance;
00225    }
00226    TGenericClassInfo *GenerateInitInstance(const ::TFileMerger*)
00227    {
00228       return GenerateInitInstanceLocal((::TFileMerger*)0);
00229    }
00230    // Static variable to force the class initialization
00231    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TFileMerger*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00232 } // end of namespace ROOT
00233 
00234 namespace ROOT {
00235    void TOutputListSelectorDataMap_ShowMembers(void *obj, TMemberInspector &R__insp);
00236    static void *new_TOutputListSelectorDataMap(void *p = 0);
00237    static void *newArray_TOutputListSelectorDataMap(Long_t size, void *p);
00238    static void delete_TOutputListSelectorDataMap(void *p);
00239    static void deleteArray_TOutputListSelectorDataMap(void *p);
00240    static void destruct_TOutputListSelectorDataMap(void *p);
00241 
00242    // Function generating the singleton type initializer
00243    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TOutputListSelectorDataMap*)
00244    {
00245       ::TOutputListSelectorDataMap *ptr = 0;
00246       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TOutputListSelectorDataMap >(0);
00247       static ::ROOT::TGenericClassInfo 
00248          instance("TOutputListSelectorDataMap", ::TOutputListSelectorDataMap::Class_Version(), "include/TOutputListSelectorDataMap.h", 32,
00249                   typeid(::TOutputListSelectorDataMap), DefineBehavior(ptr, ptr),
00250                   &::TOutputListSelectorDataMap::Dictionary, isa_proxy, 4,
00251                   sizeof(::TOutputListSelectorDataMap) );
00252       instance.SetNew(&new_TOutputListSelectorDataMap);
00253       instance.SetNewArray(&newArray_TOutputListSelectorDataMap);
00254       instance.SetDelete(&delete_TOutputListSelectorDataMap);
00255       instance.SetDeleteArray(&deleteArray_TOutputListSelectorDataMap);
00256       instance.SetDestructor(&destruct_TOutputListSelectorDataMap);
00257       return &instance;
00258    }
00259    TGenericClassInfo *GenerateInitInstance(const ::TOutputListSelectorDataMap*)
00260    {
00261       return GenerateInitInstanceLocal((::TOutputListSelectorDataMap*)0);
00262    }
00263    // Static variable to force the class initialization
00264    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TOutputListSelectorDataMap*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00265 } // end of namespace ROOT
00266 
00267 namespace ROOT {
00268    void TVirtualPacketizer_ShowMembers(void *obj, TMemberInspector &R__insp);
00269    static void delete_TVirtualPacketizer(void *p);
00270    static void deleteArray_TVirtualPacketizer(void *p);
00271    static void destruct_TVirtualPacketizer(void *p);
00272 
00273    // Function generating the singleton type initializer
00274    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TVirtualPacketizer*)
00275    {
00276       ::TVirtualPacketizer *ptr = 0;
00277       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TVirtualPacketizer >(0);
00278       static ::ROOT::TGenericClassInfo 
00279          instance("TVirtualPacketizer", ::TVirtualPacketizer::Class_Version(), "include/TVirtualPacketizer.h", 61,
00280                   typeid(::TVirtualPacketizer), DefineBehavior(ptr, ptr),
00281                   &::TVirtualPacketizer::Dictionary, isa_proxy, 4,
00282                   sizeof(::TVirtualPacketizer) );
00283       instance.SetDelete(&delete_TVirtualPacketizer);
00284       instance.SetDeleteArray(&deleteArray_TVirtualPacketizer);
00285       instance.SetDestructor(&destruct_TVirtualPacketizer);
00286       return &instance;
00287    }
00288    TGenericClassInfo *GenerateInitInstance(const ::TVirtualPacketizer*)
00289    {
00290       return GenerateInitInstanceLocal((::TVirtualPacketizer*)0);
00291    }
00292    // Static variable to force the class initialization
00293    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TVirtualPacketizer*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00294 } // end of namespace ROOT
00295 
00296 namespace ROOT {
00297    void TPacketizerAdaptive_ShowMembers(void *obj, TMemberInspector &R__insp);
00298    static void delete_TPacketizerAdaptive(void *p);
00299    static void deleteArray_TPacketizerAdaptive(void *p);
00300    static void destruct_TPacketizerAdaptive(void *p);
00301 
00302    // Function generating the singleton type initializer
00303    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPacketizerAdaptive*)
00304    {
00305       ::TPacketizerAdaptive *ptr = 0;
00306       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPacketizerAdaptive >(0);
00307       static ::ROOT::TGenericClassInfo 
00308          instance("TPacketizerAdaptive", ::TPacketizerAdaptive::Class_Version(), "include/TPacketizerAdaptive.h", 50,
00309                   typeid(::TPacketizerAdaptive), DefineBehavior(ptr, ptr),
00310                   &::TPacketizerAdaptive::Dictionary, isa_proxy, 4,
00311                   sizeof(::TPacketizerAdaptive) );
00312       instance.SetDelete(&delete_TPacketizerAdaptive);
00313       instance.SetDeleteArray(&deleteArray_TPacketizerAdaptive);
00314       instance.SetDestructor(&destruct_TPacketizerAdaptive);
00315       return &instance;
00316    }
00317    TGenericClassInfo *GenerateInitInstance(const ::TPacketizerAdaptive*)
00318    {
00319       return GenerateInitInstanceLocal((::TPacketizerAdaptive*)0);
00320    }
00321    // Static variable to force the class initialization
00322    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPacketizerAdaptive*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00323 } // end of namespace ROOT
00324 
00325 namespace ROOT {
00326    void TPacketizerFile_ShowMembers(void *obj, TMemberInspector &R__insp);
00327    static void delete_TPacketizerFile(void *p);
00328    static void deleteArray_TPacketizerFile(void *p);
00329    static void destruct_TPacketizerFile(void *p);
00330 
00331    // Function generating the singleton type initializer
00332    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPacketizerFile*)
00333    {
00334       ::TPacketizerFile *ptr = 0;
00335       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPacketizerFile >(0);
00336       static ::ROOT::TGenericClassInfo 
00337          instance("TPacketizerFile", ::TPacketizerFile::Class_Version(), "include/TPacketizerFile.h", 37,
00338                   typeid(::TPacketizerFile), DefineBehavior(ptr, ptr),
00339                   &::TPacketizerFile::Dictionary, isa_proxy, 4,
00340                   sizeof(::TPacketizerFile) );
00341       instance.SetDelete(&delete_TPacketizerFile);
00342       instance.SetDeleteArray(&deleteArray_TPacketizerFile);
00343       instance.SetDestructor(&destruct_TPacketizerFile);
00344       return &instance;
00345    }
00346    TGenericClassInfo *GenerateInitInstance(const ::TPacketizerFile*)
00347    {
00348       return GenerateInitInstanceLocal((::TPacketizerFile*)0);
00349    }
00350    // Static variable to force the class initialization
00351    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPacketizerFile*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00352 } // end of namespace ROOT
00353 
00354 namespace ROOT {
00355    void TPacketizer_ShowMembers(void *obj, TMemberInspector &R__insp);
00356    static void delete_TPacketizer(void *p);
00357    static void deleteArray_TPacketizer(void *p);
00358    static void destruct_TPacketizer(void *p);
00359 
00360    // Function generating the singleton type initializer
00361    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPacketizer*)
00362    {
00363       ::TPacketizer *ptr = 0;
00364       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPacketizer >(0);
00365       static ::ROOT::TGenericClassInfo 
00366          instance("TPacketizer", ::TPacketizer::Class_Version(), "include/TPacketizer.h", 41,
00367                   typeid(::TPacketizer), DefineBehavior(ptr, ptr),
00368                   &::TPacketizer::Dictionary, isa_proxy, 4,
00369                   sizeof(::TPacketizer) );
00370       instance.SetDelete(&delete_TPacketizer);
00371       instance.SetDeleteArray(&deleteArray_TPacketizer);
00372       instance.SetDestructor(&destruct_TPacketizer);
00373       return &instance;
00374    }
00375    TGenericClassInfo *GenerateInitInstance(const ::TPacketizer*)
00376    {
00377       return GenerateInitInstanceLocal((::TPacketizer*)0);
00378    }
00379    // Static variable to force the class initialization
00380    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPacketizer*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00381 } // end of namespace ROOT
00382 
00383 namespace ROOT {
00384    void TPacketizerMulti_ShowMembers(void *obj, TMemberInspector &R__insp);
00385    static void delete_TPacketizerMulti(void *p);
00386    static void deleteArray_TPacketizerMulti(void *p);
00387    static void destruct_TPacketizerMulti(void *p);
00388 
00389    // Function generating the singleton type initializer
00390    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPacketizerMulti*)
00391    {
00392       ::TPacketizerMulti *ptr = 0;
00393       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPacketizerMulti >(0);
00394       static ::ROOT::TGenericClassInfo 
00395          instance("TPacketizerMulti", ::TPacketizerMulti::Class_Version(), "include/TPacketizerMulti.h", 41,
00396                   typeid(::TPacketizerMulti), DefineBehavior(ptr, ptr),
00397                   &::TPacketizerMulti::Dictionary, isa_proxy, 4,
00398                   sizeof(::TPacketizerMulti) );
00399       instance.SetDelete(&delete_TPacketizerMulti);
00400       instance.SetDeleteArray(&deleteArray_TPacketizerMulti);
00401       instance.SetDestructor(&destruct_TPacketizerMulti);
00402       return &instance;
00403    }
00404    TGenericClassInfo *GenerateInitInstance(const ::TPacketizerMulti*)
00405    {
00406       return GenerateInitInstanceLocal((::TPacketizerMulti*)0);
00407    }
00408    // Static variable to force the class initialization
00409    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPacketizerMulti*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00410 } // end of namespace ROOT
00411 
00412 namespace ROOT {
00413    void TPacketizerUnit_ShowMembers(void *obj, TMemberInspector &R__insp);
00414    static void delete_TPacketizerUnit(void *p);
00415    static void deleteArray_TPacketizerUnit(void *p);
00416    static void destruct_TPacketizerUnit(void *p);
00417 
00418    // Function generating the singleton type initializer
00419    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPacketizerUnit*)
00420    {
00421       ::TPacketizerUnit *ptr = 0;
00422       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPacketizerUnit >(0);
00423       static ::ROOT::TGenericClassInfo 
00424          instance("TPacketizerUnit", ::TPacketizerUnit::Class_Version(), "include/TPacketizerUnit.h", 42,
00425                   typeid(::TPacketizerUnit), DefineBehavior(ptr, ptr),
00426                   &::TPacketizerUnit::Dictionary, isa_proxy, 4,
00427                   sizeof(::TPacketizerUnit) );
00428       instance.SetDelete(&delete_TPacketizerUnit);
00429       instance.SetDeleteArray(&deleteArray_TPacketizerUnit);
00430       instance.SetDestructor(&destruct_TPacketizerUnit);
00431       return &instance;
00432    }
00433    TGenericClassInfo *GenerateInitInstance(const ::TPacketizerUnit*)
00434    {
00435       return GenerateInitInstanceLocal((::TPacketizerUnit*)0);
00436    }
00437    // Static variable to force the class initialization
00438    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPacketizerUnit*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00439 } // end of namespace ROOT
00440 
00441 namespace ROOT {
00442    void TPerfEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
00443    static void *new_TPerfEvent(void *p = 0);
00444    static void *newArray_TPerfEvent(Long_t size, void *p);
00445    static void delete_TPerfEvent(void *p);
00446    static void deleteArray_TPerfEvent(void *p);
00447    static void destruct_TPerfEvent(void *p);
00448 
00449    // Function generating the singleton type initializer
00450    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPerfEvent*)
00451    {
00452       ::TPerfEvent *ptr = 0;
00453       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPerfEvent >(0);
00454       static ::ROOT::TGenericClassInfo 
00455          instance("TPerfEvent", ::TPerfEvent::Class_Version(), "include/TPerfStats.h", 46,
00456                   typeid(::TPerfEvent), DefineBehavior(ptr, ptr),
00457                   &::TPerfEvent::Dictionary, isa_proxy, 4,
00458                   sizeof(::TPerfEvent) );
00459       instance.SetNew(&new_TPerfEvent);
00460       instance.SetNewArray(&newArray_TPerfEvent);
00461       instance.SetDelete(&delete_TPerfEvent);
00462       instance.SetDeleteArray(&deleteArray_TPerfEvent);
00463       instance.SetDestructor(&destruct_TPerfEvent);
00464       return &instance;
00465    }
00466    TGenericClassInfo *GenerateInitInstance(const ::TPerfEvent*)
00467    {
00468       return GenerateInitInstanceLocal((::TPerfEvent*)0);
00469    }
00470    // Static variable to force the class initialization
00471    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPerfEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00472 } // end of namespace ROOT
00473 
00474 namespace ROOT {
00475    void TPerfStats_ShowMembers(void *obj, TMemberInspector &R__insp);
00476    static void delete_TPerfStats(void *p);
00477    static void deleteArray_TPerfStats(void *p);
00478    static void destruct_TPerfStats(void *p);
00479    static void streamer_TPerfStats(TBuffer &buf, void *obj);
00480 
00481    // Function generating the singleton type initializer
00482    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TPerfStats*)
00483    {
00484       ::TPerfStats *ptr = 0;
00485       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TPerfStats >(0);
00486       static ::ROOT::TGenericClassInfo 
00487          instance("TPerfStats", ::TPerfStats::Class_Version(), "include/TPerfStats.h", 77,
00488                   typeid(::TPerfStats), DefineBehavior(ptr, ptr),
00489                   &::TPerfStats::Dictionary, isa_proxy, 0,
00490                   sizeof(::TPerfStats) );
00491       instance.SetDelete(&delete_TPerfStats);
00492       instance.SetDeleteArray(&deleteArray_TPerfStats);
00493       instance.SetDestructor(&destruct_TPerfStats);
00494       instance.SetStreamerFunc(&streamer_TPerfStats);
00495       return &instance;
00496    }
00497    TGenericClassInfo *GenerateInitInstance(const ::TPerfStats*)
00498    {
00499       return GenerateInitInstanceLocal((::TPerfStats*)0);
00500    }
00501    // Static variable to force the class initialization
00502    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TPerfStats*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00503 } // end of namespace ROOT
00504 
00505 namespace ROOT {
00506    void TProofLimitsFinder_ShowMembers(void *obj, TMemberInspector &R__insp);
00507    static void *new_TProofLimitsFinder(void *p = 0);
00508    static void *newArray_TProofLimitsFinder(Long_t size, void *p);
00509    static void delete_TProofLimitsFinder(void *p);
00510    static void deleteArray_TProofLimitsFinder(void *p);
00511    static void destruct_TProofLimitsFinder(void *p);
00512    static void streamer_TProofLimitsFinder(TBuffer &buf, void *obj);
00513 
00514    // Function generating the singleton type initializer
00515    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofLimitsFinder*)
00516    {
00517       ::TProofLimitsFinder *ptr = 0;
00518       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofLimitsFinder >(0);
00519       static ::ROOT::TGenericClassInfo 
00520          instance("TProofLimitsFinder", ::TProofLimitsFinder::Class_Version(), "include/TProofLimitsFinder.h", 30,
00521                   typeid(::TProofLimitsFinder), DefineBehavior(ptr, ptr),
00522                   &::TProofLimitsFinder::Dictionary, isa_proxy, 0,
00523                   sizeof(::TProofLimitsFinder) );
00524       instance.SetNew(&new_TProofLimitsFinder);
00525       instance.SetNewArray(&newArray_TProofLimitsFinder);
00526       instance.SetDelete(&delete_TProofLimitsFinder);
00527       instance.SetDeleteArray(&deleteArray_TProofLimitsFinder);
00528       instance.SetDestructor(&destruct_TProofLimitsFinder);
00529       instance.SetStreamerFunc(&streamer_TProofLimitsFinder);
00530       return &instance;
00531    }
00532    TGenericClassInfo *GenerateInitInstance(const ::TProofLimitsFinder*)
00533    {
00534       return GenerateInitInstanceLocal((::TProofLimitsFinder*)0);
00535    }
00536    // Static variable to force the class initialization
00537    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofLimitsFinder*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00538 } // end of namespace ROOT
00539 
00540 namespace ROOT {
00541    void TProofOutputFile_ShowMembers(void *obj, TMemberInspector &R__insp);
00542    static void *new_TProofOutputFile(void *p = 0);
00543    static void *newArray_TProofOutputFile(Long_t size, void *p);
00544    static void delete_TProofOutputFile(void *p);
00545    static void deleteArray_TProofOutputFile(void *p);
00546    static void destruct_TProofOutputFile(void *p);
00547 
00548    // Function generating the singleton type initializer
00549    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofOutputFile*)
00550    {
00551       ::TProofOutputFile *ptr = 0;
00552       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofOutputFile >(0);
00553       static ::ROOT::TGenericClassInfo 
00554          instance("TProofOutputFile", ::TProofOutputFile::Class_Version(), "include/TProofOutputFile.h", 36,
00555                   typeid(::TProofOutputFile), DefineBehavior(ptr, ptr),
00556                   &::TProofOutputFile::Dictionary, isa_proxy, 4,
00557                   sizeof(::TProofOutputFile) );
00558       instance.SetNew(&new_TProofOutputFile);
00559       instance.SetNewArray(&newArray_TProofOutputFile);
00560       instance.SetDelete(&delete_TProofOutputFile);
00561       instance.SetDeleteArray(&deleteArray_TProofOutputFile);
00562       instance.SetDestructor(&destruct_TProofOutputFile);
00563       return &instance;
00564    }
00565    TGenericClassInfo *GenerateInitInstance(const ::TProofOutputFile*)
00566    {
00567       return GenerateInitInstanceLocal((::TProofOutputFile*)0);
00568    }
00569    // Static variable to force the class initialization
00570    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofOutputFile*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00571 } // end of namespace ROOT
00572 
00573 namespace ROOT {
00574    void TProofPlayer_ShowMembers(void *obj, TMemberInspector &R__insp);
00575    static void *new_TProofPlayer(void *p = 0);
00576    static void *newArray_TProofPlayer(Long_t size, void *p);
00577    static void delete_TProofPlayer(void *p);
00578    static void deleteArray_TProofPlayer(void *p);
00579    static void destruct_TProofPlayer(void *p);
00580 
00581    // Function generating the singleton type initializer
00582    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofPlayer*)
00583    {
00584       ::TProofPlayer *ptr = 0;
00585       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofPlayer >(0);
00586       static ::ROOT::TGenericClassInfo 
00587          instance("TProofPlayer", ::TProofPlayer::Class_Version(), "include/TProofPlayer.h", 75,
00588                   typeid(::TProofPlayer), DefineBehavior(ptr, ptr),
00589                   &::TProofPlayer::Dictionary, isa_proxy, 4,
00590                   sizeof(::TProofPlayer) );
00591       instance.SetNew(&new_TProofPlayer);
00592       instance.SetNewArray(&newArray_TProofPlayer);
00593       instance.SetDelete(&delete_TProofPlayer);
00594       instance.SetDeleteArray(&deleteArray_TProofPlayer);
00595       instance.SetDestructor(&destruct_TProofPlayer);
00596       return &instance;
00597    }
00598    TGenericClassInfo *GenerateInitInstance(const ::TProofPlayer*)
00599    {
00600       return GenerateInitInstanceLocal((::TProofPlayer*)0);
00601    }
00602    // Static variable to force the class initialization
00603    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofPlayer*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00604 } // end of namespace ROOT
00605 
00606 namespace ROOT {
00607    void TProofPlayerLite_ShowMembers(void *obj, TMemberInspector &R__insp);
00608    static void *new_TProofPlayerLite(void *p = 0);
00609    static void *newArray_TProofPlayerLite(Long_t size, void *p);
00610    static void delete_TProofPlayerLite(void *p);
00611    static void deleteArray_TProofPlayerLite(void *p);
00612    static void destruct_TProofPlayerLite(void *p);
00613 
00614    // Function generating the singleton type initializer
00615    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofPlayerLite*)
00616    {
00617       ::TProofPlayerLite *ptr = 0;
00618       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofPlayerLite >(0);
00619       static ::ROOT::TGenericClassInfo 
00620          instance("TProofPlayerLite", ::TProofPlayerLite::Class_Version(), "include/TProofPlayerLite.h", 30,
00621                   typeid(::TProofPlayerLite), DefineBehavior(ptr, ptr),
00622                   &::TProofPlayerLite::Dictionary, isa_proxy, 4,
00623                   sizeof(::TProofPlayerLite) );
00624       instance.SetNew(&new_TProofPlayerLite);
00625       instance.SetNewArray(&newArray_TProofPlayerLite);
00626       instance.SetDelete(&delete_TProofPlayerLite);
00627       instance.SetDeleteArray(&deleteArray_TProofPlayerLite);
00628       instance.SetDestructor(&destruct_TProofPlayerLite);
00629       return &instance;
00630    }
00631    TGenericClassInfo *GenerateInitInstance(const ::TProofPlayerLite*)
00632    {
00633       return GenerateInitInstanceLocal((::TProofPlayerLite*)0);
00634    }
00635    // Static variable to force the class initialization
00636    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofPlayerLite*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00637 } // end of namespace ROOT
00638 
00639 namespace ROOT {
00640    void TProofPlayerRemote_ShowMembers(void *obj, TMemberInspector &R__insp);
00641    static void *new_TProofPlayerRemote(void *p = 0);
00642    static void *newArray_TProofPlayerRemote(Long_t size, void *p);
00643    static void delete_TProofPlayerRemote(void *p);
00644    static void deleteArray_TProofPlayerRemote(void *p);
00645    static void destruct_TProofPlayerRemote(void *p);
00646 
00647    // Function generating the singleton type initializer
00648    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofPlayerRemote*)
00649    {
00650       ::TProofPlayerRemote *ptr = 0;
00651       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofPlayerRemote >(0);
00652       static ::ROOT::TGenericClassInfo 
00653          instance("TProofPlayerRemote", ::TProofPlayerRemote::Class_Version(), "include/TProofPlayer.h", 256,
00654                   typeid(::TProofPlayerRemote), DefineBehavior(ptr, ptr),
00655                   &::TProofPlayerRemote::Dictionary, isa_proxy, 4,
00656                   sizeof(::TProofPlayerRemote) );
00657       instance.SetNew(&new_TProofPlayerRemote);
00658       instance.SetNewArray(&newArray_TProofPlayerRemote);
00659       instance.SetDelete(&delete_TProofPlayerRemote);
00660       instance.SetDeleteArray(&deleteArray_TProofPlayerRemote);
00661       instance.SetDestructor(&destruct_TProofPlayerRemote);
00662       return &instance;
00663    }
00664    TGenericClassInfo *GenerateInitInstance(const ::TProofPlayerRemote*)
00665    {
00666       return GenerateInitInstanceLocal((::TProofPlayerRemote*)0);
00667    }
00668    // Static variable to force the class initialization
00669    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofPlayerRemote*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00670 } // end of namespace ROOT
00671 
00672 namespace ROOT {
00673    void TStatus_ShowMembers(void *obj, TMemberInspector &R__insp);
00674    static void *new_TStatus(void *p = 0);
00675    static void *newArray_TStatus(Long_t size, void *p);
00676    static void delete_TStatus(void *p);
00677    static void deleteArray_TStatus(void *p);
00678    static void destruct_TStatus(void *p);
00679 
00680    // Function generating the singleton type initializer
00681    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TStatus*)
00682    {
00683       ::TStatus *ptr = 0;
00684       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TStatus >(0);
00685       static ::ROOT::TGenericClassInfo 
00686          instance("TStatus", ::TStatus::Class_Version(), "include/TStatus.h", 39,
00687                   typeid(::TStatus), DefineBehavior(ptr, ptr),
00688                   &::TStatus::Dictionary, isa_proxy, 4,
00689                   sizeof(::TStatus) );
00690       instance.SetNew(&new_TStatus);
00691       instance.SetNewArray(&newArray_TStatus);
00692       instance.SetDelete(&delete_TStatus);
00693       instance.SetDeleteArray(&deleteArray_TStatus);
00694       instance.SetDestructor(&destruct_TStatus);
00695       return &instance;
00696    }
00697    TGenericClassInfo *GenerateInitInstance(const ::TStatus*)
00698    {
00699       return GenerateInitInstanceLocal((::TStatus*)0);
00700    }
00701    // Static variable to force the class initialization
00702    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TStatus*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00703 } // end of namespace ROOT
00704 
00705 namespace ROOT {
00706    void TProofPlayerLocal_ShowMembers(void *obj, TMemberInspector &R__insp);
00707    static void *new_TProofPlayerLocal(void *p = 0);
00708    static void *newArray_TProofPlayerLocal(Long_t size, void *p);
00709    static void delete_TProofPlayerLocal(void *p);
00710    static void deleteArray_TProofPlayerLocal(void *p);
00711    static void destruct_TProofPlayerLocal(void *p);
00712 
00713    // Function generating the singleton type initializer
00714    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofPlayerLocal*)
00715    {
00716       ::TProofPlayerLocal *ptr = 0;
00717       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofPlayerLocal >(0);
00718       static ::ROOT::TGenericClassInfo 
00719          instance("TProofPlayerLocal", ::TProofPlayerLocal::Class_Version(), "include/TProofPlayer.h", 220,
00720                   typeid(::TProofPlayerLocal), DefineBehavior(ptr, ptr),
00721                   &::TProofPlayerLocal::Dictionary, isa_proxy, 4,
00722                   sizeof(::TProofPlayerLocal) );
00723       instance.SetNew(&new_TProofPlayerLocal);
00724       instance.SetNewArray(&newArray_TProofPlayerLocal);
00725       instance.SetDelete(&delete_TProofPlayerLocal);
00726       instance.SetDeleteArray(&deleteArray_TProofPlayerLocal);
00727       instance.SetDestructor(&destruct_TProofPlayerLocal);
00728       return &instance;
00729    }
00730    TGenericClassInfo *GenerateInitInstance(const ::TProofPlayerLocal*)
00731    {
00732       return GenerateInitInstanceLocal((::TProofPlayerLocal*)0);
00733    }
00734    // Static variable to force the class initialization
00735    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofPlayerLocal*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00736 } // end of namespace ROOT
00737 
00738 namespace ROOT {
00739    void TProofPlayerSlave_ShowMembers(void *obj, TMemberInspector &R__insp);
00740    static void *new_TProofPlayerSlave(void *p = 0);
00741    static void *newArray_TProofPlayerSlave(Long_t size, void *p);
00742    static void delete_TProofPlayerSlave(void *p);
00743    static void deleteArray_TProofPlayerSlave(void *p);
00744    static void destruct_TProofPlayerSlave(void *p);
00745 
00746    // Function generating the singleton type initializer
00747    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofPlayerSlave*)
00748    {
00749       ::TProofPlayerSlave *ptr = 0;
00750       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofPlayerSlave >(0);
00751       static ::ROOT::TGenericClassInfo 
00752          instance("TProofPlayerSlave", ::TProofPlayerSlave::Class_Version(), "include/TProofPlayer.h", 333,
00753                   typeid(::TProofPlayerSlave), DefineBehavior(ptr, ptr),
00754                   &::TProofPlayerSlave::Dictionary, isa_proxy, 4,
00755                   sizeof(::TProofPlayerSlave) );
00756       instance.SetNew(&new_TProofPlayerSlave);
00757       instance.SetNewArray(&newArray_TProofPlayerSlave);
00758       instance.SetDelete(&delete_TProofPlayerSlave);
00759       instance.SetDeleteArray(&deleteArray_TProofPlayerSlave);
00760       instance.SetDestructor(&destruct_TProofPlayerSlave);
00761       return &instance;
00762    }
00763    TGenericClassInfo *GenerateInitInstance(const ::TProofPlayerSlave*)
00764    {
00765       return GenerateInitInstanceLocal((::TProofPlayerSlave*)0);
00766    }
00767    // Static variable to force the class initialization
00768    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofPlayerSlave*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00769 } // end of namespace ROOT
00770 
00771 namespace ROOT {
00772    void TProofPlayerSuperMaster_ShowMembers(void *obj, TMemberInspector &R__insp);
00773    static void *new_TProofPlayerSuperMaster(void *p = 0);
00774    static void *newArray_TProofPlayerSuperMaster(Long_t size, void *p);
00775    static void delete_TProofPlayerSuperMaster(void *p);
00776    static void deleteArray_TProofPlayerSuperMaster(void *p);
00777    static void destruct_TProofPlayerSuperMaster(void *p);
00778 
00779    // Function generating the singleton type initializer
00780    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TProofPlayerSuperMaster*)
00781    {
00782       ::TProofPlayerSuperMaster *ptr = 0;
00783       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TProofPlayerSuperMaster >(0);
00784       static ::ROOT::TGenericClassInfo 
00785          instance("TProofPlayerSuperMaster", ::TProofPlayerSuperMaster::Class_Version(), "include/TProofPlayer.h", 356,
00786                   typeid(::TProofPlayerSuperMaster), DefineBehavior(ptr, ptr),
00787                   &::TProofPlayerSuperMaster::Dictionary, isa_proxy, 4,
00788                   sizeof(::TProofPlayerSuperMaster) );
00789       instance.SetNew(&new_TProofPlayerSuperMaster);
00790       instance.SetNewArray(&newArray_TProofPlayerSuperMaster);
00791       instance.SetDelete(&delete_TProofPlayerSuperMaster);
00792       instance.SetDeleteArray(&deleteArray_TProofPlayerSuperMaster);
00793       instance.SetDestructor(&destruct_TProofPlayerSuperMaster);
00794       return &instance;
00795    }
00796    TGenericClassInfo *GenerateInitInstance(const ::TProofPlayerSuperMaster*)
00797    {
00798       return GenerateInitInstanceLocal((::TProofPlayerSuperMaster*)0);
00799    }
00800    // Static variable to force the class initialization
00801    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TProofPlayerSuperMaster*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00802 } // end of namespace ROOT
00803 
00804 //______________________________________________________________________________
00805 TClass *TDrawFeedback::fgIsA = 0;  // static to hold class pointer
00806 
00807 //______________________________________________________________________________
00808 const char *TDrawFeedback::Class_Name()
00809 {
00810    return "TDrawFeedback";
00811 }
00812 
00813 //______________________________________________________________________________
00814 const char *TDrawFeedback::ImplFileName()
00815 {
00816    return ::ROOT::GenerateInitInstanceLocal((const ::TDrawFeedback*)0x0)->GetImplFileName();
00817 }
00818 
00819 //______________________________________________________________________________
00820 int TDrawFeedback::ImplFileLine()
00821 {
00822    return ::ROOT::GenerateInitInstanceLocal((const ::TDrawFeedback*)0x0)->GetImplFileLine();
00823 }
00824 
00825 //______________________________________________________________________________
00826 void TDrawFeedback::Dictionary()
00827 {
00828    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDrawFeedback*)0x0)->GetClass();
00829 }
00830 
00831 //______________________________________________________________________________
00832 TClass *TDrawFeedback::Class()
00833 {
00834    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TDrawFeedback*)0x0)->GetClass();
00835    return fgIsA;
00836 }
00837 
00838 //______________________________________________________________________________
00839 TClass *TEventIter::fgIsA = 0;  // static to hold class pointer
00840 
00841 //______________________________________________________________________________
00842 const char *TEventIter::Class_Name()
00843 {
00844    return "TEventIter";
00845 }
00846 
00847 //______________________________________________________________________________
00848 const char *TEventIter::ImplFileName()
00849 {
00850    return ::ROOT::GenerateInitInstanceLocal((const ::TEventIter*)0x0)->GetImplFileName();
00851 }
00852 
00853 //______________________________________________________________________________
00854 int TEventIter::ImplFileLine()
00855 {
00856    return ::ROOT::GenerateInitInstanceLocal((const ::TEventIter*)0x0)->GetImplFileLine();
00857 }
00858 
00859 //______________________________________________________________________________
00860 void TEventIter::Dictionary()
00861 {
00862    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEventIter*)0x0)->GetClass();
00863 }
00864 
00865 //______________________________________________________________________________
00866 TClass *TEventIter::Class()
00867 {
00868    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEventIter*)0x0)->GetClass();
00869    return fgIsA;
00870 }
00871 
00872 //______________________________________________________________________________
00873 TClass *TEventIterUnit::fgIsA = 0;  // static to hold class pointer
00874 
00875 //______________________________________________________________________________
00876 const char *TEventIterUnit::Class_Name()
00877 {
00878    return "TEventIterUnit";
00879 }
00880 
00881 //______________________________________________________________________________
00882 const char *TEventIterUnit::ImplFileName()
00883 {
00884    return ::ROOT::GenerateInitInstanceLocal((const ::TEventIterUnit*)0x0)->GetImplFileName();
00885 }
00886 
00887 //______________________________________________________________________________
00888 int TEventIterUnit::ImplFileLine()
00889 {
00890    return ::ROOT::GenerateInitInstanceLocal((const ::TEventIterUnit*)0x0)->GetImplFileLine();
00891 }
00892 
00893 //______________________________________________________________________________
00894 void TEventIterUnit::Dictionary()
00895 {
00896    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEventIterUnit*)0x0)->GetClass();
00897 }
00898 
00899 //______________________________________________________________________________
00900 TClass *TEventIterUnit::Class()
00901 {
00902    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEventIterUnit*)0x0)->GetClass();
00903    return fgIsA;
00904 }
00905 
00906 //______________________________________________________________________________
00907 TClass *TEventIterObj::fgIsA = 0;  // static to hold class pointer
00908 
00909 //______________________________________________________________________________
00910 const char *TEventIterObj::Class_Name()
00911 {
00912    return "TEventIterObj";
00913 }
00914 
00915 //______________________________________________________________________________
00916 const char *TEventIterObj::ImplFileName()
00917 {
00918    return ::ROOT::GenerateInitInstanceLocal((const ::TEventIterObj*)0x0)->GetImplFileName();
00919 }
00920 
00921 //______________________________________________________________________________
00922 int TEventIterObj::ImplFileLine()
00923 {
00924    return ::ROOT::GenerateInitInstanceLocal((const ::TEventIterObj*)0x0)->GetImplFileLine();
00925 }
00926 
00927 //______________________________________________________________________________
00928 void TEventIterObj::Dictionary()
00929 {
00930    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEventIterObj*)0x0)->GetClass();
00931 }
00932 
00933 //______________________________________________________________________________
00934 TClass *TEventIterObj::Class()
00935 {
00936    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEventIterObj*)0x0)->GetClass();
00937    return fgIsA;
00938 }
00939 
00940 //______________________________________________________________________________
00941 TClass *TEventIterTree::fgIsA = 0;  // static to hold class pointer
00942 
00943 //______________________________________________________________________________
00944 const char *TEventIterTree::Class_Name()
00945 {
00946    return "TEventIterTree";
00947 }
00948 
00949 //______________________________________________________________________________
00950 const char *TEventIterTree::ImplFileName()
00951 {
00952    return ::ROOT::GenerateInitInstanceLocal((const ::TEventIterTree*)0x0)->GetImplFileName();
00953 }
00954 
00955 //______________________________________________________________________________
00956 int TEventIterTree::ImplFileLine()
00957 {
00958    return ::ROOT::GenerateInitInstanceLocal((const ::TEventIterTree*)0x0)->GetImplFileLine();
00959 }
00960 
00961 //______________________________________________________________________________
00962 void TEventIterTree::Dictionary()
00963 {
00964    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEventIterTree*)0x0)->GetClass();
00965 }
00966 
00967 //______________________________________________________________________________
00968 TClass *TEventIterTree::Class()
00969 {
00970    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TEventIterTree*)0x0)->GetClass();
00971    return fgIsA;
00972 }
00973 
00974 //______________________________________________________________________________
00975 TClass *TFileMerger::fgIsA = 0;  // static to hold class pointer
00976 
00977 //______________________________________________________________________________
00978 const char *TFileMerger::Class_Name()
00979 {
00980    return "TFileMerger";
00981 }
00982 
00983 //______________________________________________________________________________
00984 const char *TFileMerger::ImplFileName()
00985 {
00986    return ::ROOT::GenerateInitInstanceLocal((const ::TFileMerger*)0x0)->GetImplFileName();
00987 }
00988 
00989 //______________________________________________________________________________
00990 int TFileMerger::ImplFileLine()
00991 {
00992    return ::ROOT::GenerateInitInstanceLocal((const ::TFileMerger*)0x0)->GetImplFileLine();
00993 }
00994 
00995 //______________________________________________________________________________
00996 void TFileMerger::Dictionary()
00997 {
00998    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TFileMerger*)0x0)->GetClass();
00999 }
01000 
01001 //______________________________________________________________________________
01002 TClass *TFileMerger::Class()
01003 {
01004    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TFileMerger*)0x0)->GetClass();
01005    return fgIsA;
01006 }
01007 
01008 //______________________________________________________________________________
01009 TClass *TOutputListSelectorDataMap::fgIsA = 0;  // static to hold class pointer
01010 
01011 //______________________________________________________________________________
01012 const char *TOutputListSelectorDataMap::Class_Name()
01013 {
01014    return "TOutputListSelectorDataMap";
01015 }
01016 
01017 //______________________________________________________________________________
01018 const char *TOutputListSelectorDataMap::ImplFileName()
01019 {
01020    return ::ROOT::GenerateInitInstanceLocal((const ::TOutputListSelectorDataMap*)0x0)->GetImplFileName();
01021 }
01022 
01023 //______________________________________________________________________________
01024 int TOutputListSelectorDataMap::ImplFileLine()
01025 {
01026    return ::ROOT::GenerateInitInstanceLocal((const ::TOutputListSelectorDataMap*)0x0)->GetImplFileLine();
01027 }
01028 
01029 //______________________________________________________________________________
01030 void TOutputListSelectorDataMap::Dictionary()
01031 {
01032    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TOutputListSelectorDataMap*)0x0)->GetClass();
01033 }
01034 
01035 //______________________________________________________________________________
01036 TClass *TOutputListSelectorDataMap::Class()
01037 {
01038    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TOutputListSelectorDataMap*)0x0)->GetClass();
01039    return fgIsA;
01040 }
01041 
01042 //______________________________________________________________________________
01043 TClass *TVirtualPacketizer::fgIsA = 0;  // static to hold class pointer
01044 
01045 //______________________________________________________________________________
01046 const char *TVirtualPacketizer::Class_Name()
01047 {
01048    return "TVirtualPacketizer";
01049 }
01050 
01051 //______________________________________________________________________________
01052 const char *TVirtualPacketizer::ImplFileName()
01053 {
01054    return ::ROOT::GenerateInitInstanceLocal((const ::TVirtualPacketizer*)0x0)->GetImplFileName();
01055 }
01056 
01057 //______________________________________________________________________________
01058 int TVirtualPacketizer::ImplFileLine()
01059 {
01060    return ::ROOT::GenerateInitInstanceLocal((const ::TVirtualPacketizer*)0x0)->GetImplFileLine();
01061 }
01062 
01063 //______________________________________________________________________________
01064 void TVirtualPacketizer::Dictionary()
01065 {
01066    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TVirtualPacketizer*)0x0)->GetClass();
01067 }
01068 
01069 //______________________________________________________________________________
01070 TClass *TVirtualPacketizer::Class()
01071 {
01072    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TVirtualPacketizer*)0x0)->GetClass();
01073    return fgIsA;
01074 }
01075 
01076 //______________________________________________________________________________
01077 TClass *TPacketizerAdaptive::fgIsA = 0;  // static to hold class pointer
01078 
01079 //______________________________________________________________________________
01080 const char *TPacketizerAdaptive::Class_Name()
01081 {
01082    return "TPacketizerAdaptive";
01083 }
01084 
01085 //______________________________________________________________________________
01086 const char *TPacketizerAdaptive::ImplFileName()
01087 {
01088    return ::ROOT::GenerateInitInstanceLocal((const ::TPacketizerAdaptive*)0x0)->GetImplFileName();
01089 }
01090 
01091 //______________________________________________________________________________
01092 int TPacketizerAdaptive::ImplFileLine()
01093 {
01094    return ::ROOT::GenerateInitInstanceLocal((const ::TPacketizerAdaptive*)0x0)->GetImplFileLine();
01095 }
01096 
01097 //______________________________________________________________________________
01098 void TPacketizerAdaptive::Dictionary()
01099 {
01100    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPacketizerAdaptive*)0x0)->GetClass();
01101 }
01102 
01103 //______________________________________________________________________________
01104 TClass *TPacketizerAdaptive::Class()
01105 {
01106    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPacketizerAdaptive*)0x0)->GetClass();
01107    return fgIsA;
01108 }
01109 
01110 //______________________________________________________________________________
01111 TClass *TPacketizerFile::fgIsA = 0;  // static to hold class pointer
01112 
01113 //______________________________________________________________________________
01114 const char *TPacketizerFile::Class_Name()
01115 {
01116    return "TPacketizerFile";
01117 }
01118 
01119 //______________________________________________________________________________
01120 const char *TPacketizerFile::ImplFileName()
01121 {
01122    return ::ROOT::GenerateInitInstanceLocal((const ::TPacketizerFile*)0x0)->GetImplFileName();
01123 }
01124 
01125 //______________________________________________________________________________
01126 int TPacketizerFile::ImplFileLine()
01127 {
01128    return ::ROOT::GenerateInitInstanceLocal((const ::TPacketizerFile*)0x0)->GetImplFileLine();
01129 }
01130 
01131 //______________________________________________________________________________
01132 void TPacketizerFile::Dictionary()
01133 {
01134    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPacketizerFile*)0x0)->GetClass();
01135 }
01136 
01137 //______________________________________________________________________________
01138 TClass *TPacketizerFile::Class()
01139 {
01140    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPacketizerFile*)0x0)->GetClass();
01141    return fgIsA;
01142 }
01143 
01144 //______________________________________________________________________________
01145 TClass *TPacketizer::fgIsA = 0;  // static to hold class pointer
01146 
01147 //______________________________________________________________________________
01148 const char *TPacketizer::Class_Name()
01149 {
01150    return "TPacketizer";
01151 }
01152 
01153 //______________________________________________________________________________
01154 const char *TPacketizer::ImplFileName()
01155 {
01156    return ::ROOT::GenerateInitInstanceLocal((const ::TPacketizer*)0x0)->GetImplFileName();
01157 }
01158 
01159 //______________________________________________________________________________
01160 int TPacketizer::ImplFileLine()
01161 {
01162    return ::ROOT::GenerateInitInstanceLocal((const ::TPacketizer*)0x0)->GetImplFileLine();
01163 }
01164 
01165 //______________________________________________________________________________
01166 void TPacketizer::Dictionary()
01167 {
01168    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPacketizer*)0x0)->GetClass();
01169 }
01170 
01171 //______________________________________________________________________________
01172 TClass *TPacketizer::Class()
01173 {
01174    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPacketizer*)0x0)->GetClass();
01175    return fgIsA;
01176 }
01177 
01178 //______________________________________________________________________________
01179 TClass *TPacketizerMulti::fgIsA = 0;  // static to hold class pointer
01180 
01181 //______________________________________________________________________________
01182 const char *TPacketizerMulti::Class_Name()
01183 {
01184    return "TPacketizerMulti";
01185 }
01186 
01187 //______________________________________________________________________________
01188 const char *TPacketizerMulti::ImplFileName()
01189 {
01190    return ::ROOT::GenerateInitInstanceLocal((const ::TPacketizerMulti*)0x0)->GetImplFileName();
01191 }
01192 
01193 //______________________________________________________________________________
01194 int TPacketizerMulti::ImplFileLine()
01195 {
01196    return ::ROOT::GenerateInitInstanceLocal((const ::TPacketizerMulti*)0x0)->GetImplFileLine();
01197 }
01198 
01199 //______________________________________________________________________________
01200 void TPacketizerMulti::Dictionary()
01201 {
01202    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPacketizerMulti*)0x0)->GetClass();
01203 }
01204 
01205 //______________________________________________________________________________
01206 TClass *TPacketizerMulti::Class()
01207 {
01208    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPacketizerMulti*)0x0)->GetClass();
01209    return fgIsA;
01210 }
01211 
01212 //______________________________________________________________________________
01213 TClass *TPacketizerUnit::fgIsA = 0;  // static to hold class pointer
01214 
01215 //______________________________________________________________________________
01216 const char *TPacketizerUnit::Class_Name()
01217 {
01218    return "TPacketizerUnit";
01219 }
01220 
01221 //______________________________________________________________________________
01222 const char *TPacketizerUnit::ImplFileName()
01223 {
01224    return ::ROOT::GenerateInitInstanceLocal((const ::TPacketizerUnit*)0x0)->GetImplFileName();
01225 }
01226 
01227 //______________________________________________________________________________
01228 int TPacketizerUnit::ImplFileLine()
01229 {
01230    return ::ROOT::GenerateInitInstanceLocal((const ::TPacketizerUnit*)0x0)->GetImplFileLine();
01231 }
01232 
01233 //______________________________________________________________________________
01234 void TPacketizerUnit::Dictionary()
01235 {
01236    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPacketizerUnit*)0x0)->GetClass();
01237 }
01238 
01239 //______________________________________________________________________________
01240 TClass *TPacketizerUnit::Class()
01241 {
01242    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPacketizerUnit*)0x0)->GetClass();
01243    return fgIsA;
01244 }
01245 
01246 //______________________________________________________________________________
01247 TClass *TPerfEvent::fgIsA = 0;  // static to hold class pointer
01248 
01249 //______________________________________________________________________________
01250 const char *TPerfEvent::Class_Name()
01251 {
01252    return "TPerfEvent";
01253 }
01254 
01255 //______________________________________________________________________________
01256 const char *TPerfEvent::ImplFileName()
01257 {
01258    return ::ROOT::GenerateInitInstanceLocal((const ::TPerfEvent*)0x0)->GetImplFileName();
01259 }
01260 
01261 //______________________________________________________________________________
01262 int TPerfEvent::ImplFileLine()
01263 {
01264    return ::ROOT::GenerateInitInstanceLocal((const ::TPerfEvent*)0x0)->GetImplFileLine();
01265 }
01266 
01267 //______________________________________________________________________________
01268 void TPerfEvent::Dictionary()
01269 {
01270    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPerfEvent*)0x0)->GetClass();
01271 }
01272 
01273 //______________________________________________________________________________
01274 TClass *TPerfEvent::Class()
01275 {
01276    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPerfEvent*)0x0)->GetClass();
01277    return fgIsA;
01278 }
01279 
01280 //______________________________________________________________________________
01281 TClass *TPerfStats::fgIsA = 0;  // static to hold class pointer
01282 
01283 //______________________________________________________________________________
01284 const char *TPerfStats::Class_Name()
01285 {
01286    return "TPerfStats";
01287 }
01288 
01289 //______________________________________________________________________________
01290 const char *TPerfStats::ImplFileName()
01291 {
01292    return ::ROOT::GenerateInitInstanceLocal((const ::TPerfStats*)0x0)->GetImplFileName();
01293 }
01294 
01295 //______________________________________________________________________________
01296 int TPerfStats::ImplFileLine()
01297 {
01298    return ::ROOT::GenerateInitInstanceLocal((const ::TPerfStats*)0x0)->GetImplFileLine();
01299 }
01300 
01301 //______________________________________________________________________________
01302 void TPerfStats::Dictionary()
01303 {
01304    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPerfStats*)0x0)->GetClass();
01305 }
01306 
01307 //______________________________________________________________________________
01308 TClass *TPerfStats::Class()
01309 {
01310    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TPerfStats*)0x0)->GetClass();
01311    return fgIsA;
01312 }
01313 
01314 //______________________________________________________________________________
01315 TClass *TProofLimitsFinder::fgIsA = 0;  // static to hold class pointer
01316 
01317 //______________________________________________________________________________
01318 const char *TProofLimitsFinder::Class_Name()
01319 {
01320    return "TProofLimitsFinder";
01321 }
01322 
01323 //______________________________________________________________________________
01324 const char *TProofLimitsFinder::ImplFileName()
01325 {
01326    return ::ROOT::GenerateInitInstanceLocal((const ::TProofLimitsFinder*)0x0)->GetImplFileName();
01327 }
01328 
01329 //______________________________________________________________________________
01330 int TProofLimitsFinder::ImplFileLine()
01331 {
01332    return ::ROOT::GenerateInitInstanceLocal((const ::TProofLimitsFinder*)0x0)->GetImplFileLine();
01333 }
01334 
01335 //______________________________________________________________________________
01336 void TProofLimitsFinder::Dictionary()
01337 {
01338    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofLimitsFinder*)0x0)->GetClass();
01339 }
01340 
01341 //______________________________________________________________________________
01342 TClass *TProofLimitsFinder::Class()
01343 {
01344    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofLimitsFinder*)0x0)->GetClass();
01345    return fgIsA;
01346 }
01347 
01348 //______________________________________________________________________________
01349 TClass *TProofOutputFile::fgIsA = 0;  // static to hold class pointer
01350 
01351 //______________________________________________________________________________
01352 const char *TProofOutputFile::Class_Name()
01353 {
01354    return "TProofOutputFile";
01355 }
01356 
01357 //______________________________________________________________________________
01358 const char *TProofOutputFile::ImplFileName()
01359 {
01360    return ::ROOT::GenerateInitInstanceLocal((const ::TProofOutputFile*)0x0)->GetImplFileName();
01361 }
01362 
01363 //______________________________________________________________________________
01364 int TProofOutputFile::ImplFileLine()
01365 {
01366    return ::ROOT::GenerateInitInstanceLocal((const ::TProofOutputFile*)0x0)->GetImplFileLine();
01367 }
01368 
01369 //______________________________________________________________________________
01370 void TProofOutputFile::Dictionary()
01371 {
01372    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofOutputFile*)0x0)->GetClass();
01373 }
01374 
01375 //______________________________________________________________________________
01376 TClass *TProofOutputFile::Class()
01377 {
01378    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofOutputFile*)0x0)->GetClass();
01379    return fgIsA;
01380 }
01381 
01382 //______________________________________________________________________________
01383 TClass *TProofPlayer::fgIsA = 0;  // static to hold class pointer
01384 
01385 //______________________________________________________________________________
01386 const char *TProofPlayer::Class_Name()
01387 {
01388    return "TProofPlayer";
01389 }
01390 
01391 //______________________________________________________________________________
01392 const char *TProofPlayer::ImplFileName()
01393 {
01394    return ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayer*)0x0)->GetImplFileName();
01395 }
01396 
01397 //______________________________________________________________________________
01398 int TProofPlayer::ImplFileLine()
01399 {
01400    return ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayer*)0x0)->GetImplFileLine();
01401 }
01402 
01403 //______________________________________________________________________________
01404 void TProofPlayer::Dictionary()
01405 {
01406    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayer*)0x0)->GetClass();
01407 }
01408 
01409 //______________________________________________________________________________
01410 TClass *TProofPlayer::Class()
01411 {
01412    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayer*)0x0)->GetClass();
01413    return fgIsA;
01414 }
01415 
01416 //______________________________________________________________________________
01417 TClass *TProofPlayerLite::fgIsA = 0;  // static to hold class pointer
01418 
01419 //______________________________________________________________________________
01420 const char *TProofPlayerLite::Class_Name()
01421 {
01422    return "TProofPlayerLite";
01423 }
01424 
01425 //______________________________________________________________________________
01426 const char *TProofPlayerLite::ImplFileName()
01427 {
01428    return ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayerLite*)0x0)->GetImplFileName();
01429 }
01430 
01431 //______________________________________________________________________________
01432 int TProofPlayerLite::ImplFileLine()
01433 {
01434    return ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayerLite*)0x0)->GetImplFileLine();
01435 }
01436 
01437 //______________________________________________________________________________
01438 void TProofPlayerLite::Dictionary()
01439 {
01440    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayerLite*)0x0)->GetClass();
01441 }
01442 
01443 //______________________________________________________________________________
01444 TClass *TProofPlayerLite::Class()
01445 {
01446    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayerLite*)0x0)->GetClass();
01447    return fgIsA;
01448 }
01449 
01450 //______________________________________________________________________________
01451 TClass *TProofPlayerRemote::fgIsA = 0;  // static to hold class pointer
01452 
01453 //______________________________________________________________________________
01454 const char *TProofPlayerRemote::Class_Name()
01455 {
01456    return "TProofPlayerRemote";
01457 }
01458 
01459 //______________________________________________________________________________
01460 const char *TProofPlayerRemote::ImplFileName()
01461 {
01462    return ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayerRemote*)0x0)->GetImplFileName();
01463 }
01464 
01465 //______________________________________________________________________________
01466 int TProofPlayerRemote::ImplFileLine()
01467 {
01468    return ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayerRemote*)0x0)->GetImplFileLine();
01469 }
01470 
01471 //______________________________________________________________________________
01472 void TProofPlayerRemote::Dictionary()
01473 {
01474    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayerRemote*)0x0)->GetClass();
01475 }
01476 
01477 //______________________________________________________________________________
01478 TClass *TProofPlayerRemote::Class()
01479 {
01480    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayerRemote*)0x0)->GetClass();
01481    return fgIsA;
01482 }
01483 
01484 //______________________________________________________________________________
01485 TClass *TStatus::fgIsA = 0;  // static to hold class pointer
01486 
01487 //______________________________________________________________________________
01488 const char *TStatus::Class_Name()
01489 {
01490    return "TStatus";
01491 }
01492 
01493 //______________________________________________________________________________
01494 const char *TStatus::ImplFileName()
01495 {
01496    return ::ROOT::GenerateInitInstanceLocal((const ::TStatus*)0x0)->GetImplFileName();
01497 }
01498 
01499 //______________________________________________________________________________
01500 int TStatus::ImplFileLine()
01501 {
01502    return ::ROOT::GenerateInitInstanceLocal((const ::TStatus*)0x0)->GetImplFileLine();
01503 }
01504 
01505 //______________________________________________________________________________
01506 void TStatus::Dictionary()
01507 {
01508    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TStatus*)0x0)->GetClass();
01509 }
01510 
01511 //______________________________________________________________________________
01512 TClass *TStatus::Class()
01513 {
01514    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TStatus*)0x0)->GetClass();
01515    return fgIsA;
01516 }
01517 
01518 //______________________________________________________________________________
01519 TClass *TProofPlayerLocal::fgIsA = 0;  // static to hold class pointer
01520 
01521 //______________________________________________________________________________
01522 const char *TProofPlayerLocal::Class_Name()
01523 {
01524    return "TProofPlayerLocal";
01525 }
01526 
01527 //______________________________________________________________________________
01528 const char *TProofPlayerLocal::ImplFileName()
01529 {
01530    return ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayerLocal*)0x0)->GetImplFileName();
01531 }
01532 
01533 //______________________________________________________________________________
01534 int TProofPlayerLocal::ImplFileLine()
01535 {
01536    return ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayerLocal*)0x0)->GetImplFileLine();
01537 }
01538 
01539 //______________________________________________________________________________
01540 void TProofPlayerLocal::Dictionary()
01541 {
01542    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayerLocal*)0x0)->GetClass();
01543 }
01544 
01545 //______________________________________________________________________________
01546 TClass *TProofPlayerLocal::Class()
01547 {
01548    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayerLocal*)0x0)->GetClass();
01549    return fgIsA;
01550 }
01551 
01552 //______________________________________________________________________________
01553 TClass *TProofPlayerSlave::fgIsA = 0;  // static to hold class pointer
01554 
01555 //______________________________________________________________________________
01556 const char *TProofPlayerSlave::Class_Name()
01557 {
01558    return "TProofPlayerSlave";
01559 }
01560 
01561 //______________________________________________________________________________
01562 const char *TProofPlayerSlave::ImplFileName()
01563 {
01564    return ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayerSlave*)0x0)->GetImplFileName();
01565 }
01566 
01567 //______________________________________________________________________________
01568 int TProofPlayerSlave::ImplFileLine()
01569 {
01570    return ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayerSlave*)0x0)->GetImplFileLine();
01571 }
01572 
01573 //______________________________________________________________________________
01574 void TProofPlayerSlave::Dictionary()
01575 {
01576    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayerSlave*)0x0)->GetClass();
01577 }
01578 
01579 //______________________________________________________________________________
01580 TClass *TProofPlayerSlave::Class()
01581 {
01582    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayerSlave*)0x0)->GetClass();
01583    return fgIsA;
01584 }
01585 
01586 //______________________________________________________________________________
01587 TClass *TProofPlayerSuperMaster::fgIsA = 0;  // static to hold class pointer
01588 
01589 //______________________________________________________________________________
01590 const char *TProofPlayerSuperMaster::Class_Name()
01591 {
01592    return "TProofPlayerSuperMaster";
01593 }
01594 
01595 //______________________________________________________________________________
01596 const char *TProofPlayerSuperMaster::ImplFileName()
01597 {
01598    return ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayerSuperMaster*)0x0)->GetImplFileName();
01599 }
01600 
01601 //______________________________________________________________________________
01602 int TProofPlayerSuperMaster::ImplFileLine()
01603 {
01604    return ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayerSuperMaster*)0x0)->GetImplFileLine();
01605 }
01606 
01607 //______________________________________________________________________________
01608 void TProofPlayerSuperMaster::Dictionary()
01609 {
01610    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayerSuperMaster*)0x0)->GetClass();
01611 }
01612 
01613 //______________________________________________________________________________
01614 TClass *TProofPlayerSuperMaster::Class()
01615 {
01616    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TProofPlayerSuperMaster*)0x0)->GetClass();
01617    return fgIsA;
01618 }
01619 
01620 //______________________________________________________________________________
01621 void TProofPlayer::Streamer(TBuffer &R__b)
01622 {
01623    // Stream an object of class TProofPlayer.
01624 
01625    if (R__b.IsReading()) {
01626       R__b.ReadClassBuffer(TProofPlayer::Class(),this);
01627    } else {
01628       R__b.WriteClassBuffer(TProofPlayer::Class(),this);
01629    }
01630 }
01631 
01632 //______________________________________________________________________________
01633 void TProofPlayer::ShowMembers(TMemberInspector &R__insp)
01634 {
01635       // Inspect the data members of an object of class TProofPlayer.
01636       TClass *R__cl = ::TProofPlayer::IsA();
01637       if (R__cl || R__insp.IsA()) { }
01638       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAutoBins", &fAutoBins);
01639       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInput", &fInput);
01640       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOutput", &fOutput);
01641       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelector", &fSelector);
01642       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelectorClass", &fSelectorClass);
01643       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFeedbackTimer", &fFeedbackTimer);
01644       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFeedbackPeriod", &fFeedbackPeriod);
01645       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEvIter", &fEvIter);
01646       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSelStatus", &fSelStatus);
01647       R__insp.Inspect(R__cl, R__insp.GetParent(), "fExitStatus", &fExitStatus);
01648       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotalEvents", &fTotalEvents);
01649       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProgressStatus", &fProgressStatus);
01650       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fQueryResults", &fQueryResults);
01651       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fQuery", &fQuery);
01652       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPreviousQuery", &fPreviousQuery);
01653       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawQueries", &fDrawQueries);
01654       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxDrawQueries", &fMaxDrawQueries);
01655       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStopTimer", &fStopTimer);
01656       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStopTimerMtx", &fStopTimerMtx);
01657       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDispatchTimer", &fDispatchTimer);
01658       TVirtualProofPlayer::ShowMembers(R__insp);
01659 }
01660 
01661 namespace ROOT {
01662    // Wrappers around operator new
01663    static void *new_TProofPlayer(void *p) {
01664       return  p ? new(p) ::TProofPlayer : new ::TProofPlayer;
01665    }
01666    static void *newArray_TProofPlayer(Long_t nElements, void *p) {
01667       return p ? new(p) ::TProofPlayer[nElements] : new ::TProofPlayer[nElements];
01668    }
01669    // Wrapper around operator delete
01670    static void delete_TProofPlayer(void *p) {
01671       delete ((::TProofPlayer*)p);
01672    }
01673    static void deleteArray_TProofPlayer(void *p) {
01674       delete [] ((::TProofPlayer*)p);
01675    }
01676    static void destruct_TProofPlayer(void *p) {
01677       typedef ::TProofPlayer current_t;
01678       ((current_t*)p)->~current_t();
01679    }
01680 } // end of namespace ROOT for class ::TProofPlayer
01681 
01682 //______________________________________________________________________________
01683 void TProofPlayerLite::Streamer(TBuffer &R__b)
01684 {
01685    // Stream an object of class TProofPlayerLite.
01686 
01687    if (R__b.IsReading()) {
01688       R__b.ReadClassBuffer(TProofPlayerLite::Class(),this);
01689    } else {
01690       R__b.WriteClassBuffer(TProofPlayerLite::Class(),this);
01691    }
01692 }
01693 
01694 //______________________________________________________________________________
01695 void TProofPlayerLite::ShowMembers(TMemberInspector &R__insp)
01696 {
01697       // Inspect the data members of an object of class TProofPlayerLite.
01698       TClass *R__cl = ::TProofPlayerLite::IsA();
01699       if (R__cl || R__insp.IsA()) { }
01700       TProofPlayerRemote::ShowMembers(R__insp);
01701 }
01702 
01703 namespace ROOT {
01704    // Wrappers around operator new
01705    static void *new_TProofPlayerLite(void *p) {
01706       return  p ? new(p) ::TProofPlayerLite : new ::TProofPlayerLite;
01707    }
01708    static void *newArray_TProofPlayerLite(Long_t nElements, void *p) {
01709       return p ? new(p) ::TProofPlayerLite[nElements] : new ::TProofPlayerLite[nElements];
01710    }
01711    // Wrapper around operator delete
01712    static void delete_TProofPlayerLite(void *p) {
01713       delete ((::TProofPlayerLite*)p);
01714    }
01715    static void deleteArray_TProofPlayerLite(void *p) {
01716       delete [] ((::TProofPlayerLite*)p);
01717    }
01718    static void destruct_TProofPlayerLite(void *p) {
01719       typedef ::TProofPlayerLite current_t;
01720       ((current_t*)p)->~current_t();
01721    }
01722 } // end of namespace ROOT for class ::TProofPlayerLite
01723 
01724 //______________________________________________________________________________
01725 void TProofPlayerLocal::Streamer(TBuffer &R__b)
01726 {
01727    // Stream an object of class TProofPlayerLocal.
01728 
01729    if (R__b.IsReading()) {
01730       R__b.ReadClassBuffer(TProofPlayerLocal::Class(),this);
01731    } else {
01732       R__b.WriteClassBuffer(TProofPlayerLocal::Class(),this);
01733    }
01734 }
01735 
01736 //______________________________________________________________________________
01737 void TProofPlayerLocal::ShowMembers(TMemberInspector &R__insp)
01738 {
01739       // Inspect the data members of an object of class TProofPlayerLocal.
01740       TClass *R__cl = ::TProofPlayerLocal::IsA();
01741       if (R__cl || R__insp.IsA()) { }
01742       R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsClient", &fIsClient);
01743       TProofPlayer::ShowMembers(R__insp);
01744 }
01745 
01746 namespace ROOT {
01747    // Wrappers around operator new
01748    static void *new_TProofPlayerLocal(void *p) {
01749       return  p ? new(p) ::TProofPlayerLocal : new ::TProofPlayerLocal;
01750    }
01751    static void *newArray_TProofPlayerLocal(Long_t nElements, void *p) {
01752       return p ? new(p) ::TProofPlayerLocal[nElements] : new ::TProofPlayerLocal[nElements];
01753    }
01754    // Wrapper around operator delete
01755    static void delete_TProofPlayerLocal(void *p) {
01756       delete ((::TProofPlayerLocal*)p);
01757    }
01758    static void deleteArray_TProofPlayerLocal(void *p) {
01759       delete [] ((::TProofPlayerLocal*)p);
01760    }
01761    static void destruct_TProofPlayerLocal(void *p) {
01762       typedef ::TProofPlayerLocal current_t;
01763       ((current_t*)p)->~current_t();
01764    }
01765 } // end of namespace ROOT for class ::TProofPlayerLocal
01766 
01767 //______________________________________________________________________________
01768 void TProofPlayerRemote::Streamer(TBuffer &R__b)
01769 {
01770    // Stream an object of class TProofPlayerRemote.
01771 
01772    if (R__b.IsReading()) {
01773       R__b.ReadClassBuffer(TProofPlayerRemote::Class(),this);
01774    } else {
01775       R__b.WriteClassBuffer(TProofPlayerRemote::Class(),this);
01776    }
01777 }
01778 
01779 //______________________________________________________________________________
01780 void TProofPlayerRemote::ShowMembers(TMemberInspector &R__insp)
01781 {
01782       // Inspect the data members of an object of class TProofPlayerRemote.
01783       TClass *R__cl = ::TProofPlayerRemote::IsA();
01784       if (R__cl || R__insp.IsA()) { }
01785       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProof", &fProof);
01786       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOutputLists", &fOutputLists);
01787       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFeedback", &fFeedback);
01788       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFeedbackLists", &fFeedbackLists);
01789       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPacketizer", &fPacketizer);
01790       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMergeFiles", &fMergeFiles);
01791       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDSet", &fDSet);
01792       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fErrorHandler", &fErrorHandler);
01793       TProofPlayer::ShowMembers(R__insp);
01794 }
01795 
01796 namespace ROOT {
01797    // Wrappers around operator new
01798    static void *new_TProofPlayerRemote(void *p) {
01799       return  p ? new(p) ::TProofPlayerRemote : new ::TProofPlayerRemote;
01800    }
01801    static void *newArray_TProofPlayerRemote(Long_t nElements, void *p) {
01802       return p ? new(p) ::TProofPlayerRemote[nElements] : new ::TProofPlayerRemote[nElements];
01803    }
01804    // Wrapper around operator delete
01805    static void delete_TProofPlayerRemote(void *p) {
01806       delete ((::TProofPlayerRemote*)p);
01807    }
01808    static void deleteArray_TProofPlayerRemote(void *p) {
01809       delete [] ((::TProofPlayerRemote*)p);
01810    }
01811    static void destruct_TProofPlayerRemote(void *p) {
01812       typedef ::TProofPlayerRemote current_t;
01813       ((current_t*)p)->~current_t();
01814    }
01815 } // end of namespace ROOT for class ::TProofPlayerRemote
01816 
01817 //______________________________________________________________________________
01818 void TProofPlayerSlave::Streamer(TBuffer &R__b)
01819 {
01820    // Stream an object of class TProofPlayerSlave.
01821 
01822    if (R__b.IsReading()) {
01823       R__b.ReadClassBuffer(TProofPlayerSlave::Class(),this);
01824    } else {
01825       R__b.WriteClassBuffer(TProofPlayerSlave::Class(),this);
01826    }
01827 }
01828 
01829 //______________________________________________________________________________
01830 void TProofPlayerSlave::ShowMembers(TMemberInspector &R__insp)
01831 {
01832       // Inspect the data members of an object of class TProofPlayerSlave.
01833       TClass *R__cl = ::TProofPlayerSlave::IsA();
01834       if (R__cl || R__insp.IsA()) { }
01835       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSocket", &fSocket);
01836       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFeedback", &fFeedback);
01837       TProofPlayer::ShowMembers(R__insp);
01838 }
01839 
01840 namespace ROOT {
01841    // Wrappers around operator new
01842    static void *new_TProofPlayerSlave(void *p) {
01843       return  p ? new(p) ::TProofPlayerSlave : new ::TProofPlayerSlave;
01844    }
01845    static void *newArray_TProofPlayerSlave(Long_t nElements, void *p) {
01846       return p ? new(p) ::TProofPlayerSlave[nElements] : new ::TProofPlayerSlave[nElements];
01847    }
01848    // Wrapper around operator delete
01849    static void delete_TProofPlayerSlave(void *p) {
01850       delete ((::TProofPlayerSlave*)p);
01851    }
01852    static void deleteArray_TProofPlayerSlave(void *p) {
01853       delete [] ((::TProofPlayerSlave*)p);
01854    }
01855    static void destruct_TProofPlayerSlave(void *p) {
01856       typedef ::TProofPlayerSlave current_t;
01857       ((current_t*)p)->~current_t();
01858    }
01859 } // end of namespace ROOT for class ::TProofPlayerSlave
01860 
01861 //______________________________________________________________________________
01862 void TProofPlayerSuperMaster::Streamer(TBuffer &R__b)
01863 {
01864    // Stream an object of class TProofPlayerSuperMaster.
01865 
01866    if (R__b.IsReading()) {
01867       R__b.ReadClassBuffer(TProofPlayerSuperMaster::Class(),this);
01868    } else {
01869       R__b.WriteClassBuffer(TProofPlayerSuperMaster::Class(),this);
01870    }
01871 }
01872 
01873 //______________________________________________________________________________
01874 void TProofPlayerSuperMaster::ShowMembers(TMemberInspector &R__insp)
01875 {
01876       // Inspect the data members of an object of class TProofPlayerSuperMaster.
01877       TClass *R__cl = ::TProofPlayerSuperMaster::IsA();
01878       if (R__cl || R__insp.IsA()) { }
01879       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveProgress", &fSlaveProgress);
01880       R__insp.InspectMember(fSlaveProgress, "fSlaveProgress.");
01881       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveTotals", &fSlaveTotals);
01882       R__insp.InspectMember(fSlaveTotals, "fSlaveTotals.");
01883       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveBytesRead", &fSlaveBytesRead);
01884       R__insp.InspectMember(fSlaveBytesRead, "fSlaveBytesRead.");
01885       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveInitTime", &fSlaveInitTime);
01886       R__insp.InspectMember(fSlaveInitTime, "fSlaveInitTime.");
01887       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveProcTime", &fSlaveProcTime);
01888       R__insp.InspectMember(fSlaveProcTime, "fSlaveProcTime.");
01889       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveEvtRti", &fSlaveEvtRti);
01890       R__insp.InspectMember(fSlaveEvtRti, "fSlaveEvtRti.");
01891       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveMBRti", &fSlaveMBRti);
01892       R__insp.InspectMember(fSlaveMBRti, "fSlaveMBRti.");
01893       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveActW", &fSlaveActW);
01894       R__insp.InspectMember(fSlaveActW, "fSlaveActW.");
01895       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveTotS", &fSlaveTotS);
01896       R__insp.InspectMember(fSlaveTotS, "fSlaveTotS.");
01897       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveEffS", &fSlaveEffS);
01898       R__insp.InspectMember(fSlaveEffS, "fSlaveEffS.");
01899       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaves", &fSlaves);
01900       R__insp.InspectMember(fSlaves, "fSlaves.");
01901       R__insp.Inspect(R__cl, R__insp.GetParent(), "fReturnFeedback", &fReturnFeedback);
01902       TProofPlayerRemote::ShowMembers(R__insp);
01903 }
01904 
01905 namespace ROOT {
01906    // Wrappers around operator new
01907    static void *new_TProofPlayerSuperMaster(void *p) {
01908       return  p ? new(p) ::TProofPlayerSuperMaster : new ::TProofPlayerSuperMaster;
01909    }
01910    static void *newArray_TProofPlayerSuperMaster(Long_t nElements, void *p) {
01911       return p ? new(p) ::TProofPlayerSuperMaster[nElements] : new ::TProofPlayerSuperMaster[nElements];
01912    }
01913    // Wrapper around operator delete
01914    static void delete_TProofPlayerSuperMaster(void *p) {
01915       delete ((::TProofPlayerSuperMaster*)p);
01916    }
01917    static void deleteArray_TProofPlayerSuperMaster(void *p) {
01918       delete [] ((::TProofPlayerSuperMaster*)p);
01919    }
01920    static void destruct_TProofPlayerSuperMaster(void *p) {
01921       typedef ::TProofPlayerSuperMaster current_t;
01922       ((current_t*)p)->~current_t();
01923    }
01924 } // end of namespace ROOT for class ::TProofPlayerSuperMaster
01925 
01926 //______________________________________________________________________________
01927 void TVirtualPacketizer::Streamer(TBuffer &R__b)
01928 {
01929    // Stream an object of class TVirtualPacketizer.
01930 
01931    if (R__b.IsReading()) {
01932       R__b.ReadClassBuffer(TVirtualPacketizer::Class(),this);
01933    } else {
01934       R__b.WriteClassBuffer(TVirtualPacketizer::Class(),this);
01935    }
01936 }
01937 
01938 //______________________________________________________________________________
01939 void TVirtualPacketizer::ShowMembers(TMemberInspector &R__insp)
01940 {
01941       // Inspect the data members of an object of class TVirtualPacketizer.
01942       TClass *R__cl = ::TVirtualPacketizer::IsA();
01943       if (R__cl || R__insp.IsA()) { }
01944       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinPacketTime", &fMinPacketTime);
01945       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxPacketTime", &fMaxPacketTime);
01946       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fConfigParams", &fConfigParams);
01947       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSlaveStats", &fSlaveStats);
01948       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProgressStatus", &fProgressStatus);
01949       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProgress", &fProgress);
01950       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotalEntries", &fTotalEntries);
01951       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFailedPackets", &fFailedPackets);
01952       R__insp.Inspect(R__cl, R__insp.GetParent(), "fStartTime", &fStartTime);
01953       R__insp.InspectMember(fStartTime, "fStartTime.");
01954       R__insp.Inspect(R__cl, R__insp.GetParent(), "fInitTime", &fInitTime);
01955       R__insp.Inspect(R__cl, R__insp.GetParent(), "fProcTime", &fProcTime);
01956       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeUpdt", &fTimeUpdt);
01957       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCircProg", &fCircProg);
01958       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCircN", &fCircN);
01959       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProgressPerf", &fProgressPerf);
01960       R__insp.Inspect(R__cl, R__insp.GetParent(), "fProcTimeLast", &fProcTimeLast);
01961       R__insp.Inspect(R__cl, R__insp.GetParent(), "fActWrksLast", &fActWrksLast);
01962       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvtRateLast", &fEvtRateLast);
01963       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMBsReadLast", &fMBsReadLast);
01964       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEffSessLast", &fEffSessLast);
01965       R__insp.Inspect(R__cl, R__insp.GetParent(), "fAWLastFill", &fAWLastFill);
01966       R__insp.Inspect(R__cl, R__insp.GetParent(), "fReportPeriod", &fReportPeriod);
01967       R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseEstOpt", &fUseEstOpt);
01968       R__insp.Inspect(R__cl, R__insp.GetParent(), "fValid", &fValid);
01969       R__insp.Inspect(R__cl, R__insp.GetParent(), "fStop", &fStop);
01970       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataSet", &fDataSet);
01971       R__insp.InspectMember(fDataSet, "fDataSet.");
01972       TObject::ShowMembers(R__insp);
01973 }
01974 
01975 namespace ROOT {
01976    // Wrapper around operator delete
01977    static void delete_TVirtualPacketizer(void *p) {
01978       delete ((::TVirtualPacketizer*)p);
01979    }
01980    static void deleteArray_TVirtualPacketizer(void *p) {
01981       delete [] ((::TVirtualPacketizer*)p);
01982    }
01983    static void destruct_TVirtualPacketizer(void *p) {
01984       typedef ::TVirtualPacketizer current_t;
01985       ((current_t*)p)->~current_t();
01986    }
01987 } // end of namespace ROOT for class ::TVirtualPacketizer
01988 
01989 //______________________________________________________________________________
01990 void TPacketizer::Streamer(TBuffer &R__b)
01991 {
01992    // Stream an object of class TPacketizer.
01993 
01994    if (R__b.IsReading()) {
01995       R__b.ReadClassBuffer(TPacketizer::Class(),this);
01996    } else {
01997       R__b.WriteClassBuffer(TPacketizer::Class(),this);
01998    }
01999 }
02000 
02001 //______________________________________________________________________________
02002 void TPacketizer::ShowMembers(TMemberInspector &R__insp)
02003 {
02004       // Inspect the data members of an object of class TPacketizer.
02005       TClass *R__cl = ::TPacketizer::IsA();
02006       if (R__cl || R__insp.IsA()) { }
02007       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPackets", &fPackets);
02008       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFileNodes", &fFileNodes);
02009       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUnAllocated", &fUnAllocated);
02010       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fActive", &fActive);
02011       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSlaveStats", &fSlaveStats);
02012       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPacketSize", &fPacketSize);
02013       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxPerfIdx", &fMaxPerfIdx);
02014       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxSlaveCnt", &fMaxSlaveCnt);
02015       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPacketAsAFraction", &fPacketAsAFraction);
02016       TVirtualPacketizer::ShowMembers(R__insp);
02017 }
02018 
02019 namespace ROOT {
02020    // Wrapper around operator delete
02021    static void delete_TPacketizer(void *p) {
02022       delete ((::TPacketizer*)p);
02023    }
02024    static void deleteArray_TPacketizer(void *p) {
02025       delete [] ((::TPacketizer*)p);
02026    }
02027    static void destruct_TPacketizer(void *p) {
02028       typedef ::TPacketizer current_t;
02029       ((current_t*)p)->~current_t();
02030    }
02031 } // end of namespace ROOT for class ::TPacketizer
02032 
02033 //______________________________________________________________________________
02034 void TPacketizerUnit::Streamer(TBuffer &R__b)
02035 {
02036    // Stream an object of class TPacketizerUnit.
02037 
02038    if (R__b.IsReading()) {
02039       R__b.ReadClassBuffer(TPacketizerUnit::Class(),this);
02040    } else {
02041       R__b.WriteClassBuffer(TPacketizerUnit::Class(),this);
02042    }
02043 }
02044 
02045 //______________________________________________________________________________
02046 void TPacketizerUnit::ShowMembers(TMemberInspector &R__insp)
02047 {
02048       // Inspect the data members of an object of class TPacketizerUnit.
02049       TClass *R__cl = ::TPacketizerUnit::IsA();
02050       if (R__cl || R__insp.IsA()) { }
02051       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPackets", &fPackets);
02052       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSlaveStats", &fSlaveStats);
02053       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStopwatch", &fStopwatch);
02054       R__insp.Inspect(R__cl, R__insp.GetParent(), "fProcessing", &fProcessing);
02055       R__insp.Inspect(R__cl, R__insp.GetParent(), "fAssigned", &fAssigned);
02056       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCalibNum", &fCalibNum);
02057       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumPerWorker", &fNumPerWorker);
02058       TVirtualPacketizer::ShowMembers(R__insp);
02059 }
02060 
02061 namespace ROOT {
02062    // Wrapper around operator delete
02063    static void delete_TPacketizerUnit(void *p) {
02064       delete ((::TPacketizerUnit*)p);
02065    }
02066    static void deleteArray_TPacketizerUnit(void *p) {
02067       delete [] ((::TPacketizerUnit*)p);
02068    }
02069    static void destruct_TPacketizerUnit(void *p) {
02070       typedef ::TPacketizerUnit current_t;
02071       ((current_t*)p)->~current_t();
02072    }
02073 } // end of namespace ROOT for class ::TPacketizerUnit
02074 
02075 //______________________________________________________________________________
02076 void TPacketizerAdaptive::Streamer(TBuffer &R__b)
02077 {
02078    // Stream an object of class TPacketizerAdaptive.
02079 
02080    if (R__b.IsReading()) {
02081       R__b.ReadClassBuffer(TPacketizerAdaptive::Class(),this);
02082    } else {
02083       R__b.WriteClassBuffer(TPacketizerAdaptive::Class(),this);
02084    }
02085 }
02086 
02087 //______________________________________________________________________________
02088 void TPacketizerAdaptive::ShowMembers(TMemberInspector &R__insp)
02089 {
02090       // Inspect the data members of an object of class TPacketizerAdaptive.
02091       TClass *R__cl = ::TPacketizerAdaptive::IsA();
02092       if (R__cl || R__insp.IsA()) { }
02093       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFileNodes", &fFileNodes);
02094       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fUnAllocated", &fUnAllocated);
02095       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fActive", &fActive);
02096       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxPerfIdx", &fMaxPerfIdx);
02097       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPartitions", &fPartitions);
02098       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFilesToProcess", &fFilesToProcess);
02099       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCachePacketSync", &fCachePacketSync);
02100       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxEntriesRatio", &fMaxEntriesRatio);
02101       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFractionOfRemoteFiles", &fFractionOfRemoteFiles);
02102       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNEventsOnRemLoc", &fNEventsOnRemLoc);
02103       R__insp.Inspect(R__cl, R__insp.GetParent(), "fBaseLocalPreference", &fBaseLocalPreference);
02104       R__insp.Inspect(R__cl, R__insp.GetParent(), "fForceLocal", &fForceLocal);
02105       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxSlaveCnt", &fMaxSlaveCnt);
02106       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPacketAsAFraction", &fPacketAsAFraction);
02107       R__insp.Inspect(R__cl, R__insp.GetParent(), "fStrategy", &fStrategy);
02108       TVirtualPacketizer::ShowMembers(R__insp);
02109 }
02110 
02111 namespace ROOT {
02112    // Wrapper around operator delete
02113    static void delete_TPacketizerAdaptive(void *p) {
02114       delete ((::TPacketizerAdaptive*)p);
02115    }
02116    static void deleteArray_TPacketizerAdaptive(void *p) {
02117       delete [] ((::TPacketizerAdaptive*)p);
02118    }
02119    static void destruct_TPacketizerAdaptive(void *p) {
02120       typedef ::TPacketizerAdaptive current_t;
02121       ((current_t*)p)->~current_t();
02122    }
02123 } // end of namespace ROOT for class ::TPacketizerAdaptive
02124 
02125 //______________________________________________________________________________
02126 void TPacketizerMulti::Streamer(TBuffer &R__b)
02127 {
02128    // Stream an object of class TPacketizerMulti.
02129 
02130    if (R__b.IsReading()) {
02131       R__b.ReadClassBuffer(TPacketizerMulti::Class(),this);
02132    } else {
02133       R__b.WriteClassBuffer(TPacketizerMulti::Class(),this);
02134    }
02135 }
02136 
02137 //______________________________________________________________________________
02138 void TPacketizerMulti::ShowMembers(TMemberInspector &R__insp)
02139 {
02140       // Inspect the data members of an object of class TPacketizerMulti.
02141       TClass *R__cl = ::TPacketizerMulti::IsA();
02142       if (R__cl || R__insp.IsA()) { }
02143       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPacketizers", &fPacketizers);
02144       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPacketizersIter", &fPacketizersIter);
02145       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrent", &fCurrent);
02146       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAssignedPack", &fAssignedPack);
02147       TVirtualPacketizer::ShowMembers(R__insp);
02148 }
02149 
02150 namespace ROOT {
02151    // Wrapper around operator delete
02152    static void delete_TPacketizerMulti(void *p) {
02153       delete ((::TPacketizerMulti*)p);
02154    }
02155    static void deleteArray_TPacketizerMulti(void *p) {
02156       delete [] ((::TPacketizerMulti*)p);
02157    }
02158    static void destruct_TPacketizerMulti(void *p) {
02159       typedef ::TPacketizerMulti current_t;
02160       ((current_t*)p)->~current_t();
02161    }
02162 } // end of namespace ROOT for class ::TPacketizerMulti
02163 
02164 //______________________________________________________________________________
02165 void TPacketizerFile::Streamer(TBuffer &R__b)
02166 {
02167    // Stream an object of class TPacketizerFile.
02168 
02169    if (R__b.IsReading()) {
02170       R__b.ReadClassBuffer(TPacketizerFile::Class(),this);
02171    } else {
02172       R__b.WriteClassBuffer(TPacketizerFile::Class(),this);
02173    }
02174 }
02175 
02176 //______________________________________________________________________________
02177 void TPacketizerFile::ShowMembers(TMemberInspector &R__insp)
02178 {
02179       // Inspect the data members of an object of class TPacketizerFile.
02180       TClass *R__cl = ::TPacketizerFile::IsA();
02181       if (R__cl || R__insp.IsA()) { }
02182       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFiles", &fFiles);
02183       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNotAssigned", &fNotAssigned);
02184       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIters", &fIters);
02185       R__insp.Inspect(R__cl, R__insp.GetParent(), "fAssigned", &fAssigned);
02186       R__insp.Inspect(R__cl, R__insp.GetParent(), "fProcNotAssigned", &fProcNotAssigned);
02187       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fStopwatch", &fStopwatch);
02188       TVirtualPacketizer::ShowMembers(R__insp);
02189 }
02190 
02191 namespace ROOT {
02192    // Wrapper around operator delete
02193    static void delete_TPacketizerFile(void *p) {
02194       delete ((::TPacketizerFile*)p);
02195    }
02196    static void deleteArray_TPacketizerFile(void *p) {
02197       delete [] ((::TPacketizerFile*)p);
02198    }
02199    static void destruct_TPacketizerFile(void *p) {
02200       typedef ::TPacketizerFile current_t;
02201       ((current_t*)p)->~current_t();
02202    }
02203 } // end of namespace ROOT for class ::TPacketizerFile
02204 
02205 //______________________________________________________________________________
02206 void TEventIter::Streamer(TBuffer &R__b)
02207 {
02208    // Stream an object of class TEventIter.
02209 
02210    if (R__b.IsReading()) {
02211       R__b.ReadClassBuffer(TEventIter::Class(),this);
02212    } else {
02213       R__b.WriteClassBuffer(TEventIter::Class(),this);
02214    }
02215 }
02216 
02217 //______________________________________________________________________________
02218 void TEventIter::ShowMembers(TMemberInspector &R__insp)
02219 {
02220       // Inspect the data members of an object of class TEventIter.
02221       TClass *R__cl = ::TEventIter::IsA();
02222       if (R__cl || R__insp.IsA()) { }
02223       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDSet", &fDSet);
02224       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElem", &fElem);
02225       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFilename", &fFilename);
02226       R__insp.InspectMember(fFilename, "fFilename.");
02227       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFile", &fFile);
02228       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOldBytesRead", &fOldBytesRead);
02229       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPath", &fPath);
02230       R__insp.InspectMember(fPath, "fPath.");
02231       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDir", &fDir);
02232       R__insp.Inspect(R__cl, R__insp.GetParent(), "fElemFirst", &fElemFirst);
02233       R__insp.Inspect(R__cl, R__insp.GetParent(), "fElemNum", &fElemNum);
02234       R__insp.Inspect(R__cl, R__insp.GetParent(), "fElemCur", &fElemCur);
02235       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSel", &fSel);
02236       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFirst", &fFirst);
02237       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNum", &fNum);
02238       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCur", &fCur);
02239       R__insp.Inspect(R__cl, R__insp.GetParent(), "fStop", &fStop);
02240       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEventList", &fEventList);
02241       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEventListPos", &fEventListPos);
02242       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEntryList", &fEntryList);
02243       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEntryListPos", &fEntryListPos);
02244       TObject::ShowMembers(R__insp);
02245 }
02246 
02247 namespace ROOT {
02248    // Wrapper around operator delete
02249    static void delete_TEventIter(void *p) {
02250       delete ((::TEventIter*)p);
02251    }
02252    static void deleteArray_TEventIter(void *p) {
02253       delete [] ((::TEventIter*)p);
02254    }
02255    static void destruct_TEventIter(void *p) {
02256       typedef ::TEventIter current_t;
02257       ((current_t*)p)->~current_t();
02258    }
02259 } // end of namespace ROOT for class ::TEventIter
02260 
02261 //______________________________________________________________________________
02262 void TEventIterUnit::Streamer(TBuffer &R__b)
02263 {
02264    // Stream an object of class TEventIterUnit.
02265 
02266    if (R__b.IsReading()) {
02267       R__b.ReadClassBuffer(TEventIterUnit::Class(),this);
02268    } else {
02269       R__b.WriteClassBuffer(TEventIterUnit::Class(),this);
02270    }
02271 }
02272 
02273 //______________________________________________________________________________
02274 void TEventIterUnit::ShowMembers(TMemberInspector &R__insp)
02275 {
02276       // Inspect the data members of an object of class TEventIterUnit.
02277       TClass *R__cl = ::TEventIterUnit::IsA();
02278       if (R__cl || R__insp.IsA()) { }
02279       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNum", &fNum);
02280       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrent", &fCurrent);
02281       TEventIter::ShowMembers(R__insp);
02282 }
02283 
02284 namespace ROOT {
02285    // Wrappers around operator new
02286    static void *new_TEventIterUnit(void *p) {
02287       return  p ? new(p) ::TEventIterUnit : new ::TEventIterUnit;
02288    }
02289    static void *newArray_TEventIterUnit(Long_t nElements, void *p) {
02290       return p ? new(p) ::TEventIterUnit[nElements] : new ::TEventIterUnit[nElements];
02291    }
02292    // Wrapper around operator delete
02293    static void delete_TEventIterUnit(void *p) {
02294       delete ((::TEventIterUnit*)p);
02295    }
02296    static void deleteArray_TEventIterUnit(void *p) {
02297       delete [] ((::TEventIterUnit*)p);
02298    }
02299    static void destruct_TEventIterUnit(void *p) {
02300       typedef ::TEventIterUnit current_t;
02301       ((current_t*)p)->~current_t();
02302    }
02303 } // end of namespace ROOT for class ::TEventIterUnit
02304 
02305 //______________________________________________________________________________
02306 void TEventIterObj::Streamer(TBuffer &R__b)
02307 {
02308    // Stream an object of class TEventIterObj.
02309 
02310    if (R__b.IsReading()) {
02311       R__b.ReadClassBuffer(TEventIterObj::Class(),this);
02312    } else {
02313       R__b.WriteClassBuffer(TEventIterObj::Class(),this);
02314    }
02315 }
02316 
02317 //______________________________________________________________________________
02318 void TEventIterObj::ShowMembers(TMemberInspector &R__insp)
02319 {
02320       // Inspect the data members of an object of class TEventIterObj.
02321       TClass *R__cl = ::TEventIterObj::IsA();
02322       if (R__cl || R__insp.IsA()) { }
02323       R__insp.Inspect(R__cl, R__insp.GetParent(), "fClassName", &fClassName);
02324       R__insp.InspectMember(fClassName, "fClassName.");
02325       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fKeys", &fKeys);
02326       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNextKey", &fNextKey);
02327       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fObj", &fObj);
02328       TEventIter::ShowMembers(R__insp);
02329 }
02330 
02331 namespace ROOT {
02332    // Wrappers around operator new
02333    static void *new_TEventIterObj(void *p) {
02334       return  p ? new(p) ::TEventIterObj : new ::TEventIterObj;
02335    }
02336    static void *newArray_TEventIterObj(Long_t nElements, void *p) {
02337       return p ? new(p) ::TEventIterObj[nElements] : new ::TEventIterObj[nElements];
02338    }
02339    // Wrapper around operator delete
02340    static void delete_TEventIterObj(void *p) {
02341       delete ((::TEventIterObj*)p);
02342    }
02343    static void deleteArray_TEventIterObj(void *p) {
02344       delete [] ((::TEventIterObj*)p);
02345    }
02346    static void destruct_TEventIterObj(void *p) {
02347       typedef ::TEventIterObj current_t;
02348       ((current_t*)p)->~current_t();
02349    }
02350 } // end of namespace ROOT for class ::TEventIterObj
02351 
02352 //______________________________________________________________________________
02353 void TEventIterTree::Streamer(TBuffer &R__b)
02354 {
02355    // Stream an object of class TEventIterTree.
02356 
02357    if (R__b.IsReading()) {
02358       R__b.ReadClassBuffer(TEventIterTree::Class(),this);
02359    } else {
02360       R__b.WriteClassBuffer(TEventIterTree::Class(),this);
02361    }
02362 }
02363 
02364 //______________________________________________________________________________
02365 void TEventIterTree::ShowMembers(TMemberInspector &R__insp)
02366 {
02367       // Inspect the data members of an object of class TEventIterTree.
02368       TClass *R__cl = ::TEventIterTree::IsA();
02369       if (R__cl || R__insp.IsA()) { }
02370       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTreeName", &fTreeName);
02371       R__insp.InspectMember(fTreeName, "fTreeName.");
02372       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTree", &fTree);
02373       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTreeCache", &fTreeCache);
02374       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTreeCacheIsLearning", &fTreeCacheIsLearning);
02375       R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseTreeCache", &fUseTreeCache);
02376       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCacheSize", &fCacheSize);
02377       R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseParallelUnzip", &fUseParallelUnzip);
02378       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFileTrees", &fFileTrees);
02379       TEventIter::ShowMembers(R__insp);
02380 }
02381 
02382 namespace ROOT {
02383    // Wrappers around operator new
02384    static void *new_TEventIterTree(void *p) {
02385       return  p ? new(p) ::TEventIterTree : new ::TEventIterTree;
02386    }
02387    static void *newArray_TEventIterTree(Long_t nElements, void *p) {
02388       return p ? new(p) ::TEventIterTree[nElements] : new ::TEventIterTree[nElements];
02389    }
02390    // Wrapper around operator delete
02391    static void delete_TEventIterTree(void *p) {
02392       delete ((::TEventIterTree*)p);
02393    }
02394    static void deleteArray_TEventIterTree(void *p) {
02395       delete [] ((::TEventIterTree*)p);
02396    }
02397    static void destruct_TEventIterTree(void *p) {
02398       typedef ::TEventIterTree current_t;
02399       ((current_t*)p)->~current_t();
02400    }
02401 } // end of namespace ROOT for class ::TEventIterTree
02402 
02403 //______________________________________________________________________________
02404 void TPerfStats::Streamer(TBuffer &R__b)
02405 {
02406    // Stream an object of class TPerfStats.
02407 
02408    TVirtualPerfStats::Streamer(R__b);
02409 }
02410 
02411 //______________________________________________________________________________
02412 void TPerfStats::ShowMembers(TMemberInspector &R__insp)
02413 {
02414       // Inspect the data members of an object of class TPerfStats.
02415       TClass *R__cl = ::TPerfStats::IsA();
02416       if (R__cl || R__insp.IsA()) { }
02417       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrace", &fTrace);
02418       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTzero", &fTzero);
02419       R__insp.InspectMember(fTzero, "fTzero.");
02420       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPerfEvent", &fPerfEvent);
02421       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPacketsHist", &fPacketsHist);
02422       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEventsHist", &fEventsHist);
02423       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNodeHist", &fNodeHist);
02424       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLatencyHist", &fLatencyHist);
02425       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProcTimeHist", &fProcTimeHist);
02426       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCpuTimeHist", &fCpuTimeHist);
02427       R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytesRead", &fBytesRead);
02428       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotCpuTime", &fTotCpuTime);
02429       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotBytesRead", &fTotBytesRead);
02430       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotEvents", &fTotEvents);
02431       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumEvents", &fNumEvents);
02432       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaves", &fSlaves);
02433       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDoHist", &fDoHist);
02434       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDoTrace", &fDoTrace);
02435       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDoTraceRate", &fDoTraceRate);
02436       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDoSlaveTrace", &fDoSlaveTrace);
02437       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDoQuota", &fDoQuota);
02438       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMonitorPerPacket", &fMonitorPerPacket);
02439       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMonitoringWriter", &fMonitoringWriter);
02440       TVirtualPerfStats::ShowMembers(R__insp);
02441 }
02442 
02443 namespace ROOT {
02444    // Wrapper around operator delete
02445    static void delete_TPerfStats(void *p) {
02446       delete ((::TPerfStats*)p);
02447    }
02448    static void deleteArray_TPerfStats(void *p) {
02449       delete [] ((::TPerfStats*)p);
02450    }
02451    static void destruct_TPerfStats(void *p) {
02452       typedef ::TPerfStats current_t;
02453       ((current_t*)p)->~current_t();
02454    }
02455    // Wrapper around a custom streamer member function.
02456    static void streamer_TPerfStats(TBuffer &buf, void *obj) {
02457       ((::TPerfStats*)obj)->::TPerfStats::Streamer(buf);
02458    }
02459 } // end of namespace ROOT for class ::TPerfStats
02460 
02461 //______________________________________________________________________________
02462 void TPerfEvent::Streamer(TBuffer &R__b)
02463 {
02464    // Stream an object of class TPerfEvent.
02465 
02466    if (R__b.IsReading()) {
02467       R__b.ReadClassBuffer(TPerfEvent::Class(),this);
02468    } else {
02469       R__b.WriteClassBuffer(TPerfEvent::Class(),this);
02470    }
02471 }
02472 
02473 //______________________________________________________________________________
02474 void TPerfEvent::ShowMembers(TMemberInspector &R__insp)
02475 {
02476       // Inspect the data members of an object of class TPerfEvent.
02477       TClass *R__cl = ::TPerfEvent::IsA();
02478       if (R__cl || R__insp.IsA()) { }
02479       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvtNode", &fEvtNode);
02480       R__insp.InspectMember(fEvtNode, "fEvtNode.");
02481       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimeStamp", &fTimeStamp);
02482       R__insp.InspectMember(fTimeStamp, "fTimeStamp.");
02483       R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
02484       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlaveName", &fSlaveName);
02485       R__insp.InspectMember(fSlaveName, "fSlaveName.");
02486       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNodeName", &fNodeName);
02487       R__insp.InspectMember(fNodeName, "fNodeName.");
02488       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFileName", &fFileName);
02489       R__insp.InspectMember(fFileName, "fFileName.");
02490       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFileClass", &fFileClass);
02491       R__insp.InspectMember(fFileClass, "fFileClass.");
02492       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSlave", &fSlave);
02493       R__insp.InspectMember(fSlave, "fSlave.");
02494       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEventsProcessed", &fEventsProcessed);
02495       R__insp.Inspect(R__cl, R__insp.GetParent(), "fBytesRead", &fBytesRead);
02496       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLen", &fLen);
02497       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLatency", &fLatency);
02498       R__insp.Inspect(R__cl, R__insp.GetParent(), "fProcTime", &fProcTime);
02499       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCpuTime", &fCpuTime);
02500       R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsStart", &fIsStart);
02501       R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsOk", &fIsOk);
02502       TObject::ShowMembers(R__insp);
02503 }
02504 
02505 namespace ROOT {
02506    // Wrappers around operator new
02507    static void *new_TPerfEvent(void *p) {
02508       return  p ? new(p) ::TPerfEvent : new ::TPerfEvent;
02509    }
02510    static void *newArray_TPerfEvent(Long_t nElements, void *p) {
02511       return p ? new(p) ::TPerfEvent[nElements] : new ::TPerfEvent[nElements];
02512    }
02513    // Wrapper around operator delete
02514    static void delete_TPerfEvent(void *p) {
02515       delete ((::TPerfEvent*)p);
02516    }
02517    static void deleteArray_TPerfEvent(void *p) {
02518       delete [] ((::TPerfEvent*)p);
02519    }
02520    static void destruct_TPerfEvent(void *p) {
02521       typedef ::TPerfEvent current_t;
02522       ((current_t*)p)->~current_t();
02523    }
02524 } // end of namespace ROOT for class ::TPerfEvent
02525 
02526 //______________________________________________________________________________
02527 void TProofLimitsFinder::Streamer(TBuffer &R__b)
02528 {
02529    // Stream an object of class TProofLimitsFinder.
02530 
02531    THLimitsFinder::Streamer(R__b);
02532 }
02533 
02534 //______________________________________________________________________________
02535 void TProofLimitsFinder::ShowMembers(TMemberInspector &R__insp)
02536 {
02537       // Inspect the data members of an object of class TProofLimitsFinder.
02538       TClass *R__cl = ::TProofLimitsFinder::IsA();
02539       if (R__cl || R__insp.IsA()) { }
02540       THLimitsFinder::ShowMembers(R__insp);
02541 }
02542 
02543 namespace ROOT {
02544    // Wrappers around operator new
02545    static void *new_TProofLimitsFinder(void *p) {
02546       return  p ? new(p) ::TProofLimitsFinder : new ::TProofLimitsFinder;
02547    }
02548    static void *newArray_TProofLimitsFinder(Long_t nElements, void *p) {
02549       return p ? new(p) ::TProofLimitsFinder[nElements] : new ::TProofLimitsFinder[nElements];
02550    }
02551    // Wrapper around operator delete
02552    static void delete_TProofLimitsFinder(void *p) {
02553       delete ((::TProofLimitsFinder*)p);
02554    }
02555    static void deleteArray_TProofLimitsFinder(void *p) {
02556       delete [] ((::TProofLimitsFinder*)p);
02557    }
02558    static void destruct_TProofLimitsFinder(void *p) {
02559       typedef ::TProofLimitsFinder current_t;
02560       ((current_t*)p)->~current_t();
02561    }
02562    // Wrapper around a custom streamer member function.
02563    static void streamer_TProofLimitsFinder(TBuffer &buf, void *obj) {
02564       ((::TProofLimitsFinder*)obj)->::TProofLimitsFinder::Streamer(buf);
02565    }
02566 } // end of namespace ROOT for class ::TProofLimitsFinder
02567 
02568 //______________________________________________________________________________
02569 void TDrawFeedback::Streamer(TBuffer &R__b)
02570 {
02571    // Stream an object of class TDrawFeedback.
02572 
02573    if (R__b.IsReading()) {
02574       R__b.ReadClassBuffer(TDrawFeedback::Class(),this);
02575    } else {
02576       R__b.WriteClassBuffer(TDrawFeedback::Class(),this);
02577    }
02578 }
02579 
02580 //______________________________________________________________________________
02581 void TDrawFeedback::ShowMembers(TMemberInspector &R__insp)
02582 {
02583       // Inspect the data members of an object of class TDrawFeedback.
02584       TClass *R__cl = ::TDrawFeedback::IsA();
02585       if (R__cl || R__insp.IsA()) { }
02586       R__insp.Inspect(R__cl, R__insp.GetParent(), "fAll", &fAll);
02587       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNames", &fNames);
02588       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOption", &fOption);
02589       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fProof", &fProof);
02590       TObject::ShowMembers(R__insp);
02591       TQObject::ShowMembers(R__insp);
02592 }
02593 
02594 namespace ROOT {
02595    // Wrappers around operator new
02596    static void *new_TDrawFeedback(void *p) {
02597       return  p ? new(p) ::TDrawFeedback : new ::TDrawFeedback;
02598    }
02599    static void *newArray_TDrawFeedback(Long_t nElements, void *p) {
02600       return p ? new(p) ::TDrawFeedback[nElements] : new ::TDrawFeedback[nElements];
02601    }
02602    // Wrapper around operator delete
02603    static void delete_TDrawFeedback(void *p) {
02604       delete ((::TDrawFeedback*)p);
02605    }
02606    static void deleteArray_TDrawFeedback(void *p) {
02607       delete [] ((::TDrawFeedback*)p);
02608    }
02609    static void destruct_TDrawFeedback(void *p) {
02610       typedef ::TDrawFeedback current_t;
02611       ((current_t*)p)->~current_t();
02612    }
02613 } // end of namespace ROOT for class ::TDrawFeedback
02614 
02615 //______________________________________________________________________________
02616 void TStatus::Streamer(TBuffer &R__b)
02617 {
02618    // Stream an object of class TStatus.
02619 
02620    if (R__b.IsReading()) {
02621       R__b.ReadClassBuffer(TStatus::Class(),this);
02622    } else {
02623       R__b.WriteClassBuffer(TStatus::Class(),this);
02624    }
02625 }
02626 
02627 //______________________________________________________________________________
02628 void TStatus::ShowMembers(TMemberInspector &R__insp)
02629 {
02630       // Inspect the data members of an object of class TStatus.
02631       TClass *R__cl = ::TStatus::IsA();
02632       if (R__cl || R__insp.IsA()) { }
02633       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMsgs", (void*)&fMsgs);
02634       R__insp.InspectMember("TStatus::MsgSet_t", (void*)&fMsgs, "fMsgs.", false);
02635       R__insp.Inspect(R__cl, R__insp.GetParent(), "fIter", (void*)&fIter);
02636       R__insp.InspectMember("TStatus::MsgIter_t", (void*)&fIter, "fIter.", true);
02637       TNamed::ShowMembers(R__insp);
02638 }
02639 
02640 namespace ROOT {
02641    // Wrappers around operator new
02642    static void *new_TStatus(void *p) {
02643       return  p ? new(p) ::TStatus : new ::TStatus;
02644    }
02645    static void *newArray_TStatus(Long_t nElements, void *p) {
02646       return p ? new(p) ::TStatus[nElements] : new ::TStatus[nElements];
02647    }
02648    // Wrapper around operator delete
02649    static void delete_TStatus(void *p) {
02650       delete ((::TStatus*)p);
02651    }
02652    static void deleteArray_TStatus(void *p) {
02653       delete [] ((::TStatus*)p);
02654    }
02655    static void destruct_TStatus(void *p) {
02656       typedef ::TStatus current_t;
02657       ((current_t*)p)->~current_t();
02658    }
02659 } // end of namespace ROOT for class ::TStatus
02660 
02661 //______________________________________________________________________________
02662 void TFileMerger::Streamer(TBuffer &R__b)
02663 {
02664    // Stream an object of class TFileMerger.
02665 
02666    if (R__b.IsReading()) {
02667       R__b.ReadClassBuffer(TFileMerger::Class(),this);
02668    } else {
02669       R__b.WriteClassBuffer(TFileMerger::Class(),this);
02670    }
02671 }
02672 
02673 //______________________________________________________________________________
02674 void TFileMerger::ShowMembers(TMemberInspector &R__insp)
02675 {
02676       // Inspect the data members of an object of class TFileMerger.
02677       TClass *R__cl = ::TFileMerger::IsA();
02678       if (R__cl || R__insp.IsA()) { }
02679       R__insp.Inspect(R__cl, R__insp.GetParent(), "fWatch", &fWatch);
02680       R__insp.InspectMember(fWatch, "fWatch.");
02681       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFileList", &fFileList);
02682       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOutputFile", &fOutputFile);
02683       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOutputFilename", &fOutputFilename);
02684       R__insp.InspectMember(fOutputFilename, "fOutputFilename.");
02685       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOutputFilename1", &fOutputFilename1);
02686       R__insp.InspectMember(fOutputFilename1, "fOutputFilename1.");
02687       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFastMethod", &fFastMethod);
02688       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNoTrees", &fNoTrees);
02689       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLocal", &fLocal);
02690       R__insp.Inspect(R__cl, R__insp.GetParent(), "fHistoOneGo", &fHistoOneGo);
02691       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMergeList", &fMergeList);
02692       TObject::ShowMembers(R__insp);
02693 }
02694 
02695 namespace ROOT {
02696    // Wrappers around operator new
02697    static void *new_TFileMerger(void *p) {
02698       return  p ? new(p) ::TFileMerger : new ::TFileMerger;
02699    }
02700    static void *newArray_TFileMerger(Long_t nElements, void *p) {
02701       return p ? new(p) ::TFileMerger[nElements] : new ::TFileMerger[nElements];
02702    }
02703    // Wrapper around operator delete
02704    static void delete_TFileMerger(void *p) {
02705       delete ((::TFileMerger*)p);
02706    }
02707    static void deleteArray_TFileMerger(void *p) {
02708       delete [] ((::TFileMerger*)p);
02709    }
02710    static void destruct_TFileMerger(void *p) {
02711       typedef ::TFileMerger current_t;
02712       ((current_t*)p)->~current_t();
02713    }
02714 } // end of namespace ROOT for class ::TFileMerger
02715 
02716 //______________________________________________________________________________
02717 void TProofOutputFile::Streamer(TBuffer &R__b)
02718 {
02719    // Stream an object of class TProofOutputFile.
02720 
02721    if (R__b.IsReading()) {
02722       R__b.ReadClassBuffer(TProofOutputFile::Class(),this);
02723    } else {
02724       R__b.WriteClassBuffer(TProofOutputFile::Class(),this);
02725    }
02726 }
02727 
02728 //______________________________________________________________________________
02729 void TProofOutputFile::ShowMembers(TMemberInspector &R__insp)
02730 {
02731       // Inspect the data members of an object of class TProofOutputFile.
02732       TClass *R__cl = ::TProofOutputFile::IsA();
02733       if (R__cl || R__insp.IsA()) { }
02734       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDir", &fDir);
02735       R__insp.InspectMember(fDir, "fDir.");
02736       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRawDir", &fRawDir);
02737       R__insp.InspectMember(fRawDir, "fRawDir.");
02738       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFileName", &fFileName);
02739       R__insp.InspectMember(fFileName, "fFileName.");
02740       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptionsAnchor", &fOptionsAnchor);
02741       R__insp.InspectMember(fOptionsAnchor, "fOptionsAnchor.");
02742       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOutputFileName", &fOutputFileName);
02743       R__insp.InspectMember(fOutputFileName, "fOutputFileName.");
02744       R__insp.Inspect(R__cl, R__insp.GetParent(), "fWorkerOrdinal", &fWorkerOrdinal);
02745       R__insp.InspectMember(fWorkerOrdinal, "fWorkerOrdinal.");
02746       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLocalHost", &fLocalHost);
02747       R__insp.InspectMember(fLocalHost, "fLocalHost.");
02748       R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsLocal", &fIsLocal);
02749       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMerged", &fMerged);
02750       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRunType", &fRunType);
02751       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTypeOpt", &fTypeOpt);
02752       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataSet", &fDataSet);
02753       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMerger", &fMerger);
02754       TNamed::ShowMembers(R__insp);
02755 }
02756 
02757 namespace ROOT {
02758    // Wrappers around operator new
02759    static void *new_TProofOutputFile(void *p) {
02760       return  p ? new(p) ::TProofOutputFile : new ::TProofOutputFile;
02761    }
02762    static void *newArray_TProofOutputFile(Long_t nElements, void *p) {
02763       return p ? new(p) ::TProofOutputFile[nElements] : new ::TProofOutputFile[nElements];
02764    }
02765    // Wrapper around operator delete
02766    static void delete_TProofOutputFile(void *p) {
02767       delete ((::TProofOutputFile*)p);
02768    }
02769    static void deleteArray_TProofOutputFile(void *p) {
02770       delete [] ((::TProofOutputFile*)p);
02771    }
02772    static void destruct_TProofOutputFile(void *p) {
02773       typedef ::TProofOutputFile current_t;
02774       ((current_t*)p)->~current_t();
02775    }
02776 } // end of namespace ROOT for class ::TProofOutputFile
02777 
02778 //______________________________________________________________________________
02779 void TOutputListSelectorDataMap::Streamer(TBuffer &R__b)
02780 {
02781    // Stream an object of class TOutputListSelectorDataMap.
02782 
02783    if (R__b.IsReading()) {
02784       R__b.ReadClassBuffer(TOutputListSelectorDataMap::Class(),this);
02785    } else {
02786       R__b.WriteClassBuffer(TOutputListSelectorDataMap::Class(),this);
02787    }
02788 }
02789 
02790 //______________________________________________________________________________
02791 void TOutputListSelectorDataMap::ShowMembers(TMemberInspector &R__insp)
02792 {
02793       // Inspect the data members of an object of class TOutputListSelectorDataMap.
02794       TClass *R__cl = ::TOutputListSelectorDataMap::IsA();
02795       if (R__cl || R__insp.IsA()) { }
02796       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMap", &fMap);
02797       TObject::ShowMembers(R__insp);
02798 }
02799 
02800 namespace ROOT {
02801    // Wrappers around operator new
02802    static void *new_TOutputListSelectorDataMap(void *p) {
02803       return  p ? new(p) ::TOutputListSelectorDataMap : new ::TOutputListSelectorDataMap;
02804    }
02805    static void *newArray_TOutputListSelectorDataMap(Long_t nElements, void *p) {
02806       return p ? new(p) ::TOutputListSelectorDataMap[nElements] : new ::TOutputListSelectorDataMap[nElements];
02807    }
02808    // Wrapper around operator delete
02809    static void delete_TOutputListSelectorDataMap(void *p) {
02810       delete ((::TOutputListSelectorDataMap*)p);
02811    }
02812    static void deleteArray_TOutputListSelectorDataMap(void *p) {
02813       delete [] ((::TOutputListSelectorDataMap*)p);
02814    }
02815    static void destruct_TOutputListSelectorDataMap(void *p) {
02816       typedef ::TOutputListSelectorDataMap current_t;
02817       ((current_t*)p)->~current_t();
02818    }
02819 } // end of namespace ROOT for class ::TOutputListSelectorDataMap
02820 
02821 namespace ROOT {
02822    void setlEstringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
02823    static void setlEstringgR_Dictionary();
02824    static void *new_setlEstringgR(void *p = 0);
02825    static void *newArray_setlEstringgR(Long_t size, void *p);
02826    static void delete_setlEstringgR(void *p);
02827    static void deleteArray_setlEstringgR(void *p);
02828    static void destruct_setlEstringgR(void *p);
02829 
02830    // Function generating the singleton type initializer
02831    static TGenericClassInfo *GenerateInitInstanceLocal(const set<string>*)
02832    {
02833       set<string> *ptr = 0;
02834       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(set<string>),0);
02835       static ::ROOT::TGenericClassInfo 
02836          instance("set<string>", -2, "prec_stl/set", 49,
02837                   typeid(set<string>), DefineBehavior(ptr, ptr),
02838                   0, &setlEstringgR_Dictionary, isa_proxy, 0,
02839                   sizeof(set<string>) );
02840       instance.SetNew(&new_setlEstringgR);
02841       instance.SetNewArray(&newArray_setlEstringgR);
02842       instance.SetDelete(&delete_setlEstringgR);
02843       instance.SetDeleteArray(&deleteArray_setlEstringgR);
02844       instance.SetDestructor(&destruct_setlEstringgR);
02845       instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Insert< set<string> >()));
02846       return &instance;
02847    }
02848    // Static variable to force the class initialization
02849    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const set<string>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
02850 
02851    // Dictionary for non-ClassDef classes
02852    static void setlEstringgR_Dictionary() {
02853       ::ROOT::GenerateInitInstanceLocal((const set<string>*)0x0)->GetClass();
02854    }
02855 
02856 } // end of namespace ROOT
02857 
02858 namespace ROOT {
02859    // Wrappers around operator new
02860    static void *new_setlEstringgR(void *p) {
02861       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) set<string> : new set<string>;
02862    }
02863    static void *newArray_setlEstringgR(Long_t nElements, void *p) {
02864       return p ? ::new((::ROOT::TOperatorNewHelper*)p) set<string>[nElements] : new set<string>[nElements];
02865    }
02866    // Wrapper around operator delete
02867    static void delete_setlEstringgR(void *p) {
02868       delete ((set<string>*)p);
02869    }
02870    static void deleteArray_setlEstringgR(void *p) {
02871       delete [] ((set<string>*)p);
02872    }
02873    static void destruct_setlEstringgR(void *p) {
02874       typedef set<string> current_t;
02875       ((current_t*)p)->~current_t();
02876    }
02877 } // end of namespace ROOT for class set<string>
02878 
02879 /********************************************************
02880 * proof/proofplayer/src/G__ProofPlayer.cxx
02881 * CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED
02882 *          FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().
02883 *          CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.
02884 ********************************************************/
02885 
02886 #ifdef G__MEMTEST
02887 #undef malloc
02888 #undef free
02889 #endif
02890 
02891 #if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
02892 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
02893 #endif
02894 
02895 extern "C" void G__cpp_reset_tagtableG__ProofPlayer();
02896 
02897 extern "C" void G__set_cpp_environmentG__ProofPlayer() {
02898   G__add_compiledheader("TObject.h");
02899   G__add_compiledheader("TMemberInspector.h");
02900   G__add_compiledheader("TDrawFeedback.h");
02901   G__add_compiledheader("TEventIter.h");
02902   G__add_compiledheader("TFileMerger.h");
02903   G__add_compiledheader("TOutputListSelectorDataMap.h");
02904   G__add_compiledheader("TPacketizerAdaptive.h");
02905   G__add_compiledheader("TPacketizerFile.h");
02906   G__add_compiledheader("TPacketizer.h");
02907   G__add_compiledheader("TPacketizerMulti.h");
02908   G__add_compiledheader("TPacketizerUnit.h");
02909   G__add_compiledheader("TPerfStats.h");
02910   G__add_compiledheader("TProofLimitsFinder.h");
02911   G__add_compiledheader("TProofOutputFile.h");
02912   G__add_compiledheader("TProofPlayer.h");
02913   G__add_compiledheader("TProofPlayerLite.h");
02914   G__add_compiledheader("TStatus.h");
02915   G__add_compiledheader("TVirtualPacketizer.h");
02916   G__cpp_reset_tagtableG__ProofPlayer();
02917 }
02918 #include <new>
02919 extern "C" int G__cpp_dllrevG__ProofPlayer() { return(30051515); }
02920 
02921 /*********************************************************
02922 * Member function Interface Method
02923 *********************************************************/
02924 
02925 /* TDrawFeedback */
02926 static int G__G__ProofPlayer_116_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02927 {
02928    TDrawFeedback* p = NULL;
02929    char* gvp = (char*) G__getgvp();
02930    switch (libp->paran) {
02931    case 2:
02932      //m: 2
02933      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02934        p = new TDrawFeedback((TProof*) G__int(libp->para[0]), (TSeqCollection*) G__int(libp->para[1]));
02935      } else {
02936        p = new((void*) gvp) TDrawFeedback((TProof*) G__int(libp->para[0]), (TSeqCollection*) G__int(libp->para[1]));
02937      }
02938      break;
02939    case 1:
02940      //m: 1
02941      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02942        p = new TDrawFeedback((TProof*) G__int(libp->para[0]));
02943      } else {
02944        p = new((void*) gvp) TDrawFeedback((TProof*) G__int(libp->para[0]));
02945      }
02946      break;
02947    case 0:
02948      int n = G__getaryconstruct();
02949      if (n) {
02950        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02951          p = new TDrawFeedback[n];
02952        } else {
02953          p = new((void*) gvp) TDrawFeedback[n];
02954        }
02955      } else {
02956        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02957          p = new TDrawFeedback;
02958        } else {
02959          p = new((void*) gvp) TDrawFeedback;
02960        }
02961      }
02962      break;
02963    }
02964    result7->obj.i = (long) p;
02965    result7->ref = (long) p;
02966    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TDrawFeedback));
02967    return(1 || funcname || hash || result7 || libp) ;
02968 }
02969 
02970 static int G__G__ProofPlayer_116_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02971 {
02972       ((TDrawFeedback*) G__getstructoffset())->Feedback((TList*) G__int(libp->para[0]));
02973       G__setnull(result7);
02974    return(1 || funcname || hash || result7 || libp) ;
02975 }
02976 
02977 static int G__G__ProofPlayer_116_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02978 {
02979       ((TDrawFeedback*) G__getstructoffset())->SetOption((Option_t*) G__int(libp->para[0]));
02980       G__setnull(result7);
02981    return(1 || funcname || hash || result7 || libp) ;
02982 }
02983 
02984 static int G__G__ProofPlayer_116_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02985 {
02986       G__letint(result7, 85, (long) TDrawFeedback::Class());
02987    return(1 || funcname || hash || result7 || libp) ;
02988 }
02989 
02990 static int G__G__ProofPlayer_116_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02991 {
02992       G__letint(result7, 67, (long) TDrawFeedback::Class_Name());
02993    return(1 || funcname || hash || result7 || libp) ;
02994 }
02995 
02996 static int G__G__ProofPlayer_116_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02997 {
02998       G__letint(result7, 115, (long) TDrawFeedback::Class_Version());
02999    return(1 || funcname || hash || result7 || libp) ;
03000 }
03001 
03002 static int G__G__ProofPlayer_116_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03003 {
03004       TDrawFeedback::Dictionary();
03005       G__setnull(result7);
03006    return(1 || funcname || hash || result7 || libp) ;
03007 }
03008 
03009 static int G__G__ProofPlayer_116_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03010 {
03011       ((TDrawFeedback*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
03012       G__setnull(result7);
03013    return(1 || funcname || hash || result7 || libp) ;
03014 }
03015 
03016 static int G__G__ProofPlayer_116_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03017 {
03018       G__letint(result7, 67, (long) TDrawFeedback::DeclFileName());
03019    return(1 || funcname || hash || result7 || libp) ;
03020 }
03021 
03022 static int G__G__ProofPlayer_116_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03023 {
03024       G__letint(result7, 105, (long) TDrawFeedback::ImplFileLine());
03025    return(1 || funcname || hash || result7 || libp) ;
03026 }
03027 
03028 static int G__G__ProofPlayer_116_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03029 {
03030       G__letint(result7, 67, (long) TDrawFeedback::ImplFileName());
03031    return(1 || funcname || hash || result7 || libp) ;
03032 }
03033 
03034 static int G__G__ProofPlayer_116_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03035 {
03036       G__letint(result7, 105, (long) TDrawFeedback::DeclFileLine());
03037    return(1 || funcname || hash || result7 || libp) ;
03038 }
03039 
03040 // automatic destructor
03041 typedef TDrawFeedback G__TTDrawFeedback;
03042 static int G__G__ProofPlayer_116_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03043 {
03044    char* gvp = (char*) G__getgvp();
03045    long soff = G__getstructoffset();
03046    int n = G__getaryconstruct();
03047    //
03048    //has_a_delete: 1
03049    //has_own_delete1arg: 0
03050    //has_own_delete2arg: 0
03051    //
03052    if (!soff) {
03053      return(1);
03054    }
03055    if (n) {
03056      if (gvp == (char*)G__PVOID) {
03057        delete[] (TDrawFeedback*) soff;
03058      } else {
03059        G__setgvp((long) G__PVOID);
03060        for (int i = n - 1; i >= 0; --i) {
03061          ((TDrawFeedback*) (soff+(sizeof(TDrawFeedback)*i)))->~G__TTDrawFeedback();
03062        }
03063        G__setgvp((long)gvp);
03064      }
03065    } else {
03066      if (gvp == (char*)G__PVOID) {
03067        delete (TDrawFeedback*) soff;
03068      } else {
03069        G__setgvp((long) G__PVOID);
03070        ((TDrawFeedback*) (soff))->~G__TTDrawFeedback();
03071        G__setgvp((long)gvp);
03072      }
03073    }
03074    G__setnull(result7);
03075    return(1 || funcname || hash || result7 || libp) ;
03076 }
03077 
03078 
03079 /* TEventIter */
03080 static int G__G__ProofPlayer_126_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03081 {
03082       G__letLonglong(result7, 110, (G__int64) ((TEventIter*) G__getstructoffset())->GetCacheSize());
03083    return(1 || funcname || hash || result7 || libp) ;
03084 }
03085 
03086 static int G__G__ProofPlayer_126_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03087 {
03088       G__letint(result7, 105, (long) ((TEventIter*) G__getstructoffset())->GetLearnEntries());
03089    return(1 || funcname || hash || result7 || libp) ;
03090 }
03091 
03092 static int G__G__ProofPlayer_126_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03093 {
03094       G__letLonglong(result7, 110, (G__int64) ((TEventIter*) G__getstructoffset())->GetNextEvent());
03095    return(1 || funcname || hash || result7 || libp) ;
03096 }
03097 
03098 static int G__G__ProofPlayer_126_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03099 {
03100       ((TEventIter*) G__getstructoffset())->StopProcess((Bool_t) G__int(libp->para[0]));
03101       G__setnull(result7);
03102    return(1 || funcname || hash || result7 || libp) ;
03103 }
03104 
03105 static int G__G__ProofPlayer_126_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03106 {
03107       G__letint(result7, 85, (long) TEventIter::Create((TDSet*) G__int(libp->para[0]), (TSelector*) G__int(libp->para[1])
03108 , (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])));
03109    return(1 || funcname || hash || result7 || libp) ;
03110 }
03111 
03112 static int G__G__ProofPlayer_126_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03113 {
03114       G__letint(result7, 85, (long) TEventIter::Class());
03115    return(1 || funcname || hash || result7 || libp) ;
03116 }
03117 
03118 static int G__G__ProofPlayer_126_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03119 {
03120       G__letint(result7, 67, (long) TEventIter::Class_Name());
03121    return(1 || funcname || hash || result7 || libp) ;
03122 }
03123 
03124 static int G__G__ProofPlayer_126_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03125 {
03126       G__letint(result7, 115, (long) TEventIter::Class_Version());
03127    return(1 || funcname || hash || result7 || libp) ;
03128 }
03129 
03130 static int G__G__ProofPlayer_126_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03131 {
03132       TEventIter::Dictionary();
03133       G__setnull(result7);
03134    return(1 || funcname || hash || result7 || libp) ;
03135 }
03136 
03137 static int G__G__ProofPlayer_126_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03138 {
03139       ((TEventIter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
03140       G__setnull(result7);
03141    return(1 || funcname || hash || result7 || libp) ;
03142 }
03143 
03144 static int G__G__ProofPlayer_126_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03145 {
03146       G__letint(result7, 67, (long) TEventIter::DeclFileName());
03147    return(1 || funcname || hash || result7 || libp) ;
03148 }
03149 
03150 static int G__G__ProofPlayer_126_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03151 {
03152       G__letint(result7, 105, (long) TEventIter::ImplFileLine());
03153    return(1 || funcname || hash || result7 || libp) ;
03154 }
03155 
03156 static int G__G__ProofPlayer_126_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03157 {
03158       G__letint(result7, 67, (long) TEventIter::ImplFileName());
03159    return(1 || funcname || hash || result7 || libp) ;
03160 }
03161 
03162 static int G__G__ProofPlayer_126_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03163 {
03164       G__letint(result7, 105, (long) TEventIter::DeclFileLine());
03165    return(1 || funcname || hash || result7 || libp) ;
03166 }
03167 
03168 // automatic destructor
03169 typedef TEventIter G__TTEventIter;
03170 static int G__G__ProofPlayer_126_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03171 {
03172    char* gvp = (char*) G__getgvp();
03173    long soff = G__getstructoffset();
03174    int n = G__getaryconstruct();
03175    //
03176    //has_a_delete: 1
03177    //has_own_delete1arg: 0
03178    //has_own_delete2arg: 0
03179    //
03180    if (!soff) {
03181      return(1);
03182    }
03183    if (n) {
03184      if (gvp == (char*)G__PVOID) {
03185        delete[] (TEventIter*) soff;
03186      } else {
03187        G__setgvp((long) G__PVOID);
03188        for (int i = n - 1; i >= 0; --i) {
03189          ((TEventIter*) (soff+(sizeof(TEventIter)*i)))->~G__TTEventIter();
03190        }
03191        G__setgvp((long)gvp);
03192      }
03193    } else {
03194      if (gvp == (char*)G__PVOID) {
03195        delete (TEventIter*) soff;
03196      } else {
03197        G__setgvp((long) G__PVOID);
03198        ((TEventIter*) (soff))->~G__TTEventIter();
03199        G__setgvp((long)gvp);
03200      }
03201    }
03202    G__setnull(result7);
03203    return(1 || funcname || hash || result7 || libp) ;
03204 }
03205 
03206 // automatic assignment operator
03207 static int G__G__ProofPlayer_126_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03208 {
03209    TEventIter* dest = (TEventIter*) G__getstructoffset();
03210    *dest = *(TEventIter*) libp->para[0].ref;
03211    const TEventIter& obj = *dest;
03212    result7->ref = (long) (&obj);
03213    result7->obj.i = (long) (&obj);
03214    return(1 || funcname || hash || result7 || libp) ;
03215 }
03216 
03217 
03218 /* TEventIterUnit */
03219 static int G__G__ProofPlayer_127_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03220 {
03221    TEventIterUnit* p = NULL;
03222    char* gvp = (char*) G__getgvp();
03223    int n = G__getaryconstruct();
03224    if (n) {
03225      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03226        p = new TEventIterUnit[n];
03227      } else {
03228        p = new((void*) gvp) TEventIterUnit[n];
03229      }
03230    } else {
03231      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03232        p = new TEventIterUnit;
03233      } else {
03234        p = new((void*) gvp) TEventIterUnit;
03235      }
03236    }
03237    result7->obj.i = (long) p;
03238    result7->ref = (long) p;
03239    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit));
03240    return(1 || funcname || hash || result7 || libp) ;
03241 }
03242 
03243 static int G__G__ProofPlayer_127_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03244 {
03245    TEventIterUnit* p = NULL;
03246    char* gvp = (char*) G__getgvp();
03247    //m: 3
03248    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03249      p = new TEventIterUnit(
03250 (TDSet*) G__int(libp->para[0]), (TSelector*) G__int(libp->para[1])
03251 , (Long64_t) G__Longlong(libp->para[2]));
03252    } else {
03253      p = new((void*) gvp) TEventIterUnit(
03254 (TDSet*) G__int(libp->para[0]), (TSelector*) G__int(libp->para[1])
03255 , (Long64_t) G__Longlong(libp->para[2]));
03256    }
03257    result7->obj.i = (long) p;
03258    result7->ref = (long) p;
03259    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit));
03260    return(1 || funcname || hash || result7 || libp) ;
03261 }
03262 
03263 static int G__G__ProofPlayer_127_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03264 {
03265       G__letint(result7, 85, (long) TEventIterUnit::Class());
03266    return(1 || funcname || hash || result7 || libp) ;
03267 }
03268 
03269 static int G__G__ProofPlayer_127_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03270 {
03271       G__letint(result7, 67, (long) TEventIterUnit::Class_Name());
03272    return(1 || funcname || hash || result7 || libp) ;
03273 }
03274 
03275 static int G__G__ProofPlayer_127_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03276 {
03277       G__letint(result7, 115, (long) TEventIterUnit::Class_Version());
03278    return(1 || funcname || hash || result7 || libp) ;
03279 }
03280 
03281 static int G__G__ProofPlayer_127_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03282 {
03283       TEventIterUnit::Dictionary();
03284       G__setnull(result7);
03285    return(1 || funcname || hash || result7 || libp) ;
03286 }
03287 
03288 static int G__G__ProofPlayer_127_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03289 {
03290       ((TEventIterUnit*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
03291       G__setnull(result7);
03292    return(1 || funcname || hash || result7 || libp) ;
03293 }
03294 
03295 static int G__G__ProofPlayer_127_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03296 {
03297       G__letint(result7, 67, (long) TEventIterUnit::DeclFileName());
03298    return(1 || funcname || hash || result7 || libp) ;
03299 }
03300 
03301 static int G__G__ProofPlayer_127_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03302 {
03303       G__letint(result7, 105, (long) TEventIterUnit::ImplFileLine());
03304    return(1 || funcname || hash || result7 || libp) ;
03305 }
03306 
03307 static int G__G__ProofPlayer_127_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03308 {
03309       G__letint(result7, 67, (long) TEventIterUnit::ImplFileName());
03310    return(1 || funcname || hash || result7 || libp) ;
03311 }
03312 
03313 static int G__G__ProofPlayer_127_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03314 {
03315       G__letint(result7, 105, (long) TEventIterUnit::DeclFileLine());
03316    return(1 || funcname || hash || result7 || libp) ;
03317 }
03318 
03319 // automatic copy constructor
03320 static int G__G__ProofPlayer_127_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03321 
03322 {
03323    TEventIterUnit* p;
03324    void* tmp = (void*) G__int(libp->para[0]);
03325    p = new TEventIterUnit(*(TEventIterUnit*) tmp);
03326    result7->obj.i = (long) p;
03327    result7->ref = (long) p;
03328    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit));
03329    return(1 || funcname || hash || result7 || libp) ;
03330 }
03331 
03332 // automatic destructor
03333 typedef TEventIterUnit G__TTEventIterUnit;
03334 static int G__G__ProofPlayer_127_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03335 {
03336    char* gvp = (char*) G__getgvp();
03337    long soff = G__getstructoffset();
03338    int n = G__getaryconstruct();
03339    //
03340    //has_a_delete: 1
03341    //has_own_delete1arg: 0
03342    //has_own_delete2arg: 0
03343    //
03344    if (!soff) {
03345      return(1);
03346    }
03347    if (n) {
03348      if (gvp == (char*)G__PVOID) {
03349        delete[] (TEventIterUnit*) soff;
03350      } else {
03351        G__setgvp((long) G__PVOID);
03352        for (int i = n - 1; i >= 0; --i) {
03353          ((TEventIterUnit*) (soff+(sizeof(TEventIterUnit)*i)))->~G__TTEventIterUnit();
03354        }
03355        G__setgvp((long)gvp);
03356      }
03357    } else {
03358      if (gvp == (char*)G__PVOID) {
03359        delete (TEventIterUnit*) soff;
03360      } else {
03361        G__setgvp((long) G__PVOID);
03362        ((TEventIterUnit*) (soff))->~G__TTEventIterUnit();
03363        G__setgvp((long)gvp);
03364      }
03365    }
03366    G__setnull(result7);
03367    return(1 || funcname || hash || result7 || libp) ;
03368 }
03369 
03370 // automatic assignment operator
03371 static int G__G__ProofPlayer_127_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03372 {
03373    TEventIterUnit* dest = (TEventIterUnit*) G__getstructoffset();
03374    *dest = *(TEventIterUnit*) libp->para[0].ref;
03375    const TEventIterUnit& obj = *dest;
03376    result7->ref = (long) (&obj);
03377    result7->obj.i = (long) (&obj);
03378    return(1 || funcname || hash || result7 || libp) ;
03379 }
03380 
03381 
03382 /* TEventIterObj */
03383 static int G__G__ProofPlayer_128_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03384 {
03385    TEventIterObj* p = NULL;
03386    char* gvp = (char*) G__getgvp();
03387    int n = G__getaryconstruct();
03388    if (n) {
03389      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03390        p = new TEventIterObj[n];
03391      } else {
03392        p = new((void*) gvp) TEventIterObj[n];
03393      }
03394    } else {
03395      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03396        p = new TEventIterObj;
03397      } else {
03398        p = new((void*) gvp) TEventIterObj;
03399      }
03400    }
03401    result7->obj.i = (long) p;
03402    result7->ref = (long) p;
03403    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj));
03404    return(1 || funcname || hash || result7 || libp) ;
03405 }
03406 
03407 static int G__G__ProofPlayer_128_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03408 {
03409    TEventIterObj* p = NULL;
03410    char* gvp = (char*) G__getgvp();
03411    //m: 4
03412    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03413      p = new TEventIterObj(
03414 (TDSet*) G__int(libp->para[0]), (TSelector*) G__int(libp->para[1])
03415 , (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3]));
03416    } else {
03417      p = new((void*) gvp) TEventIterObj(
03418 (TDSet*) G__int(libp->para[0]), (TSelector*) G__int(libp->para[1])
03419 , (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3]));
03420    }
03421    result7->obj.i = (long) p;
03422    result7->ref = (long) p;
03423    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj));
03424    return(1 || funcname || hash || result7 || libp) ;
03425 }
03426 
03427 static int G__G__ProofPlayer_128_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03428 {
03429       G__letint(result7, 85, (long) TEventIterObj::Class());
03430    return(1 || funcname || hash || result7 || libp) ;
03431 }
03432 
03433 static int G__G__ProofPlayer_128_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03434 {
03435       G__letint(result7, 67, (long) TEventIterObj::Class_Name());
03436    return(1 || funcname || hash || result7 || libp) ;
03437 }
03438 
03439 static int G__G__ProofPlayer_128_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03440 {
03441       G__letint(result7, 115, (long) TEventIterObj::Class_Version());
03442    return(1 || funcname || hash || result7 || libp) ;
03443 }
03444 
03445 static int G__G__ProofPlayer_128_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03446 {
03447       TEventIterObj::Dictionary();
03448       G__setnull(result7);
03449    return(1 || funcname || hash || result7 || libp) ;
03450 }
03451 
03452 static int G__G__ProofPlayer_128_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03453 {
03454       ((TEventIterObj*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
03455       G__setnull(result7);
03456    return(1 || funcname || hash || result7 || libp) ;
03457 }
03458 
03459 static int G__G__ProofPlayer_128_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03460 {
03461       G__letint(result7, 67, (long) TEventIterObj::DeclFileName());
03462    return(1 || funcname || hash || result7 || libp) ;
03463 }
03464 
03465 static int G__G__ProofPlayer_128_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03466 {
03467       G__letint(result7, 105, (long) TEventIterObj::ImplFileLine());
03468    return(1 || funcname || hash || result7 || libp) ;
03469 }
03470 
03471 static int G__G__ProofPlayer_128_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03472 {
03473       G__letint(result7, 67, (long) TEventIterObj::ImplFileName());
03474    return(1 || funcname || hash || result7 || libp) ;
03475 }
03476 
03477 static int G__G__ProofPlayer_128_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03478 {
03479       G__letint(result7, 105, (long) TEventIterObj::DeclFileLine());
03480    return(1 || funcname || hash || result7 || libp) ;
03481 }
03482 
03483 // automatic copy constructor
03484 static int G__G__ProofPlayer_128_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03485 
03486 {
03487    TEventIterObj* p;
03488    void* tmp = (void*) G__int(libp->para[0]);
03489    p = new TEventIterObj(*(TEventIterObj*) tmp);
03490    result7->obj.i = (long) p;
03491    result7->ref = (long) p;
03492    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj));
03493    return(1 || funcname || hash || result7 || libp) ;
03494 }
03495 
03496 // automatic destructor
03497 typedef TEventIterObj G__TTEventIterObj;
03498 static int G__G__ProofPlayer_128_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03499 {
03500    char* gvp = (char*) G__getgvp();
03501    long soff = G__getstructoffset();
03502    int n = G__getaryconstruct();
03503    //
03504    //has_a_delete: 1
03505    //has_own_delete1arg: 0
03506    //has_own_delete2arg: 0
03507    //
03508    if (!soff) {
03509      return(1);
03510    }
03511    if (n) {
03512      if (gvp == (char*)G__PVOID) {
03513        delete[] (TEventIterObj*) soff;
03514      } else {
03515        G__setgvp((long) G__PVOID);
03516        for (int i = n - 1; i >= 0; --i) {
03517          ((TEventIterObj*) (soff+(sizeof(TEventIterObj)*i)))->~G__TTEventIterObj();
03518        }
03519        G__setgvp((long)gvp);
03520      }
03521    } else {
03522      if (gvp == (char*)G__PVOID) {
03523        delete (TEventIterObj*) soff;
03524      } else {
03525        G__setgvp((long) G__PVOID);
03526        ((TEventIterObj*) (soff))->~G__TTEventIterObj();
03527        G__setgvp((long)gvp);
03528      }
03529    }
03530    G__setnull(result7);
03531    return(1 || funcname || hash || result7 || libp) ;
03532 }
03533 
03534 // automatic assignment operator
03535 static int G__G__ProofPlayer_128_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03536 {
03537    TEventIterObj* dest = (TEventIterObj*) G__getstructoffset();
03538    *dest = *(TEventIterObj*) libp->para[0].ref;
03539    const TEventIterObj& obj = *dest;
03540    result7->ref = (long) (&obj);
03541    result7->obj.i = (long) (&obj);
03542    return(1 || funcname || hash || result7 || libp) ;
03543 }
03544 
03545 
03546 /* TEventIterTree */
03547 static int G__G__ProofPlayer_129_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03548 {
03549    TEventIterTree* p = NULL;
03550    char* gvp = (char*) G__getgvp();
03551    int n = G__getaryconstruct();
03552    if (n) {
03553      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03554        p = new TEventIterTree[n];
03555      } else {
03556        p = new((void*) gvp) TEventIterTree[n];
03557      }
03558    } else {
03559      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03560        p = new TEventIterTree;
03561      } else {
03562        p = new((void*) gvp) TEventIterTree;
03563      }
03564    }
03565    result7->obj.i = (long) p;
03566    result7->ref = (long) p;
03567    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree));
03568    return(1 || funcname || hash || result7 || libp) ;
03569 }
03570 
03571 static int G__G__ProofPlayer_129_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03572 {
03573    TEventIterTree* p = NULL;
03574    char* gvp = (char*) G__getgvp();
03575    //m: 4
03576    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03577      p = new TEventIterTree(
03578 (TDSet*) G__int(libp->para[0]), (TSelector*) G__int(libp->para[1])
03579 , (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3]));
03580    } else {
03581      p = new((void*) gvp) TEventIterTree(
03582 (TDSet*) G__int(libp->para[0]), (TSelector*) G__int(libp->para[1])
03583 , (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3]));
03584    }
03585    result7->obj.i = (long) p;
03586    result7->ref = (long) p;
03587    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree));
03588    return(1 || funcname || hash || result7 || libp) ;
03589 }
03590 
03591 static int G__G__ProofPlayer_129_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03592 {
03593       G__letint(result7, 85, (long) TEventIterTree::Class());
03594    return(1 || funcname || hash || result7 || libp) ;
03595 }
03596 
03597 static int G__G__ProofPlayer_129_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03598 {
03599       G__letint(result7, 67, (long) TEventIterTree::Class_Name());
03600    return(1 || funcname || hash || result7 || libp) ;
03601 }
03602 
03603 static int G__G__ProofPlayer_129_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03604 {
03605       G__letint(result7, 115, (long) TEventIterTree::Class_Version());
03606    return(1 || funcname || hash || result7 || libp) ;
03607 }
03608 
03609 static int G__G__ProofPlayer_129_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03610 {
03611       TEventIterTree::Dictionary();
03612       G__setnull(result7);
03613    return(1 || funcname || hash || result7 || libp) ;
03614 }
03615 
03616 static int G__G__ProofPlayer_129_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03617 {
03618       ((TEventIterTree*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
03619       G__setnull(result7);
03620    return(1 || funcname || hash || result7 || libp) ;
03621 }
03622 
03623 static int G__G__ProofPlayer_129_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03624 {
03625       G__letint(result7, 67, (long) TEventIterTree::DeclFileName());
03626    return(1 || funcname || hash || result7 || libp) ;
03627 }
03628 
03629 static int G__G__ProofPlayer_129_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03630 {
03631       G__letint(result7, 105, (long) TEventIterTree::ImplFileLine());
03632    return(1 || funcname || hash || result7 || libp) ;
03633 }
03634 
03635 static int G__G__ProofPlayer_129_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03636 {
03637       G__letint(result7, 67, (long) TEventIterTree::ImplFileName());
03638    return(1 || funcname || hash || result7 || libp) ;
03639 }
03640 
03641 static int G__G__ProofPlayer_129_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03642 {
03643       G__letint(result7, 105, (long) TEventIterTree::DeclFileLine());
03644    return(1 || funcname || hash || result7 || libp) ;
03645 }
03646 
03647 // automatic copy constructor
03648 static int G__G__ProofPlayer_129_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03649 
03650 {
03651    TEventIterTree* p;
03652    void* tmp = (void*) G__int(libp->para[0]);
03653    p = new TEventIterTree(*(TEventIterTree*) tmp);
03654    result7->obj.i = (long) p;
03655    result7->ref = (long) p;
03656    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree));
03657    return(1 || funcname || hash || result7 || libp) ;
03658 }
03659 
03660 // automatic destructor
03661 typedef TEventIterTree G__TTEventIterTree;
03662 static int G__G__ProofPlayer_129_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03663 {
03664    char* gvp = (char*) G__getgvp();
03665    long soff = G__getstructoffset();
03666    int n = G__getaryconstruct();
03667    //
03668    //has_a_delete: 1
03669    //has_own_delete1arg: 0
03670    //has_own_delete2arg: 0
03671    //
03672    if (!soff) {
03673      return(1);
03674    }
03675    if (n) {
03676      if (gvp == (char*)G__PVOID) {
03677        delete[] (TEventIterTree*) soff;
03678      } else {
03679        G__setgvp((long) G__PVOID);
03680        for (int i = n - 1; i >= 0; --i) {
03681          ((TEventIterTree*) (soff+(sizeof(TEventIterTree)*i)))->~G__TTEventIterTree();
03682        }
03683        G__setgvp((long)gvp);
03684      }
03685    } else {
03686      if (gvp == (char*)G__PVOID) {
03687        delete (TEventIterTree*) soff;
03688      } else {
03689        G__setgvp((long) G__PVOID);
03690        ((TEventIterTree*) (soff))->~G__TTEventIterTree();
03691        G__setgvp((long)gvp);
03692      }
03693    }
03694    G__setnull(result7);
03695    return(1 || funcname || hash || result7 || libp) ;
03696 }
03697 
03698 // automatic assignment operator
03699 static int G__G__ProofPlayer_129_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03700 {
03701    TEventIterTree* dest = (TEventIterTree*) G__getstructoffset();
03702    *dest = *(TEventIterTree*) libp->para[0].ref;
03703    const TEventIterTree& obj = *dest;
03704    result7->ref = (long) (&obj);
03705    result7->obj.i = (long) (&obj);
03706    return(1 || funcname || hash || result7 || libp) ;
03707 }
03708 
03709 
03710 /* TFileMerger */
03711 static int G__G__ProofPlayer_133_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03712 {
03713    TFileMerger* p = NULL;
03714    char* gvp = (char*) G__getgvp();
03715    switch (libp->paran) {
03716    case 2:
03717      //m: 2
03718      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03719        p = new TFileMerger((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
03720      } else {
03721        p = new((void*) gvp) TFileMerger((Bool_t) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
03722      }
03723      break;
03724    case 1:
03725      //m: 1
03726      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03727        p = new TFileMerger((Bool_t) G__int(libp->para[0]));
03728      } else {
03729        p = new((void*) gvp) TFileMerger((Bool_t) G__int(libp->para[0]));
03730      }
03731      break;
03732    case 0:
03733      int n = G__getaryconstruct();
03734      if (n) {
03735        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03736          p = new TFileMerger[n];
03737        } else {
03738          p = new((void*) gvp) TFileMerger[n];
03739        }
03740      } else {
03741        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03742          p = new TFileMerger;
03743        } else {
03744          p = new((void*) gvp) TFileMerger;
03745        }
03746      }
03747      break;
03748    }
03749    result7->obj.i = (long) p;
03750    result7->ref = (long) p;
03751    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TFileMerger));
03752    return(1 || funcname || hash || result7 || libp) ;
03753 }
03754 
03755 static int G__G__ProofPlayer_133_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03756 {
03757       G__letint(result7, 67, (long) ((const TFileMerger*) G__getstructoffset())->GetOutputFileName());
03758    return(1 || funcname || hash || result7 || libp) ;
03759 }
03760 
03761 static int G__G__ProofPlayer_133_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03762 {
03763       G__letint(result7, 85, (long) ((const TFileMerger*) G__getstructoffset())->GetMergeList());
03764    return(1 || funcname || hash || result7 || libp) ;
03765 }
03766 
03767 static int G__G__ProofPlayer_133_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03768 {
03769       G__letint(result7, 103, (long) ((TFileMerger*) G__getstructoffset())->SetCWD((const char*) G__int(libp->para[0])));
03770    return(1 || funcname || hash || result7 || libp) ;
03771 }
03772 
03773 static int G__G__ProofPlayer_133_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03774 {
03775       G__letint(result7, 67, (long) ((TFileMerger*) G__getstructoffset())->GetCWD());
03776    return(1 || funcname || hash || result7 || libp) ;
03777 }
03778 
03779 static int G__G__ProofPlayer_133_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03780 {
03781       ((TFileMerger*) G__getstructoffset())->Reset();
03782       G__setnull(result7);
03783    return(1 || funcname || hash || result7 || libp) ;
03784 }
03785 
03786 static int G__G__ProofPlayer_133_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03787 {
03788    switch (libp->paran) {
03789    case 2:
03790       G__letint(result7, 103, (long) ((TFileMerger*) G__getstructoffset())->AddFile((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
03791       break;
03792    case 1:
03793       G__letint(result7, 103, (long) ((TFileMerger*) G__getstructoffset())->AddFile((const char*) G__int(libp->para[0])));
03794       break;
03795    }
03796    return(1 || funcname || hash || result7 || libp) ;
03797 }
03798 
03799 static int G__G__ProofPlayer_133_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03800 {
03801       G__letint(result7, 103, (long) ((TFileMerger*) G__getstructoffset())->OutputFile((const char*) G__int(libp->para[0])));
03802    return(1 || funcname || hash || result7 || libp) ;
03803 }
03804 
03805 static int G__G__ProofPlayer_133_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03806 {
03807       ((TFileMerger*) G__getstructoffset())->PrintFiles((Option_t*) G__int(libp->para[0]));
03808       G__setnull(result7);
03809    return(1 || funcname || hash || result7 || libp) ;
03810 }
03811 
03812 static int G__G__ProofPlayer_133_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03813 {
03814    switch (libp->paran) {
03815    case 1:
03816       G__letint(result7, 103, (long) ((TFileMerger*) G__getstructoffset())->Merge((Bool_t) G__int(libp->para[0])));
03817       break;
03818    case 0:
03819       G__letint(result7, 103, (long) ((TFileMerger*) G__getstructoffset())->Merge());
03820       break;
03821    }
03822    return(1 || funcname || hash || result7 || libp) ;
03823 }
03824 
03825 static int G__G__ProofPlayer_133_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03826 {
03827       G__letint(result7, 103, (long) ((TFileMerger*) G__getstructoffset())->MergeRecursive((TDirectory*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])));
03828    return(1 || funcname || hash || result7 || libp) ;
03829 }
03830 
03831 static int G__G__ProofPlayer_133_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03832 {
03833    switch (libp->paran) {
03834    case 1:
03835       ((TFileMerger*) G__getstructoffset())->SetFastMethod((Bool_t) G__int(libp->para[0]));
03836       G__setnull(result7);
03837       break;
03838    case 0:
03839       ((TFileMerger*) G__getstructoffset())->SetFastMethod();
03840       G__setnull(result7);
03841       break;
03842    }
03843    return(1 || funcname || hash || result7 || libp) ;
03844 }
03845 
03846 static int G__G__ProofPlayer_133_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03847 {
03848    switch (libp->paran) {
03849    case 1:
03850       ((TFileMerger*) G__getstructoffset())->SetNotrees((Bool_t) G__int(libp->para[0]));
03851       G__setnull(result7);
03852       break;
03853    case 0:
03854       ((TFileMerger*) G__getstructoffset())->SetNotrees();
03855       G__setnull(result7);
03856       break;
03857    }
03858    return(1 || funcname || hash || result7 || libp) ;
03859 }
03860 
03861 static int G__G__ProofPlayer_133_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03862 {
03863       G__letint(result7, 85, (long) TFileMerger::Class());
03864    return(1 || funcname || hash || result7 || libp) ;
03865 }
03866 
03867 static int G__G__ProofPlayer_133_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03868 {
03869       G__letint(result7, 67, (long) TFileMerger::Class_Name());
03870    return(1 || funcname || hash || result7 || libp) ;
03871 }
03872 
03873 static int G__G__ProofPlayer_133_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03874 {
03875       G__letint(result7, 115, (long) TFileMerger::Class_Version());
03876    return(1 || funcname || hash || result7 || libp) ;
03877 }
03878 
03879 static int G__G__ProofPlayer_133_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03880 {
03881       TFileMerger::Dictionary();
03882       G__setnull(result7);
03883    return(1 || funcname || hash || result7 || libp) ;
03884 }
03885 
03886 static int G__G__ProofPlayer_133_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03887 {
03888       ((TFileMerger*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
03889       G__setnull(result7);
03890    return(1 || funcname || hash || result7 || libp) ;
03891 }
03892 
03893 static int G__G__ProofPlayer_133_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03894 {
03895       G__letint(result7, 67, (long) TFileMerger::DeclFileName());
03896    return(1 || funcname || hash || result7 || libp) ;
03897 }
03898 
03899 static int G__G__ProofPlayer_133_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03900 {
03901       G__letint(result7, 105, (long) TFileMerger::ImplFileLine());
03902    return(1 || funcname || hash || result7 || libp) ;
03903 }
03904 
03905 static int G__G__ProofPlayer_133_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03906 {
03907       G__letint(result7, 67, (long) TFileMerger::ImplFileName());
03908    return(1 || funcname || hash || result7 || libp) ;
03909 }
03910 
03911 static int G__G__ProofPlayer_133_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03912 {
03913       G__letint(result7, 105, (long) TFileMerger::DeclFileLine());
03914    return(1 || funcname || hash || result7 || libp) ;
03915 }
03916 
03917 // automatic destructor
03918 typedef TFileMerger G__TTFileMerger;
03919 static int G__G__ProofPlayer_133_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03920 {
03921    char* gvp = (char*) G__getgvp();
03922    long soff = G__getstructoffset();
03923    int n = G__getaryconstruct();
03924    //
03925    //has_a_delete: 1
03926    //has_own_delete1arg: 0
03927    //has_own_delete2arg: 0
03928    //
03929    if (!soff) {
03930      return(1);
03931    }
03932    if (n) {
03933      if (gvp == (char*)G__PVOID) {
03934        delete[] (TFileMerger*) soff;
03935      } else {
03936        G__setgvp((long) G__PVOID);
03937        for (int i = n - 1; i >= 0; --i) {
03938          ((TFileMerger*) (soff+(sizeof(TFileMerger)*i)))->~G__TTFileMerger();
03939        }
03940        G__setgvp((long)gvp);
03941      }
03942    } else {
03943      if (gvp == (char*)G__PVOID) {
03944        delete (TFileMerger*) soff;
03945      } else {
03946        G__setgvp((long) G__PVOID);
03947        ((TFileMerger*) (soff))->~G__TTFileMerger();
03948        G__setgvp((long)gvp);
03949      }
03950    }
03951    G__setnull(result7);
03952    return(1 || funcname || hash || result7 || libp) ;
03953 }
03954 
03955 
03956 /* TOutputListSelectorDataMap */
03957 static int G__G__ProofPlayer_135_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03958 {
03959    TOutputListSelectorDataMap* p = NULL;
03960    char* gvp = (char*) G__getgvp();
03961    switch (libp->paran) {
03962    case 1:
03963      //m: 1
03964      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03965        p = new TOutputListSelectorDataMap((TSelector*) G__int(libp->para[0]));
03966      } else {
03967        p = new((void*) gvp) TOutputListSelectorDataMap((TSelector*) G__int(libp->para[0]));
03968      }
03969      break;
03970    case 0:
03971      int n = G__getaryconstruct();
03972      if (n) {
03973        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03974          p = new TOutputListSelectorDataMap[n];
03975        } else {
03976          p = new((void*) gvp) TOutputListSelectorDataMap[n];
03977        }
03978      } else {
03979        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03980          p = new TOutputListSelectorDataMap;
03981        } else {
03982          p = new((void*) gvp) TOutputListSelectorDataMap;
03983        }
03984      }
03985      break;
03986    }
03987    result7->obj.i = (long) p;
03988    result7->ref = (long) p;
03989    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TOutputListSelectorDataMap));
03990    return(1 || funcname || hash || result7 || libp) ;
03991 }
03992 
03993 static int G__G__ProofPlayer_135_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03994 {
03995       G__letint(result7, 85, (long) TOutputListSelectorDataMap::FindInList((TCollection*) G__int(libp->para[0])));
03996    return(1 || funcname || hash || result7 || libp) ;
03997 }
03998 
03999 static int G__G__ProofPlayer_135_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04000 {
04001       G__letint(result7, 103, (long) ((TOutputListSelectorDataMap*) G__getstructoffset())->Init((TSelector*) G__int(libp->para[0])));
04002    return(1 || funcname || hash || result7 || libp) ;
04003 }
04004 
04005 static int G__G__ProofPlayer_135_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04006 {
04007       G__letint(result7, 103, (long) ((const TOutputListSelectorDataMap*) G__getstructoffset())->SetDataMembers((TSelector*) G__int(libp->para[0])));
04008    return(1 || funcname || hash || result7 || libp) ;
04009 }
04010 
04011 static int G__G__ProofPlayer_135_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04012 {
04013       G__letint(result7, 103, (long) ((TOutputListSelectorDataMap*) G__getstructoffset())->Merge((TObject*) G__int(libp->para[0])));
04014    return(1 || funcname || hash || result7 || libp) ;
04015 }
04016 
04017 static int G__G__ProofPlayer_135_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04018 {
04019       G__letint(result7, 85, (long) ((const TOutputListSelectorDataMap*) G__getstructoffset())->GetMap());
04020    return(1 || funcname || hash || result7 || libp) ;
04021 }
04022 
04023 static int G__G__ProofPlayer_135_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04024 {
04025       G__letint(result7, 85, (long) TOutputListSelectorDataMap::Class());
04026    return(1 || funcname || hash || result7 || libp) ;
04027 }
04028 
04029 static int G__G__ProofPlayer_135_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04030 {
04031       G__letint(result7, 67, (long) TOutputListSelectorDataMap::Class_Name());
04032    return(1 || funcname || hash || result7 || libp) ;
04033 }
04034 
04035 static int G__G__ProofPlayer_135_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04036 {
04037       G__letint(result7, 115, (long) TOutputListSelectorDataMap::Class_Version());
04038    return(1 || funcname || hash || result7 || libp) ;
04039 }
04040 
04041 static int G__G__ProofPlayer_135_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04042 {
04043       TOutputListSelectorDataMap::Dictionary();
04044       G__setnull(result7);
04045    return(1 || funcname || hash || result7 || libp) ;
04046 }
04047 
04048 static int G__G__ProofPlayer_135_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04049 {
04050       ((TOutputListSelectorDataMap*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04051       G__setnull(result7);
04052    return(1 || funcname || hash || result7 || libp) ;
04053 }
04054 
04055 static int G__G__ProofPlayer_135_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04056 {
04057       G__letint(result7, 67, (long) TOutputListSelectorDataMap::DeclFileName());
04058    return(1 || funcname || hash || result7 || libp) ;
04059 }
04060 
04061 static int G__G__ProofPlayer_135_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04062 {
04063       G__letint(result7, 105, (long) TOutputListSelectorDataMap::ImplFileLine());
04064    return(1 || funcname || hash || result7 || libp) ;
04065 }
04066 
04067 static int G__G__ProofPlayer_135_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04068 {
04069       G__letint(result7, 67, (long) TOutputListSelectorDataMap::ImplFileName());
04070    return(1 || funcname || hash || result7 || libp) ;
04071 }
04072 
04073 static int G__G__ProofPlayer_135_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04074 {
04075       G__letint(result7, 105, (long) TOutputListSelectorDataMap::DeclFileLine());
04076    return(1 || funcname || hash || result7 || libp) ;
04077 }
04078 
04079 // automatic copy constructor
04080 static int G__G__ProofPlayer_135_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04081 
04082 {
04083    TOutputListSelectorDataMap* p;
04084    void* tmp = (void*) G__int(libp->para[0]);
04085    p = new TOutputListSelectorDataMap(*(TOutputListSelectorDataMap*) tmp);
04086    result7->obj.i = (long) p;
04087    result7->ref = (long) p;
04088    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TOutputListSelectorDataMap));
04089    return(1 || funcname || hash || result7 || libp) ;
04090 }
04091 
04092 // automatic destructor
04093 typedef TOutputListSelectorDataMap G__TTOutputListSelectorDataMap;
04094 static int G__G__ProofPlayer_135_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04095 {
04096    char* gvp = (char*) G__getgvp();
04097    long soff = G__getstructoffset();
04098    int n = G__getaryconstruct();
04099    //
04100    //has_a_delete: 1
04101    //has_own_delete1arg: 0
04102    //has_own_delete2arg: 0
04103    //
04104    if (!soff) {
04105      return(1);
04106    }
04107    if (n) {
04108      if (gvp == (char*)G__PVOID) {
04109        delete[] (TOutputListSelectorDataMap*) soff;
04110      } else {
04111        G__setgvp((long) G__PVOID);
04112        for (int i = n - 1; i >= 0; --i) {
04113          ((TOutputListSelectorDataMap*) (soff+(sizeof(TOutputListSelectorDataMap)*i)))->~G__TTOutputListSelectorDataMap();
04114        }
04115        G__setgvp((long)gvp);
04116      }
04117    } else {
04118      if (gvp == (char*)G__PVOID) {
04119        delete (TOutputListSelectorDataMap*) soff;
04120      } else {
04121        G__setgvp((long) G__PVOID);
04122        ((TOutputListSelectorDataMap*) (soff))->~G__TTOutputListSelectorDataMap();
04123        G__setgvp((long)gvp);
04124      }
04125    }
04126    G__setnull(result7);
04127    return(1 || funcname || hash || result7 || libp) ;
04128 }
04129 
04130 // automatic assignment operator
04131 static int G__G__ProofPlayer_135_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04132 {
04133    TOutputListSelectorDataMap* dest = (TOutputListSelectorDataMap*) G__getstructoffset();
04134    *dest = *(TOutputListSelectorDataMap*) libp->para[0].ref;
04135    const TOutputListSelectorDataMap& obj = *dest;
04136    result7->ref = (long) (&obj);
04137    result7->obj.i = (long) (&obj);
04138    return(1 || funcname || hash || result7 || libp) ;
04139 }
04140 
04141 
04142 /* TVirtualPacketizer */
04143 static int G__G__ProofPlayer_152_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04144 {
04145       G__letint(result7, 103, (long) ((const TVirtualPacketizer*) G__getstructoffset())->IsValid());
04146    return(1 || funcname || hash || result7 || libp) ;
04147 }
04148 
04149 static int G__G__ProofPlayer_152_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04150 {
04151       G__letLonglong(result7, 110, (G__int64) ((const TVirtualPacketizer*) G__getstructoffset())->GetEntriesProcessed());
04152    return(1 || funcname || hash || result7 || libp) ;
04153 }
04154 
04155 static int G__G__ProofPlayer_152_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04156 {
04157       G__letint(result7, 105, (long) ((TVirtualPacketizer*) G__getstructoffset())->GetEstEntriesProcessed((Float_t) G__double(libp->para[0]), *(Long64_t*) G__Longlongref(&libp->para[1])
04158 , *(Long64_t*) G__Longlongref(&libp->para[2]), *(Long64_t*) G__Longlongref(&libp->para[3])));
04159    return(1 || funcname || hash || result7 || libp) ;
04160 }
04161 
04162 static int G__G__ProofPlayer_152_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04163 {
04164       G__letdouble(result7, 102, (double) ((TVirtualPacketizer*) G__getstructoffset())->GetCurrentRate(*(Bool_t*) G__Boolref(&libp->para[0])));
04165    return(1 || funcname || hash || result7 || libp) ;
04166 }
04167 
04168 static int G__G__ProofPlayer_152_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04169 {
04170       G__letLonglong(result7, 110, (G__int64) ((const TVirtualPacketizer*) G__getstructoffset())->GetTotalEntries());
04171    return(1 || funcname || hash || result7 || libp) ;
04172 }
04173 
04174 static int G__G__ProofPlayer_152_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04175 {
04176       G__letint(result7, 85, (long) ((TVirtualPacketizer*) G__getstructoffset())->GetNextPacket((TSlave*) G__int(libp->para[0]), (TMessage*) G__int(libp->para[1])));
04177    return(1 || funcname || hash || result7 || libp) ;
04178 }
04179 
04180 static int G__G__ProofPlayer_152_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04181 {
04182       ((TVirtualPacketizer*) G__getstructoffset())->SetInitTime();
04183       G__setnull(result7);
04184    return(1 || funcname || hash || result7 || libp) ;
04185 }
04186 
04187 static int G__G__ProofPlayer_152_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04188 {
04189       ((TVirtualPacketizer*) G__getstructoffset())->StopProcess((Bool_t) G__int(libp->para[0]));
04190       G__setnull(result7);
04191    return(1 || funcname || hash || result7 || libp) ;
04192 }
04193 
04194 static int G__G__ProofPlayer_152_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04195 {
04196       G__letint(result7, 85, (long) ((TVirtualPacketizer*) G__getstructoffset())->GetFailedPackets());
04197    return(1 || funcname || hash || result7 || libp) ;
04198 }
04199 
04200 static int G__G__ProofPlayer_152_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04201 {
04202       ((TVirtualPacketizer*) G__getstructoffset())->SetFailedPackets((TList*) G__int(libp->para[0]));
04203       G__setnull(result7);
04204    return(1 || funcname || hash || result7 || libp) ;
04205 }
04206 
04207 static int G__G__ProofPlayer_152_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04208 {
04209       G__letLonglong(result7, 110, (G__int64) ((const TVirtualPacketizer*) G__getstructoffset())->GetBytesRead());
04210    return(1 || funcname || hash || result7 || libp) ;
04211 }
04212 
04213 static int G__G__ProofPlayer_152_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04214 {
04215       G__letLonglong(result7, 110, (G__int64) ((const TVirtualPacketizer*) G__getstructoffset())->GetReadCalls());
04216    return(1 || funcname || hash || result7 || libp) ;
04217 }
04218 
04219 static int G__G__ProofPlayer_152_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04220 {
04221       G__letdouble(result7, 100, (double) ((const TVirtualPacketizer*) G__getstructoffset())->GetCumProcTime());
04222    return(1 || funcname || hash || result7 || libp) ;
04223 }
04224 
04225 static int G__G__ProofPlayer_152_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04226 {
04227       G__letdouble(result7, 102, (double) ((const TVirtualPacketizer*) G__getstructoffset())->GetInitTime());
04228    return(1 || funcname || hash || result7 || libp) ;
04229 }
04230 
04231 static int G__G__ProofPlayer_152_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04232 {
04233       G__letdouble(result7, 102, (double) ((const TVirtualPacketizer*) G__getstructoffset())->GetProcTime());
04234    return(1 || funcname || hash || result7 || libp) ;
04235 }
04236 
04237 static int G__G__ProofPlayer_152_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04238 {
04239    switch (libp->paran) {
04240    case 1:
04241       G__letint(result7, 85, (long) ((TVirtualPacketizer*) G__getstructoffset())->GetProgressPerf((Bool_t) G__int(libp->para[0])));
04242       break;
04243    case 0:
04244       G__letint(result7, 85, (long) ((TVirtualPacketizer*) G__getstructoffset())->GetProgressPerf());
04245       break;
04246    }
04247    return(1 || funcname || hash || result7 || libp) ;
04248 }
04249 
04250 static int G__G__ProofPlayer_152_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04251 {
04252    switch (libp->paran) {
04253    case 1:
04254       G__letint(result7, 85, (long) ((TVirtualPacketizer*) G__getstructoffset())->GetConfigParams((Bool_t) G__int(libp->para[0])));
04255       break;
04256    case 0:
04257       G__letint(result7, 85, (long) ((TVirtualPacketizer*) G__getstructoffset())->GetConfigParams());
04258       break;
04259    }
04260    return(1 || funcname || hash || result7 || libp) ;
04261 }
04262 
04263 static int G__G__ProofPlayer_152_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04264 {
04265       ((TVirtualPacketizer*) G__getstructoffset())->MarkBad((TSlave*) G__int(libp->para[0]), (TProofProgressStatus*) G__int(libp->para[1])
04266 , (TList**) G__int(libp->para[2]));
04267       G__setnull(result7);
04268    return(1 || funcname || hash || result7 || libp) ;
04269 }
04270 
04271 static int G__G__ProofPlayer_152_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04272 {
04273       G__letint(result7, 105, (long) ((TVirtualPacketizer*) G__getstructoffset())->AddProcessed((TSlave*) G__int(libp->para[0]), (TProofProgressStatus*) G__int(libp->para[1])
04274 , (Double_t) G__double(libp->para[2]), (TList**) G__int(libp->para[3])));
04275    return(1 || funcname || hash || result7 || libp) ;
04276 }
04277 
04278 static int G__G__ProofPlayer_152_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04279 {
04280       G__letint(result7, 85, (long) ((TVirtualPacketizer*) G__getstructoffset())->GetStatus());
04281    return(1 || funcname || hash || result7 || libp) ;
04282 }
04283 
04284 static int G__G__ProofPlayer_152_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04285 {
04286       ((TVirtualPacketizer*) G__getstructoffset())->SetProgressStatus((TProofProgressStatus*) G__int(libp->para[0]));
04287       G__setnull(result7);
04288    return(1 || funcname || hash || result7 || libp) ;
04289 }
04290 
04291 static int G__G__ProofPlayer_152_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04292 {
04293       ((TVirtualPacketizer*) G__getstructoffset())->SetTotalEntries((Long64_t) G__Longlong(libp->para[0]));
04294       G__setnull(result7);
04295    return(1 || funcname || hash || result7 || libp) ;
04296 }
04297 
04298 static int G__G__ProofPlayer_152_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04299 {
04300       G__letint(result7, 85, (long) ((const TVirtualPacketizer*) G__getstructoffset())->GetSlaveStats());
04301    return(1 || funcname || hash || result7 || libp) ;
04302 }
04303 
04304 static int G__G__ProofPlayer_152_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04305 {
04306       G__letint(result7, 105, (long) ((TVirtualPacketizer*) G__getstructoffset())->GetActiveWorkers());
04307    return(1 || funcname || hash || result7 || libp) ;
04308 }
04309 
04310 static int G__G__ProofPlayer_152_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04311 {
04312       G__letint(result7, 85, (long) TVirtualPacketizer::Class());
04313    return(1 || funcname || hash || result7 || libp) ;
04314 }
04315 
04316 static int G__G__ProofPlayer_152_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04317 {
04318       G__letint(result7, 67, (long) TVirtualPacketizer::Class_Name());
04319    return(1 || funcname || hash || result7 || libp) ;
04320 }
04321 
04322 static int G__G__ProofPlayer_152_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04323 {
04324       G__letint(result7, 115, (long) TVirtualPacketizer::Class_Version());
04325    return(1 || funcname || hash || result7 || libp) ;
04326 }
04327 
04328 static int G__G__ProofPlayer_152_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04329 {
04330       TVirtualPacketizer::Dictionary();
04331       G__setnull(result7);
04332    return(1 || funcname || hash || result7 || libp) ;
04333 }
04334 
04335 static int G__G__ProofPlayer_152_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04336 {
04337       ((TVirtualPacketizer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04338       G__setnull(result7);
04339    return(1 || funcname || hash || result7 || libp) ;
04340 }
04341 
04342 static int G__G__ProofPlayer_152_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04343 {
04344       G__letint(result7, 67, (long) TVirtualPacketizer::DeclFileName());
04345    return(1 || funcname || hash || result7 || libp) ;
04346 }
04347 
04348 static int G__G__ProofPlayer_152_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04349 {
04350       G__letint(result7, 105, (long) TVirtualPacketizer::ImplFileLine());
04351    return(1 || funcname || hash || result7 || libp) ;
04352 }
04353 
04354 static int G__G__ProofPlayer_152_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04355 {
04356       G__letint(result7, 67, (long) TVirtualPacketizer::ImplFileName());
04357    return(1 || funcname || hash || result7 || libp) ;
04358 }
04359 
04360 static int G__G__ProofPlayer_152_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04361 {
04362       G__letint(result7, 105, (long) TVirtualPacketizer::DeclFileLine());
04363    return(1 || funcname || hash || result7 || libp) ;
04364 }
04365 
04366 // automatic destructor
04367 typedef TVirtualPacketizer G__TTVirtualPacketizer;
04368 static int G__G__ProofPlayer_152_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04369 {
04370    char* gvp = (char*) G__getgvp();
04371    long soff = G__getstructoffset();
04372    int n = G__getaryconstruct();
04373    //
04374    //has_a_delete: 1
04375    //has_own_delete1arg: 0
04376    //has_own_delete2arg: 0
04377    //
04378    if (!soff) {
04379      return(1);
04380    }
04381    if (n) {
04382      if (gvp == (char*)G__PVOID) {
04383        delete[] (TVirtualPacketizer*) soff;
04384      } else {
04385        G__setgvp((long) G__PVOID);
04386        for (int i = n - 1; i >= 0; --i) {
04387          ((TVirtualPacketizer*) (soff+(sizeof(TVirtualPacketizer)*i)))->~G__TTVirtualPacketizer();
04388        }
04389        G__setgvp((long)gvp);
04390      }
04391    } else {
04392      if (gvp == (char*)G__PVOID) {
04393        delete (TVirtualPacketizer*) soff;
04394      } else {
04395        G__setgvp((long) G__PVOID);
04396        ((TVirtualPacketizer*) (soff))->~G__TTVirtualPacketizer();
04397        G__setgvp((long)gvp);
04398      }
04399    }
04400    G__setnull(result7);
04401    return(1 || funcname || hash || result7 || libp) ;
04402 }
04403 
04404 
04405 /* TPacketizerAdaptive */
04406 static int G__G__ProofPlayer_161_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04407 {
04408    TPacketizerAdaptive* p = NULL;
04409    char* gvp = (char*) G__getgvp();
04410    //m: 6
04411    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04412      p = new TPacketizerAdaptive(
04413 (TDSet*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
04414 , (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
04415 , (TList*) G__int(libp->para[4]), (TProofProgressStatus*) G__int(libp->para[5]));
04416    } else {
04417      p = new((void*) gvp) TPacketizerAdaptive(
04418 (TDSet*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
04419 , (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
04420 , (TList*) G__int(libp->para[4]), (TProofProgressStatus*) G__int(libp->para[5]));
04421    }
04422    result7->obj.i = (long) p;
04423    result7->ref = (long) p;
04424    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptive));
04425    return(1 || funcname || hash || result7 || libp) ;
04426 }
04427 
04428 static int G__G__ProofPlayer_161_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04429 {
04430    switch (libp->paran) {
04431    case 4:
04432       G__letint(result7, 105, (long) ((TPacketizerAdaptive*) G__getstructoffset())->AddProcessed((TSlave*) G__int(libp->para[0]), (TProofProgressStatus*) G__int(libp->para[1])
04433 , (Double_t) G__double(libp->para[2]), (TList**) G__int(libp->para[3])));
04434       break;
04435    case 3:
04436       G__letint(result7, 105, (long) ((TPacketizerAdaptive*) G__getstructoffset())->AddProcessed((TSlave*) G__int(libp->para[0]), (TProofProgressStatus*) G__int(libp->para[1])
04437 , (Double_t) G__double(libp->para[2])));
04438       break;
04439    }
04440    return(1 || funcname || hash || result7 || libp) ;
04441 }
04442 
04443 static int G__G__ProofPlayer_161_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04444 {
04445       G__letint(result7, 105, (long) ((TPacketizerAdaptive*) G__getstructoffset())->CalculatePacketSize((TObject*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
04446 , (Int_t) G__int(libp->para[2])));
04447    return(1 || funcname || hash || result7 || libp) ;
04448 }
04449 
04450 static int G__G__ProofPlayer_161_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04451 {
04452       G__letint(result7, 85, (long) TPacketizerAdaptive::Class());
04453    return(1 || funcname || hash || result7 || libp) ;
04454 }
04455 
04456 static int G__G__ProofPlayer_161_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04457 {
04458       G__letint(result7, 67, (long) TPacketizerAdaptive::Class_Name());
04459    return(1 || funcname || hash || result7 || libp) ;
04460 }
04461 
04462 static int G__G__ProofPlayer_161_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04463 {
04464       G__letint(result7, 115, (long) TPacketizerAdaptive::Class_Version());
04465    return(1 || funcname || hash || result7 || libp) ;
04466 }
04467 
04468 static int G__G__ProofPlayer_161_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04469 {
04470       TPacketizerAdaptive::Dictionary();
04471       G__setnull(result7);
04472    return(1 || funcname || hash || result7 || libp) ;
04473 }
04474 
04475 static int G__G__ProofPlayer_161_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04476 {
04477       ((TPacketizerAdaptive*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04478       G__setnull(result7);
04479    return(1 || funcname || hash || result7 || libp) ;
04480 }
04481 
04482 static int G__G__ProofPlayer_161_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04483 {
04484       G__letint(result7, 67, (long) TPacketizerAdaptive::DeclFileName());
04485    return(1 || funcname || hash || result7 || libp) ;
04486 }
04487 
04488 static int G__G__ProofPlayer_161_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04489 {
04490       G__letint(result7, 105, (long) TPacketizerAdaptive::ImplFileLine());
04491    return(1 || funcname || hash || result7 || libp) ;
04492 }
04493 
04494 static int G__G__ProofPlayer_161_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04495 {
04496       G__letint(result7, 67, (long) TPacketizerAdaptive::ImplFileName());
04497    return(1 || funcname || hash || result7 || libp) ;
04498 }
04499 
04500 static int G__G__ProofPlayer_161_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04501 {
04502       G__letint(result7, 105, (long) TPacketizerAdaptive::DeclFileLine());
04503    return(1 || funcname || hash || result7 || libp) ;
04504 }
04505 
04506 // automatic destructor
04507 typedef TPacketizerAdaptive G__TTPacketizerAdaptive;
04508 static int G__G__ProofPlayer_161_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04509 {
04510    char* gvp = (char*) G__getgvp();
04511    long soff = G__getstructoffset();
04512    int n = G__getaryconstruct();
04513    //
04514    //has_a_delete: 1
04515    //has_own_delete1arg: 0
04516    //has_own_delete2arg: 0
04517    //
04518    if (!soff) {
04519      return(1);
04520    }
04521    if (n) {
04522      if (gvp == (char*)G__PVOID) {
04523        delete[] (TPacketizerAdaptive*) soff;
04524      } else {
04525        G__setgvp((long) G__PVOID);
04526        for (int i = n - 1; i >= 0; --i) {
04527          ((TPacketizerAdaptive*) (soff+(sizeof(TPacketizerAdaptive)*i)))->~G__TTPacketizerAdaptive();
04528        }
04529        G__setgvp((long)gvp);
04530      }
04531    } else {
04532      if (gvp == (char*)G__PVOID) {
04533        delete (TPacketizerAdaptive*) soff;
04534      } else {
04535        G__setgvp((long) G__PVOID);
04536        ((TPacketizerAdaptive*) (soff))->~G__TTPacketizerAdaptive();
04537        G__setgvp((long)gvp);
04538      }
04539    }
04540    G__setnull(result7);
04541    return(1 || funcname || hash || result7 || libp) ;
04542 }
04543 
04544 
04545 /* TPacketizerFile */
04546 static int G__G__ProofPlayer_175_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04547 {
04548    TPacketizerFile* p = NULL;
04549    char* gvp = (char*) G__getgvp();
04550    switch (libp->paran) {
04551    case 4:
04552      //m: 4
04553      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04554        p = new TPacketizerFile(
04555 (TList*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
04556 , (TList*) G__int(libp->para[2]), (TProofProgressStatus*) G__int(libp->para[3]));
04557      } else {
04558        p = new((void*) gvp) TPacketizerFile(
04559 (TList*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
04560 , (TList*) G__int(libp->para[2]), (TProofProgressStatus*) G__int(libp->para[3]));
04561      }
04562      break;
04563    case 3:
04564      //m: 3
04565      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04566        p = new TPacketizerFile(
04567 (TList*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
04568 , (TList*) G__int(libp->para[2]));
04569      } else {
04570        p = new((void*) gvp) TPacketizerFile(
04571 (TList*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
04572 , (TList*) G__int(libp->para[2]));
04573      }
04574      break;
04575    }
04576    result7->obj.i = (long) p;
04577    result7->ref = (long) p;
04578    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerFile));
04579    return(1 || funcname || hash || result7 || libp) ;
04580 }
04581 
04582 static int G__G__ProofPlayer_175_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04583 {
04584       G__letdouble(result7, 100, (double) ((TPacketizerFile*) G__getstructoffset())->GetCurrentTime());
04585    return(1 || funcname || hash || result7 || libp) ;
04586 }
04587 
04588 static int G__G__ProofPlayer_175_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04589 {
04590       G__letint(result7, 85, (long) TPacketizerFile::Class());
04591    return(1 || funcname || hash || result7 || libp) ;
04592 }
04593 
04594 static int G__G__ProofPlayer_175_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04595 {
04596       G__letint(result7, 67, (long) TPacketizerFile::Class_Name());
04597    return(1 || funcname || hash || result7 || libp) ;
04598 }
04599 
04600 static int G__G__ProofPlayer_175_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04601 {
04602       G__letint(result7, 115, (long) TPacketizerFile::Class_Version());
04603    return(1 || funcname || hash || result7 || libp) ;
04604 }
04605 
04606 static int G__G__ProofPlayer_175_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04607 {
04608       TPacketizerFile::Dictionary();
04609       G__setnull(result7);
04610    return(1 || funcname || hash || result7 || libp) ;
04611 }
04612 
04613 static int G__G__ProofPlayer_175_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04614 {
04615       ((TPacketizerFile*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04616       G__setnull(result7);
04617    return(1 || funcname || hash || result7 || libp) ;
04618 }
04619 
04620 static int G__G__ProofPlayer_175_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04621 {
04622       G__letint(result7, 67, (long) TPacketizerFile::DeclFileName());
04623    return(1 || funcname || hash || result7 || libp) ;
04624 }
04625 
04626 static int G__G__ProofPlayer_175_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04627 {
04628       G__letint(result7, 105, (long) TPacketizerFile::ImplFileLine());
04629    return(1 || funcname || hash || result7 || libp) ;
04630 }
04631 
04632 static int G__G__ProofPlayer_175_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04633 {
04634       G__letint(result7, 67, (long) TPacketizerFile::ImplFileName());
04635    return(1 || funcname || hash || result7 || libp) ;
04636 }
04637 
04638 static int G__G__ProofPlayer_175_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04639 {
04640       G__letint(result7, 105, (long) TPacketizerFile::DeclFileLine());
04641    return(1 || funcname || hash || result7 || libp) ;
04642 }
04643 
04644 // automatic destructor
04645 typedef TPacketizerFile G__TTPacketizerFile;
04646 static int G__G__ProofPlayer_175_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04647 {
04648    char* gvp = (char*) G__getgvp();
04649    long soff = G__getstructoffset();
04650    int n = G__getaryconstruct();
04651    //
04652    //has_a_delete: 1
04653    //has_own_delete1arg: 0
04654    //has_own_delete2arg: 0
04655    //
04656    if (!soff) {
04657      return(1);
04658    }
04659    if (n) {
04660      if (gvp == (char*)G__PVOID) {
04661        delete[] (TPacketizerFile*) soff;
04662      } else {
04663        G__setgvp((long) G__PVOID);
04664        for (int i = n - 1; i >= 0; --i) {
04665          ((TPacketizerFile*) (soff+(sizeof(TPacketizerFile)*i)))->~G__TTPacketizerFile();
04666        }
04667        G__setgvp((long)gvp);
04668      }
04669    } else {
04670      if (gvp == (char*)G__PVOID) {
04671        delete (TPacketizerFile*) soff;
04672      } else {
04673        G__setgvp((long) G__PVOID);
04674        ((TPacketizerFile*) (soff))->~G__TTPacketizerFile();
04675        G__setgvp((long)gvp);
04676      }
04677    }
04678    G__setnull(result7);
04679    return(1 || funcname || hash || result7 || libp) ;
04680 }
04681 
04682 
04683 /* TPacketizer */
04684 static int G__G__ProofPlayer_178_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04685 {
04686    TPacketizer* p = NULL;
04687    char* gvp = (char*) G__getgvp();
04688    //m: 6
04689    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04690      p = new TPacketizer(
04691 (TDSet*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
04692 , (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
04693 , (TList*) G__int(libp->para[4]), (TProofProgressStatus*) G__int(libp->para[5]));
04694    } else {
04695      p = new((void*) gvp) TPacketizer(
04696 (TDSet*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
04697 , (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
04698 , (TList*) G__int(libp->para[4]), (TProofProgressStatus*) G__int(libp->para[5]));
04699    }
04700    result7->obj.i = (long) p;
04701    result7->ref = (long) p;
04702    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizer));
04703    return(1 || funcname || hash || result7 || libp) ;
04704 }
04705 
04706 static int G__G__ProofPlayer_178_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04707 {
04708       G__letLonglong(result7, 110, (G__int64) ((const TPacketizer*) G__getstructoffset())->GetEntriesProcessed((TSlave*) G__int(libp->para[0])));
04709    return(1 || funcname || hash || result7 || libp) ;
04710 }
04711 
04712 static int G__G__ProofPlayer_178_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04713 {
04714       G__letint(result7, 85, (long) TPacketizer::Class());
04715    return(1 || funcname || hash || result7 || libp) ;
04716 }
04717 
04718 static int G__G__ProofPlayer_178_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04719 {
04720       G__letint(result7, 67, (long) TPacketizer::Class_Name());
04721    return(1 || funcname || hash || result7 || libp) ;
04722 }
04723 
04724 static int G__G__ProofPlayer_178_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04725 {
04726       G__letint(result7, 115, (long) TPacketizer::Class_Version());
04727    return(1 || funcname || hash || result7 || libp) ;
04728 }
04729 
04730 static int G__G__ProofPlayer_178_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04731 {
04732       TPacketizer::Dictionary();
04733       G__setnull(result7);
04734    return(1 || funcname || hash || result7 || libp) ;
04735 }
04736 
04737 static int G__G__ProofPlayer_178_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04738 {
04739       ((TPacketizer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04740       G__setnull(result7);
04741    return(1 || funcname || hash || result7 || libp) ;
04742 }
04743 
04744 static int G__G__ProofPlayer_178_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04745 {
04746       G__letint(result7, 67, (long) TPacketizer::DeclFileName());
04747    return(1 || funcname || hash || result7 || libp) ;
04748 }
04749 
04750 static int G__G__ProofPlayer_178_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04751 {
04752       G__letint(result7, 105, (long) TPacketizer::ImplFileLine());
04753    return(1 || funcname || hash || result7 || libp) ;
04754 }
04755 
04756 static int G__G__ProofPlayer_178_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04757 {
04758       G__letint(result7, 67, (long) TPacketizer::ImplFileName());
04759    return(1 || funcname || hash || result7 || libp) ;
04760 }
04761 
04762 static int G__G__ProofPlayer_178_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04763 {
04764       G__letint(result7, 105, (long) TPacketizer::DeclFileLine());
04765    return(1 || funcname || hash || result7 || libp) ;
04766 }
04767 
04768 // automatic destructor
04769 typedef TPacketizer G__TTPacketizer;
04770 static int G__G__ProofPlayer_178_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04771 {
04772    char* gvp = (char*) G__getgvp();
04773    long soff = G__getstructoffset();
04774    int n = G__getaryconstruct();
04775    //
04776    //has_a_delete: 1
04777    //has_own_delete1arg: 0
04778    //has_own_delete2arg: 0
04779    //
04780    if (!soff) {
04781      return(1);
04782    }
04783    if (n) {
04784      if (gvp == (char*)G__PVOID) {
04785        delete[] (TPacketizer*) soff;
04786      } else {
04787        G__setgvp((long) G__PVOID);
04788        for (int i = n - 1; i >= 0; --i) {
04789          ((TPacketizer*) (soff+(sizeof(TPacketizer)*i)))->~G__TTPacketizer();
04790        }
04791        G__setgvp((long)gvp);
04792      }
04793    } else {
04794      if (gvp == (char*)G__PVOID) {
04795        delete (TPacketizer*) soff;
04796      } else {
04797        G__setgvp((long) G__PVOID);
04798        ((TPacketizer*) (soff))->~G__TTPacketizer();
04799        G__setgvp((long)gvp);
04800      }
04801    }
04802    G__setnull(result7);
04803    return(1 || funcname || hash || result7 || libp) ;
04804 }
04805 
04806 
04807 /* TPacketizerMulti */
04808 static int G__G__ProofPlayer_182_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04809 {
04810    TPacketizerMulti* p = NULL;
04811    char* gvp = (char*) G__getgvp();
04812    //m: 6
04813    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04814      p = new TPacketizerMulti(
04815 (TDSet*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
04816 , (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
04817 , (TList*) G__int(libp->para[4]), (TProofProgressStatus*) G__int(libp->para[5]));
04818    } else {
04819      p = new((void*) gvp) TPacketizerMulti(
04820 (TDSet*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
04821 , (Long64_t) G__Longlong(libp->para[2]), (Long64_t) G__Longlong(libp->para[3])
04822 , (TList*) G__int(libp->para[4]), (TProofProgressStatus*) G__int(libp->para[5]));
04823    }
04824    result7->obj.i = (long) p;
04825    result7->ref = (long) p;
04826    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerMulti));
04827    return(1 || funcname || hash || result7 || libp) ;
04828 }
04829 
04830 static int G__G__ProofPlayer_182_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04831 {
04832       G__letint(result7, 85, (long) TPacketizerMulti::Class());
04833    return(1 || funcname || hash || result7 || libp) ;
04834 }
04835 
04836 static int G__G__ProofPlayer_182_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04837 {
04838       G__letint(result7, 67, (long) TPacketizerMulti::Class_Name());
04839    return(1 || funcname || hash || result7 || libp) ;
04840 }
04841 
04842 static int G__G__ProofPlayer_182_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04843 {
04844       G__letint(result7, 115, (long) TPacketizerMulti::Class_Version());
04845    return(1 || funcname || hash || result7 || libp) ;
04846 }
04847 
04848 static int G__G__ProofPlayer_182_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04849 {
04850       TPacketizerMulti::Dictionary();
04851       G__setnull(result7);
04852    return(1 || funcname || hash || result7 || libp) ;
04853 }
04854 
04855 static int G__G__ProofPlayer_182_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04856 {
04857       ((TPacketizerMulti*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04858       G__setnull(result7);
04859    return(1 || funcname || hash || result7 || libp) ;
04860 }
04861 
04862 static int G__G__ProofPlayer_182_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04863 {
04864       G__letint(result7, 67, (long) TPacketizerMulti::DeclFileName());
04865    return(1 || funcname || hash || result7 || libp) ;
04866 }
04867 
04868 static int G__G__ProofPlayer_182_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04869 {
04870       G__letint(result7, 105, (long) TPacketizerMulti::ImplFileLine());
04871    return(1 || funcname || hash || result7 || libp) ;
04872 }
04873 
04874 static int G__G__ProofPlayer_182_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04875 {
04876       G__letint(result7, 67, (long) TPacketizerMulti::ImplFileName());
04877    return(1 || funcname || hash || result7 || libp) ;
04878 }
04879 
04880 static int G__G__ProofPlayer_182_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04881 {
04882       G__letint(result7, 105, (long) TPacketizerMulti::DeclFileLine());
04883    return(1 || funcname || hash || result7 || libp) ;
04884 }
04885 
04886 // automatic destructor
04887 typedef TPacketizerMulti G__TTPacketizerMulti;
04888 static int G__G__ProofPlayer_182_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04889 {
04890    char* gvp = (char*) G__getgvp();
04891    long soff = G__getstructoffset();
04892    int n = G__getaryconstruct();
04893    //
04894    //has_a_delete: 1
04895    //has_own_delete1arg: 0
04896    //has_own_delete2arg: 0
04897    //
04898    if (!soff) {
04899      return(1);
04900    }
04901    if (n) {
04902      if (gvp == (char*)G__PVOID) {
04903        delete[] (TPacketizerMulti*) soff;
04904      } else {
04905        G__setgvp((long) G__PVOID);
04906        for (int i = n - 1; i >= 0; --i) {
04907          ((TPacketizerMulti*) (soff+(sizeof(TPacketizerMulti)*i)))->~G__TTPacketizerMulti();
04908        }
04909        G__setgvp((long)gvp);
04910      }
04911    } else {
04912      if (gvp == (char*)G__PVOID) {
04913        delete (TPacketizerMulti*) soff;
04914      } else {
04915        G__setgvp((long) G__PVOID);
04916        ((TPacketizerMulti*) (soff))->~G__TTPacketizerMulti();
04917        G__setgvp((long)gvp);
04918      }
04919    }
04920    G__setnull(result7);
04921    return(1 || funcname || hash || result7 || libp) ;
04922 }
04923 
04924 
04925 /* TPacketizerUnit */
04926 static int G__G__ProofPlayer_183_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04927 {
04928    TPacketizerUnit* p = NULL;
04929    char* gvp = (char*) G__getgvp();
04930    switch (libp->paran) {
04931    case 4:
04932      //m: 4
04933      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04934        p = new TPacketizerUnit(
04935 (TList*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
04936 , (TList*) G__int(libp->para[2]), (TProofProgressStatus*) G__int(libp->para[3]));
04937      } else {
04938        p = new((void*) gvp) TPacketizerUnit(
04939 (TList*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
04940 , (TList*) G__int(libp->para[2]), (TProofProgressStatus*) G__int(libp->para[3]));
04941      }
04942      break;
04943    case 3:
04944      //m: 3
04945      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04946        p = new TPacketizerUnit(
04947 (TList*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
04948 , (TList*) G__int(libp->para[2]));
04949      } else {
04950        p = new((void*) gvp) TPacketizerUnit(
04951 (TList*) G__int(libp->para[0]), (Long64_t) G__Longlong(libp->para[1])
04952 , (TList*) G__int(libp->para[2]));
04953      }
04954      break;
04955    }
04956    result7->obj.i = (long) p;
04957    result7->ref = (long) p;
04958    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerUnit));
04959    return(1 || funcname || hash || result7 || libp) ;
04960 }
04961 
04962 static int G__G__ProofPlayer_183_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04963 {
04964       G__letdouble(result7, 100, (double) ((TPacketizerUnit*) G__getstructoffset())->GetCurrentTime());
04965    return(1 || funcname || hash || result7 || libp) ;
04966 }
04967 
04968 static int G__G__ProofPlayer_183_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04969 {
04970       G__letint(result7, 85, (long) TPacketizerUnit::Class());
04971    return(1 || funcname || hash || result7 || libp) ;
04972 }
04973 
04974 static int G__G__ProofPlayer_183_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04975 {
04976       G__letint(result7, 67, (long) TPacketizerUnit::Class_Name());
04977    return(1 || funcname || hash || result7 || libp) ;
04978 }
04979 
04980 static int G__G__ProofPlayer_183_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04981 {
04982       G__letint(result7, 115, (long) TPacketizerUnit::Class_Version());
04983    return(1 || funcname || hash || result7 || libp) ;
04984 }
04985 
04986 static int G__G__ProofPlayer_183_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04987 {
04988       TPacketizerUnit::Dictionary();
04989       G__setnull(result7);
04990    return(1 || funcname || hash || result7 || libp) ;
04991 }
04992 
04993 static int G__G__ProofPlayer_183_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04994 {
04995       ((TPacketizerUnit*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04996       G__setnull(result7);
04997    return(1 || funcname || hash || result7 || libp) ;
04998 }
04999 
05000 static int G__G__ProofPlayer_183_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05001 {
05002       G__letint(result7, 67, (long) TPacketizerUnit::DeclFileName());
05003    return(1 || funcname || hash || result7 || libp) ;
05004 }
05005 
05006 static int G__G__ProofPlayer_183_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05007 {
05008       G__letint(result7, 105, (long) TPacketizerUnit::ImplFileLine());
05009    return(1 || funcname || hash || result7 || libp) ;
05010 }
05011 
05012 static int G__G__ProofPlayer_183_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05013 {
05014       G__letint(result7, 67, (long) TPacketizerUnit::ImplFileName());
05015    return(1 || funcname || hash || result7 || libp) ;
05016 }
05017 
05018 static int G__G__ProofPlayer_183_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05019 {
05020       G__letint(result7, 105, (long) TPacketizerUnit::DeclFileLine());
05021    return(1 || funcname || hash || result7 || libp) ;
05022 }
05023 
05024 // automatic destructor
05025 typedef TPacketizerUnit G__TTPacketizerUnit;
05026 static int G__G__ProofPlayer_183_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05027 {
05028    char* gvp = (char*) G__getgvp();
05029    long soff = G__getstructoffset();
05030    int n = G__getaryconstruct();
05031    //
05032    //has_a_delete: 1
05033    //has_own_delete1arg: 0
05034    //has_own_delete2arg: 0
05035    //
05036    if (!soff) {
05037      return(1);
05038    }
05039    if (n) {
05040      if (gvp == (char*)G__PVOID) {
05041        delete[] (TPacketizerUnit*) soff;
05042      } else {
05043        G__setgvp((long) G__PVOID);
05044        for (int i = n - 1; i >= 0; --i) {
05045          ((TPacketizerUnit*) (soff+(sizeof(TPacketizerUnit)*i)))->~G__TTPacketizerUnit();
05046        }
05047        G__setgvp((long)gvp);
05048      }
05049    } else {
05050      if (gvp == (char*)G__PVOID) {
05051        delete (TPacketizerUnit*) soff;
05052      } else {
05053        G__setgvp((long) G__PVOID);
05054        ((TPacketizerUnit*) (soff))->~G__TTPacketizerUnit();
05055        G__setgvp((long)gvp);
05056      }
05057    }
05058    G__setnull(result7);
05059    return(1 || funcname || hash || result7 || libp) ;
05060 }
05061 
05062 
05063 /* TPerfEvent */
05064 static int G__G__ProofPlayer_196_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05065 {
05066    TPerfEvent* p = NULL;
05067    char* gvp = (char*) G__getgvp();
05068    switch (libp->paran) {
05069    case 1:
05070      //m: 1
05071      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05072        p = new TPerfEvent((TTimeStamp*) G__int(libp->para[0]));
05073      } else {
05074        p = new((void*) gvp) TPerfEvent((TTimeStamp*) G__int(libp->para[0]));
05075      }
05076      break;
05077    case 0:
05078      int n = G__getaryconstruct();
05079      if (n) {
05080        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05081          p = new TPerfEvent[n];
05082        } else {
05083          p = new((void*) gvp) TPerfEvent[n];
05084        }
05085      } else {
05086        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05087          p = new TPerfEvent;
05088        } else {
05089          p = new((void*) gvp) TPerfEvent;
05090        }
05091      }
05092      break;
05093    }
05094    result7->obj.i = (long) p;
05095    result7->ref = (long) p;
05096    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfEvent));
05097    return(1 || funcname || hash || result7 || libp) ;
05098 }
05099 
05100 static int G__G__ProofPlayer_196_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05101 {
05102       G__letint(result7, 85, (long) TPerfEvent::Class());
05103    return(1 || funcname || hash || result7 || libp) ;
05104 }
05105 
05106 static int G__G__ProofPlayer_196_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05107 {
05108       G__letint(result7, 67, (long) TPerfEvent::Class_Name());
05109    return(1 || funcname || hash || result7 || libp) ;
05110 }
05111 
05112 static int G__G__ProofPlayer_196_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05113 {
05114       G__letint(result7, 115, (long) TPerfEvent::Class_Version());
05115    return(1 || funcname || hash || result7 || libp) ;
05116 }
05117 
05118 static int G__G__ProofPlayer_196_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05119 {
05120       TPerfEvent::Dictionary();
05121       G__setnull(result7);
05122    return(1 || funcname || hash || result7 || libp) ;
05123 }
05124 
05125 static int G__G__ProofPlayer_196_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05126 {
05127       ((TPerfEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05128       G__setnull(result7);
05129    return(1 || funcname || hash || result7 || libp) ;
05130 }
05131 
05132 static int G__G__ProofPlayer_196_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05133 {
05134       G__letint(result7, 67, (long) TPerfEvent::DeclFileName());
05135    return(1 || funcname || hash || result7 || libp) ;
05136 }
05137 
05138 static int G__G__ProofPlayer_196_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05139 {
05140       G__letint(result7, 105, (long) TPerfEvent::ImplFileLine());
05141    return(1 || funcname || hash || result7 || libp) ;
05142 }
05143 
05144 static int G__G__ProofPlayer_196_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05145 {
05146       G__letint(result7, 67, (long) TPerfEvent::ImplFileName());
05147    return(1 || funcname || hash || result7 || libp) ;
05148 }
05149 
05150 static int G__G__ProofPlayer_196_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05151 {
05152       G__letint(result7, 105, (long) TPerfEvent::DeclFileLine());
05153    return(1 || funcname || hash || result7 || libp) ;
05154 }
05155 
05156 // automatic copy constructor
05157 static int G__G__ProofPlayer_196_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05158 
05159 {
05160    TPerfEvent* p;
05161    void* tmp = (void*) G__int(libp->para[0]);
05162    p = new TPerfEvent(*(TPerfEvent*) tmp);
05163    result7->obj.i = (long) p;
05164    result7->ref = (long) p;
05165    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfEvent));
05166    return(1 || funcname || hash || result7 || libp) ;
05167 }
05168 
05169 // automatic destructor
05170 typedef TPerfEvent G__TTPerfEvent;
05171 static int G__G__ProofPlayer_196_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05172 {
05173    char* gvp = (char*) G__getgvp();
05174    long soff = G__getstructoffset();
05175    int n = G__getaryconstruct();
05176    //
05177    //has_a_delete: 1
05178    //has_own_delete1arg: 0
05179    //has_own_delete2arg: 0
05180    //
05181    if (!soff) {
05182      return(1);
05183    }
05184    if (n) {
05185      if (gvp == (char*)G__PVOID) {
05186        delete[] (TPerfEvent*) soff;
05187      } else {
05188        G__setgvp((long) G__PVOID);
05189        for (int i = n - 1; i >= 0; --i) {
05190          ((TPerfEvent*) (soff+(sizeof(TPerfEvent)*i)))->~G__TTPerfEvent();
05191        }
05192        G__setgvp((long)gvp);
05193      }
05194    } else {
05195      if (gvp == (char*)G__PVOID) {
05196        delete (TPerfEvent*) soff;
05197      } else {
05198        G__setgvp((long) G__PVOID);
05199        ((TPerfEvent*) (soff))->~G__TTPerfEvent();
05200        G__setgvp((long)gvp);
05201      }
05202    }
05203    G__setnull(result7);
05204    return(1 || funcname || hash || result7 || libp) ;
05205 }
05206 
05207 // automatic assignment operator
05208 static int G__G__ProofPlayer_196_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05209 {
05210    TPerfEvent* dest = (TPerfEvent*) G__getstructoffset();
05211    *dest = *(TPerfEvent*) libp->para[0].ref;
05212    const TPerfEvent& obj = *dest;
05213    result7->ref = (long) (&obj);
05214    result7->obj.i = (long) (&obj);
05215    return(1 || funcname || hash || result7 || libp) ;
05216 }
05217 
05218 
05219 /* TPerfStats */
05220 static int G__G__ProofPlayer_197_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05221 {
05222       TPerfStats::Start((TList*) G__int(libp->para[0]), (TList*) G__int(libp->para[1]));
05223       G__setnull(result7);
05224    return(1 || funcname || hash || result7 || libp) ;
05225 }
05226 
05227 static int G__G__ProofPlayer_197_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05228 {
05229       TPerfStats::Stop();
05230       G__setnull(result7);
05231    return(1 || funcname || hash || result7 || libp) ;
05232 }
05233 
05234 static int G__G__ProofPlayer_197_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05235 {
05236       TPerfStats::Setup((TList*) G__int(libp->para[0]));
05237       G__setnull(result7);
05238    return(1 || funcname || hash || result7 || libp) ;
05239 }
05240 
05241 static int G__G__ProofPlayer_197_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05242 {
05243       G__letint(result7, 85, (long) TPerfStats::Class());
05244    return(1 || funcname || hash || result7 || libp) ;
05245 }
05246 
05247 static int G__G__ProofPlayer_197_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05248 {
05249       G__letint(result7, 67, (long) TPerfStats::Class_Name());
05250    return(1 || funcname || hash || result7 || libp) ;
05251 }
05252 
05253 static int G__G__ProofPlayer_197_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05254 {
05255       G__letint(result7, 115, (long) TPerfStats::Class_Version());
05256    return(1 || funcname || hash || result7 || libp) ;
05257 }
05258 
05259 static int G__G__ProofPlayer_197_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05260 {
05261       TPerfStats::Dictionary();
05262       G__setnull(result7);
05263    return(1 || funcname || hash || result7 || libp) ;
05264 }
05265 
05266 static int G__G__ProofPlayer_197_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05267 {
05268       ((TPerfStats*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05269       G__setnull(result7);
05270    return(1 || funcname || hash || result7 || libp) ;
05271 }
05272 
05273 static int G__G__ProofPlayer_197_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05274 {
05275       G__letint(result7, 67, (long) TPerfStats::DeclFileName());
05276    return(1 || funcname || hash || result7 || libp) ;
05277 }
05278 
05279 static int G__G__ProofPlayer_197_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05280 {
05281       G__letint(result7, 105, (long) TPerfStats::ImplFileLine());
05282    return(1 || funcname || hash || result7 || libp) ;
05283 }
05284 
05285 static int G__G__ProofPlayer_197_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05286 {
05287       G__letint(result7, 67, (long) TPerfStats::ImplFileName());
05288    return(1 || funcname || hash || result7 || libp) ;
05289 }
05290 
05291 static int G__G__ProofPlayer_197_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05292 {
05293       G__letint(result7, 105, (long) TPerfStats::DeclFileLine());
05294    return(1 || funcname || hash || result7 || libp) ;
05295 }
05296 
05297 // automatic copy constructor
05298 static int G__G__ProofPlayer_197_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05299 
05300 {
05301    TPerfStats* p;
05302    void* tmp = (void*) G__int(libp->para[0]);
05303    p = new TPerfStats(*(TPerfStats*) tmp);
05304    result7->obj.i = (long) p;
05305    result7->ref = (long) p;
05306    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfStats));
05307    return(1 || funcname || hash || result7 || libp) ;
05308 }
05309 
05310 // automatic destructor
05311 typedef TPerfStats G__TTPerfStats;
05312 static int G__G__ProofPlayer_197_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05313 {
05314    char* gvp = (char*) G__getgvp();
05315    long soff = G__getstructoffset();
05316    int n = G__getaryconstruct();
05317    //
05318    //has_a_delete: 1
05319    //has_own_delete1arg: 0
05320    //has_own_delete2arg: 0
05321    //
05322    if (!soff) {
05323      return(1);
05324    }
05325    if (n) {
05326      if (gvp == (char*)G__PVOID) {
05327        delete[] (TPerfStats*) soff;
05328      } else {
05329        G__setgvp((long) G__PVOID);
05330        for (int i = n - 1; i >= 0; --i) {
05331          ((TPerfStats*) (soff+(sizeof(TPerfStats)*i)))->~G__TTPerfStats();
05332        }
05333        G__setgvp((long)gvp);
05334      }
05335    } else {
05336      if (gvp == (char*)G__PVOID) {
05337        delete (TPerfStats*) soff;
05338      } else {
05339        G__setgvp((long) G__PVOID);
05340        ((TPerfStats*) (soff))->~G__TTPerfStats();
05341        G__setgvp((long)gvp);
05342      }
05343    }
05344    G__setnull(result7);
05345    return(1 || funcname || hash || result7 || libp) ;
05346 }
05347 
05348 // automatic assignment operator
05349 static int G__G__ProofPlayer_197_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05350 {
05351    TPerfStats* dest = (TPerfStats*) G__getstructoffset();
05352    *dest = *(TPerfStats*) libp->para[0].ref;
05353    const TPerfStats& obj = *dest;
05354    result7->ref = (long) (&obj);
05355    result7->obj.i = (long) (&obj);
05356    return(1 || funcname || hash || result7 || libp) ;
05357 }
05358 
05359 
05360 /* TProofLimitsFinder */
05361 static int G__G__ProofPlayer_200_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05362 {
05363    TProofLimitsFinder* p = NULL;
05364    char* gvp = (char*) G__getgvp();
05365    int n = G__getaryconstruct();
05366    if (n) {
05367      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05368        p = new TProofLimitsFinder[n];
05369      } else {
05370        p = new((void*) gvp) TProofLimitsFinder[n];
05371      }
05372    } else {
05373      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05374        p = new TProofLimitsFinder;
05375      } else {
05376        p = new((void*) gvp) TProofLimitsFinder;
05377      }
05378    }
05379    result7->obj.i = (long) p;
05380    result7->ref = (long) p;
05381    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofLimitsFinder));
05382    return(1 || funcname || hash || result7 || libp) ;
05383 }
05384 
05385 static int G__G__ProofPlayer_200_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05386 {
05387       TProofLimitsFinder::AutoBinFunc(
05388 *(TString*) libp->para[0].ref, *(Double_t*) G__Doubleref(&libp->para[1])
05389 , *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
05390 , *(Double_t*) G__Doubleref(&libp->para[4]), *(Double_t*) G__Doubleref(&libp->para[5])
05391 , *(Double_t*) G__Doubleref(&libp->para[6]));
05392       G__setnull(result7);
05393    return(1 || funcname || hash || result7 || libp) ;
05394 }
05395 
05396 static int G__G__ProofPlayer_200_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05397 {
05398       G__letint(result7, 85, (long) TProofLimitsFinder::Class());
05399    return(1 || funcname || hash || result7 || libp) ;
05400 }
05401 
05402 static int G__G__ProofPlayer_200_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05403 {
05404       G__letint(result7, 67, (long) TProofLimitsFinder::Class_Name());
05405    return(1 || funcname || hash || result7 || libp) ;
05406 }
05407 
05408 static int G__G__ProofPlayer_200_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05409 {
05410       G__letint(result7, 115, (long) TProofLimitsFinder::Class_Version());
05411    return(1 || funcname || hash || result7 || libp) ;
05412 }
05413 
05414 static int G__G__ProofPlayer_200_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05415 {
05416       TProofLimitsFinder::Dictionary();
05417       G__setnull(result7);
05418    return(1 || funcname || hash || result7 || libp) ;
05419 }
05420 
05421 static int G__G__ProofPlayer_200_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05422 {
05423       ((TProofLimitsFinder*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05424       G__setnull(result7);
05425    return(1 || funcname || hash || result7 || libp) ;
05426 }
05427 
05428 static int G__G__ProofPlayer_200_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05429 {
05430       G__letint(result7, 67, (long) TProofLimitsFinder::DeclFileName());
05431    return(1 || funcname || hash || result7 || libp) ;
05432 }
05433 
05434 static int G__G__ProofPlayer_200_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05435 {
05436       G__letint(result7, 105, (long) TProofLimitsFinder::ImplFileLine());
05437    return(1 || funcname || hash || result7 || libp) ;
05438 }
05439 
05440 static int G__G__ProofPlayer_200_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05441 {
05442       G__letint(result7, 67, (long) TProofLimitsFinder::ImplFileName());
05443    return(1 || funcname || hash || result7 || libp) ;
05444 }
05445 
05446 static int G__G__ProofPlayer_200_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05447 {
05448       G__letint(result7, 105, (long) TProofLimitsFinder::DeclFileLine());
05449    return(1 || funcname || hash || result7 || libp) ;
05450 }
05451 
05452 // automatic copy constructor
05453 static int G__G__ProofPlayer_200_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05454 
05455 {
05456    TProofLimitsFinder* p;
05457    void* tmp = (void*) G__int(libp->para[0]);
05458    p = new TProofLimitsFinder(*(TProofLimitsFinder*) tmp);
05459    result7->obj.i = (long) p;
05460    result7->ref = (long) p;
05461    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofLimitsFinder));
05462    return(1 || funcname || hash || result7 || libp) ;
05463 }
05464 
05465 // automatic destructor
05466 typedef TProofLimitsFinder G__TTProofLimitsFinder;
05467 static int G__G__ProofPlayer_200_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05468 {
05469    char* gvp = (char*) G__getgvp();
05470    long soff = G__getstructoffset();
05471    int n = G__getaryconstruct();
05472    //
05473    //has_a_delete: 1
05474    //has_own_delete1arg: 0
05475    //has_own_delete2arg: 0
05476    //
05477    if (!soff) {
05478      return(1);
05479    }
05480    if (n) {
05481      if (gvp == (char*)G__PVOID) {
05482        delete[] (TProofLimitsFinder*) soff;
05483      } else {
05484        G__setgvp((long) G__PVOID);
05485        for (int i = n - 1; i >= 0; --i) {
05486          ((TProofLimitsFinder*) (soff+(sizeof(TProofLimitsFinder)*i)))->~G__TTProofLimitsFinder();
05487        }
05488        G__setgvp((long)gvp);
05489      }
05490    } else {
05491      if (gvp == (char*)G__PVOID) {
05492        delete (TProofLimitsFinder*) soff;
05493      } else {
05494        G__setgvp((long) G__PVOID);
05495        ((TProofLimitsFinder*) (soff))->~G__TTProofLimitsFinder();
05496        G__setgvp((long)gvp);
05497      }
05498    }
05499    G__setnull(result7);
05500    return(1 || funcname || hash || result7 || libp) ;
05501 }
05502 
05503 // automatic assignment operator
05504 static int G__G__ProofPlayer_200_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05505 {
05506    TProofLimitsFinder* dest = (TProofLimitsFinder*) G__getstructoffset();
05507    *dest = *(TProofLimitsFinder*) libp->para[0].ref;
05508    const TProofLimitsFinder& obj = *dest;
05509    result7->ref = (long) (&obj);
05510    result7->obj.i = (long) (&obj);
05511    return(1 || funcname || hash || result7 || libp) ;
05512 }
05513 
05514 
05515 /* TProofOutputFile */
05516 static int G__G__ProofPlayer_201_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05517 {
05518    TProofOutputFile* p = NULL;
05519    char* gvp = (char*) G__getgvp();
05520    int n = G__getaryconstruct();
05521    if (n) {
05522      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05523        p = new TProofOutputFile[n];
05524      } else {
05525        p = new((void*) gvp) TProofOutputFile[n];
05526      }
05527    } else {
05528      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05529        p = new TProofOutputFile;
05530      } else {
05531        p = new((void*) gvp) TProofOutputFile;
05532      }
05533    }
05534    result7->obj.i = (long) p;
05535    result7->ref = (long) p;
05536    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFile));
05537    return(1 || funcname || hash || result7 || libp) ;
05538 }
05539 
05540 static int G__G__ProofPlayer_201_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05541 {
05542    TProofOutputFile* p = NULL;
05543    char* gvp = (char*) G__getgvp();
05544    switch (libp->paran) {
05545    case 3:
05546      //m: 3
05547      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05548        p = new TProofOutputFile(
05549 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05550 , (const char*) G__int(libp->para[2]));
05551      } else {
05552        p = new((void*) gvp) TProofOutputFile(
05553 (const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
05554 , (const char*) G__int(libp->para[2]));
05555      }
05556      break;
05557    case 2:
05558      //m: 2
05559      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05560        p = new TProofOutputFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
05561      } else {
05562        p = new((void*) gvp) TProofOutputFile((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
05563      }
05564      break;
05565    case 1:
05566      //m: 1
05567      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05568        p = new TProofOutputFile((const char*) G__int(libp->para[0]));
05569      } else {
05570        p = new((void*) gvp) TProofOutputFile((const char*) G__int(libp->para[0]));
05571      }
05572      break;
05573    }
05574    result7->obj.i = (long) p;
05575    result7->ref = (long) p;
05576    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFile));
05577    return(1 || funcname || hash || result7 || libp) ;
05578 }
05579 
05580 static int G__G__ProofPlayer_201_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05581 {
05582    TProofOutputFile* p = NULL;
05583    char* gvp = (char*) G__getgvp();
05584    switch (libp->paran) {
05585    case 4:
05586      //m: 4
05587      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05588        p = new TProofOutputFile(
05589 (const char*) G__int(libp->para[0]), (TProofOutputFile::ERunType) G__int(libp->para[1])
05590 , (UInt_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
05591      } else {
05592        p = new((void*) gvp) TProofOutputFile(
05593 (const char*) G__int(libp->para[0]), (TProofOutputFile::ERunType) G__int(libp->para[1])
05594 , (UInt_t) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
05595      }
05596      break;
05597    case 3:
05598      //m: 3
05599      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05600        p = new TProofOutputFile(
05601 (const char*) G__int(libp->para[0]), (TProofOutputFile::ERunType) G__int(libp->para[1])
05602 , (UInt_t) G__int(libp->para[2]));
05603      } else {
05604        p = new((void*) gvp) TProofOutputFile(
05605 (const char*) G__int(libp->para[0]), (TProofOutputFile::ERunType) G__int(libp->para[1])
05606 , (UInt_t) G__int(libp->para[2]));
05607      }
05608      break;
05609    case 2:
05610      //m: 2
05611      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05612        p = new TProofOutputFile((const char*) G__int(libp->para[0]), (TProofOutputFile::ERunType) G__int(libp->para[1]));
05613      } else {
05614        p = new((void*) gvp) TProofOutputFile((const char*) G__int(libp->para[0]), (TProofOutputFile::ERunType) G__int(libp->para[1]));
05615      }
05616      break;
05617    }
05618    result7->obj.i = (long) p;
05619    result7->ref = (long) p;
05620    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFile));
05621    return(1 || funcname || hash || result7 || libp) ;
05622 }
05623 
05624 static int G__G__ProofPlayer_201_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05625 {
05626    switch (libp->paran) {
05627    case 1:
05628       G__letint(result7, 67, (long) ((const TProofOutputFile*) G__getstructoffset())->GetDir((Bool_t) G__int(libp->para[0])));
05629       break;
05630    case 0:
05631       G__letint(result7, 67, (long) ((const TProofOutputFile*) G__getstructoffset())->GetDir());
05632       break;
05633    }
05634    return(1 || funcname || hash || result7 || libp) ;
05635 }
05636 
05637 static int G__G__ProofPlayer_201_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05638 {
05639       G__letint(result7, 85, (long) ((TProofOutputFile*) G__getstructoffset())->GetFileCollection());
05640    return(1 || funcname || hash || result7 || libp) ;
05641 }
05642 
05643 static int G__G__ProofPlayer_201_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05644 {
05645    switch (libp->paran) {
05646    case 1:
05647       G__letint(result7, 85, (long) ((TProofOutputFile*) G__getstructoffset())->GetFileMerger((Bool_t) G__int(libp->para[0])));
05648       break;
05649    case 0:
05650       G__letint(result7, 85, (long) ((TProofOutputFile*) G__getstructoffset())->GetFileMerger());
05651       break;
05652    }
05653    return(1 || funcname || hash || result7 || libp) ;
05654 }
05655 
05656 static int G__G__ProofPlayer_201_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05657 {
05658       G__letint(result7, 67, (long) ((const TProofOutputFile*) G__getstructoffset())->GetFileName());
05659    return(1 || funcname || hash || result7 || libp) ;
05660 }
05661 
05662 static int G__G__ProofPlayer_201_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05663 {
05664       G__letint(result7, 67, (long) ((const TProofOutputFile*) G__getstructoffset())->GetLocalHost());
05665    return(1 || funcname || hash || result7 || libp) ;
05666 }
05667 
05668 static int G__G__ProofPlayer_201_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05669 {
05670       G__letint(result7, 67, (long) ((const TProofOutputFile*) G__getstructoffset())->GetOptionsAnchor());
05671    return(1 || funcname || hash || result7 || libp) ;
05672 }
05673 
05674 static int G__G__ProofPlayer_201_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05675 {
05676       G__letint(result7, 67, (long) ((const TProofOutputFile*) G__getstructoffset())->GetOutputFileName());
05677    return(1 || funcname || hash || result7 || libp) ;
05678 }
05679 
05680 static int G__G__ProofPlayer_201_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05681 {
05682       G__letint(result7, 67, (long) ((const TProofOutputFile*) G__getstructoffset())->GetWorkerOrdinal());
05683    return(1 || funcname || hash || result7 || libp) ;
05684 }
05685 
05686 static int G__G__ProofPlayer_201_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05687 {
05688       G__letint(result7, 105, (long) ((const TProofOutputFile*) G__getstructoffset())->GetRunType());
05689    return(1 || funcname || hash || result7 || libp) ;
05690 }
05691 
05692 static int G__G__ProofPlayer_201_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05693 {
05694       G__letint(result7, 104, (long) ((const TProofOutputFile*) G__getstructoffset())->GetTypeOpt());
05695    return(1 || funcname || hash || result7 || libp) ;
05696 }
05697 
05698 static int G__G__ProofPlayer_201_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05699 {
05700       G__letint(result7, 103, (long) ((const TProofOutputFile*) G__getstructoffset())->IsMerge());
05701    return(1 || funcname || hash || result7 || libp) ;
05702 }
05703 
05704 static int G__G__ProofPlayer_201_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05705 {
05706       G__letint(result7, 103, (long) ((const TProofOutputFile*) G__getstructoffset())->IsMerged());
05707    return(1 || funcname || hash || result7 || libp) ;
05708 }
05709 
05710 static int G__G__ProofPlayer_201_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05711 {
05712       G__letint(result7, 103, (long) ((const TProofOutputFile*) G__getstructoffset())->IsRegister());
05713    return(1 || funcname || hash || result7 || libp) ;
05714 }
05715 
05716 static int G__G__ProofPlayer_201_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05717 {
05718       G__letint(result7, 105, (long) ((TProofOutputFile*) G__getstructoffset())->AdoptFile((TFile*) G__int(libp->para[0])));
05719    return(1 || funcname || hash || result7 || libp) ;
05720 }
05721 
05722 static int G__G__ProofPlayer_201_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05723 {
05724       G__letint(result7, 85, (long) ((TProofOutputFile*) G__getstructoffset())->OpenFile((const char*) G__int(libp->para[0])));
05725    return(1 || funcname || hash || result7 || libp) ;
05726 }
05727 
05728 static int G__G__ProofPlayer_201_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05729 {
05730       G__letLonglong(result7, 110, (G__int64) ((TProofOutputFile*) G__getstructoffset())->Merge((TCollection*) G__int(libp->para[0])));
05731    return(1 || funcname || hash || result7 || libp) ;
05732 }
05733 
05734 static int G__G__ProofPlayer_201_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05735 {
05736       ((TProofOutputFile*) G__getstructoffset())->SetOutputFileName((const char*) G__int(libp->para[0]));
05737       G__setnull(result7);
05738    return(1 || funcname || hash || result7 || libp) ;
05739 }
05740 
05741 static int G__G__ProofPlayer_201_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05742 {
05743       ((TProofOutputFile*) G__getstructoffset())->ResetFileCollection();
05744       G__setnull(result7);
05745    return(1 || funcname || hash || result7 || libp) ;
05746 }
05747 
05748 static int G__G__ProofPlayer_201_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05749 {
05750       G__letint(result7, 85, (long) TProofOutputFile::Class());
05751    return(1 || funcname || hash || result7 || libp) ;
05752 }
05753 
05754 static int G__G__ProofPlayer_201_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05755 {
05756       G__letint(result7, 67, (long) TProofOutputFile::Class_Name());
05757    return(1 || funcname || hash || result7 || libp) ;
05758 }
05759 
05760 static int G__G__ProofPlayer_201_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05761 {
05762       G__letint(result7, 115, (long) TProofOutputFile::Class_Version());
05763    return(1 || funcname || hash || result7 || libp) ;
05764 }
05765 
05766 static int G__G__ProofPlayer_201_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05767 {
05768       TProofOutputFile::Dictionary();
05769       G__setnull(result7);
05770    return(1 || funcname || hash || result7 || libp) ;
05771 }
05772 
05773 static int G__G__ProofPlayer_201_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05774 {
05775       ((TProofOutputFile*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05776       G__setnull(result7);
05777    return(1 || funcname || hash || result7 || libp) ;
05778 }
05779 
05780 static int G__G__ProofPlayer_201_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05781 {
05782       G__letint(result7, 67, (long) TProofOutputFile::DeclFileName());
05783    return(1 || funcname || hash || result7 || libp) ;
05784 }
05785 
05786 static int G__G__ProofPlayer_201_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05787 {
05788       G__letint(result7, 105, (long) TProofOutputFile::ImplFileLine());
05789    return(1 || funcname || hash || result7 || libp) ;
05790 }
05791 
05792 static int G__G__ProofPlayer_201_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05793 {
05794       G__letint(result7, 67, (long) TProofOutputFile::ImplFileName());
05795    return(1 || funcname || hash || result7 || libp) ;
05796 }
05797 
05798 static int G__G__ProofPlayer_201_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05799 {
05800       G__letint(result7, 105, (long) TProofOutputFile::DeclFileLine());
05801    return(1 || funcname || hash || result7 || libp) ;
05802 }
05803 
05804 // automatic destructor
05805 typedef TProofOutputFile G__TTProofOutputFile;
05806 static int G__G__ProofPlayer_201_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05807 {
05808    char* gvp = (char*) G__getgvp();
05809    long soff = G__getstructoffset();
05810    int n = G__getaryconstruct();
05811    //
05812    //has_a_delete: 1
05813    //has_own_delete1arg: 0
05814    //has_own_delete2arg: 0
05815    //
05816    if (!soff) {
05817      return(1);
05818    }
05819    if (n) {
05820      if (gvp == (char*)G__PVOID) {
05821        delete[] (TProofOutputFile*) soff;
05822      } else {
05823        G__setgvp((long) G__PVOID);
05824        for (int i = n - 1; i >= 0; --i) {
05825          ((TProofOutputFile*) (soff+(sizeof(TProofOutputFile)*i)))->~G__TTProofOutputFile();
05826        }
05827        G__setgvp((long)gvp);
05828      }
05829    } else {
05830      if (gvp == (char*)G__PVOID) {
05831        delete (TProofOutputFile*) soff;
05832      } else {
05833        G__setgvp((long) G__PVOID);
05834        ((TProofOutputFile*) (soff))->~G__TTProofOutputFile();
05835        G__setgvp((long)gvp);
05836      }
05837    }
05838    G__setnull(result7);
05839    return(1 || funcname || hash || result7 || libp) ;
05840 }
05841 
05842 
05843 /* TProofPlayer */
05844 static int G__G__ProofPlayer_203_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05845 {
05846       ((TProofPlayer*) G__getstructoffset())->StopFeedback();
05847       G__setnull(result7);
05848    return(1 || funcname || hash || result7 || libp) ;
05849 }
05850 
05851 static int G__G__ProofPlayer_203_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05852 {
05853    TProofPlayer* p = NULL;
05854    char* gvp = (char*) G__getgvp();
05855    switch (libp->paran) {
05856    case 1:
05857      //m: 1
05858      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05859        p = new TProofPlayer((TProof*) G__int(libp->para[0]));
05860      } else {
05861        p = new((void*) gvp) TProofPlayer((TProof*) G__int(libp->para[0]));
05862      }
05863      break;
05864    case 0:
05865      int n = G__getaryconstruct();
05866      if (n) {
05867        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05868          p = new TProofPlayer[n];
05869        } else {
05870          p = new((void*) gvp) TProofPlayer[n];
05871        }
05872      } else {
05873        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05874          p = new TProofPlayer;
05875        } else {
05876          p = new((void*) gvp) TProofPlayer;
05877        }
05878      }
05879      break;
05880    }
05881    result7->obj.i = (long) p;
05882    result7->ref = (long) p;
05883    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer));
05884    return(1 || funcname || hash || result7 || libp) ;
05885 }
05886 
05887 static int G__G__ProofPlayer_203_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05888 {
05889       ((TProofPlayer*) G__getstructoffset())->FeedBackCanvas((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
05890       G__setnull(result7);
05891    return(1 || funcname || hash || result7 || libp) ;
05892 }
05893 
05894 static int G__G__ProofPlayer_203_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05895 {
05896    switch (libp->paran) {
05897    case 1:
05898       ((TProofPlayer*) G__getstructoffset())->SetProcessing((Bool_t) G__int(libp->para[0]));
05899       G__setnull(result7);
05900       break;
05901    case 0:
05902       ((TProofPlayer*) G__getstructoffset())->SetProcessing();
05903       G__setnull(result7);
05904       break;
05905    }
05906    return(1 || funcname || hash || result7 || libp) ;
05907 }
05908 
05909 static int G__G__ProofPlayer_203_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05910 {
05911       G__letint(result7, 85, (long) TProofPlayer::Class());
05912    return(1 || funcname || hash || result7 || libp) ;
05913 }
05914 
05915 static int G__G__ProofPlayer_203_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05916 {
05917       G__letint(result7, 67, (long) TProofPlayer::Class_Name());
05918    return(1 || funcname || hash || result7 || libp) ;
05919 }
05920 
05921 static int G__G__ProofPlayer_203_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05922 {
05923       G__letint(result7, 115, (long) TProofPlayer::Class_Version());
05924    return(1 || funcname || hash || result7 || libp) ;
05925 }
05926 
05927 static int G__G__ProofPlayer_203_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05928 {
05929       TProofPlayer::Dictionary();
05930       G__setnull(result7);
05931    return(1 || funcname || hash || result7 || libp) ;
05932 }
05933 
05934 static int G__G__ProofPlayer_203_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05935 {
05936       ((TProofPlayer*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05937       G__setnull(result7);
05938    return(1 || funcname || hash || result7 || libp) ;
05939 }
05940 
05941 static int G__G__ProofPlayer_203_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05942 {
05943       G__letint(result7, 67, (long) TProofPlayer::DeclFileName());
05944    return(1 || funcname || hash || result7 || libp) ;
05945 }
05946 
05947 static int G__G__ProofPlayer_203_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05948 {
05949       G__letint(result7, 105, (long) TProofPlayer::ImplFileLine());
05950    return(1 || funcname || hash || result7 || libp) ;
05951 }
05952 
05953 static int G__G__ProofPlayer_203_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05954 {
05955       G__letint(result7, 67, (long) TProofPlayer::ImplFileName());
05956    return(1 || funcname || hash || result7 || libp) ;
05957 }
05958 
05959 static int G__G__ProofPlayer_203_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05960 {
05961       G__letint(result7, 105, (long) TProofPlayer::DeclFileLine());
05962    return(1 || funcname || hash || result7 || libp) ;
05963 }
05964 
05965 // automatic destructor
05966 typedef TProofPlayer G__TTProofPlayer;
05967 static int G__G__ProofPlayer_203_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05968 {
05969    char* gvp = (char*) G__getgvp();
05970    long soff = G__getstructoffset();
05971    int n = G__getaryconstruct();
05972    //
05973    //has_a_delete: 1
05974    //has_own_delete1arg: 0
05975    //has_own_delete2arg: 0
05976    //
05977    if (!soff) {
05978      return(1);
05979    }
05980    if (n) {
05981      if (gvp == (char*)G__PVOID) {
05982        delete[] (TProofPlayer*) soff;
05983      } else {
05984        G__setgvp((long) G__PVOID);
05985        for (int i = n - 1; i >= 0; --i) {
05986          ((TProofPlayer*) (soff+(sizeof(TProofPlayer)*i)))->~G__TTProofPlayer();
05987        }
05988        G__setgvp((long)gvp);
05989      }
05990    } else {
05991      if (gvp == (char*)G__PVOID) {
05992        delete (TProofPlayer*) soff;
05993      } else {
05994        G__setgvp((long) G__PVOID);
05995        ((TProofPlayer*) (soff))->~G__TTProofPlayer();
05996        G__setgvp((long)gvp);
05997      }
05998    }
05999    G__setnull(result7);
06000    return(1 || funcname || hash || result7 || libp) ;
06001 }
06002 
06003 
06004 /* TProofPlayerLite */
06005 static int G__G__ProofPlayer_259_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06006 {
06007    TProofPlayerLite* p = NULL;
06008    char* gvp = (char*) G__getgvp();
06009    switch (libp->paran) {
06010    case 1:
06011      //m: 1
06012      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06013        p = new TProofPlayerLite((TProof*) G__int(libp->para[0]));
06014      } else {
06015        p = new((void*) gvp) TProofPlayerLite((TProof*) G__int(libp->para[0]));
06016      }
06017      break;
06018    case 0:
06019      int n = G__getaryconstruct();
06020      if (n) {
06021        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06022          p = new TProofPlayerLite[n];
06023        } else {
06024          p = new((void*) gvp) TProofPlayerLite[n];
06025        }
06026      } else {
06027        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06028          p = new TProofPlayerLite;
06029        } else {
06030          p = new((void*) gvp) TProofPlayerLite;
06031        }
06032      }
06033      break;
06034    }
06035    result7->obj.i = (long) p;
06036    result7->ref = (long) p;
06037    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLite));
06038    return(1 || funcname || hash || result7 || libp) ;
06039 }
06040 
06041 static int G__G__ProofPlayer_259_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06042 {
06043       G__letint(result7, 85, (long) TProofPlayerLite::Class());
06044    return(1 || funcname || hash || result7 || libp) ;
06045 }
06046 
06047 static int G__G__ProofPlayer_259_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06048 {
06049       G__letint(result7, 67, (long) TProofPlayerLite::Class_Name());
06050    return(1 || funcname || hash || result7 || libp) ;
06051 }
06052 
06053 static int G__G__ProofPlayer_259_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06054 {
06055       G__letint(result7, 115, (long) TProofPlayerLite::Class_Version());
06056    return(1 || funcname || hash || result7 || libp) ;
06057 }
06058 
06059 static int G__G__ProofPlayer_259_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06060 {
06061       TProofPlayerLite::Dictionary();
06062       G__setnull(result7);
06063    return(1 || funcname || hash || result7 || libp) ;
06064 }
06065 
06066 static int G__G__ProofPlayer_259_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06067 {
06068       ((TProofPlayerLite*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06069       G__setnull(result7);
06070    return(1 || funcname || hash || result7 || libp) ;
06071 }
06072 
06073 static int G__G__ProofPlayer_259_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06074 {
06075       G__letint(result7, 67, (long) TProofPlayerLite::DeclFileName());
06076    return(1 || funcname || hash || result7 || libp) ;
06077 }
06078 
06079 static int G__G__ProofPlayer_259_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06080 {
06081       G__letint(result7, 105, (long) TProofPlayerLite::ImplFileLine());
06082    return(1 || funcname || hash || result7 || libp) ;
06083 }
06084 
06085 static int G__G__ProofPlayer_259_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06086 {
06087       G__letint(result7, 67, (long) TProofPlayerLite::ImplFileName());
06088    return(1 || funcname || hash || result7 || libp) ;
06089 }
06090 
06091 static int G__G__ProofPlayer_259_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06092 {
06093       G__letint(result7, 105, (long) TProofPlayerLite::DeclFileLine());
06094    return(1 || funcname || hash || result7 || libp) ;
06095 }
06096 
06097 // automatic destructor
06098 typedef TProofPlayerLite G__TTProofPlayerLite;
06099 static int G__G__ProofPlayer_259_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06100 {
06101    char* gvp = (char*) G__getgvp();
06102    long soff = G__getstructoffset();
06103    int n = G__getaryconstruct();
06104    //
06105    //has_a_delete: 1
06106    //has_own_delete1arg: 0
06107    //has_own_delete2arg: 0
06108    //
06109    if (!soff) {
06110      return(1);
06111    }
06112    if (n) {
06113      if (gvp == (char*)G__PVOID) {
06114        delete[] (TProofPlayerLite*) soff;
06115      } else {
06116        G__setgvp((long) G__PVOID);
06117        for (int i = n - 1; i >= 0; --i) {
06118          ((TProofPlayerLite*) (soff+(sizeof(TProofPlayerLite)*i)))->~G__TTProofPlayerLite();
06119        }
06120        G__setgvp((long)gvp);
06121      }
06122    } else {
06123      if (gvp == (char*)G__PVOID) {
06124        delete (TProofPlayerLite*) soff;
06125      } else {
06126        G__setgvp((long) G__PVOID);
06127        ((TProofPlayerLite*) (soff))->~G__TTProofPlayerLite();
06128        G__setgvp((long)gvp);
06129      }
06130    }
06131    G__setnull(result7);
06132    return(1 || funcname || hash || result7 || libp) ;
06133 }
06134 
06135 
06136 /* TProofPlayerRemote */
06137 static int G__G__ProofPlayer_260_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06138 {
06139    TProofPlayerRemote* p = NULL;
06140    char* gvp = (char*) G__getgvp();
06141    switch (libp->paran) {
06142    case 1:
06143      //m: 1
06144      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06145        p = new TProofPlayerRemote((TProof*) G__int(libp->para[0]));
06146      } else {
06147        p = new((void*) gvp) TProofPlayerRemote((TProof*) G__int(libp->para[0]));
06148      }
06149      break;
06150    case 0:
06151      int n = G__getaryconstruct();
06152      if (n) {
06153        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06154          p = new TProofPlayerRemote[n];
06155        } else {
06156          p = new((void*) gvp) TProofPlayerRemote[n];
06157        }
06158      } else {
06159        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06160          p = new TProofPlayerRemote;
06161        } else {
06162          p = new((void*) gvp) TProofPlayerRemote;
06163        }
06164      }
06165      break;
06166    }
06167    result7->obj.i = (long) p;
06168    result7->ref = (long) p;
06169    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote));
06170    return(1 || funcname || hash || result7 || libp) ;
06171 }
06172 
06173 static int G__G__ProofPlayer_260_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06174 {
06175    switch (libp->paran) {
06176    case 1:
06177       ((TProofPlayerRemote*) G__getstructoffset())->RedirectOutput((Bool_t) G__int(libp->para[0]));
06178       G__setnull(result7);
06179       break;
06180    case 0:
06181       ((TProofPlayerRemote*) G__getstructoffset())->RedirectOutput();
06182       G__setnull(result7);
06183       break;
06184    }
06185    return(1 || funcname || hash || result7 || libp) ;
06186 }
06187 
06188 static int G__G__ProofPlayer_260_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06189 {
06190       G__letint(result7, 105, (long) ((TProofPlayerRemote*) G__getstructoffset())->Incorporate((TObject*) G__int(libp->para[0]), (TList*) G__int(libp->para[1])
06191 , *(Bool_t*) G__Boolref(&libp->para[2])));
06192    return(1 || funcname || hash || result7 || libp) ;
06193 }
06194 
06195 static int G__G__ProofPlayer_260_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06196 {
06197       G__letint(result7, 85, (long) ((TProofPlayerRemote*) G__getstructoffset())->HandleHistogram((TObject*) G__int(libp->para[0])));
06198    return(1 || funcname || hash || result7 || libp) ;
06199 }
06200 
06201 static int G__G__ProofPlayer_260_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06202 {
06203       G__letint(result7, 85, (long) TProofPlayerRemote::Class());
06204    return(1 || funcname || hash || result7 || libp) ;
06205 }
06206 
06207 static int G__G__ProofPlayer_260_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06208 {
06209       G__letint(result7, 67, (long) TProofPlayerRemote::Class_Name());
06210    return(1 || funcname || hash || result7 || libp) ;
06211 }
06212 
06213 static int G__G__ProofPlayer_260_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06214 {
06215       G__letint(result7, 115, (long) TProofPlayerRemote::Class_Version());
06216    return(1 || funcname || hash || result7 || libp) ;
06217 }
06218 
06219 static int G__G__ProofPlayer_260_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06220 {
06221       TProofPlayerRemote::Dictionary();
06222       G__setnull(result7);
06223    return(1 || funcname || hash || result7 || libp) ;
06224 }
06225 
06226 static int G__G__ProofPlayer_260_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06227 {
06228       ((TProofPlayerRemote*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06229       G__setnull(result7);
06230    return(1 || funcname || hash || result7 || libp) ;
06231 }
06232 
06233 static int G__G__ProofPlayer_260_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06234 {
06235       G__letint(result7, 67, (long) TProofPlayerRemote::DeclFileName());
06236    return(1 || funcname || hash || result7 || libp) ;
06237 }
06238 
06239 static int G__G__ProofPlayer_260_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06240 {
06241       G__letint(result7, 105, (long) TProofPlayerRemote::ImplFileLine());
06242    return(1 || funcname || hash || result7 || libp) ;
06243 }
06244 
06245 static int G__G__ProofPlayer_260_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06246 {
06247       G__letint(result7, 67, (long) TProofPlayerRemote::ImplFileName());
06248    return(1 || funcname || hash || result7 || libp) ;
06249 }
06250 
06251 static int G__G__ProofPlayer_260_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06252 {
06253       G__letint(result7, 105, (long) TProofPlayerRemote::DeclFileLine());
06254    return(1 || funcname || hash || result7 || libp) ;
06255 }
06256 
06257 // automatic destructor
06258 typedef TProofPlayerRemote G__TTProofPlayerRemote;
06259 static int G__G__ProofPlayer_260_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06260 {
06261    char* gvp = (char*) G__getgvp();
06262    long soff = G__getstructoffset();
06263    int n = G__getaryconstruct();
06264    //
06265    //has_a_delete: 1
06266    //has_own_delete1arg: 0
06267    //has_own_delete2arg: 0
06268    //
06269    if (!soff) {
06270      return(1);
06271    }
06272    if (n) {
06273      if (gvp == (char*)G__PVOID) {
06274        delete[] (TProofPlayerRemote*) soff;
06275      } else {
06276        G__setgvp((long) G__PVOID);
06277        for (int i = n - 1; i >= 0; --i) {
06278          ((TProofPlayerRemote*) (soff+(sizeof(TProofPlayerRemote)*i)))->~G__TTProofPlayerRemote();
06279        }
06280        G__setgvp((long)gvp);
06281      }
06282    } else {
06283      if (gvp == (char*)G__PVOID) {
06284        delete (TProofPlayerRemote*) soff;
06285      } else {
06286        G__setgvp((long) G__PVOID);
06287        ((TProofPlayerRemote*) (soff))->~G__TTProofPlayerRemote();
06288        G__setgvp((long)gvp);
06289      }
06290    }
06291    G__setnull(result7);
06292    return(1 || funcname || hash || result7 || libp) ;
06293 }
06294 
06295 
06296 /* TStatus */
06297 static int G__G__ProofPlayer_265_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06298 {
06299    TStatus* p = NULL;
06300    char* gvp = (char*) G__getgvp();
06301    int n = G__getaryconstruct();
06302    if (n) {
06303      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06304        p = new TStatus[n];
06305      } else {
06306        p = new((void*) gvp) TStatus[n];
06307      }
06308    } else {
06309      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06310        p = new TStatus;
06311      } else {
06312        p = new((void*) gvp) TStatus;
06313      }
06314    }
06315    result7->obj.i = (long) p;
06316    result7->ref = (long) p;
06317    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatus));
06318    return(1 || funcname || hash || result7 || libp) ;
06319 }
06320 
06321 static int G__G__ProofPlayer_265_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06322 {
06323       G__letint(result7, 103, (long) ((const TStatus*) G__getstructoffset())->IsOk());
06324    return(1 || funcname || hash || result7 || libp) ;
06325 }
06326 
06327 static int G__G__ProofPlayer_265_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06328 {
06329       ((TStatus*) G__getstructoffset())->Add((const char*) G__int(libp->para[0]));
06330       G__setnull(result7);
06331    return(1 || funcname || hash || result7 || libp) ;
06332 }
06333 
06334 static int G__G__ProofPlayer_265_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06335 {
06336       G__letint(result7, 105, (long) ((TStatus*) G__getstructoffset())->Merge((TCollection*) G__int(libp->para[0])));
06337    return(1 || funcname || hash || result7 || libp) ;
06338 }
06339 
06340 static int G__G__ProofPlayer_265_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06341 {
06342       ((TStatus*) G__getstructoffset())->Reset();
06343       G__setnull(result7);
06344    return(1 || funcname || hash || result7 || libp) ;
06345 }
06346 
06347 static int G__G__ProofPlayer_265_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06348 {
06349       G__letint(result7, 67, (long) ((TStatus*) G__getstructoffset())->NextMesg());
06350    return(1 || funcname || hash || result7 || libp) ;
06351 }
06352 
06353 static int G__G__ProofPlayer_265_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06354 {
06355       G__letint(result7, 85, (long) TStatus::Class());
06356    return(1 || funcname || hash || result7 || libp) ;
06357 }
06358 
06359 static int G__G__ProofPlayer_265_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06360 {
06361       G__letint(result7, 67, (long) TStatus::Class_Name());
06362    return(1 || funcname || hash || result7 || libp) ;
06363 }
06364 
06365 static int G__G__ProofPlayer_265_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06366 {
06367       G__letint(result7, 115, (long) TStatus::Class_Version());
06368    return(1 || funcname || hash || result7 || libp) ;
06369 }
06370 
06371 static int G__G__ProofPlayer_265_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06372 {
06373       TStatus::Dictionary();
06374       G__setnull(result7);
06375    return(1 || funcname || hash || result7 || libp) ;
06376 }
06377 
06378 static int G__G__ProofPlayer_265_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06379 {
06380       ((TStatus*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06381       G__setnull(result7);
06382    return(1 || funcname || hash || result7 || libp) ;
06383 }
06384 
06385 static int G__G__ProofPlayer_265_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06386 {
06387       G__letint(result7, 67, (long) TStatus::DeclFileName());
06388    return(1 || funcname || hash || result7 || libp) ;
06389 }
06390 
06391 static int G__G__ProofPlayer_265_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06392 {
06393       G__letint(result7, 105, (long) TStatus::ImplFileLine());
06394    return(1 || funcname || hash || result7 || libp) ;
06395 }
06396 
06397 static int G__G__ProofPlayer_265_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06398 {
06399       G__letint(result7, 67, (long) TStatus::ImplFileName());
06400    return(1 || funcname || hash || result7 || libp) ;
06401 }
06402 
06403 static int G__G__ProofPlayer_265_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06404 {
06405       G__letint(result7, 105, (long) TStatus::DeclFileLine());
06406    return(1 || funcname || hash || result7 || libp) ;
06407 }
06408 
06409 // automatic copy constructor
06410 static int G__G__ProofPlayer_265_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06411 
06412 {
06413    TStatus* p;
06414    void* tmp = (void*) G__int(libp->para[0]);
06415    p = new TStatus(*(TStatus*) tmp);
06416    result7->obj.i = (long) p;
06417    result7->ref = (long) p;
06418    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatus));
06419    return(1 || funcname || hash || result7 || libp) ;
06420 }
06421 
06422 // automatic destructor
06423 typedef TStatus G__TTStatus;
06424 static int G__G__ProofPlayer_265_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06425 {
06426    char* gvp = (char*) G__getgvp();
06427    long soff = G__getstructoffset();
06428    int n = G__getaryconstruct();
06429    //
06430    //has_a_delete: 1
06431    //has_own_delete1arg: 0
06432    //has_own_delete2arg: 0
06433    //
06434    if (!soff) {
06435      return(1);
06436    }
06437    if (n) {
06438      if (gvp == (char*)G__PVOID) {
06439        delete[] (TStatus*) soff;
06440      } else {
06441        G__setgvp((long) G__PVOID);
06442        for (int i = n - 1; i >= 0; --i) {
06443          ((TStatus*) (soff+(sizeof(TStatus)*i)))->~G__TTStatus();
06444        }
06445        G__setgvp((long)gvp);
06446      }
06447    } else {
06448      if (gvp == (char*)G__PVOID) {
06449        delete (TStatus*) soff;
06450      } else {
06451        G__setgvp((long) G__PVOID);
06452        ((TStatus*) (soff))->~G__TTStatus();
06453        G__setgvp((long)gvp);
06454      }
06455    }
06456    G__setnull(result7);
06457    return(1 || funcname || hash || result7 || libp) ;
06458 }
06459 
06460 // automatic assignment operator
06461 static int G__G__ProofPlayer_265_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06462 {
06463    TStatus* dest = (TStatus*) G__getstructoffset();
06464    *dest = *(TStatus*) libp->para[0].ref;
06465    const TStatus& obj = *dest;
06466    result7->ref = (long) (&obj);
06467    result7->obj.i = (long) (&obj);
06468    return(1 || funcname || hash || result7 || libp) ;
06469 }
06470 
06471 
06472 /* TProofPlayerLocal */
06473 static int G__G__ProofPlayer_268_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06474 {
06475    TProofPlayerLocal* p = NULL;
06476    char* gvp = (char*) G__getgvp();
06477    switch (libp->paran) {
06478    case 1:
06479      //m: 1
06480      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06481        p = new TProofPlayerLocal((Bool_t) G__int(libp->para[0]));
06482      } else {
06483        p = new((void*) gvp) TProofPlayerLocal((Bool_t) G__int(libp->para[0]));
06484      }
06485      break;
06486    case 0:
06487      int n = G__getaryconstruct();
06488      if (n) {
06489        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06490          p = new TProofPlayerLocal[n];
06491        } else {
06492          p = new((void*) gvp) TProofPlayerLocal[n];
06493        }
06494      } else {
06495        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06496          p = new TProofPlayerLocal;
06497        } else {
06498          p = new((void*) gvp) TProofPlayerLocal;
06499        }
06500      }
06501      break;
06502    }
06503    result7->obj.i = (long) p;
06504    result7->ref = (long) p;
06505    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLocal));
06506    return(1 || funcname || hash || result7 || libp) ;
06507 }
06508 
06509 static int G__G__ProofPlayer_268_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06510 {
06511       G__letint(result7, 85, (long) TProofPlayerLocal::Class());
06512    return(1 || funcname || hash || result7 || libp) ;
06513 }
06514 
06515 static int G__G__ProofPlayer_268_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06516 {
06517       G__letint(result7, 67, (long) TProofPlayerLocal::Class_Name());
06518    return(1 || funcname || hash || result7 || libp) ;
06519 }
06520 
06521 static int G__G__ProofPlayer_268_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06522 {
06523       G__letint(result7, 115, (long) TProofPlayerLocal::Class_Version());
06524    return(1 || funcname || hash || result7 || libp) ;
06525 }
06526 
06527 static int G__G__ProofPlayer_268_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06528 {
06529       TProofPlayerLocal::Dictionary();
06530       G__setnull(result7);
06531    return(1 || funcname || hash || result7 || libp) ;
06532 }
06533 
06534 static int G__G__ProofPlayer_268_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06535 {
06536       ((TProofPlayerLocal*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06537       G__setnull(result7);
06538    return(1 || funcname || hash || result7 || libp) ;
06539 }
06540 
06541 static int G__G__ProofPlayer_268_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06542 {
06543       G__letint(result7, 67, (long) TProofPlayerLocal::DeclFileName());
06544    return(1 || funcname || hash || result7 || libp) ;
06545 }
06546 
06547 static int G__G__ProofPlayer_268_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06548 {
06549       G__letint(result7, 105, (long) TProofPlayerLocal::ImplFileLine());
06550    return(1 || funcname || hash || result7 || libp) ;
06551 }
06552 
06553 static int G__G__ProofPlayer_268_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06554 {
06555       G__letint(result7, 67, (long) TProofPlayerLocal::ImplFileName());
06556    return(1 || funcname || hash || result7 || libp) ;
06557 }
06558 
06559 static int G__G__ProofPlayer_268_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06560 {
06561       G__letint(result7, 105, (long) TProofPlayerLocal::DeclFileLine());
06562    return(1 || funcname || hash || result7 || libp) ;
06563 }
06564 
06565 // automatic destructor
06566 typedef TProofPlayerLocal G__TTProofPlayerLocal;
06567 static int G__G__ProofPlayer_268_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06568 {
06569    char* gvp = (char*) G__getgvp();
06570    long soff = G__getstructoffset();
06571    int n = G__getaryconstruct();
06572    //
06573    //has_a_delete: 1
06574    //has_own_delete1arg: 0
06575    //has_own_delete2arg: 0
06576    //
06577    if (!soff) {
06578      return(1);
06579    }
06580    if (n) {
06581      if (gvp == (char*)G__PVOID) {
06582        delete[] (TProofPlayerLocal*) soff;
06583      } else {
06584        G__setgvp((long) G__PVOID);
06585        for (int i = n - 1; i >= 0; --i) {
06586          ((TProofPlayerLocal*) (soff+(sizeof(TProofPlayerLocal)*i)))->~G__TTProofPlayerLocal();
06587        }
06588        G__setgvp((long)gvp);
06589      }
06590    } else {
06591      if (gvp == (char*)G__PVOID) {
06592        delete (TProofPlayerLocal*) soff;
06593      } else {
06594        G__setgvp((long) G__PVOID);
06595        ((TProofPlayerLocal*) (soff))->~G__TTProofPlayerLocal();
06596        G__setgvp((long)gvp);
06597      }
06598    }
06599    G__setnull(result7);
06600    return(1 || funcname || hash || result7 || libp) ;
06601 }
06602 
06603 
06604 /* TProofPlayerSlave */
06605 static int G__G__ProofPlayer_269_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06606 {
06607    TProofPlayerSlave* p = NULL;
06608    char* gvp = (char*) G__getgvp();
06609    switch (libp->paran) {
06610    case 1:
06611      //m: 1
06612      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06613        p = new TProofPlayerSlave((TSocket*) G__int(libp->para[0]));
06614      } else {
06615        p = new((void*) gvp) TProofPlayerSlave((TSocket*) G__int(libp->para[0]));
06616      }
06617      break;
06618    case 0:
06619      int n = G__getaryconstruct();
06620      if (n) {
06621        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06622          p = new TProofPlayerSlave[n];
06623        } else {
06624          p = new((void*) gvp) TProofPlayerSlave[n];
06625        }
06626      } else {
06627        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06628          p = new TProofPlayerSlave;
06629        } else {
06630          p = new((void*) gvp) TProofPlayerSlave;
06631        }
06632      }
06633      break;
06634    }
06635    result7->obj.i = (long) p;
06636    result7->ref = (long) p;
06637    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSlave));
06638    return(1 || funcname || hash || result7 || libp) ;
06639 }
06640 
06641 static int G__G__ProofPlayer_269_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06642 {
06643       G__letint(result7, 85, (long) TProofPlayerSlave::Class());
06644    return(1 || funcname || hash || result7 || libp) ;
06645 }
06646 
06647 static int G__G__ProofPlayer_269_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06648 {
06649       G__letint(result7, 67, (long) TProofPlayerSlave::Class_Name());
06650    return(1 || funcname || hash || result7 || libp) ;
06651 }
06652 
06653 static int G__G__ProofPlayer_269_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06654 {
06655       G__letint(result7, 115, (long) TProofPlayerSlave::Class_Version());
06656    return(1 || funcname || hash || result7 || libp) ;
06657 }
06658 
06659 static int G__G__ProofPlayer_269_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06660 {
06661       TProofPlayerSlave::Dictionary();
06662       G__setnull(result7);
06663    return(1 || funcname || hash || result7 || libp) ;
06664 }
06665 
06666 static int G__G__ProofPlayer_269_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06667 {
06668       ((TProofPlayerSlave*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06669       G__setnull(result7);
06670    return(1 || funcname || hash || result7 || libp) ;
06671 }
06672 
06673 static int G__G__ProofPlayer_269_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06674 {
06675       G__letint(result7, 67, (long) TProofPlayerSlave::DeclFileName());
06676    return(1 || funcname || hash || result7 || libp) ;
06677 }
06678 
06679 static int G__G__ProofPlayer_269_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06680 {
06681       G__letint(result7, 105, (long) TProofPlayerSlave::ImplFileLine());
06682    return(1 || funcname || hash || result7 || libp) ;
06683 }
06684 
06685 static int G__G__ProofPlayer_269_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06686 {
06687       G__letint(result7, 67, (long) TProofPlayerSlave::ImplFileName());
06688    return(1 || funcname || hash || result7 || libp) ;
06689 }
06690 
06691 static int G__G__ProofPlayer_269_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06692 {
06693       G__letint(result7, 105, (long) TProofPlayerSlave::DeclFileLine());
06694    return(1 || funcname || hash || result7 || libp) ;
06695 }
06696 
06697 // automatic destructor
06698 typedef TProofPlayerSlave G__TTProofPlayerSlave;
06699 static int G__G__ProofPlayer_269_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06700 {
06701    char* gvp = (char*) G__getgvp();
06702    long soff = G__getstructoffset();
06703    int n = G__getaryconstruct();
06704    //
06705    //has_a_delete: 1
06706    //has_own_delete1arg: 0
06707    //has_own_delete2arg: 0
06708    //
06709    if (!soff) {
06710      return(1);
06711    }
06712    if (n) {
06713      if (gvp == (char*)G__PVOID) {
06714        delete[] (TProofPlayerSlave*) soff;
06715      } else {
06716        G__setgvp((long) G__PVOID);
06717        for (int i = n - 1; i >= 0; --i) {
06718          ((TProofPlayerSlave*) (soff+(sizeof(TProofPlayerSlave)*i)))->~G__TTProofPlayerSlave();
06719        }
06720        G__setgvp((long)gvp);
06721      }
06722    } else {
06723      if (gvp == (char*)G__PVOID) {
06724        delete (TProofPlayerSlave*) soff;
06725      } else {
06726        G__setgvp((long) G__PVOID);
06727        ((TProofPlayerSlave*) (soff))->~G__TTProofPlayerSlave();
06728        G__setgvp((long)gvp);
06729      }
06730    }
06731    G__setnull(result7);
06732    return(1 || funcname || hash || result7 || libp) ;
06733 }
06734 
06735 
06736 /* TProofPlayerSuperMaster */
06737 static int G__G__ProofPlayer_270_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06738 {
06739    TProofPlayerSuperMaster* p = NULL;
06740    char* gvp = (char*) G__getgvp();
06741    switch (libp->paran) {
06742    case 1:
06743      //m: 1
06744      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06745        p = new TProofPlayerSuperMaster((TProof*) G__int(libp->para[0]));
06746      } else {
06747        p = new((void*) gvp) TProofPlayerSuperMaster((TProof*) G__int(libp->para[0]));
06748      }
06749      break;
06750    case 0:
06751      int n = G__getaryconstruct();
06752      if (n) {
06753        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06754          p = new TProofPlayerSuperMaster[n];
06755        } else {
06756          p = new((void*) gvp) TProofPlayerSuperMaster[n];
06757        }
06758      } else {
06759        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06760          p = new TProofPlayerSuperMaster;
06761        } else {
06762          p = new((void*) gvp) TProofPlayerSuperMaster;
06763        }
06764      }
06765      break;
06766    }
06767    result7->obj.i = (long) p;
06768    result7->ref = (long) p;
06769    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSuperMaster));
06770    return(1 || funcname || hash || result7 || libp) ;
06771 }
06772 
06773 static int G__G__ProofPlayer_270_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06774 {
06775       G__letint(result7, 85, (long) TProofPlayerSuperMaster::Class());
06776    return(1 || funcname || hash || result7 || libp) ;
06777 }
06778 
06779 static int G__G__ProofPlayer_270_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06780 {
06781       G__letint(result7, 67, (long) TProofPlayerSuperMaster::Class_Name());
06782    return(1 || funcname || hash || result7 || libp) ;
06783 }
06784 
06785 static int G__G__ProofPlayer_270_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06786 {
06787       G__letint(result7, 115, (long) TProofPlayerSuperMaster::Class_Version());
06788    return(1 || funcname || hash || result7 || libp) ;
06789 }
06790 
06791 static int G__G__ProofPlayer_270_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06792 {
06793       TProofPlayerSuperMaster::Dictionary();
06794       G__setnull(result7);
06795    return(1 || funcname || hash || result7 || libp) ;
06796 }
06797 
06798 static int G__G__ProofPlayer_270_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06799 {
06800       ((TProofPlayerSuperMaster*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06801       G__setnull(result7);
06802    return(1 || funcname || hash || result7 || libp) ;
06803 }
06804 
06805 static int G__G__ProofPlayer_270_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06806 {
06807       G__letint(result7, 67, (long) TProofPlayerSuperMaster::DeclFileName());
06808    return(1 || funcname || hash || result7 || libp) ;
06809 }
06810 
06811 static int G__G__ProofPlayer_270_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06812 {
06813       G__letint(result7, 105, (long) TProofPlayerSuperMaster::ImplFileLine());
06814    return(1 || funcname || hash || result7 || libp) ;
06815 }
06816 
06817 static int G__G__ProofPlayer_270_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06818 {
06819       G__letint(result7, 67, (long) TProofPlayerSuperMaster::ImplFileName());
06820    return(1 || funcname || hash || result7 || libp) ;
06821 }
06822 
06823 static int G__G__ProofPlayer_270_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06824 {
06825       G__letint(result7, 105, (long) TProofPlayerSuperMaster::DeclFileLine());
06826    return(1 || funcname || hash || result7 || libp) ;
06827 }
06828 
06829 // automatic destructor
06830 typedef TProofPlayerSuperMaster G__TTProofPlayerSuperMaster;
06831 static int G__G__ProofPlayer_270_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06832 {
06833    char* gvp = (char*) G__getgvp();
06834    long soff = G__getstructoffset();
06835    int n = G__getaryconstruct();
06836    //
06837    //has_a_delete: 1
06838    //has_own_delete1arg: 0
06839    //has_own_delete2arg: 0
06840    //
06841    if (!soff) {
06842      return(1);
06843    }
06844    if (n) {
06845      if (gvp == (char*)G__PVOID) {
06846        delete[] (TProofPlayerSuperMaster*) soff;
06847      } else {
06848        G__setgvp((long) G__PVOID);
06849        for (int i = n - 1; i >= 0; --i) {
06850          ((TProofPlayerSuperMaster*) (soff+(sizeof(TProofPlayerSuperMaster)*i)))->~G__TTProofPlayerSuperMaster();
06851        }
06852        G__setgvp((long)gvp);
06853      }
06854    } else {
06855      if (gvp == (char*)G__PVOID) {
06856        delete (TProofPlayerSuperMaster*) soff;
06857      } else {
06858        G__setgvp((long) G__PVOID);
06859        ((TProofPlayerSuperMaster*) (soff))->~G__TTProofPlayerSuperMaster();
06860        G__setgvp((long)gvp);
06861      }
06862    }
06863    G__setnull(result7);
06864    return(1 || funcname || hash || result7 || libp) ;
06865 }
06866 
06867 
06868 /* Setting up global function */
06869 
06870 /*********************************************************
06871 * Member function Stub
06872 *********************************************************/
06873 
06874 /* TDrawFeedback */
06875 
06876 /* TEventIter */
06877 
06878 /* TEventIterUnit */
06879 
06880 /* TEventIterObj */
06881 
06882 /* TEventIterTree */
06883 
06884 /* TFileMerger */
06885 
06886 /* TOutputListSelectorDataMap */
06887 
06888 /* TVirtualPacketizer */
06889 
06890 /* TPacketizerAdaptive */
06891 
06892 /* TPacketizerFile */
06893 
06894 /* TPacketizer */
06895 
06896 /* TPacketizerMulti */
06897 
06898 /* TPacketizerUnit */
06899 
06900 /* TPerfEvent */
06901 
06902 /* TPerfStats */
06903 
06904 /* TProofLimitsFinder */
06905 
06906 /* TProofOutputFile */
06907 
06908 /* TProofPlayer */
06909 
06910 /* TProofPlayerLite */
06911 
06912 /* TProofPlayerRemote */
06913 
06914 /* TStatus */
06915 
06916 /* TProofPlayerLocal */
06917 
06918 /* TProofPlayerSlave */
06919 
06920 /* TProofPlayerSuperMaster */
06921 
06922 /*********************************************************
06923 * Global function Stub
06924 *********************************************************/
06925 
06926 /*********************************************************
06927 * Get size of pointer to member function
06928 *********************************************************/
06929 class G__Sizep2memfuncG__ProofPlayer {
06930  public:
06931   G__Sizep2memfuncG__ProofPlayer(): p(&G__Sizep2memfuncG__ProofPlayer::sizep2memfunc) {}
06932     size_t sizep2memfunc() { return(sizeof(p)); }
06933   private:
06934     size_t (G__Sizep2memfuncG__ProofPlayer::*p)();
06935 };
06936 
06937 size_t G__get_sizep2memfuncG__ProofPlayer()
06938 {
06939   G__Sizep2memfuncG__ProofPlayer a;
06940   G__setsizep2memfunc((int)a.sizep2memfunc());
06941   return((size_t)a.sizep2memfunc());
06942 }
06943 
06944 
06945 /*********************************************************
06946 * virtual base class offset calculation interface
06947 *********************************************************/
06948 
06949    /* Setting up class inheritance */
06950 
06951 /*********************************************************
06952 * Inheritance information setup/
06953 *********************************************************/
06954 extern "C" void G__cpp_setup_inheritanceG__ProofPlayer() {
06955 
06956    /* Setting up class inheritance */
06957    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TDrawFeedback))) {
06958      TDrawFeedback *G__Lderived;
06959      G__Lderived=(TDrawFeedback*)0x1000;
06960      {
06961        TObject *G__Lpbase=(TObject*)G__Lderived;
06962        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TDrawFeedback),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
06963      }
06964      {
06965        TQObject *G__Lpbase=(TQObject*)G__Lderived;
06966        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TDrawFeedback),G__get_linked_tagnum(&G__G__ProofPlayerLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
06967      }
06968    }
06969    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIter))) {
06970      TEventIter *G__Lderived;
06971      G__Lderived=(TEventIter*)0x1000;
06972      {
06973        TObject *G__Lpbase=(TObject*)G__Lderived;
06974        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIter),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
06975      }
06976    }
06977    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit))) {
06978      TEventIterUnit *G__Lderived;
06979      G__Lderived=(TEventIterUnit*)0x1000;
06980      {
06981        TEventIter *G__Lpbase=(TEventIter*)G__Lderived;
06982        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit),G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIter),(long)G__Lpbase-(long)G__Lderived,1,1);
06983      }
06984      {
06985        TObject *G__Lpbase=(TObject*)G__Lderived;
06986        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
06987      }
06988    }
06989    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj))) {
06990      TEventIterObj *G__Lderived;
06991      G__Lderived=(TEventIterObj*)0x1000;
06992      {
06993        TEventIter *G__Lpbase=(TEventIter*)G__Lderived;
06994        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj),G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIter),(long)G__Lpbase-(long)G__Lderived,1,1);
06995      }
06996      {
06997        TObject *G__Lpbase=(TObject*)G__Lderived;
06998        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
06999      }
07000    }
07001    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree))) {
07002      TEventIterTree *G__Lderived;
07003      G__Lderived=(TEventIterTree*)0x1000;
07004      {
07005        TEventIter *G__Lpbase=(TEventIter*)G__Lderived;
07006        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree),G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIter),(long)G__Lpbase-(long)G__Lderived,1,1);
07007      }
07008      {
07009        TObject *G__Lpbase=(TObject*)G__Lderived;
07010        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07011      }
07012    }
07013    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TFileMerger))) {
07014      TFileMerger *G__Lderived;
07015      G__Lderived=(TFileMerger*)0x1000;
07016      {
07017        TObject *G__Lpbase=(TObject*)G__Lderived;
07018        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TFileMerger),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
07019      }
07020    }
07021    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TOutputListSelectorDataMap))) {
07022      TOutputListSelectorDataMap *G__Lderived;
07023      G__Lderived=(TOutputListSelectorDataMap*)0x1000;
07024      {
07025        TObject *G__Lpbase=(TObject*)G__Lderived;
07026        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TOutputListSelectorDataMap),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
07027      }
07028    }
07029    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer))) {
07030      TVirtualPacketizer *G__Lderived;
07031      G__Lderived=(TVirtualPacketizer*)0x1000;
07032      {
07033        TObject *G__Lpbase=(TObject*)G__Lderived;
07034        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
07035      }
07036    }
07037    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptive))) {
07038      TPacketizerAdaptive *G__Lderived;
07039      G__Lderived=(TPacketizerAdaptive*)0x1000;
07040      {
07041        TVirtualPacketizer *G__Lpbase=(TVirtualPacketizer*)G__Lderived;
07042        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptive),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer),(long)G__Lpbase-(long)G__Lderived,1,1);
07043      }
07044      {
07045        TObject *G__Lpbase=(TObject*)G__Lderived;
07046        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptive),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07047      }
07048    }
07049    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerFile))) {
07050      TPacketizerFile *G__Lderived;
07051      G__Lderived=(TPacketizerFile*)0x1000;
07052      {
07053        TVirtualPacketizer *G__Lpbase=(TVirtualPacketizer*)G__Lderived;
07054        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerFile),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer),(long)G__Lpbase-(long)G__Lderived,1,1);
07055      }
07056      {
07057        TObject *G__Lpbase=(TObject*)G__Lderived;
07058        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerFile),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07059      }
07060    }
07061    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizer))) {
07062      TPacketizer *G__Lderived;
07063      G__Lderived=(TPacketizer*)0x1000;
07064      {
07065        TVirtualPacketizer *G__Lpbase=(TVirtualPacketizer*)G__Lderived;
07066        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizer),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer),(long)G__Lpbase-(long)G__Lderived,1,1);
07067      }
07068      {
07069        TObject *G__Lpbase=(TObject*)G__Lderived;
07070        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizer),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07071      }
07072    }
07073    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerMulti))) {
07074      TPacketizerMulti *G__Lderived;
07075      G__Lderived=(TPacketizerMulti*)0x1000;
07076      {
07077        TVirtualPacketizer *G__Lpbase=(TVirtualPacketizer*)G__Lderived;
07078        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerMulti),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer),(long)G__Lpbase-(long)G__Lderived,1,1);
07079      }
07080      {
07081        TObject *G__Lpbase=(TObject*)G__Lderived;
07082        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerMulti),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07083      }
07084    }
07085    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerUnit))) {
07086      TPacketizerUnit *G__Lderived;
07087      G__Lderived=(TPacketizerUnit*)0x1000;
07088      {
07089        TVirtualPacketizer *G__Lpbase=(TVirtualPacketizer*)G__Lderived;
07090        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerUnit),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer),(long)G__Lpbase-(long)G__Lderived,1,1);
07091      }
07092      {
07093        TObject *G__Lpbase=(TObject*)G__Lderived;
07094        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerUnit),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07095      }
07096    }
07097    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfEvent))) {
07098      TPerfEvent *G__Lderived;
07099      G__Lderived=(TPerfEvent*)0x1000;
07100      {
07101        TObject *G__Lpbase=(TObject*)G__Lderived;
07102        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfEvent),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
07103      }
07104    }
07105    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfStats))) {
07106      TPerfStats *G__Lderived;
07107      G__Lderived=(TPerfStats*)0x1000;
07108      {
07109        TVirtualPerfStats *G__Lpbase=(TVirtualPerfStats*)G__Lderived;
07110        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfStats),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPerfStats),(long)G__Lpbase-(long)G__Lderived,1,1);
07111      }
07112      {
07113        TObject *G__Lpbase=(TObject*)G__Lderived;
07114        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfStats),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07115      }
07116    }
07117    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofLimitsFinder))) {
07118      TProofLimitsFinder *G__Lderived;
07119      G__Lderived=(TProofLimitsFinder*)0x1000;
07120      {
07121        THLimitsFinder *G__Lpbase=(THLimitsFinder*)G__Lderived;
07122        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofLimitsFinder),G__get_linked_tagnum(&G__G__ProofPlayerLN_THLimitsFinder),(long)G__Lpbase-(long)G__Lderived,1,1);
07123      }
07124      {
07125        TObject *G__Lpbase=(TObject*)G__Lderived;
07126        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofLimitsFinder),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07127      }
07128    }
07129    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFile))) {
07130      TProofOutputFile *G__Lderived;
07131      G__Lderived=(TProofOutputFile*)0x1000;
07132      {
07133        TNamed *G__Lpbase=(TNamed*)G__Lderived;
07134        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFile),G__get_linked_tagnum(&G__G__ProofPlayerLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
07135      }
07136      {
07137        TObject *G__Lpbase=(TObject*)G__Lderived;
07138        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFile),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07139      }
07140    }
07141    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer))) {
07142      TProofPlayer *G__Lderived;
07143      G__Lderived=(TProofPlayer*)0x1000;
07144      {
07145        TVirtualProofPlayer *G__Lpbase=(TVirtualProofPlayer*)G__Lderived;
07146        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,1);
07147      }
07148      {
07149        TObject *G__Lpbase=(TObject*)G__Lderived;
07150        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07151      }
07152      {
07153        TQObject *G__Lpbase=(TQObject*)G__Lderived;
07154        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer),G__get_linked_tagnum(&G__G__ProofPlayerLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07155      }
07156    }
07157    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualProofPlayer))) {
07158      TVirtualProofPlayer *G__Lderived;
07159      G__Lderived=(TVirtualProofPlayer*)0x1000;
07160      {
07161        TObject *G__Lpbase=(TObject*)G__Lderived;
07162        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualProofPlayer),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
07163      }
07164      {
07165        TQObject *G__Lpbase=(TQObject*)G__Lderived;
07166        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualProofPlayer),G__get_linked_tagnum(&G__G__ProofPlayerLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,1);
07167      }
07168    }
07169    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLite))) {
07170      TProofPlayerLite *G__Lderived;
07171      G__Lderived=(TProofPlayerLite*)0x1000;
07172      {
07173        TProofPlayerRemote *G__Lpbase=(TProofPlayerRemote*)G__Lderived;
07174        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLite),G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote),(long)G__Lpbase-(long)G__Lderived,1,1);
07175      }
07176      {
07177        TProofPlayer *G__Lpbase=(TProofPlayer*)G__Lderived;
07178        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLite),G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,0);
07179      }
07180      {
07181        TVirtualProofPlayer *G__Lpbase=(TVirtualProofPlayer*)G__Lderived;
07182        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLite),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,0);
07183      }
07184      {
07185        TObject *G__Lpbase=(TObject*)G__Lderived;
07186        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLite),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07187      }
07188      {
07189        TQObject *G__Lpbase=(TQObject*)G__Lderived;
07190        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLite),G__get_linked_tagnum(&G__G__ProofPlayerLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07191      }
07192    }
07193    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote))) {
07194      TProofPlayerRemote *G__Lderived;
07195      G__Lderived=(TProofPlayerRemote*)0x1000;
07196      {
07197        TProofPlayer *G__Lpbase=(TProofPlayer*)G__Lderived;
07198        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote),G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,1);
07199      }
07200      {
07201        TVirtualProofPlayer *G__Lpbase=(TVirtualProofPlayer*)G__Lderived;
07202        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,0);
07203      }
07204      {
07205        TObject *G__Lpbase=(TObject*)G__Lderived;
07206        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07207      }
07208      {
07209        TQObject *G__Lpbase=(TQObject*)G__Lderived;
07210        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote),G__get_linked_tagnum(&G__G__ProofPlayerLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07211      }
07212    }
07213    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatus))) {
07214      TStatus *G__Lderived;
07215      G__Lderived=(TStatus*)0x1000;
07216      {
07217        TNamed *G__Lpbase=(TNamed*)G__Lderived;
07218        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatus),G__get_linked_tagnum(&G__G__ProofPlayerLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
07219      }
07220      {
07221        TObject *G__Lpbase=(TObject*)G__Lderived;
07222        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatus),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07223      }
07224    }
07225    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLocal))) {
07226      TProofPlayerLocal *G__Lderived;
07227      G__Lderived=(TProofPlayerLocal*)0x1000;
07228      {
07229        TProofPlayer *G__Lpbase=(TProofPlayer*)G__Lderived;
07230        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLocal),G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,1);
07231      }
07232      {
07233        TVirtualProofPlayer *G__Lpbase=(TVirtualProofPlayer*)G__Lderived;
07234        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLocal),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,0);
07235      }
07236      {
07237        TObject *G__Lpbase=(TObject*)G__Lderived;
07238        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLocal),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07239      }
07240      {
07241        TQObject *G__Lpbase=(TQObject*)G__Lderived;
07242        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLocal),G__get_linked_tagnum(&G__G__ProofPlayerLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07243      }
07244    }
07245    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSlave))) {
07246      TProofPlayerSlave *G__Lderived;
07247      G__Lderived=(TProofPlayerSlave*)0x1000;
07248      {
07249        TProofPlayer *G__Lpbase=(TProofPlayer*)G__Lderived;
07250        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSlave),G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,1);
07251      }
07252      {
07253        TVirtualProofPlayer *G__Lpbase=(TVirtualProofPlayer*)G__Lderived;
07254        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSlave),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,0);
07255      }
07256      {
07257        TObject *G__Lpbase=(TObject*)G__Lderived;
07258        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSlave),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07259      }
07260      {
07261        TQObject *G__Lpbase=(TQObject*)G__Lderived;
07262        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSlave),G__get_linked_tagnum(&G__G__ProofPlayerLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07263      }
07264    }
07265    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSuperMaster))) {
07266      TProofPlayerSuperMaster *G__Lderived;
07267      G__Lderived=(TProofPlayerSuperMaster*)0x1000;
07268      {
07269        TProofPlayerRemote *G__Lpbase=(TProofPlayerRemote*)G__Lderived;
07270        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSuperMaster),G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote),(long)G__Lpbase-(long)G__Lderived,1,1);
07271      }
07272      {
07273        TProofPlayer *G__Lpbase=(TProofPlayer*)G__Lderived;
07274        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSuperMaster),G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,0);
07275      }
07276      {
07277        TVirtualProofPlayer *G__Lpbase=(TVirtualProofPlayer*)G__Lderived;
07278        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSuperMaster),G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualProofPlayer),(long)G__Lpbase-(long)G__Lderived,1,0);
07279      }
07280      {
07281        TObject *G__Lpbase=(TObject*)G__Lderived;
07282        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSuperMaster),G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07283      }
07284      {
07285        TQObject *G__Lpbase=(TQObject*)G__Lderived;
07286        G__inheritance_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSuperMaster),G__get_linked_tagnum(&G__G__ProofPlayerLN_TQObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07287      }
07288    }
07289 }
07290 
07291 /*********************************************************
07292 * typedef information setup/
07293 *********************************************************/
07294 extern "C" void G__cpp_setup_typetableG__ProofPlayer() {
07295 
07296    /* Setting up typedef entry */
07297    G__search_typename2("Int_t",105,-1,0,-1);
07298    G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
07299    G__search_typename2("UInt_t",104,-1,0,-1);
07300    G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
07301    G__search_typename2("Float_t",102,-1,0,-1);
07302    G__setnewtype(-1,"Float 4 bytes (float)",0);
07303    G__search_typename2("Double_t",100,-1,0,-1);
07304    G__setnewtype(-1,"Double 8 bytes",0);
07305    G__search_typename2("Bool_t",103,-1,0,-1);
07306    G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
07307    G__search_typename2("Version_t",115,-1,0,-1);
07308    G__setnewtype(-1,"Class version identifier (short)",0);
07309    G__search_typename2("Option_t",99,-1,256,-1);
07310    G__setnewtype(-1,"Option string (const char)",0);
07311    G__search_typename2("Long64_t",110,-1,0,-1);
07312    G__setnewtype(-1,"Portable signed long integer 8 bytes",0);
07313    G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
07314    G__setnewtype(-1,NULL,0);
07315    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
07316    G__setnewtype(-1,NULL,0);
07317    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
07318    G__setnewtype(-1,NULL,0);
07319    G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
07320    G__setnewtype(-1,NULL,0);
07321    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
07322    G__setnewtype(-1,NULL,0);
07323    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
07324    G__setnewtype(-1,NULL,0);
07325    G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
07326    G__setnewtype(-1,NULL,0);
07327    G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
07328    G__setnewtype(-1,NULL,0);
07329    G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
07330    G__setnewtype(-1,NULL,0);
07331    G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
07332    G__setnewtype(-1,NULL,0);
07333    G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
07334    G__setnewtype(-1,NULL,0);
07335    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
07336    G__setnewtype(-1,NULL,0);
07337    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
07338    G__setnewtype(-1,NULL,0);
07339    G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
07340    G__setnewtype(-1,NULL,0);
07341    G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
07342    G__setnewtype(-1,NULL,0);
07343    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlETStringcOallocatorlETStringgRsPgR));
07344    G__setnewtype(-1,NULL,0);
07345    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__ProofPlayerLN_vectorlETStringcOallocatorlETStringgRsPgR));
07346    G__setnewtype(-1,NULL,0);
07347    G__search_typename2("set<std::string>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR),0,-1);
07348    G__setnewtype(-1,NULL,0);
07349    G__search_typename2("set<string>",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR),0,-1);
07350    G__setnewtype(-1,NULL,0);
07351    G__search_typename2("set<string,less<string> >",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR),0,-1);
07352    G__setnewtype(-1,NULL,0);
07353    G__search_typename2("MsgSet_t",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR),0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatus));
07354    G__setnewtype(-1,NULL,0);
07355    G__search_typename2("MsgIter_t",117,G__get_linked_tagnum(&G__G__ProofPlayerLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatus));
07356    G__setnewtype(-1,NULL,0);
07357 }
07358 
07359 /*********************************************************
07360 * Data Member information setup/
07361 *********************************************************/
07362 
07363    /* Setting up class,struct,union tag member variable */
07364 
07365    /* TDrawFeedback */
07366 static void G__setup_memvarTDrawFeedback(void) {
07367    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TDrawFeedback));
07368    { TDrawFeedback *p; p=(TDrawFeedback*)0x1000; if (p) { }
07369    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fAll=",0,"draw all or selected objects");
07370    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_THashList),-1,-1,4,"fNames=",0,"selected objects");
07371    G__memvar_setup((void*)0,67,0,0,-1,G__defined_typename("Option_t"),-1,2,"fOption=",0,"draw option");
07372    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProof),-1,-1,2,"fProof=",0,"handle to PROOF session");
07373    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07374    }
07375    G__tag_memvar_reset();
07376 }
07377 
07378 
07379    /* TEventIter */
07380 static void G__setup_memvarTEventIter(void) {
07381    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIter));
07382    { TEventIter *p; p=(TEventIter*)0x1000; if (p) { }
07383    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSet),-1,-1,2,"fDSet=",0,"data set over which to iterate");
07384    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSetElement),-1,-1,2,"fElem=",0,"Current Element");
07385    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,2,"fFilename=",0,"Name of the current file");
07386    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TFile),-1,-1,2,"fFile=",0,"Current file");
07387    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fOldBytesRead=",0,"last reported number of bytes read");
07388    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,2,"fPath=",0,"Path to current TDirectory");
07389    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TDirectory),-1,-1,2,"fDir=",0,"directory containing the objects or the TTree");
07390    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fElemFirst=",0,"first entry to process for this element");
07391    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fElemNum=",0,"number of entries to process for this element");
07392    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fElemCur=",0,"current entry for this element");
07393    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TSelector),-1,-1,2,"fSel=",0,"selector to be used");
07394    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fFirst=",0,"first entry to process");
07395    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fNum=",0,"number of entries to process");
07396    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fCur=",0,"current entry");
07397    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fStop=",0,"termination of run requested");
07398    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventList),-1,-1,2,"fEventList=",0,"! eventList for processing");
07399    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fEventListPos=",0,"! current position in the eventList");
07400    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TEntryList),-1,-1,2,"fEntryList=",0,"! entry list for processing");
07401    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fEntryListPos=",0,"! current position in the entrylist");
07402    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07403    }
07404    G__tag_memvar_reset();
07405 }
07406 
07407 
07408    /* TEventIterUnit */
07409 static void G__setup_memvarTEventIterUnit(void) {
07410    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit));
07411    { TEventIterUnit *p; p=(TEventIterUnit*)0x1000; if (p) { }
07412    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fNum=",0,(char*)NULL);
07413    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fCurrent=",0,(char*)NULL);
07414    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07415    }
07416    G__tag_memvar_reset();
07417 }
07418 
07419 
07420    /* TEventIterObj */
07421 static void G__setup_memvarTEventIterObj(void) {
07422    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj));
07423    { TEventIterObj *p; p=(TEventIterObj*)0x1000; if (p) { }
07424    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,4,"fClassName=",0,"class name of objects to iterate over");
07425    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fKeys=",0,"list of keys");
07426    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TIter),-1,-1,4,"fNextKey=",0,"next key in directory");
07427    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject),-1,-1,4,"fObj=",0,"object found");
07428    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07429    }
07430    G__tag_memvar_reset();
07431 }
07432 
07433 
07434    /* TEventIterTree */
07435 static void G__setup_memvarTEventIterTree(void) {
07436    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree));
07437    { TEventIterTree *p; p=(TEventIterTree*)0x1000; if (p) { }
07438    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,4,"fTreeName=",0,"name of the tree object to iterate over");
07439    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTree),-1,-1,4,"fTree=",0,"tree we are iterating over");
07440    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTreeCache),-1,-1,4,"fTreeCache=",0,"instance of the tree cache for the tree");
07441    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTreeCacheIsLearning=",0,"Whether cache is in learning phase");
07442    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseTreeCache=",0,"Control usage of the tree cache");
07443    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fCacheSize=",0,"Cache size");
07444    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseParallelUnzip=",0,"Control usage of parallel unzip");
07445    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fFileTrees=",0,"Files && Trees currently open");
07446    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07447    }
07448    G__tag_memvar_reset();
07449 }
07450 
07451 
07452    /* TFileMerger */
07453 static void G__setup_memvarTFileMerger(void) {
07454    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TFileMerger));
07455    { TFileMerger *p; p=(TFileMerger*)0x1000; if (p) { }
07456    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TStopwatch),-1,-1,2,"fWatch=",0,"stop watch to measure file copy speed");
07457    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,2,"fFileList=",0,"a list of files, which shall be merged");
07458    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TFile),-1,-1,2,"fOutputFile=",0,"the outputfile for merging");
07459    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,2,"fOutputFilename=",0,"the name of the outputfile for merging");
07460    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,2,"fOutputFilename1=",0,"the name of the temporary outputfile for merging");
07461    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fFastMethod=",0,"True if using Fast merging algorithm (default)");
07462    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fNoTrees=",0,"True if Trees should not be merged (default is kFALSE)");
07463    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fLocal=",0,"Makes local copies of merging files if True (default is kTRUE)");
07464    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fHistoOneGo=",0,"Merger histos in one go (default is kTRUE)");
07465    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,2,"fMergeList=",0,"list of the files need to be merged");
07466    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07467    }
07468    G__tag_memvar_reset();
07469 }
07470 
07471 
07472    /* TOutputListSelectorDataMap */
07473 static void G__setup_memvarTOutputListSelectorDataMap(void) {
07474    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TOutputListSelectorDataMap));
07475    { TOutputListSelectorDataMap *p; p=(TOutputListSelectorDataMap*)0x1000; if (p) { }
07476    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TCollection),-1,-1,4,"fMap=",0,(char*)NULL);
07477    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07478    }
07479    G__tag_memvar_reset();
07480 }
07481 
07482 
07483    /* TVirtualPacketizer */
07484 static void G__setup_memvarTVirtualPacketizer(void) {
07485    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer));
07486    { TVirtualPacketizer *p; p=(TVirtualPacketizer*)0x1000; if (p) { }
07487    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizercLcLEUseEstOpt),-1,-2,2,"kEstOff=0LL",0,(char*)NULL);
07488    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizercLcLEUseEstOpt),-1,-2,2,"kEstCurrent=1LL",0,(char*)NULL);
07489    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizercLcLEUseEstOpt),-1,-2,2,"kEstAverage=2LL",0,(char*)NULL);
07490    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMinPacketTime=",0,"minimum packet time");
07491    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMaxPacketTime=",0,"maximum packet time");
07492    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,2,"fConfigParams=",0,"List of configuration parameters");
07493    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TMap),-1,-1,2,"fSlaveStats=",0,"slave status, keyed by correspondig TSlave");
07494    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofProgressStatus),-1,-1,2,"fProgressStatus=",0,"pointer to status in the player.");
07495    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTimer),-1,-1,2,"fProgress=",0,"progress updates timer");
07496    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fTotalEntries=",0,"total number of entries to be distributed;");
07497    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,2,"fFailedPackets=",0,"a list of packets that failed while processing");
07498    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTime),-1,-1,2,"fStartTime=",0,"time offset");
07499    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fInitTime=",0,"time before processing");
07500    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fProcTime=",0,"time since start of processing");
07501    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fTimeUpdt=",0,"time between updates");
07502    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TNtupleD),-1,-1,2,"fCircProg=",0,"Keeps circular info for \"instantenous\"");
07503    G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,2,"fCircN=",0,"Circularity");
07504    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TNtuple),-1,-1,2,"fProgressPerf=",0,"{Active workers, evt rate, MBs read} as a function of processing time");
07505    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fProcTimeLast=",0,"Time of the last measurement");
07506    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fActWrksLast=",0,"Active workers at fProcTimeLast");
07507    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fEvtRateLast=",0,"Evt rate at fProcTimeLast");
07508    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fMBsReadLast=",0,"MBs read at fProcTimeLast");
07509    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fEffSessLast=",0,"Number of effective sessions at fProcTimeLast");
07510    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fAWLastFill=",0,"Whether to fill the last measurement");
07511    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fReportPeriod=",0,"Time between reports if nothing changes (estimated proc time / 100)");
07512    G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizercLcLEUseEstOpt),-1,-1,2,"fUseEstOpt=",0,"Control usage of estimated values for the progress info");
07513    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fValid=",0,"Constructed properly?");
07514    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fStop=",0,"Termination of Process() requested?");
07515    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,2,"fDataSet=",0,"Name of the dataset being processed (for dataset-driven runs)");
07516    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizercLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kIsInitializing=%lldLL",(long long)TVirtualPacketizer::kIsInitializing).data(),0,(char*)NULL);
07517    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizercLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kIsDone=%lldLL",(long long)TVirtualPacketizer::kIsDone).data(),0,(char*)NULL);
07518    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizercLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kIsTree=%lldLL",(long long)TVirtualPacketizer::kIsTree).data(),0,(char*)NULL);
07519    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07520    }
07521    G__tag_memvar_reset();
07522 }
07523 
07524 
07525    /* TPacketizerAdaptive */
07526 static void G__setup_memvarTPacketizerAdaptive(void) {
07527    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptive));
07528    { TPacketizerAdaptive *p; p=(TPacketizerAdaptive*)0x1000; if (p) { }
07529    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fFileNodes=",0,"nodes with files");
07530    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fUnAllocated=",0,"nodes with unallocated files");
07531    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fActive=",0,"nodes with unfinished files");
07532    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMaxPerfIdx=",0,"maximum of our slaves' performance index");
07533    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fPartitions=",0,"list of partitions on nodes");
07534    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TSortedList),-1,-1,4,"fFilesToProcess=",0,"Global list of files (TFileStat) to be processed");
07535    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fCachePacketSync=",0,"control synchronization of cache and packet sizes");
07536    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMaxEntriesRatio=",0,"max file entries to avg allowed ratio for cache-to-packet sync");
07537    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fFractionOfRemoteFiles=",0,"fraction of TDSetElements that are on non-workers");
07538    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fNEventsOnRemLoc=",0,"number of events in currently");
07539    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fBaseLocalPreference=",0,"indicates how much more likely the nodes will be");
07540    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fForceLocal=",0,"if 1 - eliminate the remote processing");
07541    G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"fMaxSlaveCnt=",0,"maximum number of workers per filenode (Long_t to avoid");
07542    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPacketAsAFraction=",0,"used to calculate the packet size");
07543    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fStrategy=",0,"0 means the classic and 1 (default) - the adaptive strategy");
07544    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07545    }
07546    G__tag_memvar_reset();
07547 }
07548 
07549 
07550    /* TPacketizerFile */
07551 static void G__setup_memvarTPacketizerFile(void) {
07552    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerFile));
07553    { TPacketizerFile *p; p=(TPacketizerFile*)0x1000; if (p) { }
07554    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TMap),-1,-1,4,"fFiles=",0,"Files to be produced/processed per node");
07555    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fNotAssigned=",0,"List of files not assigned to a specific node");
07556    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fIters=",0,"Iterators on the file lists per node");
07557    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fAssigned=",0,"No.files processed or being processed.");
07558    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fProcNotAssigned=",0,"Whether to process files not asdigned to a worker");
07559    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TStopwatch),-1,-1,4,"fStopwatch=",0,"For measuring the start time of each packet");
07560    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07561    }
07562    G__tag_memvar_reset();
07563 }
07564 
07565 
07566    /* TPacketizer */
07567 static void G__setup_memvarTPacketizer(void) {
07568    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizer));
07569    { TPacketizer *p; p=(TPacketizer*)0x1000; if (p) { }
07570    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fPackets=",0,"all processed packets");
07571    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fFileNodes=",0,"nodes with files");
07572    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fUnAllocated=",0,"nodes with unallocated files");
07573    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fActive=",0,"nodes with unfinished files");
07574    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TMap),-1,-1,4,"fSlaveStats=",0,"slave status, keyed by correspondig TSlave");
07575    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fPacketSize=",0,"global base packet size");
07576    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMaxPerfIdx=",0,"maximum of our slaves' performance index");
07577    G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,4,"fMaxSlaveCnt=",0,"maximum number of workers per filenode (Long_t to avoid");
07578    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPacketAsAFraction=",0,"used to calculate the packet size");
07579    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07580    }
07581    G__tag_memvar_reset();
07582 }
07583 
07584 
07585    /* TPacketizerMulti */
07586 static void G__setup_memvarTPacketizerMulti(void) {
07587    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerMulti));
07588    { TPacketizerMulti *p; p=(TPacketizerMulti*)0x1000; if (p) { }
07589    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fPacketizers=",0,"Packetizers to be processed");
07590    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TIter),-1,-1,4,"fPacketizersIter=",0,"Iterator on fPacketizers");
07591    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer),-1,-1,4,"fCurrent=",0,"Packetizer being currently processed");
07592    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TMap),-1,-1,4,"fAssignedPack=",0,"Map {worker,packetizer} of lat assignement");
07593    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07594    }
07595    G__tag_memvar_reset();
07596 }
07597 
07598 
07599    /* TPacketizerUnit */
07600 static void G__setup_memvarTPacketizerUnit(void) {
07601    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerUnit));
07602    { TPacketizerUnit *p; p=(TPacketizerUnit*)0x1000; if (p) { }
07603    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fPackets=",0,"All processed packets");
07604    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TMap),-1,-1,4,"fSlaveStats=",0,"Slave status, keyed by correspondig TSlave");
07605    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TStopwatch),-1,-1,4,"fStopwatch=",0,"For measuring the start time of each packet");
07606    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fProcessing=",0,"Event being processed");
07607    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fAssigned=",0,"Entries processed or being processed.");
07608    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fCalibNum=",0,"Size of the calibrating packet");
07609    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fNumPerWorker=",0,"Number of cycles per worker, if this option");
07610    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07611    }
07612    G__tag_memvar_reset();
07613 }
07614 
07615 
07616    /* TPerfEvent */
07617 static void G__setup_memvarTPerfEvent(void) {
07618    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfEvent));
07619    { TPerfEvent *p; p=(TPerfEvent*)0x1000; if (p) { }
07620    G__memvar_setup((void*)((long)(&p->fEvtNode)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,1,"fEvtNode=",0,"node on which the event was generated");
07621    G__memvar_setup((void*)((long)(&p->fTimeStamp)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTimeStamp),-1,-1,1,"fTimeStamp=",0,"time offset from start of run");
07622    G__memvar_setup((void*)((long)(&p->fType)-(long)(p)),105,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPerfStatscLcLEEventType),-1,-1,1,"fType=",0,(char*)NULL);
07623    G__memvar_setup((void*)((long)(&p->fSlaveName)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,1,"fSlaveName=",0,(char*)NULL);
07624    G__memvar_setup((void*)((long)(&p->fNodeName)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,1,"fNodeName=",0,(char*)NULL);
07625    G__memvar_setup((void*)((long)(&p->fFileName)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,1,"fFileName=",0,(char*)NULL);
07626    G__memvar_setup((void*)((long)(&p->fFileClass)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,1,"fFileClass=",0,(char*)NULL);
07627    G__memvar_setup((void*)((long)(&p->fSlave)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,1,"fSlave=",0,(char*)NULL);
07628    G__memvar_setup((void*)((long)(&p->fEventsProcessed)-(long)(p)),110,0,0,-1,G__defined_typename("Long64_t"),-1,1,"fEventsProcessed=",0,(char*)NULL);
07629    G__memvar_setup((void*)((long)(&p->fBytesRead)-(long)(p)),110,0,0,-1,G__defined_typename("Long64_t"),-1,1,"fBytesRead=",0,(char*)NULL);
07630    G__memvar_setup((void*)((long)(&p->fLen)-(long)(p)),110,0,0,-1,G__defined_typename("Long64_t"),-1,1,"fLen=",0,(char*)NULL);
07631    G__memvar_setup((void*)((long)(&p->fLatency)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fLatency=",0,(char*)NULL);
07632    G__memvar_setup((void*)((long)(&p->fProcTime)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fProcTime=",0,(char*)NULL);
07633    G__memvar_setup((void*)((long)(&p->fCpuTime)-(long)(p)),100,0,0,-1,G__defined_typename("Double_t"),-1,1,"fCpuTime=",0,(char*)NULL);
07634    G__memvar_setup((void*)((long)(&p->fIsStart)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fIsStart=",0,(char*)NULL);
07635    G__memvar_setup((void*)((long)(&p->fIsOk)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fIsOk=",0,(char*)NULL);
07636    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07637    }
07638    G__tag_memvar_reset();
07639 }
07640 
07641 
07642    /* TPerfStats */
07643 static void G__setup_memvarTPerfStats(void) {
07644    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfStats));
07645    { TPerfStats *p; p=(TPerfStats*)0x1000; if (p) { }
07646    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTree),-1,-1,4,"fTrace=",0,"!TTree with trace events");
07647    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTimeStamp),-1,-1,4,"fTzero=",0,"!start time of this run");
07648    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfEvent),-1,-1,4,"fPerfEvent=",0,"!TPerfEvent used to fill tree");
07649    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TH1D),-1,-1,4,"fPacketsHist=",0,"!histogram of packets processed per slave");
07650    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TH1D),-1,-1,4,"fEventsHist=",0,"!histogram of events processed per slave");
07651    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TH1D),-1,-1,4,"fNodeHist=",0,"!histogram of slaves per file serving node");
07652    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TH2D),-1,-1,4,"fLatencyHist=",0,"!histogram of latency due to packet requests");
07653    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TH2D),-1,-1,4,"fProcTimeHist=",0,"!histogram of real time spent processing packets");
07654    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TH2D),-1,-1,4,"fCpuTimeHist=",0,"!histogram of cpu time spent processing packets");
07655    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fBytesRead=",0,"!track bytes read of main file");
07656    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTotCpuTime=",0,"!total cpu time of all slaves");
07657    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fTotBytesRead=",0,"!total bytes read on all slaves");
07658    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fTotEvents=",0,"!total number of events processed");
07659    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,4,"fNumEvents=",0,"!total number of events to be processed");
07660    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSlaves=",0,"!number of active slaves");
07661    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDoHist=",0,"!Fill histos");
07662    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDoTrace=",0,"!Trace details in master");
07663    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDoTraceRate=",0,"!Trace processing rate in master");
07664    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDoSlaveTrace=",0,"!Full tracing in workers");
07665    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDoQuota=",0,"!Save stats on SQL server for quota management");
07666    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMonitorPerPacket=",0,"!Whether to send the full entry per each packet ");
07667    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualMonitoringWriter),-1,-1,4,"fMonitoringWriter=",0,"!Monitoring engine");
07668    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07669    }
07670    G__tag_memvar_reset();
07671 }
07672 
07673 
07674    /* TProofLimitsFinder */
07675 static void G__setup_memvarTProofLimitsFinder(void) {
07676    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofLimitsFinder));
07677    { TProofLimitsFinder *p; p=(TProofLimitsFinder*)0x1000; if (p) { }
07678    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07679    }
07680    G__tag_memvar_reset();
07681 }
07682 
07683 
07684    /* TProofOutputFile */
07685 static void G__setup_memvarTProofOutputFile(void) {
07686    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFile));
07687    { TProofOutputFile *p; p=(TProofOutputFile*)0x1000; if (p) { }
07688    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFilecLcLERunType),-1,-2,1,G__FastAllocString(2048).Format("kMerge=%lldLL",(long long)TProofOutputFile::kMerge).data(),0,(char*)NULL);
07689    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFilecLcLERunType),-1,-2,1,G__FastAllocString(2048).Format("kDataset=%lldLL",(long long)TProofOutputFile::kDataset).data(),0,(char*)NULL);
07690    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFilecLcLETypeOpt),-1,-2,1,G__FastAllocString(2048).Format("kRemote=%lldLL",(long long)TProofOutputFile::kRemote).data(),0,(char*)NULL);
07691    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFilecLcLETypeOpt),-1,-2,1,G__FastAllocString(2048).Format("kLocal=%lldLL",(long long)TProofOutputFile::kLocal).data(),0,(char*)NULL);
07692    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFilecLcLETypeOpt),-1,-2,1,G__FastAllocString(2048).Format("kCreate=%lldLL",(long long)TProofOutputFile::kCreate).data(),0,(char*)NULL);
07693    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFilecLcLETypeOpt),-1,-2,1,G__FastAllocString(2048).Format("kRegister=%lldLL",(long long)TProofOutputFile::kRegister).data(),0,(char*)NULL);
07694    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFilecLcLETypeOpt),-1,-2,1,G__FastAllocString(2048).Format("kOverwrite=%lldLL",(long long)TProofOutputFile::kOverwrite).data(),0,(char*)NULL);
07695    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFilecLcLETypeOpt),-1,-2,1,G__FastAllocString(2048).Format("kVerify=%lldLL",(long long)TProofOutputFile::kVerify).data(),0,(char*)NULL);
07696    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,4,"fDir=",0,"name of the directory to be exported");
07697    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,4,"fRawDir=",0,"name of the local directory where to create the file");
07698    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,4,"fFileName=",0,(char*)NULL);
07699    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,4,"fOptionsAnchor=",0,"options and anchor string including delimiters, e.g. \"?myopts#myanchor\"");
07700    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,4,"fOutputFileName=",0,(char*)NULL);
07701    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,4,"fWorkerOrdinal=",0,(char*)NULL);
07702    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TString),-1,-1,4,"fLocalHost=",0,"Host where the file was created");
07703    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsLocal=",0,"kTRUE if the file is in the sandbox");
07704    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMerged=",0,(char*)NULL);
07705    G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFilecLcLERunType),-1,-1,4,"fRunType=",0,"Type of run (see enum ERunType)");
07706    G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fTypeOpt=",0,"Option (see enum ETypeOpt)");
07707    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TFileCollection),-1,-1,4,"fDataSet=",0,"Instance of the file collection in 'dataset' mode");
07708    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TFileMerger),-1,-1,4,"fMerger=",0,"Instance of the file merger in 'merge' mode");
07709    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07710    }
07711    G__tag_memvar_reset();
07712 }
07713 
07714 
07715    /* TProofPlayer */
07716 static void G__setup_memvarTProofPlayer(void) {
07717    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer));
07718    { TProofPlayer *p; p=(TProofPlayer*)0x1000; if (p) { }
07719    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fAutoBins=",0,"Map of min/max values by name for slaves");
07720    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,2,"fInput=",0,"-> list with input objects");
07721    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,2,"fOutput=",0,"list with output objects");
07722    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TSelector),-1,-1,2,"fSelector=",0,"!  the latest selector");
07723    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-1,2,"fSelectorClass=",0,"!  class of the latest selector");
07724    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTimer),-1,-1,2,"fFeedbackTimer=",0,"!  timer for sending intermediate results");
07725    G__memvar_setup((void*)0,108,0,0,-1,G__defined_typename("Long_t"),-1,2,"fFeedbackPeriod=",0,"!  period (ms) for sending intermediate results");
07726    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIter),-1,-1,2,"fEvIter=",0,"!  iterator on events or objects");
07727    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatus),-1,-1,2,"fSelStatus=",0,"!  status of query in progress");
07728    G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualProofPlayercLcLEExitStatus),-1,-1,2,"fExitStatus=",0,"exit status");
07729    G__memvar_setup((void*)0,110,0,0,-1,G__defined_typename("Long64_t"),-1,2,"fTotalEvents=",0,"number of events requested");
07730    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofProgressStatus),-1,-1,2,"fProgressStatus=",0,"the progress status object;");
07731    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,2,"fQueryResults=",0,"List of TQueryResult");
07732    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TQueryResult),-1,-1,2,"fQuery=",0,"Instance of TQueryResult currently processed");
07733    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TQueryResult),-1,-1,2,"fPreviousQuery=",0,"Previous instance of TQueryResult processed");
07734    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDrawQueries=",0,"Number of Draw queries in the list");
07735    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaxDrawQueries=",0,"Max number of Draw queries kept");
07736    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTimer),-1,-1,2,"fStopTimer=",0,"Timer associated with a stop request");
07737    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TMutex),-1,-1,2,"fStopTimerMtx=",0,"To protect the stop timer");
07738    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TTimer),-1,-1,2,"fDispatchTimer=",0,"Dispatch pending events while processing");
07739    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_THashList),-1,-2,2,"fgDrawInputPars=",0,"List of input parameters to be kept on drawing actions");
07740    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayercLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kDispatchOneEvent=%lldLL",(long long)TProofPlayer::kDispatchOneEvent).data(),0,(char*)NULL);
07741    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayercLcLEStatusBits),-1,-2,1,G__FastAllocString(2048).Format("kIsProcessing=%lldLL",(long long)TProofPlayer::kIsProcessing).data(),0,(char*)NULL);
07742    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07743    }
07744    G__tag_memvar_reset();
07745 }
07746 
07747 
07748    /* TProofPlayerLite */
07749 static void G__setup_memvarTProofPlayerLite(void) {
07750    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLite));
07751    { TProofPlayerLite *p; p=(TProofPlayerLite*)0x1000; if (p) { }
07752    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07753    }
07754    G__tag_memvar_reset();
07755 }
07756 
07757 
07758    /* TProofPlayerRemote */
07759 static void G__setup_memvarTProofPlayerRemote(void) {
07760    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote));
07761    { TProofPlayerRemote *p; p=(TProofPlayerRemote*)0x1000; if (p) { }
07762    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TProof),-1,-1,2,"fProof=",0,"link to associated PROOF session");
07763    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,2,"fOutputLists=",0,"results returned by slaves");
07764    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,2,"fFeedback=",0,"reference for use on master");
07765    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,2,"fFeedbackLists=",0,"intermediate results");
07766    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer),-1,-1,2,"fPacketizer=",0,"transform TDSet into packets for slaves");
07767    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMergeFiles=",0,"is True when merging output files centrally is needed");
07768    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSet),-1,-1,2,"fDSet=",0,"!tdset for current processing");
07769    G__memvar_setup((void*)0,89,0,0,-1,G__defined_typename("ErrorHandlerFunc_t"),-1,2,"fErrorHandler=",0,"Store previous handler when redirecting output");
07770    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07771    }
07772    G__tag_memvar_reset();
07773 }
07774 
07775 
07776    /* TStatus */
07777 static void G__setup_memvarTStatus(void) {
07778    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatus));
07779    { TStatus *p; p=(TStatus*)0x1000; if (p) { }
07780    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR),G__defined_typename("MsgSet_t"),-1,4,"fMsgs=",0,"list of error messages");
07781    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgRcLcLiterator),G__defined_typename("MsgIter_t"),-1,4,"fIter=",0,"!iterator in messages");
07782    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07783    }
07784    G__tag_memvar_reset();
07785 }
07786 
07787 
07788    /* TProofPlayerLocal */
07789 static void G__setup_memvarTProofPlayerLocal(void) {
07790    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLocal));
07791    { TProofPlayerLocal *p; p=(TProofPlayerLocal*)0x1000; if (p) { }
07792    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsClient=",0,(char*)NULL);
07793    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07794    }
07795    G__tag_memvar_reset();
07796 }
07797 
07798 
07799    /* TProofPlayerSlave */
07800 static void G__setup_memvarTProofPlayerSlave(void) {
07801    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSlave));
07802    { TProofPlayerSlave *p; p=(TProofPlayerSlave*)0x1000; if (p) { }
07803    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TSocket),-1,-1,4,"fSocket=",0,(char*)NULL);
07804    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fFeedback=",0,"List of objects to send updates of");
07805    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07806    }
07807    G__tag_memvar_reset();
07808 }
07809 
07810 
07811    /* TProofPlayerSuperMaster */
07812 static void G__setup_memvarTProofPlayerSuperMaster(void) {
07813    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSuperMaster));
07814    { TProofPlayerSuperMaster *p; p=(TProofPlayerSuperMaster*)0x1000; if (p) { }
07815    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TArrayL64),-1,-1,4,"fSlaveProgress=",0,(char*)NULL);
07816    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TArrayL64),-1,-1,4,"fSlaveTotals=",0,(char*)NULL);
07817    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TArrayL64),-1,-1,4,"fSlaveBytesRead=",0,(char*)NULL);
07818    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TArrayF),-1,-1,4,"fSlaveInitTime=",0,(char*)NULL);
07819    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TArrayF),-1,-1,4,"fSlaveProcTime=",0,(char*)NULL);
07820    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TArrayF),-1,-1,4,"fSlaveEvtRti=",0,(char*)NULL);
07821    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TArrayF),-1,-1,4,"fSlaveMBRti=",0,(char*)NULL);
07822    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TArrayI),-1,-1,4,"fSlaveActW=",0,(char*)NULL);
07823    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TArrayI),-1,-1,4,"fSlaveTotS=",0,(char*)NULL);
07824    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TArrayF),-1,-1,4,"fSlaveEffS=",0,(char*)NULL);
07825    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TList),-1,-1,4,"fSlaves=",0,(char*)NULL);
07826    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fReturnFeedback=",0,(char*)NULL);
07827    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07828    }
07829    G__tag_memvar_reset();
07830 }
07831 
07832 extern "C" void G__cpp_setup_memvarG__ProofPlayer() {
07833 }
07834 /***********************************************************
07835 ************************************************************
07836 ************************************************************
07837 ************************************************************
07838 ************************************************************
07839 ************************************************************
07840 ************************************************************
07841 ***********************************************************/
07842 
07843 /*********************************************************
07844 * Member function information setup for each class
07845 *********************************************************/
07846 static void G__setup_memfuncTDrawFeedback(void) {
07847    /* TDrawFeedback */
07848    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TDrawFeedback));
07849    G__memfunc_setup("TDrawFeedback",1255,G__G__ProofPlayer_116_0_1, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDrawFeedback), -1, 0, 2, 1, 1, 0, 
07850 "U 'TProof' - 0 '0' proof U 'TSeqCollection' - 0 '0' names", (char*)NULL, (void*) NULL, 0);
07851    G__memfunc_setup("Feedback",773,G__G__ProofPlayer_116_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - objs", (char*)NULL, (void*) NULL, 0);
07852    G__memfunc_setup("SetOption",933,G__G__ProofPlayer_116_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - option", (char*)NULL, (void*) NULL, 0);
07853    G__memfunc_setup("Class",502,G__G__ProofPlayer_116_0_4, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TDrawFeedback::Class) ), 0);
07854    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_116_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDrawFeedback::Class_Name) ), 0);
07855    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_116_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TDrawFeedback::Class_Version) ), 0);
07856    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_116_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TDrawFeedback::Dictionary) ), 0);
07857    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
07858    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);
07859    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);
07860    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_116_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
07861    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_116_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDrawFeedback::DeclFileName) ), 0);
07862    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_116_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDrawFeedback::ImplFileLine) ), 0);
07863    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_116_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TDrawFeedback::ImplFileName) ), 0);
07864    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_116_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TDrawFeedback::DeclFileLine) ), 0);
07865    // automatic destructor
07866    G__memfunc_setup("~TDrawFeedback", 1381, G__G__ProofPlayer_116_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
07867    G__tag_memfunc_reset();
07868 }
07869 
07870 static void G__setup_memfuncTEventIter(void) {
07871    /* TEventIter */
07872    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIter));
07873    G__memfunc_setup("LoadDir",671,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", "Load the directory pointed to by fElem", (void*) NULL, 0);
07874    G__memfunc_setup("GetCacheSize",1167,G__G__ProofPlayer_126_0_4, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
07875    G__memfunc_setup("GetLearnEntries",1516,G__G__ProofPlayer_126_0_5, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
07876    G__memfunc_setup("GetNextEvent",1217,G__G__ProofPlayer_126_0_6, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
07877    G__memfunc_setup("StopProcess",1157,G__G__ProofPlayer_126_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - abort", (char*)NULL, (void*) NULL, 1);
07878    G__memfunc_setup("Create",596,G__G__ProofPlayer_126_0_8, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIter), -1, 0, 4, 3, 1, 0, 
07879 "U 'TDSet' - 0 - dset U 'TSelector' - 0 - sel "
07880 "n - 'Long64_t' 0 - first n - 'Long64_t' 0 - num", (char*)NULL, (void*) G__func2void( (TEventIter* (*)(TDSet*, TSelector*, Long64_t, Long64_t))(&TEventIter::Create) ), 0);
07881    G__memfunc_setup("Class",502,G__G__ProofPlayer_126_0_9, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEventIter::Class) ), 0);
07882    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_126_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIter::Class_Name) ), 0);
07883    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_126_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEventIter::Class_Version) ), 0);
07884    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_126_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEventIter::Dictionary) ), 0);
07885    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
07886    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);
07887    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);
07888    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_126_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
07889    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_126_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIter::DeclFileName) ), 0);
07890    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_126_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEventIter::ImplFileLine) ), 0);
07891    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_126_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIter::ImplFileName) ), 0);
07892    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_126_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEventIter::DeclFileLine) ), 0);
07893    // automatic destructor
07894    G__memfunc_setup("~TEventIter", 1128, G__G__ProofPlayer_126_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
07895    // automatic assignment operator
07896    G__memfunc_setup("operator=", 937, G__G__ProofPlayer_126_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIter), -1, 1, 1, 1, 1, 0, "u 'TEventIter' - 11 - -", (char*) NULL, (void*) NULL, 0);
07897    G__tag_memfunc_reset();
07898 }
07899 
07900 static void G__setup_memfuncTEventIterUnit(void) {
07901    /* TEventIterUnit */
07902    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit));
07903    G__memfunc_setup("TEventIterUnit",1418,G__G__ProofPlayer_127_0_1, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
07904    G__memfunc_setup("TEventIterUnit",1418,G__G__ProofPlayer_127_0_2, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit), -1, 0, 3, 1, 1, 0, 
07905 "U 'TDSet' - 0 - dset U 'TSelector' - 0 - sel "
07906 "n - 'Long64_t' 0 - num", (char*)NULL, (void*) NULL, 0);
07907    G__memfunc_setup("GetCacheSize",1167,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
07908    G__memfunc_setup("GetLearnEntries",1516,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
07909    G__memfunc_setup("GetNextEvent",1217,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
07910    G__memfunc_setup("Class",502,G__G__ProofPlayer_127_0_6, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEventIterUnit::Class) ), 0);
07911    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_127_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIterUnit::Class_Name) ), 0);
07912    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_127_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEventIterUnit::Class_Version) ), 0);
07913    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_127_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEventIterUnit::Dictionary) ), 0);
07914    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
07915    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);
07916    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);
07917    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_127_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
07918    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_127_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIterUnit::DeclFileName) ), 0);
07919    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_127_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEventIterUnit::ImplFileLine) ), 0);
07920    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_127_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIterUnit::ImplFileName) ), 0);
07921    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_127_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEventIterUnit::DeclFileLine) ), 0);
07922    // automatic copy constructor
07923    G__memfunc_setup("TEventIterUnit", 1418, G__G__ProofPlayer_127_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit), -1, 0, 1, 1, 1, 0, "u 'TEventIterUnit' - 11 - -", (char*) NULL, (void*) NULL, 0);
07924    // automatic destructor
07925    G__memfunc_setup("~TEventIterUnit", 1544, G__G__ProofPlayer_127_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
07926    // automatic assignment operator
07927    G__memfunc_setup("operator=", 937, G__G__ProofPlayer_127_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterUnit), -1, 1, 1, 1, 1, 0, "u 'TEventIterUnit' - 11 - -", (char*) NULL, (void*) NULL, 0);
07928    G__tag_memfunc_reset();
07929 }
07930 
07931 static void G__setup_memfuncTEventIterObj(void) {
07932    /* TEventIterObj */
07933    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj));
07934    G__memfunc_setup("TEventIterObj",1285,G__G__ProofPlayer_128_0_1, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
07935    G__memfunc_setup("TEventIterObj",1285,G__G__ProofPlayer_128_0_2, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj), -1, 0, 4, 1, 1, 0, 
07936 "U 'TDSet' - 0 - dset U 'TSelector' - 0 - sel "
07937 "n - 'Long64_t' 0 - first n - 'Long64_t' 0 - num", (char*)NULL, (void*) NULL, 0);
07938    G__memfunc_setup("GetCacheSize",1167,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
07939    G__memfunc_setup("GetLearnEntries",1516,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
07940    G__memfunc_setup("GetNextEvent",1217,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
07941    G__memfunc_setup("Class",502,G__G__ProofPlayer_128_0_6, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEventIterObj::Class) ), 0);
07942    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_128_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIterObj::Class_Name) ), 0);
07943    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_128_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEventIterObj::Class_Version) ), 0);
07944    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_128_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEventIterObj::Dictionary) ), 0);
07945    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
07946    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);
07947    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);
07948    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_128_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
07949    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_128_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIterObj::DeclFileName) ), 0);
07950    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_128_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEventIterObj::ImplFileLine) ), 0);
07951    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_128_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIterObj::ImplFileName) ), 0);
07952    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_128_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEventIterObj::DeclFileLine) ), 0);
07953    // automatic copy constructor
07954    G__memfunc_setup("TEventIterObj", 1285, G__G__ProofPlayer_128_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj), -1, 0, 1, 1, 1, 0, "u 'TEventIterObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
07955    // automatic destructor
07956    G__memfunc_setup("~TEventIterObj", 1411, G__G__ProofPlayer_128_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
07957    // automatic assignment operator
07958    G__memfunc_setup("operator=", 937, G__G__ProofPlayer_128_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterObj), -1, 1, 1, 1, 1, 0, "u 'TEventIterObj' - 11 - -", (char*) NULL, (void*) NULL, 0);
07959    G__tag_memfunc_reset();
07960 }
07961 
07962 static void G__setup_memfuncTEventIterTree(void) {
07963    /* TEventIterTree */
07964    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree));
07965    G__memfunc_setup("Load",384,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TTree), -1, 0, 2, 1, 4, 0, 
07966 "U 'TDSetElement' - 0 - elem g - 'Bool_t' 1 - localfile", (char*)NULL, (void*) NULL, 0);
07967    G__memfunc_setup("GetTrees",803,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TTree), -1, 0, 1, 1, 4, 0, "U 'TDSetElement' - 0 - elem", (char*)NULL, (void*) NULL, 0);
07968    G__memfunc_setup("TEventIterTree",1402,G__G__ProofPlayer_129_0_3, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
07969    G__memfunc_setup("TEventIterTree",1402,G__G__ProofPlayer_129_0_4, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree), -1, 0, 4, 1, 1, 0, 
07970 "U 'TDSet' - 0 - dset U 'TSelector' - 0 - sel "
07971 "n - 'Long64_t' 0 - first n - 'Long64_t' 0 - num", (char*)NULL, (void*) NULL, 0);
07972    G__memfunc_setup("GetCacheSize",1167,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
07973    G__memfunc_setup("GetLearnEntries",1516,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
07974    G__memfunc_setup("GetNextEvent",1217,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
07975    G__memfunc_setup("Class",502,G__G__ProofPlayer_129_0_8, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TEventIterTree::Class) ), 0);
07976    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_129_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIterTree::Class_Name) ), 0);
07977    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_129_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TEventIterTree::Class_Version) ), 0);
07978    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_129_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TEventIterTree::Dictionary) ), 0);
07979    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
07980    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);
07981    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);
07982    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_129_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
07983    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_129_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIterTree::DeclFileName) ), 0);
07984    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_129_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEventIterTree::ImplFileLine) ), 0);
07985    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_129_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TEventIterTree::ImplFileName) ), 0);
07986    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_129_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TEventIterTree::DeclFileLine) ), 0);
07987    // automatic copy constructor
07988    G__memfunc_setup("TEventIterTree", 1402, G__G__ProofPlayer_129_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree), -1, 0, 1, 1, 1, 0, "u 'TEventIterTree' - 11 - -", (char*) NULL, (void*) NULL, 0);
07989    // automatic destructor
07990    G__memfunc_setup("~TEventIterTree", 1528, G__G__ProofPlayer_129_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
07991    // automatic assignment operator
07992    G__memfunc_setup("operator=", 937, G__G__ProofPlayer_129_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TEventIterTree), -1, 1, 1, 1, 1, 0, "u 'TEventIterTree' - 11 - -", (char*) NULL, (void*) NULL, 0);
07993    G__tag_memfunc_reset();
07994 }
07995 
07996 static void G__setup_memfuncTFileMerger(void) {
07997    /* TFileMerger */
07998    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TFileMerger));
07999    G__memfunc_setup("TFileMerger",1078,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TFileMerger), -1, 0, 1, 1, 4, 0, "u 'TFileMerger' - 11 - -", "Not implemented", (void*) NULL, 0);
08000    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__ProofPlayerLN_TFileMerger), -1, 1, 1, 1, 4, 0, "u 'TFileMerger' - 11 - -", "Not implemented", (void*) NULL, 0);
08001    G__memfunc_setup("TFileMerger",1078,G__G__ProofPlayer_133_0_3, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TFileMerger), -1, 0, 2, 1, 1, 0, 
08002 "g - 'Bool_t' 0 'kTRUE' isLocal g - 'Bool_t' 0 'kTRUE' histoOneGo", (char*)NULL, (void*) NULL, 0);
08003    G__memfunc_setup("GetOutputFileName",1714,G__G__ProofPlayer_133_0_4, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
08004    G__memfunc_setup("GetMergeList",1196,G__G__ProofPlayer_133_0_5, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08005    G__memfunc_setup("SetCWD",522,G__G__ProofPlayer_133_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
08006    G__memfunc_setup("GetCWD",510,G__G__ProofPlayer_133_0_7, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
08007    G__memfunc_setup("Reset",515,G__G__ProofPlayer_133_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
08008    G__memfunc_setup("AddFile",649,G__G__ProofPlayer_133_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
08009 "C - - 10 - url g - 'Bool_t' 0 'kTRUE' cpProgress", (char*)NULL, (void*) NULL, 1);
08010    G__memfunc_setup("OutputFile",1041,G__G__ProofPlayer_133_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "C - - 10 - url", (char*)NULL, (void*) NULL, 1);
08011    G__memfunc_setup("PrintFiles",1024,G__G__ProofPlayer_133_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 - options", (char*)NULL, (void*) NULL, 1);
08012    G__memfunc_setup("Merge",496,G__G__ProofPlayer_133_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' -", (char*)NULL, (void*) NULL, 1);
08013    G__memfunc_setup("MergeRecursive",1448,G__G__ProofPlayer_133_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
08014 "U 'TDirectory' - 0 - target U 'TList' - 0 - sourcelist", (char*)NULL, (void*) NULL, 1);
08015    G__memfunc_setup("SetFastMethod",1307,G__G__ProofPlayer_133_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' fast", (char*)NULL, (void*) NULL, 1);
08016    G__memfunc_setup("SetNotrees",1036,G__G__ProofPlayer_133_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' notrees", (char*)NULL, (void*) NULL, 1);
08017    G__memfunc_setup("Class",502,G__G__ProofPlayer_133_0_16, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFileMerger::Class) ), 0);
08018    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_133_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileMerger::Class_Name) ), 0);
08019    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_133_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFileMerger::Class_Version) ), 0);
08020    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_133_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFileMerger::Dictionary) ), 0);
08021    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08022    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);
08023    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);
08024    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_133_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08025    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_133_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileMerger::DeclFileName) ), 0);
08026    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_133_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFileMerger::ImplFileLine) ), 0);
08027    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_133_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFileMerger::ImplFileName) ), 0);
08028    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_133_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFileMerger::DeclFileLine) ), 0);
08029    // automatic destructor
08030    G__memfunc_setup("~TFileMerger", 1204, G__G__ProofPlayer_133_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08031    G__tag_memfunc_reset();
08032 }
08033 
08034 static void G__setup_memfuncTOutputListSelectorDataMap(void) {
08035    /* TOutputListSelectorDataMap */
08036    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TOutputListSelectorDataMap));
08037    G__memfunc_setup("TOutputListSelectorDataMap",2650,G__G__ProofPlayer_135_0_1, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TOutputListSelectorDataMap), -1, 0, 1, 1, 1, 0, "U 'TSelector' - 0 '0' sel", (char*)NULL, (void*) NULL, 0);
08038    G__memfunc_setup("FindInList",980,G__G__ProofPlayer_135_0_2, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TOutputListSelectorDataMap), -1, 0, 1, 3, 1, 0, "U 'TCollection' - 0 - coll", (char*)NULL, (void*) G__func2void( (TOutputListSelectorDataMap* (*)(TCollection*))(&TOutputListSelectorDataMap::FindInList) ), 0);
08039    G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
08040    G__memfunc_setup("Init",404,G__G__ProofPlayer_135_0_4, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TSelector' - 0 - sel", (char*)NULL, (void*) NULL, 0);
08041    G__memfunc_setup("SetDataMembers",1393,G__G__ProofPlayer_135_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "U 'TSelector' - 0 - sel", (char*)NULL, (void*) NULL, 0);
08042    G__memfunc_setup("Merge",496,G__G__ProofPlayer_135_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
08043    G__memfunc_setup("GetMap",574,G__G__ProofPlayer_135_0_7, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TCollection), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08044    G__memfunc_setup("Class",502,G__G__ProofPlayer_135_0_8, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TOutputListSelectorDataMap::Class) ), 0);
08045    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_135_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TOutputListSelectorDataMap::Class_Name) ), 0);
08046    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_135_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TOutputListSelectorDataMap::Class_Version) ), 0);
08047    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_135_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TOutputListSelectorDataMap::Dictionary) ), 0);
08048    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08049    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);
08050    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);
08051    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_135_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08052    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_135_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TOutputListSelectorDataMap::DeclFileName) ), 0);
08053    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_135_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TOutputListSelectorDataMap::ImplFileLine) ), 0);
08054    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_135_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TOutputListSelectorDataMap::ImplFileName) ), 0);
08055    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_135_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TOutputListSelectorDataMap::DeclFileLine) ), 0);
08056    // automatic copy constructor
08057    G__memfunc_setup("TOutputListSelectorDataMap", 2650, G__G__ProofPlayer_135_0_20, (int) ('i'), 
08058 G__get_linked_tagnum(&G__G__ProofPlayerLN_TOutputListSelectorDataMap), -1, 0, 1, 1, 1, 0, "u 'TOutputListSelectorDataMap' - 11 - -", (char*) NULL, (void*) NULL, 0);
08059    // automatic destructor
08060    G__memfunc_setup("~TOutputListSelectorDataMap", 2776, G__G__ProofPlayer_135_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08061    // automatic assignment operator
08062    G__memfunc_setup("operator=", 937, G__G__ProofPlayer_135_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TOutputListSelectorDataMap), -1, 1, 1, 1, 1, 0, "u 'TOutputListSelectorDataMap' - 11 - -", (char*) NULL, (void*) NULL, 0);
08063    G__tag_memfunc_reset();
08064 }
08065 
08066 static void G__setup_memfuncTVirtualPacketizer(void) {
08067    /* TVirtualPacketizer */
08068    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer));
08069    G__memfunc_setup("TVirtualPacketizer",1869,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer), -1, 0, 2, 1, 2, 0, 
08070 "U 'TList' - 0 - input U 'TProofProgressStatus' - 0 '0' st", (char*)NULL, (void*) NULL, 0);
08071    G__memfunc_setup("TVirtualPacketizer",1869,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer), -1, 0, 1, 1, 2, 0, "u 'TVirtualPacketizer' - 11 - -", "no implementation, will generate", (void*) NULL, 0);
08072    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TVirtualPacketizer' - 11 - -", "error on accidental usage", (void*) NULL, 0);
08073    G__memfunc_setup("CreateNewPacket",1494,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSetElement), -1, 0, 3, 1, 2, 0, 
08074 "U 'TDSetElement' - 0 - base n - 'Long64_t' 0 - first "
08075 "n - 'Long64_t' 0 - num", (char*)NULL, (void*) NULL, 0);
08076    G__memfunc_setup("GetEntries",1018,(G__InterfaceMethod) NULL, 110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 2, 0, 
08077 "g - 'Bool_t' 0 - tree U 'TDSetElement' - 0 - e", "Num of entries or objects", (void*) NULL, 0);
08078    G__memfunc_setup("HandleTimer",1101,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'TTimer' - 0 - timer", (char*)NULL, (void*) NULL, 1);
08079    G__memfunc_setup("IsValid",684,G__G__ProofPlayer_152_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08080    G__memfunc_setup("GetEntriesProcessed",1954,G__G__ProofPlayer_152_0_8, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08081    G__memfunc_setup("GetEstEntriesProcessed",2254,G__G__ProofPlayer_152_0_9, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
08082 "f - 'Float_t' 0 - - n - 'Long64_t' 1 - ent "
08083 "n - 'Long64_t' 1 - bytes n - 'Long64_t' 1 - calls", (char*)NULL, (void*) NULL, 1);
08084    G__memfunc_setup("GetCurrentRate",1423,G__G__ProofPlayer_152_0_10, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 1 - all", (char*)NULL, (void*) NULL, 1);
08085    G__memfunc_setup("GetTotalEntries",1534,G__G__ProofPlayer_152_0_11, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08086    G__memfunc_setup("GetNextPacket",1303,G__G__ProofPlayer_152_0_12, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSetElement), -1, 0, 2, 1, 1, 0, 
08087 "U 'TSlave' - 0 - sl U 'TMessage' - 0 - r", (char*)NULL, (void*) NULL, 1);
08088    G__memfunc_setup("SetInitTime",1103,G__G__ProofPlayer_152_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
08089    G__memfunc_setup("StopProcess",1157,G__G__ProofPlayer_152_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - abort", (char*)NULL, (void*) NULL, 1);
08090    G__memfunc_setup("GetFailedPackets",1584,G__G__ProofPlayer_152_0_15, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TList), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08091    G__memfunc_setup("SetFailedPackets",1596,G__G__ProofPlayer_152_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - list", (char*)NULL, (void*) NULL, 0);
08092    G__memfunc_setup("GetBytesRead",1187,G__G__ProofPlayer_152_0_17, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08093    G__memfunc_setup("GetReadCalls",1163,G__G__ProofPlayer_152_0_18, 110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08094    G__memfunc_setup("GetCumProcTime",1384,G__G__ProofPlayer_152_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08095    G__memfunc_setup("GetInitTime",1091,G__G__ProofPlayer_152_0_20, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08096    G__memfunc_setup("GetProcTime",1091,G__G__ProofPlayer_152_0_21, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08097    G__memfunc_setup("GetProgressPerf",1538,G__G__ProofPlayer_152_0_22, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TNtuple), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' steal", (char*)NULL, (void*) NULL, 0);
08098    G__memfunc_setup("GetConfigParams",1498,G__G__ProofPlayer_152_0_23, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TList), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' steal", (char*)NULL, (void*) NULL, 0);
08099    G__memfunc_setup("MarkBad",658,G__G__ProofPlayer_152_0_24, 121, -1, -1, 0, 3, 1, 1, 0, 
08100 "U 'TSlave' - 0 - - U 'TProofProgressStatus' - 0 - - "
08101 "U 'TList' - 2 - -", (char*)NULL, (void*) NULL, 1);
08102    G__memfunc_setup("AddProcessed",1201,G__G__ProofPlayer_152_0_25, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
08103 "U 'TSlave' - 0 - - U 'TProofProgressStatus' - 0 - - "
08104 "d - 'Double_t' 0 - - U 'TList' - 2 - -", (char*)NULL, (void*) NULL, 1);
08105    G__memfunc_setup("GetStatus",932,G__G__ProofPlayer_152_0_26, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofProgressStatus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08106    G__memfunc_setup("SetProgressStatus",1797,G__G__ProofPlayer_152_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TProofProgressStatus' - 0 - st", (char*)NULL, (void*) NULL, 0);
08107    G__memfunc_setup("SetTotalEntries",1546,G__G__ProofPlayer_152_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - ent", (char*)NULL, (void*) NULL, 0);
08108    G__memfunc_setup("GetSlaveStats",1322,G__G__ProofPlayer_152_0_29, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TMap), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08109    G__memfunc_setup("GetActiveWorkers",1641,G__G__ProofPlayer_152_0_30, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
08110    G__memfunc_setup("Class",502,G__G__ProofPlayer_152_0_31, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TVirtualPacketizer::Class) ), 0);
08111    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_152_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualPacketizer::Class_Name) ), 0);
08112    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_152_0_33, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TVirtualPacketizer::Class_Version) ), 0);
08113    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_152_0_34, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TVirtualPacketizer::Dictionary) ), 0);
08114    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08115    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);
08116    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);
08117    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_152_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08118    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_152_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualPacketizer::DeclFileName) ), 0);
08119    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_152_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualPacketizer::ImplFileLine) ), 0);
08120    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_152_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TVirtualPacketizer::ImplFileName) ), 0);
08121    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_152_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TVirtualPacketizer::DeclFileLine) ), 0);
08122    // automatic destructor
08123    G__memfunc_setup("~TVirtualPacketizer", 1995, G__G__ProofPlayer_152_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08124    G__tag_memfunc_reset();
08125 }
08126 
08127 static void G__setup_memfuncTPacketizerAdaptive(void) {
08128    /* TPacketizerAdaptive */
08129    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptive));
08130    G__memfunc_setup("TPacketizerAdaptive",1940,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptive), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08131    G__memfunc_setup("TPacketizerAdaptive",1940,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptive), -1, 0, 1, 1, 4, 0, "u 'TPacketizerAdaptive' - 11 - -", "no implementation, will generate", (void*) NULL, 0);
08132    G__memfunc_setup("InitStats",931,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", "initialise the stats", (void*) NULL, 0);
08133    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TPacketizerAdaptive' - 11 - -", "error on accidental usage", (void*) NULL, 0);
08134    G__memfunc_setup("NextNode",805,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptivecLcLTFileNode), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08135    G__memfunc_setup("RemoveUnAllocNode",1698,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TPacketizerAdaptive::TFileNode' - 0 - -", (char*)NULL, (void*) NULL, 0);
08136    G__memfunc_setup("NextActiveNode",1409,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptivecLcLTFileNode), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08137    G__memfunc_setup("RemoveActiveNode",1616,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TPacketizerAdaptive::TFileNode' - 0 - -", (char*)NULL, (void*) NULL, 0);
08138    G__memfunc_setup("GetNextUnAlloc",1389,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptivecLcLTFileStat), -1, 0, 2, 1, 4, 0, 
08139 "U 'TPacketizerAdaptive::TFileNode' - 0 '0' node C - - 10 '0' nodeHostName", (char*)NULL, (void*) NULL, 0);
08140    G__memfunc_setup("GetNextActive",1307,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptivecLcLTFileStat), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08141    G__memfunc_setup("RemoveActive",1226,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TPacketizerAdaptive::TFileStat' - 0 - file", (char*)NULL, (void*) NULL, 0);
08142    G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08143    G__memfunc_setup("ValidateFiles",1309,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
08144 "U 'TDSet' - 0 - dset U 'TList' - 0 - slaves "
08145 "n - 'Long64_t' 0 '-1' maxent g - 'Bool_t' 0 'kFALSE' byfile", (char*)NULL, (void*) NULL, 0);
08146    G__memfunc_setup("ReassignPacket",1428,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 4, 0, 
08147 "U 'TDSetElement' - 0 - e U 'TList' - 2 - listOfMissingFiles", (char*)NULL, (void*) NULL, 0);
08148    G__memfunc_setup("SplitPerHost",1233,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
08149 "U 'TList' - 0 - elements U 'TList' - 2 - listOfMissingFiles", (char*)NULL, (void*) NULL, 0);
08150    G__memfunc_setup("TPacketizerAdaptive",1940,G__G__ProofPlayer_161_0_16, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerAdaptive), -1, 0, 6, 1, 1, 0, 
08151 "U 'TDSet' - 0 - dset U 'TList' - 0 - slaves "
08152 "n - 'Long64_t' 0 - first n - 'Long64_t' 0 - num "
08153 "U 'TList' - 0 - input U 'TProofProgressStatus' - 0 - st", (char*)NULL, (void*) NULL, 0);
08154    G__memfunc_setup("AddProcessed",1201,G__G__ProofPlayer_161_0_17, 105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
08155 "U 'TSlave' - 0 - sl U 'TProofProgressStatus' - 0 - st "
08156 "d - 'Double_t' 0 - latency U 'TList' - 2 '0' listOfMissingFiles", (char*)NULL, (void*) NULL, 1);
08157    G__memfunc_setup("GetEstEntriesProcessed",2254,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
08158 "f - 'Float_t' 0 - - n - 'Long64_t' 1 - ent "
08159 "n - 'Long64_t' 1 - bytes n - 'Long64_t' 1 - calls", (char*)NULL, (void*) NULL, 1);
08160    G__memfunc_setup("GetCurrentRate",1423,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 1 - all", (char*)NULL, (void*) NULL, 1);
08161    G__memfunc_setup("CalculatePacketSize",1921,G__G__ProofPlayer_161_0_20, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
08162 "U 'TObject' - 0 - slstat n - 'Long64_t' 0 - cachesz "
08163 "i - 'Int_t' 0 - learnent", (char*)NULL, (void*) NULL, 0);
08164    G__memfunc_setup("GetNextPacket",1303,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSetElement), -1, 0, 2, 1, 1, 0, 
08165 "U 'TSlave' - 0 - sl U 'TMessage' - 0 - r", (char*)NULL, (void*) NULL, 1);
08166    G__memfunc_setup("MarkBad",658,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
08167 "U 'TSlave' - 0 - s U 'TProofProgressStatus' - 0 - status "
08168 "U 'TList' - 2 - missingFiles", (char*)NULL, (void*) NULL, 1);
08169    G__memfunc_setup("GetActiveWorkers",1641,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
08170    G__memfunc_setup("Class",502,G__G__ProofPlayer_161_0_24, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPacketizerAdaptive::Class) ), 0);
08171    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_161_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerAdaptive::Class_Name) ), 0);
08172    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_161_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPacketizerAdaptive::Class_Version) ), 0);
08173    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_161_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPacketizerAdaptive::Dictionary) ), 0);
08174    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08175    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);
08176    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);
08177    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_161_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08178    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_161_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerAdaptive::DeclFileName) ), 0);
08179    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_161_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPacketizerAdaptive::ImplFileLine) ), 0);
08180    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_161_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerAdaptive::ImplFileName) ), 0);
08181    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_161_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPacketizerAdaptive::DeclFileLine) ), 0);
08182    // automatic destructor
08183    G__memfunc_setup("~TPacketizerAdaptive", 2066, G__G__ProofPlayer_161_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08184    G__tag_memfunc_reset();
08185 }
08186 
08187 static void G__setup_memfuncTPacketizerFile(void) {
08188    /* TPacketizerFile */
08189    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerFile));
08190    G__memfunc_setup("TPacketizerFile",1510,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerFile), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08191    G__memfunc_setup("TPacketizerFile",1510,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerFile), -1, 0, 1, 1, 4, 0, "u 'TPacketizerFile' - 11 - -", "no implementation, will generate", (void*) NULL, 0);
08192    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TPacketizerFile' - 11 - -", "error on accidental usage", (void*) NULL, 0);
08193    G__memfunc_setup("TPacketizerFile",1510,G__G__ProofPlayer_175_0_4, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerFile), -1, 0, 4, 1, 1, 0, 
08194 "U 'TList' - 0 - workers n - 'Long64_t' 0 - - "
08195 "U 'TList' - 0 - input U 'TProofProgressStatus' - 0 '0' st", (char*)NULL, (void*) NULL, 0);
08196    G__memfunc_setup("GetNextPacket",1303,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSetElement), -1, 0, 2, 1, 1, 0, 
08197 "U 'TSlave' - 0 - wrk U 'TMessage' - 0 - r", (char*)NULL, (void*) NULL, 1);
08198    G__memfunc_setup("GetCurrentTime",1426,G__G__ProofPlayer_175_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08199    G__memfunc_setup("GetCurrentRate",1423,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 1 - all", (char*)NULL, (void*) NULL, 1);
08200    G__memfunc_setup("GetActiveWorkers",1641,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
08201    G__memfunc_setup("Class",502,G__G__ProofPlayer_175_0_9, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPacketizerFile::Class) ), 0);
08202    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_175_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerFile::Class_Name) ), 0);
08203    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_175_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPacketizerFile::Class_Version) ), 0);
08204    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_175_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPacketizerFile::Dictionary) ), 0);
08205    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08206    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);
08207    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);
08208    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_175_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08209    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_175_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerFile::DeclFileName) ), 0);
08210    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_175_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPacketizerFile::ImplFileLine) ), 0);
08211    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_175_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerFile::ImplFileName) ), 0);
08212    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_175_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPacketizerFile::DeclFileLine) ), 0);
08213    // automatic destructor
08214    G__memfunc_setup("~TPacketizerFile", 1636, G__G__ProofPlayer_175_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08215    G__tag_memfunc_reset();
08216 }
08217 
08218 static void G__setup_memfuncTPacketizer(void) {
08219    /* TPacketizer */
08220    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizer));
08221    G__memfunc_setup("TPacketizer",1126,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizer), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08222    G__memfunc_setup("TPacketizer",1126,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizer), -1, 0, 1, 1, 4, 0, "u 'TPacketizer' - 11 - -", "no implementation, will generate", (void*) NULL, 0);
08223    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TPacketizer' - 11 - -", "error on accidental usage", (void*) NULL, 0);
08224    G__memfunc_setup("NextUnAllocNode",1491,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizercLcLTFileNode), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08225    G__memfunc_setup("RemoveUnAllocNode",1698,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TPacketizer::TFileNode' - 0 - -", (char*)NULL, (void*) NULL, 0);
08226    G__memfunc_setup("NextActiveNode",1409,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizercLcLTFileNode), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08227    G__memfunc_setup("RemoveActiveNode",1616,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TPacketizer::TFileNode' - 0 - -", (char*)NULL, (void*) NULL, 0);
08228    G__memfunc_setup("GetNextUnAlloc",1389,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizercLcLTFileStat), -1, 0, 1, 1, 4, 0, "U 'TPacketizer::TFileNode' - 0 '0' node", (char*)NULL, (void*) NULL, 0);
08229    G__memfunc_setup("GetNextActive",1307,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizercLcLTFileStat), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08230    G__memfunc_setup("RemoveActive",1226,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TPacketizer::TFileStat' - 0 - file", (char*)NULL, (void*) NULL, 0);
08231    G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08232    G__memfunc_setup("ValidateFiles",1309,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
08233 "U 'TDSet' - 0 - dset U 'TList' - 0 - slaves "
08234 "n - 'Long64_t' 0 '-1' maxent g - 'Bool_t' 0 'kFALSE' byfile", (char*)NULL, (void*) NULL, 0);
08235    G__memfunc_setup("TPacketizer",1126,G__G__ProofPlayer_178_0_13, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizer), -1, 0, 6, 1, 1, 0, 
08236 "U 'TDSet' - 0 - dset U 'TList' - 0 - slaves "
08237 "n - 'Long64_t' 0 - first n - 'Long64_t' 0 - num "
08238 "U 'TList' - 0 - input U 'TProofProgressStatus' - 0 - st", (char*)NULL, (void*) NULL, 0);
08239    G__memfunc_setup("GetNextPacket",1303,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSetElement), -1, 0, 2, 1, 1, 0, 
08240 "U 'TSlave' - 0 - sl U 'TMessage' - 0 - r", (char*)NULL, (void*) NULL, 1);
08241    G__memfunc_setup("GetEntriesProcessed",1954,G__G__ProofPlayer_178_0_15, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 8, "U 'TSlave' - 0 - sl", (char*)NULL, (void*) NULL, 0);
08242    G__memfunc_setup("GetCurrentRate",1423,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 1 - all", (char*)NULL, (void*) NULL, 1);
08243    G__memfunc_setup("GetActiveWorkers",1641,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
08244    G__memfunc_setup("Class",502,G__G__ProofPlayer_178_0_18, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPacketizer::Class) ), 0);
08245    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_178_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizer::Class_Name) ), 0);
08246    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_178_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPacketizer::Class_Version) ), 0);
08247    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_178_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPacketizer::Dictionary) ), 0);
08248    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08249    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);
08250    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);
08251    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_178_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08252    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_178_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizer::DeclFileName) ), 0);
08253    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_178_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPacketizer::ImplFileLine) ), 0);
08254    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_178_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizer::ImplFileName) ), 0);
08255    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_178_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPacketizer::DeclFileLine) ), 0);
08256    // automatic destructor
08257    G__memfunc_setup("~TPacketizer", 1252, G__G__ProofPlayer_178_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08258    G__tag_memfunc_reset();
08259 }
08260 
08261 static void G__setup_memfuncTPacketizerMulti(void) {
08262    /* TPacketizerMulti */
08263    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerMulti));
08264    G__memfunc_setup("TPacketizerMulti",1649,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerMulti), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08265    G__memfunc_setup("TPacketizerMulti",1649,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerMulti), -1, 0, 1, 1, 4, 0, "u 'TPacketizerMulti' - 11 - -", "no implementation, will generate", (void*) NULL, 0);
08266    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TPacketizerMulti' - 11 - -", "error on accidental usage", (void*) NULL, 0);
08267    G__memfunc_setup("CreatePacketizer",1638,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer), -1, 0, 6, 1, 4, 0, 
08268 "U 'TDSet' - 0 - dset U 'TList' - 0 - wrks "
08269 "n - 'Long64_t' 0 - first n - 'Long64_t' 0 - num "
08270 "U 'TList' - 0 - input U 'TProofProgressStatus' - 0 - st", (char*)NULL, (void*) NULL, 0);
08271    G__memfunc_setup("TPacketizerMulti",1649,G__G__ProofPlayer_182_0_5, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerMulti), -1, 0, 6, 1, 1, 0, 
08272 "U 'TDSet' - 0 - dset U 'TList' - 0 - slaves "
08273 "n - 'Long64_t' 0 - first n - 'Long64_t' 0 - num "
08274 "U 'TList' - 0 - input U 'TProofProgressStatus' - 0 - st", (char*)NULL, (void*) NULL, 0);
08275    G__memfunc_setup("GetNextPacket",1303,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSetElement), -1, 0, 2, 1, 1, 0, 
08276 "U 'TSlave' - 0 - wrk U 'TMessage' - 0 - r", (char*)NULL, (void*) NULL, 1);
08277    G__memfunc_setup("GetEstEntriesProcessed",2254,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
08278 "f - 'Float_t' 0 - f n - 'Long64_t' 1 - ent "
08279 "n - 'Long64_t' 1 - bytes n - 'Long64_t' 1 - calls", (char*)NULL, (void*) NULL, 1);
08280    G__memfunc_setup("GetCurrentRate",1423,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 1 - all", (char*)NULL, (void*) NULL, 1);
08281    G__memfunc_setup("StopProcess",1157,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - abort", (char*)NULL, (void*) NULL, 1);
08282    G__memfunc_setup("MarkBad",658,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
08283 "U 'TSlave' - 0 - wrk U 'TProofProgressStatus' - 0 - st "
08284 "U 'TList' - 2 - missing", (char*)NULL, (void*) NULL, 1);
08285    G__memfunc_setup("AddProcessed",1201,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 4, 1, 1, 0, 
08286 "U 'TSlave' - 0 - wrk U 'TProofProgressStatus' - 0 - st "
08287 "d - 'Double_t' 0 - lat U 'TList' - 2 - missing", (char*)NULL, (void*) NULL, 1);
08288    G__memfunc_setup("GetActiveWorkers",1641,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
08289    G__memfunc_setup("Class",502,G__G__ProofPlayer_182_0_13, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPacketizerMulti::Class) ), 0);
08290    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_182_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerMulti::Class_Name) ), 0);
08291    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_182_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPacketizerMulti::Class_Version) ), 0);
08292    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_182_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPacketizerMulti::Dictionary) ), 0);
08293    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08294    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);
08295    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);
08296    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_182_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08297    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_182_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerMulti::DeclFileName) ), 0);
08298    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_182_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPacketizerMulti::ImplFileLine) ), 0);
08299    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_182_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerMulti::ImplFileName) ), 0);
08300    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_182_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPacketizerMulti::DeclFileLine) ), 0);
08301    // automatic destructor
08302    G__memfunc_setup("~TPacketizerMulti", 1775, G__G__ProofPlayer_182_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08303    G__tag_memfunc_reset();
08304 }
08305 
08306 static void G__setup_memfuncTPacketizerUnit(void) {
08307    /* TPacketizerUnit */
08308    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerUnit));
08309    G__memfunc_setup("TPacketizerUnit",1542,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerUnit), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08310    G__memfunc_setup("TPacketizerUnit",1542,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerUnit), -1, 0, 1, 1, 4, 0, "u 'TPacketizerUnit' - 11 - -", "no implementation, will generate", (void*) NULL, 0);
08311    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TPacketizerUnit' - 11 - -", "error on accidental usage", (void*) NULL, 0);
08312    G__memfunc_setup("TPacketizerUnit",1542,G__G__ProofPlayer_183_0_4, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPacketizerUnit), -1, 0, 4, 1, 1, 0, 
08313 "U 'TList' - 0 - slaves n - 'Long64_t' 0 - num "
08314 "U 'TList' - 0 - input U 'TProofProgressStatus' - 0 '0' st", (char*)NULL, (void*) NULL, 0);
08315    G__memfunc_setup("GetNextPacket",1303,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSetElement), -1, 0, 2, 1, 1, 0, 
08316 "U 'TSlave' - 0 - sl U 'TMessage' - 0 - r", (char*)NULL, (void*) NULL, 1);
08317    G__memfunc_setup("GetCurrentTime",1426,G__G__ProofPlayer_183_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08318    G__memfunc_setup("GetCurrentRate",1423,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 0, "g - 'Bool_t' 1 - all", (char*)NULL, (void*) NULL, 1);
08319    G__memfunc_setup("GetActiveWorkers",1641,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
08320    G__memfunc_setup("Class",502,G__G__ProofPlayer_183_0_9, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPacketizerUnit::Class) ), 0);
08321    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_183_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerUnit::Class_Name) ), 0);
08322    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_183_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPacketizerUnit::Class_Version) ), 0);
08323    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_183_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPacketizerUnit::Dictionary) ), 0);
08324    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08325    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);
08326    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);
08327    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_183_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08328    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_183_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerUnit::DeclFileName) ), 0);
08329    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_183_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPacketizerUnit::ImplFileLine) ), 0);
08330    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_183_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPacketizerUnit::ImplFileName) ), 0);
08331    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_183_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPacketizerUnit::DeclFileLine) ), 0);
08332    // automatic destructor
08333    G__memfunc_setup("~TPacketizerUnit", 1668, G__G__ProofPlayer_183_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08334    G__tag_memfunc_reset();
08335 }
08336 
08337 static void G__setup_memfuncTPerfEvent(void) {
08338    /* TPerfEvent */
08339    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfEvent));
08340    G__memfunc_setup("TPerfEvent",995,G__G__ProofPlayer_196_0_1, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfEvent), -1, 0, 1, 1, 1, 0, "U 'TTimeStamp' - 0 '0' offset", (char*)NULL, (void*) NULL, 0);
08341    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);
08342    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);
08343    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);
08344    G__memfunc_setup("Class",502,G__G__ProofPlayer_196_0_5, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPerfEvent::Class) ), 0);
08345    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_196_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPerfEvent::Class_Name) ), 0);
08346    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_196_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPerfEvent::Class_Version) ), 0);
08347    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_196_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPerfEvent::Dictionary) ), 0);
08348    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08349    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);
08350    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);
08351    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_196_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08352    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_196_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPerfEvent::DeclFileName) ), 0);
08353    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_196_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPerfEvent::ImplFileLine) ), 0);
08354    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_196_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPerfEvent::ImplFileName) ), 0);
08355    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_196_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPerfEvent::DeclFileLine) ), 0);
08356    // automatic copy constructor
08357    G__memfunc_setup("TPerfEvent", 995, G__G__ProofPlayer_196_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfEvent), -1, 0, 1, 1, 1, 0, "u 'TPerfEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
08358    // automatic destructor
08359    G__memfunc_setup("~TPerfEvent", 1121, G__G__ProofPlayer_196_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08360    // automatic assignment operator
08361    G__memfunc_setup("operator=", 937, G__G__ProofPlayer_196_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfEvent), -1, 1, 1, 1, 1, 0, "u 'TPerfEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
08362    G__tag_memfunc_reset();
08363 }
08364 
08365 static void G__setup_memfuncTPerfStats(void) {
08366    /* TPerfStats */
08367    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfStats));
08368    G__memfunc_setup("TPerfStats",1008,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfStats), -1, 0, 2, 1, 4, 0, 
08369 "U 'TList' - 0 - input U 'TList' - 0 - output", (char*)NULL, (void*) NULL, 0);
08370    G__memfunc_setup("WriteQueryLog",1347,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08371    G__memfunc_setup("SimpleEvent",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i 'TVirtualPerfStats::EEventType' - 0 - type", (char*)NULL, (void*) NULL, 1);
08372    G__memfunc_setup("PacketEvent",1114,(G__InterfaceMethod) NULL,121, -1, -1, 0, 8, 1, 1, 0, 
08373 "C - - 10 - slave C - - 10 - slavename "
08374 "C - - 10 - filename n - 'Long64_t' 0 - eventsprocessed "
08375 "d - 'Double_t' 0 - latency d - 'Double_t' 0 - proctime "
08376 "d - 'Double_t' 0 - cputime n - 'Long64_t' 0 - bytesRead", (char*)NULL, (void*) NULL, 1);
08377    G__memfunc_setup("FileEvent",898,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
08378 "C - - 10 - slave C - - 10 - slavename "
08379 "C - - 10 - nodename C - - 10 - filename "
08380 "g - 'Bool_t' 0 - isStart", (char*)NULL, (void*) NULL, 1);
08381    G__memfunc_setup("FileOpenEvent",1300,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
08382 "U 'TFile' - 0 - file C - - 10 - filename "
08383 "d - 'Double_t' 0 - start", (char*)NULL, (void*) NULL, 1);
08384    G__memfunc_setup("FileReadEvent",1278,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
08385 "U 'TFile' - 0 - file i - 'Int_t' 0 - len "
08386 "d - 'Double_t' 0 - start", (char*)NULL, (void*) NULL, 1);
08387    G__memfunc_setup("RateEvent",910,(G__InterfaceMethod) NULL,121, -1, -1, 0, 4, 1, 1, 0, 
08388 "d - 'Double_t' 0 - proctime d - 'Double_t' 0 - deltatime "
08389 "n - 'Long64_t' 0 - eventsprocessed n - 'Long64_t' 0 - bytesRead", (char*)NULL, (void*) NULL, 1);
08390    G__memfunc_setup("SetBytesRead",1199,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - num", (char*)NULL, (void*) NULL, 1);
08391    G__memfunc_setup("GetBytesRead",1187,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08392    G__memfunc_setup("SetNumEvents",1233,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - num", (char*)NULL, (void*) NULL, 1);
08393    G__memfunc_setup("GetNumEvents",1221,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08394    G__memfunc_setup("Start",526,G__G__ProofPlayer_197_0_13, 121, -1, -1, 0, 2, 3, 1, 0, 
08395 "U 'TList' - 0 - input U 'TList' - 0 - output", (char*)NULL, (void*) G__func2void( (void (*)(TList*, TList*))(&TPerfStats::Start) ), 0);
08396    G__memfunc_setup("Stop",422,G__G__ProofPlayer_197_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPerfStats::Stop) ), 0);
08397    G__memfunc_setup("Setup",529,G__G__ProofPlayer_197_0_15, 121, -1, -1, 0, 1, 3, 1, 0, "U 'TList' - 0 - input", (char*)NULL, (void*) G__func2void( (void (*)(TList*))(&TPerfStats::Setup) ), 0);
08398    G__memfunc_setup("Class",502,G__G__ProofPlayer_197_0_16, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TPerfStats::Class) ), 0);
08399    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_197_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPerfStats::Class_Name) ), 0);
08400    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_197_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TPerfStats::Class_Version) ), 0);
08401    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_197_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TPerfStats::Dictionary) ), 0);
08402    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08403    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);
08404    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);
08405    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_197_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08406    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_197_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPerfStats::DeclFileName) ), 0);
08407    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_197_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPerfStats::ImplFileLine) ), 0);
08408    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_197_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TPerfStats::ImplFileName) ), 0);
08409    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_197_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TPerfStats::DeclFileLine) ), 0);
08410    // automatic copy constructor
08411    G__memfunc_setup("TPerfStats", 1008, G__G__ProofPlayer_197_0_28, (int) ('i'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfStats), -1, 0, 1, 1, 1, 0, "u 'TPerfStats' - 11 - -", (char*) NULL, (void*) NULL, 0);
08412    // automatic destructor
08413    G__memfunc_setup("~TPerfStats", 1134, G__G__ProofPlayer_197_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08414    // automatic assignment operator
08415    G__memfunc_setup("operator=", 937, G__G__ProofPlayer_197_0_30, (int) ('u'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TPerfStats), -1, 1, 1, 1, 1, 0, "u 'TPerfStats' - 11 - -", (char*) NULL, (void*) NULL, 0);
08416    G__tag_memfunc_reset();
08417 }
08418 
08419 static void G__setup_memfuncTProofLimitsFinder(void) {
08420    /* TProofLimitsFinder */
08421    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofLimitsFinder));
08422    G__memfunc_setup("TProofLimitsFinder",1828,G__G__ProofPlayer_200_0_1, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofLimitsFinder), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08423    G__memfunc_setup("FindGoodLimits",1404,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
08424 "U 'TH1' - 0 - h d - 'Axis_t' 0 - xmin "
08425 "d - 'Axis_t' 0 - xmax", (char*)NULL, (void*) NULL, 1);
08426    G__memfunc_setup("FindGoodLimits",1404,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
08427 "U 'TH1' - 0 - h d - 'Axis_t' 0 - xmin "
08428 "d - 'Axis_t' 0 - xmax d - 'Axis_t' 0 - ymin "
08429 "d - 'Axis_t' 0 - ymax", (char*)NULL, (void*) NULL, 1);
08430    G__memfunc_setup("FindGoodLimits",1404,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 7, 1, 1, 0, 
08431 "U 'TH1' - 0 - h d - 'Axis_t' 0 - xmin "
08432 "d - 'Axis_t' 0 - xmax d - 'Axis_t' 0 - ymin "
08433 "d - 'Axis_t' 0 - ymax d - 'Axis_t' 0 - zmin "
08434 "d - 'Axis_t' 0 - zmax", (char*)NULL, (void*) NULL, 1);
08435    G__memfunc_setup("AutoBinFunc",1086,G__G__ProofPlayer_200_0_5, 121, -1, -1, 0, 7, 3, 1, 0, 
08436 "u 'TString' - 1 - key d - 'Double_t' 1 - xmin "
08437 "d - 'Double_t' 1 - xmax d - 'Double_t' 1 - ymin "
08438 "d - 'Double_t' 1 - ymax d - 'Double_t' 1 - zmin "
08439 "d - 'Double_t' 1 - zmax", (char*)NULL, (void*) G__func2void( (void (*)(TString&, Double_t&, Double_t&, Double_t&, Double_t&, Double_t&, Double_t&))(&TProofLimitsFinder::AutoBinFunc) ), 0);
08440    G__memfunc_setup("Class",502,G__G__ProofPlayer_200_0_6, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofLimitsFinder::Class) ), 0);
08441    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_200_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofLimitsFinder::Class_Name) ), 0);
08442    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_200_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofLimitsFinder::Class_Version) ), 0);
08443    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_200_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofLimitsFinder::Dictionary) ), 0);
08444    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08445    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);
08446    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);
08447    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_200_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08448    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_200_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofLimitsFinder::DeclFileName) ), 0);
08449    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_200_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofLimitsFinder::ImplFileLine) ), 0);
08450    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_200_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofLimitsFinder::ImplFileName) ), 0);
08451    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_200_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofLimitsFinder::DeclFileLine) ), 0);
08452    // automatic copy constructor
08453    G__memfunc_setup("TProofLimitsFinder", 1828, G__G__ProofPlayer_200_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofLimitsFinder), -1, 0, 1, 1, 1, 0, "u 'TProofLimitsFinder' - 11 - -", (char*) NULL, (void*) NULL, 0);
08454    // automatic destructor
08455    G__memfunc_setup("~TProofLimitsFinder", 1954, G__G__ProofPlayer_200_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08456    // automatic assignment operator
08457    G__memfunc_setup("operator=", 937, G__G__ProofPlayer_200_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofLimitsFinder), -1, 1, 1, 1, 1, 0, "u 'TProofLimitsFinder' - 11 - -", (char*) NULL, (void*) NULL, 0);
08458    G__tag_memfunc_reset();
08459 }
08460 
08461 static void G__setup_memfuncTProofOutputFile(void) {
08462    /* TProofOutputFile */
08463    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFile));
08464    G__memfunc_setup("TProofOutputFile",1643,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFile), -1, 0, 1, 1, 4, 0, "u 'TProofOutputFile' - 11 - -", "Not implemented", (void*) NULL, 0);
08465    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFile), -1, 1, 1, 1, 4, 0, "u 'TProofOutputFile' - 11 - -", "Not implemented", (void*) NULL, 0);
08466    G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
08467 "C - - 10 - path C - - 10 - dsname", (char*)NULL, (void*) NULL, 0);
08468    G__memfunc_setup("SetFileName",1069,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
08469    G__memfunc_setup("SetDir",587,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "C - - 10 - dir", (char*)NULL, (void*) NULL, 0);
08470    G__memfunc_setup("SetWorkerOrdinal",1647,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "C - - 10 - ordinal", (char*)NULL, (void*) NULL, 0);
08471    G__memfunc_setup("AddFile",649,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
08472 "U 'TFileMerger' - 0 - merger C - - 10 - path", (char*)NULL, (void*) NULL, 0);
08473    G__memfunc_setup("NotifyError",1155,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "C - - 10 - errmsg", (char*)NULL, (void*) NULL, 0);
08474    G__memfunc_setup("Unlink",625,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "C - - 10 - path", (char*)NULL, (void*) NULL, 0);
08475    G__memfunc_setup("TProofOutputFile",1643,G__G__ProofPlayer_201_0_10, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFile), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08476    G__memfunc_setup("TProofOutputFile",1643,G__G__ProofPlayer_201_0_11, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFile), -1, 0, 3, 1, 1, 0, 
08477 "C - - 10 - path C - - 10 '\"M\"' option "
08478 "C - - 10 '0' dsname", (char*)NULL, (void*) NULL, 0);
08479    G__memfunc_setup("TProofOutputFile",1643,G__G__ProofPlayer_201_0_12, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFile), -1, 0, 4, 1, 1, 0, 
08480 "C - - 10 - path i 'TProofOutputFile::ERunType' - 0 - type "
08481 "h - 'UInt_t' 0 'kRemote' opt C - - 10 '0' dsname", (char*)NULL, (void*) NULL, 0);
08482    G__memfunc_setup("GetDir",575,G__G__ProofPlayer_201_0_13, 67, -1, -1, 0, 1, 1, 1, 9, "g - 'Bool_t' 0 'kFALSE' raw", (char*)NULL, (void*) NULL, 0);
08483    G__memfunc_setup("GetFileCollection",1708,G__G__ProofPlayer_201_0_14, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TFileCollection), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08484    G__memfunc_setup("GetFileMerger",1282,G__G__ProofPlayer_201_0_15, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TFileMerger), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kFALSE' local", (char*)NULL, (void*) NULL, 0);
08485    G__memfunc_setup("GetFileName",1057,G__G__ProofPlayer_201_0_16, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
08486    G__memfunc_setup("GetLocalHost",1193,G__G__ProofPlayer_201_0_17, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
08487    G__memfunc_setup("GetOptionsAnchor",1639,G__G__ProofPlayer_201_0_18, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
08488    G__memfunc_setup("GetOutputFileName",1714,G__G__ProofPlayer_201_0_19, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
08489    G__memfunc_setup("GetWorkerOrdinal",1635,G__G__ProofPlayer_201_0_20, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
08490    G__memfunc_setup("GetRunType",1015,G__G__ProofPlayer_201_0_21, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofOutputFilecLcLERunType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08491    G__memfunc_setup("GetTypeOpt",1013,G__G__ProofPlayer_201_0_22, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08492    G__memfunc_setup("IsMerge",684,G__G__ProofPlayer_201_0_23, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08493    G__memfunc_setup("IsMerged",784,G__G__ProofPlayer_201_0_24, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08494    G__memfunc_setup("IsRegister",1025,G__G__ProofPlayer_201_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08495    G__memfunc_setup("AdoptFile",888,G__G__ProofPlayer_201_0_26, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TFile' - 0 - f", "Adopt a TFile already open", (void*) NULL, 0);
08496    G__memfunc_setup("OpenFile",786,G__G__ProofPlayer_201_0_27, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TFile), -1, 0, 1, 1, 1, 0, "C - - 10 - opt", "Open a file with the specified name in fFileName1", (void*) NULL, 0);
08497    G__memfunc_setup("Merge",496,G__G__ProofPlayer_201_0_28, 110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - list", (char*)NULL, (void*) NULL, 0);
08498    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);
08499    G__memfunc_setup("SetOutputFileName",1726,G__G__ProofPlayer_201_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 0);
08500    G__memfunc_setup("ResetFileCollection",1935,G__G__ProofPlayer_201_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08501    G__memfunc_setup("Class",502,G__G__ProofPlayer_201_0_32, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofOutputFile::Class) ), 0);
08502    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_201_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofOutputFile::Class_Name) ), 0);
08503    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_201_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofOutputFile::Class_Version) ), 0);
08504    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_201_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofOutputFile::Dictionary) ), 0);
08505    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08506    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);
08507    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);
08508    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_201_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08509    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_201_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofOutputFile::DeclFileName) ), 0);
08510    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_201_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofOutputFile::ImplFileLine) ), 0);
08511    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_201_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofOutputFile::ImplFileName) ), 0);
08512    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_201_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofOutputFile::DeclFileLine) ), 0);
08513    // automatic destructor
08514    G__memfunc_setup("~TProofOutputFile", 1769, G__G__ProofPlayer_201_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08515    G__tag_memfunc_reset();
08516 }
08517 
08518 static void G__setup_memfuncTProofPlayer(void) {
08519    /* TProofPlayer */
08520    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer));
08521    G__memfunc_setup("GetSender",897,(G__InterfaceMethod) NULL, 89, -1, -1, 0, 0, 1, 2, 0, "", "used to set gTQSender", (void*) NULL, 1);
08522    G__memfunc_setup("DrawCanvas",1002,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "U 'TObject' - 0 - obj", "Canvas drawing via libProofDraw", (void*) NULL, 1);
08523    G__memfunc_setup("SetupFeedback",1302,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "specialized setup", (void*) NULL, 1);
08524    G__memfunc_setup("MergeOutput",1153,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
08525    G__memfunc_setup("StopFeedback",1195,G__G__ProofPlayer_203_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", "specialized teardown", (void*) NULL, 1);
08526    G__memfunc_setup("CheckMemUsage",1266,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 2, 0, 
08527 "n - 'Long64_t' 1 - mfreq g - 'Bool_t' 1 - w80r "
08528 "g - 'Bool_t' 1 - w80v u 'TString' - 1 - wmsg", (char*)NULL, (void*) NULL, 0);
08529    G__memfunc_setup("MapOutputListToDataMembers",2643,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
08530    G__memfunc_setup("TProofPlayer",1223,G__G__ProofPlayer_203_0_8, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayer), -1, 0, 1, 1, 1, 0, "U 'TProof' - 0 '0' proof", (char*)NULL, (void*) NULL, 0);
08531    G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
08532 "U 'TDSet' - 0 - set C - - 10 - selector "
08533 "C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
08534 "n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
08535    G__memfunc_setup("GetPacketizer",1330,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08536    G__memfunc_setup("Finalize",818,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
08537 "g - 'Bool_t' 0 'kFALSE' force g - 'Bool_t' 0 'kFALSE' sync", (char*)NULL, (void*) NULL, 1);
08538    G__memfunc_setup("Finalize",818,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "U 'TQueryResult' - 0 - qr", (char*)NULL, (void*) NULL, 1);
08539    G__memfunc_setup("DrawSelect",1006,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 6, 1, 1, 0, 
08540 "U 'TDSet' - 0 - set C - - 10 - varexp "
08541 "C - - 10 - selection C - 'Option_t' 10 '\"\"' option "
08542 "n - 'Long64_t' 0 '-1' nentries n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
08543    G__memfunc_setup("GetDrawArgs",1083,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
08544 "C - - 10 - var C - - 10 - sel "
08545 "C - 'Option_t' 10 - opt u 'TString' - 1 - selector "
08546 "u 'TString' - 1 - objname", (char*)NULL, (void*) NULL, 1);
08547    G__memfunc_setup("HandleGetTreeHeader",1861,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TMessage' - 0 - mess", (char*)NULL, (void*) NULL, 1);
08548    G__memfunc_setup("HandleRecvHisto",1507,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TMessage' - 0 - mess", (char*)NULL, (void*) NULL, 1);
08549    G__memfunc_setup("FeedBackCanvas",1345,G__G__ProofPlayer_203_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
08550 "C - - 10 - name g - 'Bool_t' 0 - create", (char*)NULL, (void*) NULL, 0);
08551    G__memfunc_setup("StopProcess",1157,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
08552 "g - 'Bool_t' 0 - abort i - 'Int_t' 0 '-1' timeout", (char*)NULL, (void*) NULL, 1);
08553    G__memfunc_setup("AddInput",793,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - inp", (char*)NULL, (void*) NULL, 1);
08554    G__memfunc_setup("ClearInput",1015,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
08555    G__memfunc_setup("GetOutput",945,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
08556    G__memfunc_setup("GetOutputList",1357,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08557    G__memfunc_setup("GetInputList",1228,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08558    G__memfunc_setup("GetListOfResults",1635,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TList), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08559    G__memfunc_setup("AddQueryResult",1438,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TQueryResult' - 0 - q", (char*)NULL, (void*) NULL, 1);
08560    G__memfunc_setup("GetCurrentQuery",1561,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TQueryResult), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08561    G__memfunc_setup("GetQueryResult",1461,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TQueryResult), -1, 0, 1, 1, 1, 0, "C - - 10 - ref", (char*)NULL, (void*) NULL, 1);
08562    G__memfunc_setup("RemoveQueryResult",1795,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - ref", (char*)NULL, (void*) NULL, 1);
08563    G__memfunc_setup("SetCurrentQuery",1573,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TQueryResult' - 0 - q", (char*)NULL, (void*) NULL, 1);
08564    G__memfunc_setup("SetMaxDrawQueries",1726,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 1);
08565    G__memfunc_setup("RestorePreviousQuery",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
08566    G__memfunc_setup("AddOutputObject",1521,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
08567    G__memfunc_setup("AddOutput",922,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - out", "Incorporate a list", (void*) NULL, 1);
08568    G__memfunc_setup("StoreOutput",1182,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - out", "Adopts the list", (void*) NULL, 1);
08569    G__memfunc_setup("StoreFeedback",1298,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
08570 "U 'TObject' - 0 - slave U 'TList' - 0 - out", "Adopts the list", (void*) NULL, 1);
08571    G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
08572 "n - 'Long64_t' 0 - total n - 'Long64_t' 0 - processed", "*SIGNAL*", (void*) NULL, 1);
08573    G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
08574 "U 'TSlave' - 0 - - n - 'Long64_t' 0 - total "
08575 "n - 'Long64_t' 0 - processed", (char*)NULL, (void*) NULL, 1);
08576    G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 7, 1, 1, 0, 
08577 "n - 'Long64_t' 0 - total n - 'Long64_t' 0 - processed "
08578 "n - 'Long64_t' 0 - bytesread f - 'Float_t' 0 - initTime "
08579 "f - 'Float_t' 0 - procTime f - 'Float_t' 0 - evtrti "
08580 "f - 'Float_t' 0 - mbrti", "*SIGNAL*", (void*) NULL, 1);
08581    G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 8, 1, 1, 0, 
08582 "U 'TSlave' - 0 - - n - 'Long64_t' 0 - total "
08583 "n - 'Long64_t' 0 - processed n - 'Long64_t' 0 - bytesread "
08584 "f - 'Float_t' 0 - initTime f - 'Float_t' 0 - procTime "
08585 "f - 'Float_t' 0 - evtrti f - 'Float_t' 0 - mbrti", "*SIGNAL*", (void*) NULL, 1);
08586    G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TProofProgressInfo' - 0 - pi", "*SIGNAL*", (void*) NULL, 1);
08587    G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
08588 "U 'TSlave' - 0 - - U 'TProofProgressInfo' - 0 - pi", "*SIGNAL*", (void*) NULL, 1);
08589    G__memfunc_setup("Feedback",773,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - objs", "*SIGNAL*", (void*) NULL, 1);
08590    G__memfunc_setup("CreateDrawFeedback",1767,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDrawFeedback), -1, 0, 1, 1, 1, 0, "U 'TProof' - 0 - p", (char*)NULL, (void*) NULL, 1);
08591    G__memfunc_setup("SetDrawFeedbackOption",2104,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
08592 "U 'TDrawFeedback' - 0 - f C - 'Option_t' 10 - opt", (char*)NULL, (void*) NULL, 1);
08593    G__memfunc_setup("DeleteDrawFeedback",1766,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TDrawFeedback' - 0 - f", (char*)NULL, (void*) NULL, 1);
08594    G__memfunc_setup("GetNextPacket",1303,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSetElement), -1, 0, 2, 1, 1, 0, 
08595 "U 'TSlave' - 0 - slave U 'TMessage' - 0 - r", (char*)NULL, (void*) NULL, 1);
08596    G__memfunc_setup("ReinitSelector",1452,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TQueryResult' - 0 - qr", (char*)NULL, (void*) NULL, 1);
08597    G__memfunc_setup("UpdateAutoBin",1301,(G__InterfaceMethod) NULL,121, -1, -1, 0, 7, 1, 1, 0, 
08598 "C - - 10 - name d - 'Double_t' 1 - xmin "
08599 "d - 'Double_t' 1 - xmax d - 'Double_t' 1 - ymin "
08600 "d - 'Double_t' 1 - ymax d - 'Double_t' 1 - zmin "
08601 "d - 'Double_t' 1 - zmax", (char*)NULL, (void*) NULL, 1);
08602    G__memfunc_setup("IsClient",795,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08603    G__memfunc_setup("GetExitStatus",1342,(G__InterfaceMethod) NULL,105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualProofPlayercLcLEExitStatus), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08604    G__memfunc_setup("GetEventsProcessed",1853,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08605    G__memfunc_setup("AddEventsProcessed",1830,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "n - 'Long64_t' 0 - ev", (char*)NULL, (void*) NULL, 1);
08606    G__memfunc_setup("SetDispatchTimer",1629,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 1);
08607    G__memfunc_setup("SetStopTimer",1235,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
08608 "g - 'Bool_t' 0 'kTRUE' on g - 'Bool_t' 0 'kFALSE' abort "
08609 "i - 'Int_t' 0 '0' timeout", (char*)NULL, (void*) NULL, 1);
08610    G__memfunc_setup("SetInitTime",1103,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
08611    G__memfunc_setup("GetCacheSize",1167,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
08612    G__memfunc_setup("GetLearnEntries",1516,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
08613    G__memfunc_setup("SetProcessing",1353,G__G__ProofPlayer_203_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 0);
08614    G__memfunc_setup("GetProgressStatus",1785,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofProgressStatus), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08615    G__memfunc_setup("Class",502,G__G__ProofPlayer_203_0_60, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofPlayer::Class) ), 0);
08616    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_203_0_61, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayer::Class_Name) ), 0);
08617    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_203_0_62, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofPlayer::Class_Version) ), 0);
08618    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_203_0_63, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofPlayer::Dictionary) ), 0);
08619    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08620    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);
08621    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);
08622    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_203_0_67, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08623    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_203_0_68, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayer::DeclFileName) ), 0);
08624    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_203_0_69, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayer::ImplFileLine) ), 0);
08625    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_203_0_70, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayer::ImplFileName) ), 0);
08626    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_203_0_71, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayer::DeclFileLine) ), 0);
08627    // automatic destructor
08628    G__memfunc_setup("~TProofPlayer", 1349, G__G__ProofPlayer_203_0_72, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08629    G__tag_memfunc_reset();
08630 }
08631 
08632 static void G__setup_memfuncTProofPlayerLite(void) {
08633    /* TProofPlayerLite */
08634    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLite));
08635    G__memfunc_setup("HandleTimer",1101,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'TTimer' - 0 - timer", (char*)NULL, (void*) NULL, 1);
08636    G__memfunc_setup("MakeSelector",1215,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "C - - 10 - selfile", (char*)NULL, (void*) NULL, 0);
08637    G__memfunc_setup("SetupFeedback",1302,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
08638    G__memfunc_setup("TProofPlayerLite",1621,G__G__ProofPlayer_259_0_4, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLite), -1, 0, 1, 1, 1, 0, "U 'TProof' - 0 '0' proof", (char*)NULL, (void*) NULL, 0);
08639    G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
08640 "U 'TDSet' - 0 - set C - - 10 - selector "
08641 "C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
08642 "n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
08643    G__memfunc_setup("Finalize",818,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
08644 "g - 'Bool_t' 0 'kFALSE' force g - 'Bool_t' 0 'kFALSE' sync", (char*)NULL, (void*) NULL, 1);
08645    G__memfunc_setup("Finalize",818,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "U 'TQueryResult' - 0 - qr", (char*)NULL, (void*) NULL, 1);
08646    G__memfunc_setup("StoreFeedback",1298,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
08647 "U 'TObject' - 0 - slave U 'TList' - 0 - out", "Adopts the list", (void*) NULL, 1);
08648    G__memfunc_setup("Class",502,G__G__ProofPlayer_259_0_9, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofPlayerLite::Class) ), 0);
08649    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_259_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerLite::Class_Name) ), 0);
08650    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_259_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofPlayerLite::Class_Version) ), 0);
08651    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_259_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofPlayerLite::Dictionary) ), 0);
08652    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08653    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);
08654    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);
08655    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_259_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08656    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_259_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerLite::DeclFileName) ), 0);
08657    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_259_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayerLite::ImplFileLine) ), 0);
08658    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_259_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerLite::ImplFileName) ), 0);
08659    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_259_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayerLite::DeclFileLine) ), 0);
08660    // automatic destructor
08661    G__memfunc_setup("~TProofPlayerLite", 1747, G__G__ProofPlayer_259_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08662    G__tag_memfunc_reset();
08663 }
08664 
08665 static void G__setup_memfuncTProofPlayerRemote(void) {
08666    /* TProofPlayerRemote */
08667    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote));
08668    G__memfunc_setup("HandleTimer",1101,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'TTimer' - 0 - timer", (char*)NULL, (void*) NULL, 1);
08669    G__memfunc_setup("InitPacketizer",1446,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 2, 0, 
08670 "U 'TDSet' - 0 - dset n - 'Long64_t' 0 - nentries "
08671 "n - 'Long64_t' 0 - first C - - 10 - defpackunit "
08672 "C - - 10 - defpackdata", (char*)NULL, (void*) NULL, 0);
08673    G__memfunc_setup("MergeFeedback",1269,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TList), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
08674    G__memfunc_setup("MergeOutputFiles",1652,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
08675    G__memfunc_setup("NotifyMemory",1266,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
08676    G__memfunc_setup("SetLastMergingMsg",1712,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
08677    G__memfunc_setup("SendSelector",1227,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "C - - 10 - selector_file", "send selector to slaves", (void*) NULL, 1);
08678    G__memfunc_setup("GetProof",806,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProof), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
08679    G__memfunc_setup("SetupFeedback",1302,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "specialized setup", (void*) NULL, 1);
08680    G__memfunc_setup("StopFeedback",1195,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "specialized teardown", (void*) NULL, 1);
08681    G__memfunc_setup("SetSelectorDataMembersFromOutputList",3699,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
08682    G__memfunc_setup("TProofPlayerRemote",1843,G__G__ProofPlayer_260_0_12, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerRemote), -1, 0, 1, 1, 1, 0, "U 'TProof' - 0 '0' proof", (char*)NULL, (void*) NULL, 0);
08683    G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
08684 "U 'TDSet' - 0 - set C - - 10 - selector "
08685 "C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
08686 "n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
08687    G__memfunc_setup("Finalize",818,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 2, 1, 1, 0, 
08688 "g - 'Bool_t' 0 'kFALSE' force g - 'Bool_t' 0 'kFALSE' sync", (char*)NULL, (void*) NULL, 1);
08689    G__memfunc_setup("Finalize",818,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 1, 1, 1, 0, "U 'TQueryResult' - 0 - qr", (char*)NULL, (void*) NULL, 1);
08690    G__memfunc_setup("DrawSelect",1006,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 6, 1, 1, 0, 
08691 "U 'TDSet' - 0 - set C - - 10 - varexp "
08692 "C - - 10 - selection C - 'Option_t' 10 '\"\"' option "
08693 "n - 'Long64_t' 0 '-1' nentries n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
08694    G__memfunc_setup("RedirectOutput",1475,G__G__ProofPlayer_260_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' on", (char*)NULL, (void*) NULL, 0);
08695    G__memfunc_setup("StopProcess",1157,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
08696 "g - 'Bool_t' 0 - abort i - 'Int_t' 0 '-1' timeout", (char*)NULL, (void*) NULL, 1);
08697    G__memfunc_setup("StoreOutput",1182,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - out", "Adopts the list", (void*) NULL, 1);
08698    G__memfunc_setup("StoreFeedback",1298,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
08699 "U 'TObject' - 0 - slave U 'TList' - 0 - out", "Adopts the list", (void*) NULL, 1);
08700    G__memfunc_setup("Incorporate",1158,G__G__ProofPlayer_260_0_21, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
08701 "U 'TObject' - 0 - obj U 'TList' - 0 - out "
08702 "g - 'Bool_t' 1 - merged", (char*)NULL, (void*) NULL, 0);
08703    G__memfunc_setup("HandleHistogram",1530,G__G__ProofPlayer_260_0_22, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TObject), -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 0);
08704    G__memfunc_setup("AddOutputObject",1521,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TObject' - 0 - obj", (char*)NULL, (void*) NULL, 1);
08705    G__memfunc_setup("AddOutput",922,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - out", "Incorporate a list", (void*) NULL, 1);
08706    G__memfunc_setup("MergeOutput",1153,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
08707    G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
08708 "n - 'Long64_t' 0 - total n - 'Long64_t' 0 - processed", "*SIGNAL*", (void*) NULL, 1);
08709    G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
08710 "U 'TSlave' - 0 - - n - 'Long64_t' 0 - total "
08711 "n - 'Long64_t' 0 - processed", (char*)NULL, (void*) NULL, 1);
08712    G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 7, 1, 1, 0, 
08713 "n - 'Long64_t' 0 - total n - 'Long64_t' 0 - processed "
08714 "n - 'Long64_t' 0 - bytesread f - 'Float_t' 0 - initTime "
08715 "f - 'Float_t' 0 - procTime f - 'Float_t' 0 - evtrti "
08716 "f - 'Float_t' 0 - mbrti", "*SIGNAL*", (void*) NULL, 1);
08717    G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 8, 1, 1, 0, 
08718 "U 'TSlave' - 0 - - n - 'Long64_t' 0 - total "
08719 "n - 'Long64_t' 0 - processed n - 'Long64_t' 0 - bytesread "
08720 "f - 'Float_t' 0 - initTime f - 'Float_t' 0 - procTime "
08721 "f - 'Float_t' 0 - evtrti f - 'Float_t' 0 - mbrti", "*SIGNAL*", (void*) NULL, 1);
08722    G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TProofProgressInfo' - 0 - pi", "*SIGNAL*", (void*) NULL, 1);
08723    G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
08724 "U 'TSlave' - 0 - - U 'TProofProgressInfo' - 0 - pi", "*SIGNAL*", (void*) NULL, 1);
08725    G__memfunc_setup("Feedback",773,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TList' - 0 - objs", "*SIGNAL*", (void*) NULL, 1);
08726    G__memfunc_setup("GetNextPacket",1303,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TDSetElement), -1, 0, 2, 1, 1, 0, 
08727 "U 'TSlave' - 0 - slave U 'TMessage' - 0 - r", (char*)NULL, (void*) NULL, 1);
08728    G__memfunc_setup("GetPacketizer",1330,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TVirtualPacketizer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08729    G__memfunc_setup("IsClient",795,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08730    G__memfunc_setup("SetInitTime",1103,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
08731    G__memfunc_setup("Class",502,G__G__ProofPlayer_260_0_37, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofPlayerRemote::Class) ), 0);
08732    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_260_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerRemote::Class_Name) ), 0);
08733    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_260_0_39, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofPlayerRemote::Class_Version) ), 0);
08734    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_260_0_40, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofPlayerRemote::Dictionary) ), 0);
08735    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08736    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);
08737    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);
08738    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_260_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08739    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_260_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerRemote::DeclFileName) ), 0);
08740    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_260_0_46, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayerRemote::ImplFileLine) ), 0);
08741    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_260_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerRemote::ImplFileName) ), 0);
08742    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_260_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayerRemote::DeclFileLine) ), 0);
08743    // automatic destructor
08744    G__memfunc_setup("~TProofPlayerRemote", 1969, G__G__ProofPlayer_260_0_49, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08745    G__tag_memfunc_reset();
08746 }
08747 
08748 static void G__setup_memfuncTStatus(void) {
08749    /* TStatus */
08750    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatus));
08751    G__memfunc_setup("TStatus",728,G__G__ProofPlayer_265_0_1, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatus), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08752    G__memfunc_setup("IsOk",374,G__G__ProofPlayer_265_0_2, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08753    G__memfunc_setup("Add",265,G__G__ProofPlayer_265_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - mesg", (char*)NULL, (void*) NULL, 0);
08754    G__memfunc_setup("Merge",496,G__G__ProofPlayer_265_0_4, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "U 'TCollection' - 0 - list", (char*)NULL, (void*) NULL, 1);
08755    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);
08756    G__memfunc_setup("Reset",515,G__G__ProofPlayer_265_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08757    G__memfunc_setup("NextMesg",811,G__G__ProofPlayer_265_0_7, 67, -1, -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
08758    G__memfunc_setup("Class",502,G__G__ProofPlayer_265_0_8, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TStatus::Class) ), 0);
08759    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_265_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStatus::Class_Name) ), 0);
08760    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_265_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TStatus::Class_Version) ), 0);
08761    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_265_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TStatus::Dictionary) ), 0);
08762    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08763    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);
08764    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);
08765    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_265_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08766    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_265_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStatus::DeclFileName) ), 0);
08767    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_265_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStatus::ImplFileLine) ), 0);
08768    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_265_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TStatus::ImplFileName) ), 0);
08769    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_265_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TStatus::DeclFileLine) ), 0);
08770    // automatic copy constructor
08771    G__memfunc_setup("TStatus", 728, G__G__ProofPlayer_265_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatus), -1, 0, 1, 1, 1, 0, "u 'TStatus' - 11 - -", (char*) NULL, (void*) NULL, 0);
08772    // automatic destructor
08773    G__memfunc_setup("~TStatus", 854, G__G__ProofPlayer_265_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08774    // automatic assignment operator
08775    G__memfunc_setup("operator=", 937, G__G__ProofPlayer_265_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__ProofPlayerLN_TStatus), -1, 1, 1, 1, 1, 0, "u 'TStatus' - 11 - -", (char*) NULL, (void*) NULL, 0);
08776    G__tag_memfunc_reset();
08777 }
08778 
08779 static void G__setup_memfuncTProofPlayerLocal(void) {
08780    /* TProofPlayerLocal */
08781    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLocal));
08782    G__memfunc_setup("SetupFeedback",1302,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
08783    G__memfunc_setup("StopFeedback",1195,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
08784    G__memfunc_setup("TProofPlayerLocal",1714,G__G__ProofPlayer_268_0_3, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerLocal), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' client", (char*)NULL, (void*) NULL, 0);
08785    G__memfunc_setup("IsClient",795,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08786    G__memfunc_setup("Class",502,G__G__ProofPlayer_268_0_5, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofPlayerLocal::Class) ), 0);
08787    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_268_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerLocal::Class_Name) ), 0);
08788    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_268_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofPlayerLocal::Class_Version) ), 0);
08789    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_268_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofPlayerLocal::Dictionary) ), 0);
08790    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08791    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);
08792    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);
08793    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_268_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08794    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_268_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerLocal::DeclFileName) ), 0);
08795    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_268_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayerLocal::ImplFileLine) ), 0);
08796    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_268_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerLocal::ImplFileName) ), 0);
08797    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_268_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayerLocal::DeclFileLine) ), 0);
08798    // automatic destructor
08799    G__memfunc_setup("~TProofPlayerLocal", 1840, G__G__ProofPlayer_268_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08800    G__tag_memfunc_reset();
08801 }
08802 
08803 static void G__setup_memfuncTProofPlayerSlave(void) {
08804    /* TProofPlayerSlave */
08805    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSlave));
08806    G__memfunc_setup("HandleTimer",1101,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 4, 0, "U 'TTimer' - 0 - timer", (char*)NULL, (void*) NULL, 1);
08807    G__memfunc_setup("SetupFeedback",1302,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
08808    G__memfunc_setup("StopFeedback",1195,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
08809    G__memfunc_setup("TProofPlayerSlave",1730,G__G__ProofPlayer_269_0_4, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSlave), -1, 0, 1, 1, 1, 0, "U 'TSocket' - 0 '0' socket", (char*)NULL, (void*) NULL, 0);
08810    G__memfunc_setup("HandleGetTreeHeader",1861,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TMessage' - 0 - mess", (char*)NULL, (void*) NULL, 1);
08811    G__memfunc_setup("Class",502,G__G__ProofPlayer_269_0_6, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofPlayerSlave::Class) ), 0);
08812    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_269_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerSlave::Class_Name) ), 0);
08813    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_269_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofPlayerSlave::Class_Version) ), 0);
08814    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_269_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofPlayerSlave::Dictionary) ), 0);
08815    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08816    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);
08817    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);
08818    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_269_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08819    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_269_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerSlave::DeclFileName) ), 0);
08820    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_269_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayerSlave::ImplFileLine) ), 0);
08821    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_269_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerSlave::ImplFileName) ), 0);
08822    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_269_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayerSlave::DeclFileLine) ), 0);
08823    // automatic destructor
08824    G__memfunc_setup("~TProofPlayerSlave", 1856, G__G__ProofPlayer_269_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
08825    G__tag_memfunc_reset();
08826 }
08827 
08828 static void G__setup_memfuncTProofPlayerSuperMaster(void) {
08829    /* TProofPlayerSuperMaster */
08830    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSuperMaster));
08831    G__memfunc_setup("HandleTimer",1101,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'TTimer' - 0 - timer", (char*)NULL, (void*) NULL, 1);
08832    G__memfunc_setup("SetupFeedback",1302,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
08833    G__memfunc_setup("TProofPlayerSuperMaster",2370,G__G__ProofPlayer_270_0_3, 105, G__get_linked_tagnum(&G__G__ProofPlayerLN_TProofPlayerSuperMaster), -1, 0, 1, 1, 1, 0, "U 'TProof' - 0 '0' proof", (char*)NULL, (void*) NULL, 0);
08834    G__memfunc_setup("Process",735,(G__InterfaceMethod) NULL,110, -1, G__defined_typename("Long64_t"), 0, 5, 1, 1, 0, 
08835 "U 'TDSet' - 0 - set C - - 10 - selector "
08836 "C - 'Option_t' 10 '\"\"' option n - 'Long64_t' 0 '-1' nentries "
08837 "n - 'Long64_t' 0 '0' firstentry", (char*)NULL, (void*) NULL, 1);
08838    G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
08839 "n - 'Long64_t' 0 - total n - 'Long64_t' 0 - processed", (char*)NULL, (void*) NULL, 1);
08840    G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 7, 1, 1, 0, 
08841 "n - 'Long64_t' 0 - total n - 'Long64_t' 0 - processed "
08842 "n - 'Long64_t' 0 - bytesread f - 'Float_t' 0 - initTime "
08843 "f - 'Float_t' 0 - procTime f - 'Float_t' 0 - evtrti "
08844 "f - 'Float_t' 0 - mbrti", (char*)NULL, (void*) NULL, 1);
08845    G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TProofProgressInfo' - 0 - pi", (char*)NULL, (void*) NULL, 1);
08846    G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 0, 
08847 "U 'TSlave' - 0 - sl n - 'Long64_t' 0 - total "
08848 "n - 'Long64_t' 0 - processed", (char*)NULL, (void*) NULL, 1);
08849    G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 8, 1, 1, 0, 
08850 "U 'TSlave' - 0 - sl n - 'Long64_t' 0 - total "
08851 "n - 'Long64_t' 0 - processed n - 'Long64_t' 0 - bytesread "
08852 "f - 'Float_t' 0 - initTime f - 'Float_t' 0 - procTime "
08853 "f - 'Float_t' 0 - evtrti f - 'Float_t' 0 - mbrti", (char*)NULL, (void*) NULL, 1);
08854    G__memfunc_setup("Progress",853,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
08855 "U 'TSlave' - 0 - sl U 'TProofProgressInfo' - 0 - pi", (char*)NULL, (void*) NULL, 1);
08856    G__memfunc_setup("Class",502,G__G__ProofPlayer_270_0_11, 85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TProofPlayerSuperMaster::Class) ), 0);
08857    G__memfunc_setup("Class_Name",982,G__G__ProofPlayer_270_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerSuperMaster::Class_Name) ), 0);
08858    G__memfunc_setup("Class_Version",1339,G__G__ProofPlayer_270_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TProofPlayerSuperMaster::Class_Version) ), 0);
08859    G__memfunc_setup("Dictionary",1046,G__G__ProofPlayer_270_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TProofPlayerSuperMaster::Dictionary) ), 0);
08860    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__ProofPlayerLN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08861    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);
08862    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);
08863    G__memfunc_setup("StreamerNVirtual",1656,G__G__ProofPlayer_270_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08864    G__memfunc_setup("DeclFileName",1145,G__G__ProofPlayer_270_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerSuperMaster::DeclFileName) ), 0);
08865    G__memfunc_setup("ImplFileLine",1178,G__G__ProofPlayer_270_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayerSuperMaster::ImplFileLine) ), 0);
08866    G__memfunc_setup("ImplFileName",1171,G__G__ProofPlayer_270_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TProofPlayerSuperMaster::ImplFileName) ), 0);
08867    G__memfunc_setup("DeclFileLine",1152,G__G__ProofPlayer_270_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TProofPlayerSuperMaster::DeclFileLine) ), 0);
08868    // automatic destructor
08869    G__memfunc_setup("~TProofPlayerSuperMaster", 2496, G__G__ProofPlayer_270_0_23, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08870    G__tag_memfunc_reset();
08871 }
08872 
08873 
08874 /*********************************************************
08875 * Member function information setup
08876 *********************************************************/
08877 extern "C" void G__cpp_setup_memfuncG__ProofPlayer() {
08878 }
08879 
08880 /*********************************************************
08881 * Global variable information setup for each class
08882 *********************************************************/
08883 static void G__cpp_setup_global0() {
08884 
08885    /* Setting up global variables */
08886    G__resetplocal();
08887 
08888 }
08889 
08890 static void G__cpp_setup_global1() {
08891 }
08892 
08893 static void G__cpp_setup_global2() {
08894 }
08895 
08896 static void G__cpp_setup_global3() {
08897 
08898    G__resetglobalenv();
08899 }
08900 extern "C" void G__cpp_setup_globalG__ProofPlayer() {
08901   G__cpp_setup_global0();
08902   G__cpp_setup_global1();
08903   G__cpp_setup_global2();
08904   G__cpp_setup_global3();
08905 }
08906 
08907 /*********************************************************
08908 * Global function information setup for each class
08909 *********************************************************/
08910 static void G__cpp_setup_func0() {
08911    G__lastifuncposition();
08912 
08913 }
08914 
08915 static void G__cpp_setup_func1() {
08916 }
08917 
08918 static void G__cpp_setup_func2() {
08919 }
08920 
08921 static void G__cpp_setup_func3() {
08922 }
08923 
08924 static void G__cpp_setup_func4() {
08925 }
08926 
08927 static void G__cpp_setup_func5() {
08928 
08929    G__resetifuncposition();
08930 }
08931 
08932 extern "C" void G__cpp_setup_funcG__ProofPlayer() {
08933   G__cpp_setup_func0();
08934   G__cpp_setup_func1();
08935   G__cpp_setup_func2();
08936   G__cpp_setup_func3();
08937   G__cpp_setup_func4();
08938   G__cpp_setup_func5();
08939 }
08940 
08941 /*********************************************************
08942 * Class,struct,union,enum tag information setup
08943 *********************************************************/
08944 /* Setup class/struct taginfo */
08945 G__linked_taginfo G__G__ProofPlayerLN_TClass = { "TClass" , 99 , -1 };
08946 G__linked_taginfo G__G__ProofPlayerLN_TBuffer = { "TBuffer" , 99 , -1 };
08947 G__linked_taginfo G__G__ProofPlayerLN_TDirectory = { "TDirectory" , 99 , -1 };
08948 G__linked_taginfo G__G__ProofPlayerLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
08949 G__linked_taginfo G__G__ProofPlayerLN_TObject = { "TObject" , 99 , -1 };
08950 G__linked_taginfo G__G__ProofPlayerLN_TNamed = { "TNamed" , 99 , -1 };
08951 G__linked_taginfo G__G__ProofPlayerLN_TString = { "TString" , 99 , -1 };
08952 G__linked_taginfo G__G__ProofPlayerLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
08953 G__linked_taginfo G__G__ProofPlayerLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
08954 G__linked_taginfo G__G__ProofPlayerLN_TList = { "TList" , 99 , -1 };
08955 G__linked_taginfo G__G__ProofPlayerLN_TTimer = { "TTimer" , 99 , -1 };
08956 G__linked_taginfo G__G__ProofPlayerLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
08957 G__linked_taginfo G__G__ProofPlayerLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
08958 G__linked_taginfo G__G__ProofPlayerLN_TQObject = { "TQObject" , 99 , -1 };
08959 G__linked_taginfo G__G__ProofPlayerLN_TProof = { "TProof" , 99 , -1 };
08960 G__linked_taginfo G__G__ProofPlayerLN_THashList = { "THashList" , 99 , -1 };
08961 G__linked_taginfo G__G__ProofPlayerLN_TSeqCollection = { "TSeqCollection" , 99 , -1 };
08962 G__linked_taginfo G__G__ProofPlayerLN_TDrawFeedback = { "TDrawFeedback" , 99 , -1 };
08963 G__linked_taginfo G__G__ProofPlayerLN_TDSet = { "TDSet" , 99 , -1 };
08964 G__linked_taginfo G__G__ProofPlayerLN_TDSetElement = { "TDSetElement" , 99 , -1 };
08965 G__linked_taginfo G__G__ProofPlayerLN_TFile = { "TFile" , 99 , -1 };
08966 G__linked_taginfo G__G__ProofPlayerLN_TSelector = { "TSelector" , 99 , -1 };
08967 G__linked_taginfo G__G__ProofPlayerLN_TIter = { "TIter" , 99 , -1 };
08968 G__linked_taginfo G__G__ProofPlayerLN_TTree = { "TTree" , 99 , -1 };
08969 G__linked_taginfo G__G__ProofPlayerLN_TTreeCache = { "TTreeCache" , 99 , -1 };
08970 G__linked_taginfo G__G__ProofPlayerLN_TEventList = { "TEventList" , 99 , -1 };
08971 G__linked_taginfo G__G__ProofPlayerLN_TEntryList = { "TEntryList" , 99 , -1 };
08972 G__linked_taginfo G__G__ProofPlayerLN_TEventIter = { "TEventIter" , 99 , -1 };
08973 G__linked_taginfo G__G__ProofPlayerLN_TEventIterUnit = { "TEventIterUnit" , 99 , -1 };
08974 G__linked_taginfo G__G__ProofPlayerLN_TEventIterObj = { "TEventIterObj" , 99 , -1 };
08975 G__linked_taginfo G__G__ProofPlayerLN_TEventIterTree = { "TEventIterTree" , 99 , -1 };
08976 G__linked_taginfo G__G__ProofPlayerLN_TStopwatch = { "TStopwatch" , 99 , -1 };
08977 G__linked_taginfo G__G__ProofPlayerLN_TFileMerger = { "TFileMerger" , 99 , -1 };
08978 G__linked_taginfo G__G__ProofPlayerLN_TCollection = { "TCollection" , 99 , -1 };
08979 G__linked_taginfo G__G__ProofPlayerLN_TOutputListSelectorDataMap = { "TOutputListSelectorDataMap" , 99 , -1 };
08980 G__linked_taginfo G__G__ProofPlayerLN_TSlave = { "TSlave" , 99 , -1 };
08981 G__linked_taginfo G__G__ProofPlayerLN_TSocket = { "TSocket" , 99 , -1 };
08982 G__linked_taginfo G__G__ProofPlayerLN_TProofProgressStatus = { "TProofProgressStatus" , 99 , -1 };
08983 G__linked_taginfo G__G__ProofPlayerLN_TTime = { "TTime" , 99 , -1 };
08984 G__linked_taginfo G__G__ProofPlayerLN_TMap = { "TMap" , 99 , -1 };
08985 G__linked_taginfo G__G__ProofPlayerLN_TMessage = { "TMessage" , 99 , -1 };
08986 G__linked_taginfo G__G__ProofPlayerLN_TNtuple = { "TNtuple" , 99 , -1 };
08987 G__linked_taginfo G__G__ProofPlayerLN_TNtupleD = { "TNtupleD" , 99 , -1 };
08988 G__linked_taginfo G__G__ProofPlayerLN_TProofProgressInfo = { "TProofProgressInfo" , 99 , -1 };
08989 G__linked_taginfo G__G__ProofPlayerLN_TVirtualPacketizer = { "TVirtualPacketizer" , 99 , -1 };
08990 G__linked_taginfo G__G__ProofPlayerLN_TVirtualPacketizercLcLEUseEstOpt = { "TVirtualPacketizer::EUseEstOpt" , 101 , -1 };
08991 G__linked_taginfo G__G__ProofPlayerLN_TVirtualPacketizercLcLEStatusBits = { "TVirtualPacketizer::EStatusBits" , 101 , -1 };
08992 G__linked_taginfo G__G__ProofPlayerLN_TSortedList = { "TSortedList" , 99 , -1 };
08993 G__linked_taginfo G__G__ProofPlayerLN_TPacketizerAdaptive = { "TPacketizerAdaptive" , 99 , -1 };
08994 G__linked_taginfo G__G__ProofPlayerLN_TPacketizerAdaptivecLcLTFileNode = { "TPacketizerAdaptive::TFileNode" , 99 , -1 };
08995 G__linked_taginfo G__G__ProofPlayerLN_TPacketizerAdaptivecLcLTFileStat = { "TPacketizerAdaptive::TFileStat" , 99 , -1 };
08996 G__linked_taginfo G__G__ProofPlayerLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
08997 G__linked_taginfo G__G__ProofPlayerLN_TPacketizerFile = { "TPacketizerFile" , 99 , -1 };
08998 G__linked_taginfo G__G__ProofPlayerLN_TPacketizer = { "TPacketizer" , 99 , -1 };
08999 G__linked_taginfo G__G__ProofPlayerLN_TPacketizercLcLTFileNode = { "TPacketizer::TFileNode" , 99 , -1 };
09000 G__linked_taginfo G__G__ProofPlayerLN_TPacketizercLcLTFileStat = { "TPacketizer::TFileStat" , 99 , -1 };
09001 G__linked_taginfo G__G__ProofPlayerLN_TPacketizerMulti = { "TPacketizerMulti" , 99 , -1 };
09002 G__linked_taginfo G__G__ProofPlayerLN_TPacketizerUnit = { "TPacketizerUnit" , 99 , -1 };
09003 G__linked_taginfo G__G__ProofPlayerLN_TTimeStamp = { "TTimeStamp" , 99 , -1 };
09004 G__linked_taginfo G__G__ProofPlayerLN_TVirtualPerfStats = { "TVirtualPerfStats" , 99 , -1 };
09005 G__linked_taginfo G__G__ProofPlayerLN_TVirtualPerfStatscLcLEEventType = { "TVirtualPerfStats::EEventType" , 101 , -1 };
09006 G__linked_taginfo G__G__ProofPlayerLN_TH1D = { "TH1D" , 99 , -1 };
09007 G__linked_taginfo G__G__ProofPlayerLN_TH2D = { "TH2D" , 99 , -1 };
09008 G__linked_taginfo G__G__ProofPlayerLN_TVirtualMonitoringWriter = { "TVirtualMonitoringWriter" , 99 , -1 };
09009 G__linked_taginfo G__G__ProofPlayerLN_TPerfEvent = { "TPerfEvent" , 99 , -1 };
09010 G__linked_taginfo G__G__ProofPlayerLN_TPerfStats = { "TPerfStats" , 99 , -1 };
09011 G__linked_taginfo G__G__ProofPlayerLN_TH1 = { "TH1" , 99 , -1 };
09012 G__linked_taginfo G__G__ProofPlayerLN_THLimitsFinder = { "THLimitsFinder" , 99 , -1 };
09013 G__linked_taginfo G__G__ProofPlayerLN_TProofLimitsFinder = { "TProofLimitsFinder" , 99 , -1 };
09014 G__linked_taginfo G__G__ProofPlayerLN_TProofOutputFile = { "TProofOutputFile" , 99 , -1 };
09015 G__linked_taginfo G__G__ProofPlayerLN_TFileCollection = { "TFileCollection" , 99 , -1 };
09016 G__linked_taginfo G__G__ProofPlayerLN_TProofPlayer = { "TProofPlayer" , 99 , -1 };
09017 G__linked_taginfo G__G__ProofPlayerLN_TProofOutputFilecLcLERunType = { "TProofOutputFile::ERunType" , 101 , -1 };
09018 G__linked_taginfo G__G__ProofPlayerLN_TProofOutputFilecLcLETypeOpt = { "TProofOutputFile::ETypeOpt" , 101 , -1 };
09019 G__linked_taginfo G__G__ProofPlayerLN_TQueryResult = { "TQueryResult" , 99 , -1 };
09020 G__linked_taginfo G__G__ProofPlayerLN_TVirtualProofPlayer = { "TVirtualProofPlayer" , 99 , -1 };
09021 G__linked_taginfo G__G__ProofPlayerLN_TVirtualProofPlayercLcLEExitStatus = { "TVirtualProofPlayer::EExitStatus" , 101 , -1 };
09022 G__linked_taginfo G__G__ProofPlayerLN_TArrayL64 = { "TArrayL64" , 99 , -1 };
09023 G__linked_taginfo G__G__ProofPlayerLN_TArrayF = { "TArrayF" , 99 , -1 };
09024 G__linked_taginfo G__G__ProofPlayerLN_TArrayI = { "TArrayI" , 99 , -1 };
09025 G__linked_taginfo G__G__ProofPlayerLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
09026 G__linked_taginfo G__G__ProofPlayerLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
09027 G__linked_taginfo G__G__ProofPlayerLN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
09028 G__linked_taginfo G__G__ProofPlayerLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
09029 G__linked_taginfo G__G__ProofPlayerLN_TProofPlayerLite = { "TProofPlayerLite" , 99 , -1 };
09030 G__linked_taginfo G__G__ProofPlayerLN_TProofPlayerRemote = { "TProofPlayerRemote" , 99 , -1 };
09031 G__linked_taginfo G__G__ProofPlayerLN_TMutex = { "TMutex" , 99 , -1 };
09032 G__linked_taginfo G__G__ProofPlayerLN_TStatus = { "TStatus" , 99 , -1 };
09033 G__linked_taginfo G__G__ProofPlayerLN_TProofPlayercLcLEStatusBits = { "TProofPlayer::EStatusBits" , 101 , -1 };
09034 G__linked_taginfo G__G__ProofPlayerLN_TProofPlayerLocal = { "TProofPlayerLocal" , 99 , -1 };
09035 G__linked_taginfo G__G__ProofPlayerLN_TProofPlayerSlave = { "TProofPlayerSlave" , 99 , -1 };
09036 G__linked_taginfo G__G__ProofPlayerLN_TProofPlayerSuperMaster = { "TProofPlayerSuperMaster" , 99 , -1 };
09037 G__linked_taginfo G__G__ProofPlayerLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR = { "set<string,less<string>,allocator<string> >" , 99 , -1 };
09038 G__linked_taginfo G__G__ProofPlayerLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgRcLcLiterator = { "set<string,less<string>,allocator<string> >::iterator" , 99 , -1 };
09039 
09040 /* Reset class/struct taginfo */
09041 extern "C" void G__cpp_reset_tagtableG__ProofPlayer() {
09042   G__G__ProofPlayerLN_TClass.tagnum = -1 ;
09043   G__G__ProofPlayerLN_TBuffer.tagnum = -1 ;
09044   G__G__ProofPlayerLN_TDirectory.tagnum = -1 ;
09045   G__G__ProofPlayerLN_TMemberInspector.tagnum = -1 ;
09046   G__G__ProofPlayerLN_TObject.tagnum = -1 ;
09047   G__G__ProofPlayerLN_TNamed.tagnum = -1 ;
09048   G__G__ProofPlayerLN_TString.tagnum = -1 ;
09049   G__G__ProofPlayerLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
09050   G__G__ProofPlayerLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
09051   G__G__ProofPlayerLN_TList.tagnum = -1 ;
09052   G__G__ProofPlayerLN_TTimer.tagnum = -1 ;
09053   G__G__ProofPlayerLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
09054   G__G__ProofPlayerLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
09055   G__G__ProofPlayerLN_TQObject.tagnum = -1 ;
09056   G__G__ProofPlayerLN_TProof.tagnum = -1 ;
09057   G__G__ProofPlayerLN_THashList.tagnum = -1 ;
09058   G__G__ProofPlayerLN_TSeqCollection.tagnum = -1 ;
09059   G__G__ProofPlayerLN_TDrawFeedback.tagnum = -1 ;
09060   G__G__ProofPlayerLN_TDSet.tagnum = -1 ;
09061   G__G__ProofPlayerLN_TDSetElement.tagnum = -1 ;
09062   G__G__ProofPlayerLN_TFile.tagnum = -1 ;
09063   G__G__ProofPlayerLN_TSelector.tagnum = -1 ;
09064   G__G__ProofPlayerLN_TIter.tagnum = -1 ;
09065   G__G__ProofPlayerLN_TTree.tagnum = -1 ;
09066   G__G__ProofPlayerLN_TTreeCache.tagnum = -1 ;
09067   G__G__ProofPlayerLN_TEventList.tagnum = -1 ;
09068   G__G__ProofPlayerLN_TEntryList.tagnum = -1 ;
09069   G__G__ProofPlayerLN_TEventIter.tagnum = -1 ;
09070   G__G__ProofPlayerLN_TEventIterUnit.tagnum = -1 ;
09071   G__G__ProofPlayerLN_TEventIterObj.tagnum = -1 ;
09072   G__G__ProofPlayerLN_TEventIterTree.tagnum = -1 ;
09073   G__G__ProofPlayerLN_TStopwatch.tagnum = -1 ;
09074   G__G__ProofPlayerLN_TFileMerger.tagnum = -1 ;
09075   G__G__ProofPlayerLN_TCollection.tagnum = -1 ;
09076   G__G__ProofPlayerLN_TOutputListSelectorDataMap.tagnum = -1 ;
09077   G__G__ProofPlayerLN_TSlave.tagnum = -1 ;
09078   G__G__ProofPlayerLN_TSocket.tagnum = -1 ;
09079   G__G__ProofPlayerLN_TProofProgressStatus.tagnum = -1 ;
09080   G__G__ProofPlayerLN_TTime.tagnum = -1 ;
09081   G__G__ProofPlayerLN_TMap.tagnum = -1 ;
09082   G__G__ProofPlayerLN_TMessage.tagnum = -1 ;
09083   G__G__ProofPlayerLN_TNtuple.tagnum = -1 ;
09084   G__G__ProofPlayerLN_TNtupleD.tagnum = -1 ;
09085   G__G__ProofPlayerLN_TProofProgressInfo.tagnum = -1 ;
09086   G__G__ProofPlayerLN_TVirtualPacketizer.tagnum = -1 ;
09087   G__G__ProofPlayerLN_TVirtualPacketizercLcLEUseEstOpt.tagnum = -1 ;
09088   G__G__ProofPlayerLN_TVirtualPacketizercLcLEStatusBits.tagnum = -1 ;
09089   G__G__ProofPlayerLN_TSortedList.tagnum = -1 ;
09090   G__G__ProofPlayerLN_TPacketizerAdaptive.tagnum = -1 ;
09091   G__G__ProofPlayerLN_TPacketizerAdaptivecLcLTFileNode.tagnum = -1 ;
09092   G__G__ProofPlayerLN_TPacketizerAdaptivecLcLTFileStat.tagnum = -1 ;
09093   G__G__ProofPlayerLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
09094   G__G__ProofPlayerLN_TPacketizerFile.tagnum = -1 ;
09095   G__G__ProofPlayerLN_TPacketizer.tagnum = -1 ;
09096   G__G__ProofPlayerLN_TPacketizercLcLTFileNode.tagnum = -1 ;
09097   G__G__ProofPlayerLN_TPacketizercLcLTFileStat.tagnum = -1 ;
09098   G__G__ProofPlayerLN_TPacketizerMulti.tagnum = -1 ;
09099   G__G__ProofPlayerLN_TPacketizerUnit.tagnum = -1 ;
09100   G__G__ProofPlayerLN_TTimeStamp.tagnum = -1 ;
09101   G__G__ProofPlayerLN_TVirtualPerfStats.tagnum = -1 ;
09102   G__G__ProofPlayerLN_TVirtualPerfStatscLcLEEventType.tagnum = -1 ;
09103   G__G__ProofPlayerLN_TH1D.tagnum = -1 ;
09104   G__G__ProofPlayerLN_TH2D.tagnum = -1 ;
09105   G__G__ProofPlayerLN_TVirtualMonitoringWriter.tagnum = -1 ;
09106   G__G__ProofPlayerLN_TPerfEvent.tagnum = -1 ;
09107   G__G__ProofPlayerLN_TPerfStats.tagnum = -1 ;
09108   G__G__ProofPlayerLN_TH1.tagnum = -1 ;
09109   G__G__ProofPlayerLN_THLimitsFinder.tagnum = -1 ;
09110   G__G__ProofPlayerLN_TProofLimitsFinder.tagnum = -1 ;
09111   G__G__ProofPlayerLN_TProofOutputFile.tagnum = -1 ;
09112   G__G__ProofPlayerLN_TFileCollection.tagnum = -1 ;
09113   G__G__ProofPlayerLN_TProofPlayer.tagnum = -1 ;
09114   G__G__ProofPlayerLN_TProofOutputFilecLcLERunType.tagnum = -1 ;
09115   G__G__ProofPlayerLN_TProofOutputFilecLcLETypeOpt.tagnum = -1 ;
09116   G__G__ProofPlayerLN_TQueryResult.tagnum = -1 ;
09117   G__G__ProofPlayerLN_TVirtualProofPlayer.tagnum = -1 ;
09118   G__G__ProofPlayerLN_TVirtualProofPlayercLcLEExitStatus.tagnum = -1 ;
09119   G__G__ProofPlayerLN_TArrayL64.tagnum = -1 ;
09120   G__G__ProofPlayerLN_TArrayF.tagnum = -1 ;
09121   G__G__ProofPlayerLN_TArrayI.tagnum = -1 ;
09122   G__G__ProofPlayerLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
09123   G__G__ProofPlayerLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
09124   G__G__ProofPlayerLN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
09125   G__G__ProofPlayerLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
09126   G__G__ProofPlayerLN_TProofPlayerLite.tagnum = -1 ;
09127   G__G__ProofPlayerLN_TProofPlayerRemote.tagnum = -1 ;
09128   G__G__ProofPlayerLN_TMutex.tagnum = -1 ;
09129   G__G__ProofPlayerLN_TStatus.tagnum = -1 ;
09130   G__G__ProofPlayerLN_TProofPlayercLcLEStatusBits.tagnum = -1 ;
09131   G__G__ProofPlayerLN_TProofPlayerLocal.tagnum = -1 ;
09132   G__G__ProofPlayerLN_TProofPlayerSlave.tagnum = -1 ;
09133   G__G__ProofPlayerLN_TProofPlayerSuperMaster.tagnum = -1 ;
09134   G__G__ProofPlayerLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR.tagnum = -1 ;
09135   G__G__ProofPlayerLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgRcLcLiterator.tagnum = -1 ;
09136 }
09137 
09138 
09139 extern "C" void G__cpp_setup_tagtableG__ProofPlayer() {
09140 
09141    /* Setting up class,struct,union tag entry */
09142    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TClass);
09143    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TBuffer);
09144    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TDirectory);
09145    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TMemberInspector);
09146    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TObject);
09147    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TNamed);
09148    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TString);
09149    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
09150    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
09151    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TList);
09152    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TTimer);
09153    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
09154    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
09155    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TQObject);
09156    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProof);
09157    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_THashList);
09158    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TSeqCollection);
09159    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TDrawFeedback),sizeof(TDrawFeedback),-1,292096,"Present PROOF query feedback",G__setup_memvarTDrawFeedback,G__setup_memfuncTDrawFeedback);
09160    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TDSet);
09161    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TDSetElement);
09162    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TFile);
09163    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TSelector);
09164    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TIter);
09165    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TTree);
09166    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TTreeCache);
09167    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TEventList);
09168    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TEntryList);
09169    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TEventIter),sizeof(TEventIter),-1,324867,"Event iterator used by TProofPlayer's",G__setup_memvarTEventIter,G__setup_memfuncTEventIter);
09170    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TEventIterUnit),sizeof(TEventIterUnit),-1,324864,"Event iterator for objects",G__setup_memvarTEventIterUnit,G__setup_memfuncTEventIterUnit);
09171    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TEventIterObj),sizeof(TEventIterObj),-1,324864,"Event iterator for objects",G__setup_memvarTEventIterObj,G__setup_memfuncTEventIterObj);
09172    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TEventIterTree),sizeof(TEventIterTree),-1,324864,"Event iterator for Trees",G__setup_memvarTEventIterTree,G__setup_memfuncTEventIterTree);
09173    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TStopwatch);
09174    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TFileMerger),sizeof(TFileMerger),-1,294656,"File copying and merging services",G__setup_memvarTFileMerger,G__setup_memfuncTFileMerger);
09175    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TCollection);
09176    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TOutputListSelectorDataMap),sizeof(TOutputListSelectorDataMap),-1,292096,"Converter from output list to TSelector data members",G__setup_memvarTOutputListSelectorDataMap,G__setup_memfuncTOutputListSelectorDataMap);
09177    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TSlave);
09178    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TSocket);
09179    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofProgressStatus);
09180    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TTime);
09181    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TMap);
09182    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TMessage);
09183    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TNtuple);
09184    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TNtupleD);
09185    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofProgressInfo);
09186    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TVirtualPacketizer),sizeof(TVirtualPacketizer),-1,327168,"Generate work packets for parallel processing",G__setup_memvarTVirtualPacketizer,G__setup_memfuncTVirtualPacketizer);
09187    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TVirtualPacketizercLcLEUseEstOpt);
09188    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TVirtualPacketizercLcLEStatusBits);
09189    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TSortedList);
09190    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPacketizerAdaptive),sizeof(TPacketizerAdaptive),-1,327424,"Generate work packets for parallel processing",G__setup_memvarTPacketizerAdaptive,G__setup_memfuncTPacketizerAdaptive);
09191    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPacketizerAdaptivecLcLTFileNode);
09192    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPacketizerAdaptivecLcLTFileStat);
09193    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
09194    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPacketizerFile),sizeof(TPacketizerFile),-1,327424,"Generate work packets for parallel processing",G__setup_memvarTPacketizerFile,G__setup_memfuncTPacketizerFile);
09195    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPacketizer),sizeof(TPacketizer),-1,327424,"Generate work packets for parallel processing",G__setup_memvarTPacketizer,G__setup_memfuncTPacketizer);
09196    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPacketizercLcLTFileNode);
09197    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPacketizercLcLTFileStat);
09198    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPacketizerMulti),sizeof(TPacketizerMulti),-1,327424,"Generate work packets for parallel processing",G__setup_memvarTPacketizerMulti,G__setup_memfuncTPacketizerMulti);
09199    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPacketizerUnit),sizeof(TPacketizerUnit),-1,327424,"Generate work packets for parallel processing",G__setup_memvarTPacketizerUnit,G__setup_memfuncTPacketizerUnit);
09200    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TTimeStamp);
09201    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TVirtualPerfStats);
09202    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TVirtualPerfStatscLcLEEventType);
09203    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TH1D);
09204    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TH2D);
09205    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TVirtualMonitoringWriter);
09206    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPerfEvent),sizeof(TPerfEvent),-1,292096,"Class holding TProof Event Info",G__setup_memvarTPerfEvent,G__setup_memfuncTPerfEvent);
09207    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TPerfStats),sizeof(TPerfStats),-1,62464,"Class for collecting PROOF statistics",G__setup_memvarTPerfStats,G__setup_memfuncTPerfStats);
09208    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TH1);
09209    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_THLimitsFinder);
09210    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofLimitsFinder),sizeof(TProofLimitsFinder),-1,29952,"Find and communicate best axis limits",G__setup_memvarTProofLimitsFinder,G__setup_memfuncTProofLimitsFinder);
09211    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofOutputFile),sizeof(TProofOutputFile),-1,327424,"Wrapper class to steer the merging of files produced on workers",G__setup_memvarTProofOutputFile,G__setup_memfuncTProofOutputFile);
09212    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TFileCollection);
09213    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofPlayer),sizeof(TProofPlayer),-1,292096,"Basic PROOF player",G__setup_memvarTProofPlayer,G__setup_memfuncTProofPlayer);
09214    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofOutputFilecLcLERunType);
09215    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofOutputFilecLcLETypeOpt);
09216    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TQueryResult);
09217    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TVirtualProofPlayer);
09218    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TVirtualProofPlayercLcLEExitStatus);
09219    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TArrayL64);
09220    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TArrayF);
09221    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TArrayI);
09222    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
09223    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
09224    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_vectorlETStringcOallocatorlETStringgRsPgR);
09225    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
09226    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofPlayerLite),sizeof(TProofPlayerLite),-1,292096,"PROOF player running in PROOF-Lite",G__setup_memvarTProofPlayerLite,G__setup_memfuncTProofPlayerLite);
09227    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofPlayerRemote),sizeof(TProofPlayerRemote),-1,292096,"PROOF player running on master server",G__setup_memvarTProofPlayerRemote,G__setup_memfuncTProofPlayerRemote);
09228    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TMutex);
09229    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TStatus),sizeof(TStatus),-1,324864,"Status class",G__setup_memvarTStatus,G__setup_memfuncTStatus);
09230    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofPlayercLcLEStatusBits);
09231    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofPlayerLocal),sizeof(TProofPlayerLocal),-1,292096,"PROOF player running on client",G__setup_memvarTProofPlayerLocal,G__setup_memfuncTProofPlayerLocal);
09232    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofPlayerSlave),sizeof(TProofPlayerSlave),-1,291072,"PROOF player running on slave server",G__setup_memvarTProofPlayerSlave,G__setup_memfuncTProofPlayerSlave);
09233    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_TProofPlayerSuperMaster),sizeof(TProofPlayerSuperMaster),-1,292096,"PROOF player running on super master",G__setup_memvarTProofPlayerSuperMaster,G__setup_memfuncTProofPlayerSuperMaster);
09234    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgR);
09235    G__get_linked_tagnum_fwd(&G__G__ProofPlayerLN_setlEstringcOlesslEstringgRcOallocatorlEstringgRsPgRcLcLiterator);
09236 }
09237 extern "C" void G__cpp_setupG__ProofPlayer(void) {
09238   G__check_setup_version(30051515,"G__cpp_setupG__ProofPlayer()");
09239   G__set_cpp_environmentG__ProofPlayer();
09240   G__cpp_setup_tagtableG__ProofPlayer();
09241 
09242   G__cpp_setup_inheritanceG__ProofPlayer();
09243 
09244   G__cpp_setup_typetableG__ProofPlayer();
09245 
09246   G__cpp_setup_memvarG__ProofPlayer();
09247 
09248   G__cpp_setup_memfuncG__ProofPlayer();
09249   G__cpp_setup_globalG__ProofPlayer();
09250   G__cpp_setup_funcG__ProofPlayer();
09251 
09252    if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__ProofPlayer();
09253   return;
09254 }
09255 class G__cpp_setup_initG__ProofPlayer {
09256   public:
09257     G__cpp_setup_initG__ProofPlayer() { G__add_setup_func("G__ProofPlayer",(G__incsetup)(&G__cpp_setupG__ProofPlayer)); G__call_setup_funcs(); }
09258    ~G__cpp_setup_initG__ProofPlayer() { G__remove_setup_func("G__ProofPlayer"); }
09259 };
09260 G__cpp_setup_initG__ProofPlayer G__cpp_setup_initializerG__ProofPlayer;
09261