// @(#)root/proofplayer:$Id$
// Author: Maarten Ballintijn   07/01/02

/*************************************************************************
 * Copyright (C) 1995-2001, Rene Brun and Fons Rademakers.               *
 * All rights reserved.                                                  *
 *                                                                       *
 * For the licensing terms see $ROOTSYS/LICENSE.                         *
 * For the list of contributors see $ROOTSYS/README/CREDITS.             *
 *************************************************************************/

#ifndef ROOT_TProofPlayer
#define ROOT_TProofPlayer


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TProofPlayer                                                         //
//                                                                      //
// This internal class and its subclasses steer the processing in PROOF.//
// Instances of the TProofPlayer class are created on the worker nodes  //
// per session and do the processing.                                   //
// Instances of its subclass - TProofPlayerRemote are created per each  //
// query on the master(s) and on the client. On the master(s),          //
// TProofPlayerRemote coordinate processing, check the dataset, create  //
// the packetizer and take care of merging the results of the workers.  //
// The instance on the client collects information on the input         //
// (dataset and selector), it invokes the Begin() method and finalizes  //
// the query by calling Terminate().                                    //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#ifndef ROOT_TVirtualProofPlayer
#include "TVirtualProofPlayer.h"
#endif
#ifndef ROOT_TArrayL64
#include "TArrayL64.h"
#endif
#ifndef ROOT_TArrayF
#include "TArrayF.h"
#endif
#ifndef ROOT_TArrayI
#include "TArrayI.h"
#endif
#ifndef ROOT_TList
#include "TList.h"
#endif
#ifndef ROOT_TSystem
#include "TSystem.h"
#endif
#ifndef ROOT_TQueryResult
#include "TQueryResult.h"
#endif
#ifndef ROOT_TProofProgressStatus
#include "TProofProgressStatus.h"
#endif
#ifndef ROOT_TError
#include "TError.h"
#endif

class TSelector;
class TSocket;
class TVirtualPacketizer;
class TSlave;
class TEventIter;
class TProofStats;
class TMutex;
class TStatus;
class TTimer;
class THashList;
class TH1;
class TFile;
class TStopwatch;

//------------------------------------------------------------------------

class TProofPlayer : public TVirtualProofPlayer {

private:
   TList        *fAutoBins;  // Map of min/max values by name for slaves

protected:
   TList        *fInput;           //-> list with input objects
   THashList    *fOutput;          //   list with output objects
   TSelector    *fSelector;        //!  the latest selector
   Bool_t        fCreateSelObj;    //!  kTRUE when fSelector has been created locally
   TClass       *fSelectorClass;   //!  class of the latest selector
   TTimer       *fFeedbackTimer;   //!  timer for sending intermediate results
   Long_t        fFeedbackPeriod;  //!  period (ms) for sending intermediate results
   TEventIter   *fEvIter;          //!  iterator on events or objects
   TStatus      *fSelStatus;       //!  status of query in progress
   EExitStatus   fExitStatus;      //   exit status
   Long64_t      fTotalEvents;     //   number of events requested
   TProofProgressStatus *fProgressStatus; // the progress status object;

   Long64_t      fReadBytesRun;   //! Bytes read in this run
   Long64_t      fReadCallsRun;   //! Read calls in this run
   Long64_t      fProcessedRun;   //! Events processed in this run

   TList        *fQueryResults;    //List of TQueryResult
   TQueryResult *fQuery;           //Instance of TQueryResult currently processed
   TQueryResult *fPreviousQuery;   //Previous instance of TQueryResult processed
   Int_t         fDrawQueries;     //Number of Draw queries in the list
   Int_t         fMaxDrawQueries;  //Max number of Draw queries kept

   TTimer       *fStopTimer;       //Timer associated with a stop request
   TMutex       *fStopTimerMtx;    //To protect the stop timer

   TTimer       *fDispatchTimer;    //Dispatch pending events while processing

   TTimer       *fProcTimeTimer;    //Notifies reaching of allowed max proc time
   TStopwatch   *fProcTime;         //Packet proc time

   TString       fOutputFilePath;   //Path to file with (partial) results of the query
   TFile        *fOutputFile;       //TFile object attached to fOutputFilePath
   Long_t        fSaveMemThreshold; //Threshold for saving output to file
   Bool_t        fSavePartialResults; //Whether to save the partial results
   Bool_t        fSaveResultsPerPacket; //Whether to save partial results after each packet

   static THashList *fgDrawInputPars;  // List of input parameters to be kept on drawing actions

   void         *GetSender() { return this; }  //used to set gTQSender

   virtual Int_t DrawCanvas(TObject *obj); // Canvas drawing via libProofDraw

   virtual void SetupFeedback();  // specialized setup
   
   virtual void  MergeOutput(Bool_t savememvalues = kFALSE);

public:   // fix for broken compilers so TCleanup can call StopFeedback()
   virtual void StopFeedback();   // specialized teardown

protected:
   class TCleanup {
   private:
      TProofPlayer *fPlayer;
   public:
      TCleanup(TProofPlayer *p) : fPlayer(p) { }
      ~TCleanup() { fPlayer->StopFeedback(); }
   };

   Int_t  AssertSelector(const char *selector_file);
   Bool_t CheckMemUsage(Long64_t &mfreq, Bool_t &w80r, Bool_t &w80v, TString &wmsg);

   void MapOutputListToDataMembers() const;

public:
   enum EStatusBits { kDispatchOneEvent = BIT(15), kIsProcessing = BIT(16),
                      kMaxProcTimeReached = BIT(17), kMaxProcTimeExtended = BIT(18) };

   TProofPlayer(TProof *proof = 0);
   virtual ~TProofPlayer();

   Long64_t  Process(TDSet *set,
                     const char *selector, Option_t *option = "",
                     Long64_t nentries = -1, Long64_t firstentry = 0);
   Long64_t  Process(TDSet *set,
                     TSelector *selector, Option_t *option = "",
                     Long64_t nentries = -1, Long64_t firstentry = 0);
   virtual Bool_t JoinProcess(TList *workers);
   TVirtualPacketizer *GetPacketizer() const { return 0; }
   Long64_t  Finalize(Bool_t force = kFALSE, Bool_t sync = kFALSE);
   Long64_t  Finalize(TQueryResult *qr);
   Long64_t  DrawSelect(TDSet *set, const char *varexp,
                        const char *selection, Option_t *option = "",
                        Long64_t nentries = -1, Long64_t firstentry = 0);
   Int_t     GetDrawArgs(const char *var, const char *sel, Option_t *opt,
                         TString &selector, TString &objname);
   void      HandleGetTreeHeader(TMessage *mess);
   void      HandleRecvHisto(TMessage *mess);
   void      FeedBackCanvas(const char *name, Bool_t create);

   void      StopProcess(Bool_t abort, Int_t timeout = -1);
   void      AddInput(TObject *inp);
   void      ClearInput();
   TObject  *GetOutput(const char *name) const;
   TList    *GetOutputList() const;
   TList    *GetInputList() const { return fInput; }
   TList    *GetListOfResults() const { return fQueryResults; }
   void      AddQueryResult(TQueryResult *q);
   TQueryResult *GetCurrentQuery() const { return fQuery; }
   TQueryResult *GetQueryResult(const char *ref);
   void      RemoveQueryResult(const char *ref);
   void      SetCurrentQuery(TQueryResult *q);
   void      SetMaxDrawQueries(Int_t max) { fMaxDrawQueries = max; }
   void      RestorePreviousQuery() { fQuery = fPreviousQuery; }
   Int_t     AddOutputObject(TObject *obj);
   void      AddOutput(TList *out);   // Incorporate a list
   void      StoreOutput(TList *out);   // Adopts the list
   void      StoreFeedback(TObject *slave, TList *out); // Adopts the list
   void      Progress(Long64_t total, Long64_t processed); // *SIGNAL*
   void      Progress(TSlave *, Long64_t total, Long64_t processed)
                { Progress(total, processed); }
   void      Progress(Long64_t total, Long64_t processed, Long64_t bytesread,
                      Float_t initTime, Float_t procTime,
                      Float_t evtrti, Float_t mbrti); // *SIGNAL*
   void      Progress(TSlave *, Long64_t total, Long64_t processed, Long64_t bytesread,
                      Float_t initTime, Float_t procTime,
                      Float_t evtrti, Float_t mbrti)
                { Progress(total, processed, bytesread, initTime, procTime,
                           evtrti, mbrti); } // *SIGNAL*
   void      Progress(TProofProgressInfo *pi); // *SIGNAL*
   void      Progress(TSlave *, TProofProgressInfo *pi) { Progress(pi); } // *SIGNAL*
   void      Feedback(TList *objs); // *SIGNAL*

   TDrawFeedback *CreateDrawFeedback(TProof *p);
   void           SetDrawFeedbackOption(TDrawFeedback *f, Option_t *opt);
   void           DeleteDrawFeedback(TDrawFeedback *f);

   TDSetElement *GetNextPacket(TSlave *slave, TMessage *r);

   Int_t     ReinitSelector(TQueryResult *qr);

   void      UpdateAutoBin(const char *name,
                           Double_t& xmin, Double_t& xmax,
                           Double_t& ymin, Double_t& ymax,
                           Double_t& zmin, Double_t& zmax);

   Bool_t    IsClient() const { return kFALSE; }

   void      SetExitStatus(EExitStatus st) { fExitStatus = st; }
   EExitStatus GetExitStatus() const { return fExitStatus; }
   Long64_t    GetEventsProcessed() const { return fProgressStatus->GetEntries(); }
   void        AddEventsProcessed(Long64_t ev) { fProgressStatus->IncEntries(ev); }

   void      SetDispatchTimer(Bool_t on = kTRUE);
   void      SetStopTimer(Bool_t on = kTRUE,
                          Bool_t abort = kFALSE, Int_t timeout = 0);

   virtual void      SetInitTime() { }

   virtual void      SetMerging(Bool_t = kTRUE) { }

   Long64_t  GetCacheSize();
   Int_t     GetLearnEntries();

   void      SetOutputFilePath(const char *fp) { fOutputFilePath = fp; }
   Int_t     SavePartialResults(Bool_t queryend = kFALSE, Bool_t force = kFALSE);

   void              SetProcessing(Bool_t on = kTRUE);
   TProofProgressStatus  *GetProgressStatus() const { return fProgressStatus; }

   void      UpdateProgressInfo();

   ClassDef(TProofPlayer,0)  // Basic PROOF player
};


//------------------------------------------------------------------------

class TProofPlayerLocal : public TProofPlayer {

private:
   Bool_t   fIsClient;

protected:
   void SetupFeedback() { }
   void StopFeedback() { }

public:
   TProofPlayerLocal(Bool_t client = kTRUE) : fIsClient(client) { }
   virtual ~TProofPlayerLocal() { }

   Bool_t         IsClient() const { return fIsClient; }
   Long64_t  Process(const char *selector, Long64_t nentries = -1, Option_t *option = "");
   Long64_t  Process(TSelector *selector, Long64_t nentries = -1, Option_t *option = "");
   Long64_t  Process(TDSet *set,
                     const char *selector, Option_t *option = "",
                     Long64_t nentries = -1, Long64_t firstentry = 0) {
             return TProofPlayer::Process(set, selector, option, nentries, firstentry); }
   Long64_t  Process(TDSet *set,
                     TSelector *selector, Option_t *option = "",
                     Long64_t nentries = -1, Long64_t firstentry = 0) {
             return TProofPlayer::Process(set, selector, option, nentries, firstentry); }
   ClassDef(TProofPlayerLocal,0)  // PROOF player running on client
};


//------------------------------------------------------------------------

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TProofPlayerRemote                                                   //
//                                                                      //
// Instances of TProofPlayerRemote are created per each query on the    //
// master(s) and on the client. On the master(s), TProofPlayerRemote    //
// coordinate processing, check the dataset, create the packetizer      //
// and take care of merging the results of the workers.                 //
// The instance on the client collects information on the input         //
// (dataset and selector), it invokes the Begin() method and finalizes  //
// the query by calling Terminate().                                    //
//                                                                      //
//////////////////////////////////////////////////////////////////////////


class TProofPlayerRemote : public TProofPlayer {

protected:
   TProof             *fProof;         // link to associated PROOF session
   TList              *fOutputLists;   // results returned by slaves
   TList              *fFeedback;      // reference for use on master
   TList              *fFeedbackLists; // intermediate results
   TVirtualPacketizer *fPacketizer;    // transform TDSet into packets for slaves
   Bool_t              fMergeFiles;    // is True when merging output files centrally is needed
   TDSet              *fDSet;          //!tdset for current processing
   ErrorHandlerFunc_t  fErrorHandler;  // Store previous handler when redirecting output
   Bool_t              fMergeTH1OneByOne;  // If kTRUE forces TH1 merge one-by-one [kTRUE]
   TH1                *fProcPackets;    //!Histogram with packets being processed (owned by TPerfStats)
   TMessage           *fProcessMessage; // Process message to replay when adding new workers dynamically
   TString             fSelectorFileName; // Current Selector's name, set by Process()

   TStopwatch         *fMergeSTW;      // Merging stop watch
   Int_t               fNumMergers;    // Number of submergers

   virtual Bool_t  HandleTimer(TTimer *timer);
   Int_t           InitPacketizer(TDSet *dset, Long64_t nentries,
                                  Long64_t first, const char *defpackunit,
                                  const char *defpackdata);
   TList          *MergeFeedback();
   Bool_t          MergeOutputFiles();
   void            NotifyMemory(TObject *obj);
   void            SetLastMergingMsg(TObject *obj);
   virtual Bool_t  SendSelector(const char *selector_file); //send selector to slaves
   TProof         *GetProof() const { return fProof; }
   void            SetupFeedback();  // specialized setup
   void            StopFeedback();   // specialized teardown
   void            SetSelectorDataMembersFromOutputList();

public:
   TProofPlayerRemote(TProof *proof = 0) : fProof(proof), fOutputLists(0), fFeedback(0),
                                           fFeedbackLists(0), fPacketizer(0),
                                           fMergeFiles(kFALSE), fDSet(0), fErrorHandler(0),
                                           fMergeTH1OneByOne(kTRUE), fProcPackets(0),
                                           fProcessMessage(0), fMergeSTW(0), fNumMergers(0) 
                                           { fProgressStatus = new TProofProgressStatus(); }
   virtual ~TProofPlayerRemote();   // Owns the fOutput list
   virtual Long64_t Process(TDSet *set, const char *selector,
                            Option_t *option = "", Long64_t nentries = -1,
                            Long64_t firstentry = 0);
   virtual Long64_t Process(TDSet *set, TSelector *selector,
                            Option_t *option = "", Long64_t nentries = -1,
                            Long64_t firstentry = 0);
   virtual Bool_t JoinProcess(TList *workers);
   virtual Long64_t Finalize(Bool_t force = kFALSE, Bool_t sync = kFALSE);
   virtual Long64_t Finalize(TQueryResult *qr);
   Long64_t       DrawSelect(TDSet *set, const char *varexp,
                             const char *selection, Option_t *option = "",
                             Long64_t nentries = -1, Long64_t firstentry = 0);

   void           RedirectOutput(Bool_t on = kTRUE);
   void           StopProcess(Bool_t abort, Int_t timeout = -1);
   void           StoreOutput(TList *out);   // Adopts the list
   virtual void   StoreFeedback(TObject *slave, TList *out); // Adopts the list
   Int_t          Incorporate(TObject *obj, TList *out, Bool_t &merged);
   TObject       *HandleHistogram(TObject *obj, Bool_t &merged);
   Bool_t         HistoSameAxis(TH1 *h0, TH1 *h1);
   Int_t          AddOutputObject(TObject *obj);
   void           AddOutput(TList *out);   // Incorporate a list
   virtual void   MergeOutput(Bool_t savememvalues = kFALSE);
   void           Progress(Long64_t total, Long64_t processed); // *SIGNAL*
   void           Progress(TSlave*, Long64_t total, Long64_t processed)
                     { Progress(total, processed); }
   void           Progress(Long64_t total, Long64_t processed, Long64_t bytesread,
                           Float_t initTime, Float_t procTime,
                           Float_t evtrti, Float_t mbrti); // *SIGNAL*
   void           Progress(TSlave *, Long64_t total, Long64_t processed, Long64_t bytesread,
                           Float_t initTime, Float_t procTime,
                           Float_t evtrti, Float_t mbrti)
                      { Progress(total, processed, bytesread, initTime, procTime,
                           evtrti, mbrti); } // *SIGNAL*
   void           Progress(TProofProgressInfo *pi); // *SIGNAL*
   void           Progress(TSlave *, TProofProgressInfo *pi) { Progress(pi); } // *SIGNAL*
   void           Feedback(TList *objs); // *SIGNAL*
   TDSetElement  *GetNextPacket(TSlave *slave, TMessage *r);
   TVirtualPacketizer *GetPacketizer() const { return fPacketizer; }

   Bool_t         IsClient() const;

   void           SetInitTime();

   void           SetMerging(Bool_t on = kTRUE);

   ClassDef(TProofPlayerRemote,0)  // PROOF player running on master server
};


//------------------------------------------------------------------------

class TProofPlayerSlave : public TProofPlayer {

private:
   TSocket *fSocket;
   TList   *fFeedback;  // List of objects to send updates of

   Bool_t HandleTimer(TTimer *timer);

protected:
   void SetupFeedback();
   void StopFeedback();

public:
   TProofPlayerSlave(TSocket *socket = 0) : fSocket(socket), fFeedback(0) { }

   void  HandleGetTreeHeader(TMessage *mess);

   ClassDef(TProofPlayerSlave,0)  // PROOF player running on slave server
};


//------------------------------------------------------------------------

class TProofPlayerSuperMaster : public TProofPlayerRemote {

private:
   TArrayL64 fSlaveProgress;
   TArrayL64 fSlaveTotals;
   TArrayL64 fSlaveBytesRead;
   TArrayF   fSlaveInitTime;
   TArrayF   fSlaveProcTime;
   TArrayF   fSlaveEvtRti;
   TArrayF   fSlaveMBRti;
   TArrayI   fSlaveActW;
   TArrayI   fSlaveTotS;
   TArrayF   fSlaveEffS;
   TList     fSlaves;
   Bool_t    fReturnFeedback;

protected:
   Bool_t HandleTimer(TTimer *timer);
   void   SetupFeedback();

public:
   TProofPlayerSuperMaster(TProof *proof = 0) :
      TProofPlayerRemote(proof), fReturnFeedback(kFALSE) { }
   virtual ~TProofPlayerSuperMaster() { }

   Long64_t Process(TDSet *set, const char *selector,
                    Option_t *option = "", Long64_t nentries = -1,
                    Long64_t firstentry = 0);
   Long64_t Process(TDSet *set, TSelector *selector,
                    Option_t *option = "", Long64_t nentries = -1,
                    Long64_t firstentry = 0)
                    { return TProofPlayerRemote::Process(set, selector, option,
                                                         nentries, firstentry); }
   void  Progress(Long64_t total, Long64_t processed)
                    { TProofPlayerRemote::Progress(total, processed); }
   void  Progress(Long64_t total, Long64_t processed, Long64_t bytesread,
                  Float_t initTime, Float_t procTime,
                  Float_t evtrti, Float_t mbrti)
                    { TProofPlayerRemote::Progress(total, processed, bytesread,
                                                   initTime, procTime, evtrti, mbrti); }
   void  Progress(TProofProgressInfo *pi) { TProofPlayerRemote::Progress(pi); }
   void  Progress(TSlave *sl, Long64_t total, Long64_t processed);
   void  Progress(TSlave *sl, Long64_t total, Long64_t processed, Long64_t bytesread,
                  Float_t initTime, Float_t procTime,
                  Float_t evtrti, Float_t mbrti);
   void  Progress(TSlave *sl, TProofProgressInfo *pi);

   ClassDef(TProofPlayerSuperMaster,0)  // PROOF player running on super master
};

#endif
 TProofPlayer.h:1
 TProofPlayer.h:2
 TProofPlayer.h:3
 TProofPlayer.h:4
 TProofPlayer.h:5
 TProofPlayer.h:6
 TProofPlayer.h:7
 TProofPlayer.h:8
 TProofPlayer.h:9
 TProofPlayer.h:10
 TProofPlayer.h:11
 TProofPlayer.h:12
 TProofPlayer.h:13
 TProofPlayer.h:14
 TProofPlayer.h:15
 TProofPlayer.h:16
 TProofPlayer.h:17
 TProofPlayer.h:18
 TProofPlayer.h:19
 TProofPlayer.h:20
 TProofPlayer.h:21
 TProofPlayer.h:22
 TProofPlayer.h:23
 TProofPlayer.h:24
 TProofPlayer.h:25
 TProofPlayer.h:26
 TProofPlayer.h:27
 TProofPlayer.h:28
 TProofPlayer.h:29
 TProofPlayer.h:30
 TProofPlayer.h:31
 TProofPlayer.h:32
 TProofPlayer.h:33
 TProofPlayer.h:34
 TProofPlayer.h:35
 TProofPlayer.h:36
 TProofPlayer.h:37
 TProofPlayer.h:38
 TProofPlayer.h:39
 TProofPlayer.h:40
 TProofPlayer.h:41
 TProofPlayer.h:42
 TProofPlayer.h:43
 TProofPlayer.h:44
 TProofPlayer.h:45
 TProofPlayer.h:46
 TProofPlayer.h:47
 TProofPlayer.h:48
 TProofPlayer.h:49
 TProofPlayer.h:50
 TProofPlayer.h:51
 TProofPlayer.h:52
 TProofPlayer.h:53
 TProofPlayer.h:54
 TProofPlayer.h:55
 TProofPlayer.h:56
 TProofPlayer.h:57
 TProofPlayer.h:58
 TProofPlayer.h:59
 TProofPlayer.h:60
 TProofPlayer.h:61
 TProofPlayer.h:62
 TProofPlayer.h:63
 TProofPlayer.h:64
 TProofPlayer.h:65
 TProofPlayer.h:66
 TProofPlayer.h:67
 TProofPlayer.h:68
 TProofPlayer.h:69
 TProofPlayer.h:70
 TProofPlayer.h:71
 TProofPlayer.h:72
 TProofPlayer.h:73
 TProofPlayer.h:74
 TProofPlayer.h:75
 TProofPlayer.h:76
 TProofPlayer.h:77
 TProofPlayer.h:78
 TProofPlayer.h:79
 TProofPlayer.h:80
 TProofPlayer.h:81
 TProofPlayer.h:82
 TProofPlayer.h:83
 TProofPlayer.h:84
 TProofPlayer.h:85
 TProofPlayer.h:86
 TProofPlayer.h:87
 TProofPlayer.h:88
 TProofPlayer.h:89
 TProofPlayer.h:90
 TProofPlayer.h:91
 TProofPlayer.h:92
 TProofPlayer.h:93
 TProofPlayer.h:94
 TProofPlayer.h:95
 TProofPlayer.h:96
 TProofPlayer.h:97
 TProofPlayer.h:98
 TProofPlayer.h:99
 TProofPlayer.h:100
 TProofPlayer.h:101
 TProofPlayer.h:102
 TProofPlayer.h:103
 TProofPlayer.h:104
 TProofPlayer.h:105
 TProofPlayer.h:106
 TProofPlayer.h:107
 TProofPlayer.h:108
 TProofPlayer.h:109
 TProofPlayer.h:110
 TProofPlayer.h:111
 TProofPlayer.h:112
 TProofPlayer.h:113
 TProofPlayer.h:114
 TProofPlayer.h:115
 TProofPlayer.h:116
 TProofPlayer.h:117
 TProofPlayer.h:118
 TProofPlayer.h:119
 TProofPlayer.h:120
 TProofPlayer.h:121
 TProofPlayer.h:122
 TProofPlayer.h:123
 TProofPlayer.h:124
 TProofPlayer.h:125
 TProofPlayer.h:126
 TProofPlayer.h:127
 TProofPlayer.h:128
 TProofPlayer.h:129
 TProofPlayer.h:130
 TProofPlayer.h:131
 TProofPlayer.h:132
 TProofPlayer.h:133
 TProofPlayer.h:134
 TProofPlayer.h:135
 TProofPlayer.h:136
 TProofPlayer.h:137
 TProofPlayer.h:138
 TProofPlayer.h:139
 TProofPlayer.h:140
 TProofPlayer.h:141
 TProofPlayer.h:142
 TProofPlayer.h:143
 TProofPlayer.h:144
 TProofPlayer.h:145
 TProofPlayer.h:146
 TProofPlayer.h:147
 TProofPlayer.h:148
 TProofPlayer.h:149
 TProofPlayer.h:150
 TProofPlayer.h:151
 TProofPlayer.h:152
 TProofPlayer.h:153
 TProofPlayer.h:154
 TProofPlayer.h:155
 TProofPlayer.h:156
 TProofPlayer.h:157
 TProofPlayer.h:158
 TProofPlayer.h:159
 TProofPlayer.h:160
 TProofPlayer.h:161
 TProofPlayer.h:162
 TProofPlayer.h:163
 TProofPlayer.h:164
 TProofPlayer.h:165
 TProofPlayer.h:166
 TProofPlayer.h:167
 TProofPlayer.h:168
 TProofPlayer.h:169
 TProofPlayer.h:170
 TProofPlayer.h:171
 TProofPlayer.h:172
 TProofPlayer.h:173
 TProofPlayer.h:174
 TProofPlayer.h:175
 TProofPlayer.h:176
 TProofPlayer.h:177
 TProofPlayer.h:178
 TProofPlayer.h:179
 TProofPlayer.h:180
 TProofPlayer.h:181
 TProofPlayer.h:182
 TProofPlayer.h:183
 TProofPlayer.h:184
 TProofPlayer.h:185
 TProofPlayer.h:186
 TProofPlayer.h:187
 TProofPlayer.h:188
 TProofPlayer.h:189
 TProofPlayer.h:190
 TProofPlayer.h:191
 TProofPlayer.h:192
 TProofPlayer.h:193
 TProofPlayer.h:194
 TProofPlayer.h:195
 TProofPlayer.h:196
 TProofPlayer.h:197
 TProofPlayer.h:198
 TProofPlayer.h:199
 TProofPlayer.h:200
 TProofPlayer.h:201
 TProofPlayer.h:202
 TProofPlayer.h:203
 TProofPlayer.h:204
 TProofPlayer.h:205
 TProofPlayer.h:206
 TProofPlayer.h:207
 TProofPlayer.h:208
 TProofPlayer.h:209
 TProofPlayer.h:210
 TProofPlayer.h:211
 TProofPlayer.h:212
 TProofPlayer.h:213
 TProofPlayer.h:214
 TProofPlayer.h:215
 TProofPlayer.h:216
 TProofPlayer.h:217
 TProofPlayer.h:218
 TProofPlayer.h:219
 TProofPlayer.h:220
 TProofPlayer.h:221
 TProofPlayer.h:222
 TProofPlayer.h:223
 TProofPlayer.h:224
 TProofPlayer.h:225
 TProofPlayer.h:226
 TProofPlayer.h:227
 TProofPlayer.h:228
 TProofPlayer.h:229
 TProofPlayer.h:230
 TProofPlayer.h:231
 TProofPlayer.h:232
 TProofPlayer.h:233
 TProofPlayer.h:234
 TProofPlayer.h:235
 TProofPlayer.h:236
 TProofPlayer.h:237
 TProofPlayer.h:238
 TProofPlayer.h:239
 TProofPlayer.h:240
 TProofPlayer.h:241
 TProofPlayer.h:242
 TProofPlayer.h:243
 TProofPlayer.h:244
 TProofPlayer.h:245
 TProofPlayer.h:246
 TProofPlayer.h:247
 TProofPlayer.h:248
 TProofPlayer.h:249
 TProofPlayer.h:250
 TProofPlayer.h:251
 TProofPlayer.h:252
 TProofPlayer.h:253
 TProofPlayer.h:254
 TProofPlayer.h:255
 TProofPlayer.h:256
 TProofPlayer.h:257
 TProofPlayer.h:258
 TProofPlayer.h:259
 TProofPlayer.h:260
 TProofPlayer.h:261
 TProofPlayer.h:262
 TProofPlayer.h:263
 TProofPlayer.h:264
 TProofPlayer.h:265
 TProofPlayer.h:266
 TProofPlayer.h:267
 TProofPlayer.h:268
 TProofPlayer.h:269
 TProofPlayer.h:270
 TProofPlayer.h:271
 TProofPlayer.h:272
 TProofPlayer.h:273
 TProofPlayer.h:274
 TProofPlayer.h:275
 TProofPlayer.h:276
 TProofPlayer.h:277
 TProofPlayer.h:278
 TProofPlayer.h:279
 TProofPlayer.h:280
 TProofPlayer.h:281
 TProofPlayer.h:282
 TProofPlayer.h:283
 TProofPlayer.h:284
 TProofPlayer.h:285
 TProofPlayer.h:286
 TProofPlayer.h:287
 TProofPlayer.h:288
 TProofPlayer.h:289
 TProofPlayer.h:290
 TProofPlayer.h:291
 TProofPlayer.h:292
 TProofPlayer.h:293
 TProofPlayer.h:294
 TProofPlayer.h:295
 TProofPlayer.h:296
 TProofPlayer.h:297
 TProofPlayer.h:298
 TProofPlayer.h:299
 TProofPlayer.h:300
 TProofPlayer.h:301
 TProofPlayer.h:302
 TProofPlayer.h:303
 TProofPlayer.h:304
 TProofPlayer.h:305
 TProofPlayer.h:306
 TProofPlayer.h:307
 TProofPlayer.h:308
 TProofPlayer.h:309
 TProofPlayer.h:310
 TProofPlayer.h:311
 TProofPlayer.h:312
 TProofPlayer.h:313
 TProofPlayer.h:314
 TProofPlayer.h:315
 TProofPlayer.h:316
 TProofPlayer.h:317
 TProofPlayer.h:318
 TProofPlayer.h:319
 TProofPlayer.h:320
 TProofPlayer.h:321
 TProofPlayer.h:322
 TProofPlayer.h:323
 TProofPlayer.h:324
 TProofPlayer.h:325
 TProofPlayer.h:326
 TProofPlayer.h:327
 TProofPlayer.h:328
 TProofPlayer.h:329
 TProofPlayer.h:330
 TProofPlayer.h:331
 TProofPlayer.h:332
 TProofPlayer.h:333
 TProofPlayer.h:334
 TProofPlayer.h:335
 TProofPlayer.h:336
 TProofPlayer.h:337
 TProofPlayer.h:338
 TProofPlayer.h:339
 TProofPlayer.h:340
 TProofPlayer.h:341
 TProofPlayer.h:342
 TProofPlayer.h:343
 TProofPlayer.h:344
 TProofPlayer.h:345
 TProofPlayer.h:346
 TProofPlayer.h:347
 TProofPlayer.h:348
 TProofPlayer.h:349
 TProofPlayer.h:350
 TProofPlayer.h:351
 TProofPlayer.h:352
 TProofPlayer.h:353
 TProofPlayer.h:354
 TProofPlayer.h:355
 TProofPlayer.h:356
 TProofPlayer.h:357
 TProofPlayer.h:358
 TProofPlayer.h:359
 TProofPlayer.h:360
 TProofPlayer.h:361
 TProofPlayer.h:362
 TProofPlayer.h:363
 TProofPlayer.h:364
 TProofPlayer.h:365
 TProofPlayer.h:366
 TProofPlayer.h:367
 TProofPlayer.h:368
 TProofPlayer.h:369
 TProofPlayer.h:370
 TProofPlayer.h:371
 TProofPlayer.h:372
 TProofPlayer.h:373
 TProofPlayer.h:374
 TProofPlayer.h:375
 TProofPlayer.h:376
 TProofPlayer.h:377
 TProofPlayer.h:378
 TProofPlayer.h:379
 TProofPlayer.h:380
 TProofPlayer.h:381
 TProofPlayer.h:382
 TProofPlayer.h:383
 TProofPlayer.h:384
 TProofPlayer.h:385
 TProofPlayer.h:386
 TProofPlayer.h:387
 TProofPlayer.h:388
 TProofPlayer.h:389
 TProofPlayer.h:390
 TProofPlayer.h:391
 TProofPlayer.h:392
 TProofPlayer.h:393
 TProofPlayer.h:394
 TProofPlayer.h:395
 TProofPlayer.h:396
 TProofPlayer.h:397
 TProofPlayer.h:398
 TProofPlayer.h:399
 TProofPlayer.h:400
 TProofPlayer.h:401
 TProofPlayer.h:402
 TProofPlayer.h:403
 TProofPlayer.h:404
 TProofPlayer.h:405
 TProofPlayer.h:406
 TProofPlayer.h:407
 TProofPlayer.h:408
 TProofPlayer.h:409
 TProofPlayer.h:410
 TProofPlayer.h:411
 TProofPlayer.h:412
 TProofPlayer.h:413
 TProofPlayer.h:414
 TProofPlayer.h:415
 TProofPlayer.h:416
 TProofPlayer.h:417
 TProofPlayer.h:418
 TProofPlayer.h:419
 TProofPlayer.h:420
 TProofPlayer.h:421
 TProofPlayer.h:422
 TProofPlayer.h:423
 TProofPlayer.h:424
 TProofPlayer.h:425
 TProofPlayer.h:426
 TProofPlayer.h:427
 TProofPlayer.h:428
 TProofPlayer.h:429
 TProofPlayer.h:430
 TProofPlayer.h:431
 TProofPlayer.h:432
 TProofPlayer.h:433
 TProofPlayer.h:434
 TProofPlayer.h:435
 TProofPlayer.h:436
 TProofPlayer.h:437
 TProofPlayer.h:438
 TProofPlayer.h:439
 TProofPlayer.h:440
 TProofPlayer.h:441
 TProofPlayer.h:442
 TProofPlayer.h:443
 TProofPlayer.h:444
 TProofPlayer.h:445
 TProofPlayer.h:446
 TProofPlayer.h:447
 TProofPlayer.h:448
 TProofPlayer.h:449
 TProofPlayer.h:450
 TProofPlayer.h:451
 TProofPlayer.h:452
 TProofPlayer.h:453
 TProofPlayer.h:454
 TProofPlayer.h:455
 TProofPlayer.h:456
 TProofPlayer.h:457
 TProofPlayer.h:458
 TProofPlayer.h:459
 TProofPlayer.h:460
 TProofPlayer.h:461
 TProofPlayer.h:462