// @(#)root/proof:$Id$
// Author: Fons Rademakers   13/02/97

/*************************************************************************
 * Copyright (C) 1995-2000, 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_TProof
#define ROOT_TProof


//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TProof                                                               //
//                                                                      //
// This class controls a Parallel ROOT Facility, PROOF, cluster.        //
// It fires the worker servers, it keeps track of how many workers are  //
// running, it keeps track of the workers running status, it broadcasts //
// messages to all workers, it collects results, etc.                   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#ifndef ROOT_TProofMgr
#include "TProofMgr.h"
#endif
#ifndef ROOT_TProofDebug
#include "TProofDebug.h"
#endif
#ifndef ROOT_TString
#include "TString.h"
#endif
#ifndef ROOT_TMacro
#include "TMacro.h"
#endif
#ifndef ROOT_MessageTypes
#include "MessageTypes.h"
#endif
#ifndef ROOT_TMD5
#include "TMD5.h"
#endif
#ifndef ROOT_TRegexp
#include "TRegexp.h"
#endif
#ifndef ROOT_TSysEvtHandler
#include "TSysEvtHandler.h"
#endif
#ifndef ROOT_TThread
#include "TThread.h"
#endif
#ifndef ROOT_TUrl
#include "TUrl.h"
#endif
#ifndef ROOT_TProofOutputList
#include "TProofOutputList.h"
#endif
#ifndef ROOT_TStopwatch
#include "TStopwatch.h"
#endif

#include <map>

#ifdef R__GLOBALSTL
namespace std { using ::map; }
#endif

#define CANNOTUSE(x) Info(x,"Not manager: cannot use this method")

class TChain;
class TCondor;
class TCondorSlave;
class TDrawFeedback;
class TDSet;
class TEventList;
class THashList;
class TList;
class TCollection;
class TMessage;
class TMonitor;
class TPluginHandler;
class TProof;
class TProofInputHandler;
class TProofInterruptHandler;
class TProofLockPath;
class TVirtualProofPlayer;
class TProofPlayer;
class TProofPlayerRemote;
class TProofProgressDialog;
class TProofServ;
class TQueryResult;
class TSignalHandler;
class TSlave;
class TSemaphore;
class TSocket;
class TTree;
class TVirtualMutex;
class TFileCollection;
class TMap;
class TDataSetManager;
class TDataSetManagerFile;
class TMacro;
class TSelector;

// protocol changes:
// 1 -> 2: new arguments for Process() command, option added
// 2 -> 3: package manager enabling protocol changed
// 3 -> 4: introduction of multi-level-master support
// 4 -> 5: added friends support
// 5 -> 6: drop TFTP, support for asynchronous queries
// 6 -> 7: support for multisessions, archieve, retrieve, ...
// 7 -> 8: return number of entries in GetNextPacket
// 8 -> 9: support for stateless connection via xproofd
// 9 -> 10: new features requested, tested at CAF
// 10 -> 11: new merging strategy
// 11 -> 12: new progress message
// 12 -> 13: exchange version/architecture/compiler info
// 13 -> 14: new proofserv environment setting
// 14 -> 15: add support for entry lists; new version of TFileInfo
// 15 -> 16: add support for generic non-data based processing
// 16 -> 17: new dataset handling system; support for TFileCollection processing
// 17 -> 18: support for reconnection on daemon restarts
// 18 -> 19: TProofProgressStatus used in kPROOF_PROGRESS, kPROOF_STOPPROCESS
//           and kPROOF_GETNEXTPACKET messages in Master - worker communication
// 19 -> 20: Fix the asynchronous mode (required changes in some messages)
// 20 -> 21: Add support for session queuing
// 21 -> 22: Add support for switching from sync to async while running ('Ctrl-Z' functionality)
// 22 -> 23: New dataset features (default tree name; classification per fileserver)
// 23 -> 24: Merging optimization
// 24 -> 25: Handling of 'data' dir; group information
// 25 -> 26: Use new TProofProgressInfo class
// 26 -> 27: Use new file for updating the session status
// 27 -> 28: Support for multi-datasets, fix global pack dirs, fix AskStatistics,
//           package download, dataset caching
// 28 -> 29: Support for config parameters in EnablePackage, idle-timeout
// 29 -> 30: Add information about data dir in TSlaveInfo
// 30 -> 31: Development cycle 5.29
// 31 -> 32: New log path trasmission
// 32 -> 33: Development cycle 5.29/04 (fixed worker activation, new startup technology, ...)
// 33 -> 34: Development cycle 5.33/02 (fix load issue, ...)
// 34 -> 35: Development cycle 5.99/01 (PLite on workers, staging requests in separate dsmgr...)
// 35 -> 36: SetParallel in dynamic mode (changes default in GoParallel), cancel staging requests

// PROOF magic constants
const Int_t       kPROOF_Protocol        = 36;            // protocol version number
const Int_t       kPROOF_Port            = 1093;          // IANA registered PROOF port
const char* const kPROOF_ConfFile        = "proof.conf";  // default config file
const char* const kPROOF_ConfDir         = "/usr/local/root";  // default config dir
const char* const kPROOF_WorkDir         = ".proof";      // default working directory
const char* const kPROOF_CacheDir        = "cache";       // file cache dir, under WorkDir
const char* const kPROOF_PackDir         = "packages";    // package dir, under WorkDir
const char* const kPROOF_PackDownloadDir = "downloaded";  // subdir with downloaded PARs, under PackDir
const char* const kPROOF_QueryDir        = "queries";     // query dir, under WorkDir
const char* const kPROOF_DataSetDir      = "datasets";    // dataset dir, under WorkDir
const char* const kPROOF_DataDir         = "data";        // dir for produced data, under WorkDir
const char* const kPROOF_CacheLockFile   = "proof-cache-lock-";   // cache lock file
const char* const kPROOF_PackageLockFile = "proof-package-lock-"; // package lock file
const char* const kPROOF_QueryLockFile   = "proof-query-lock-";   // query lock file
const char* const kPROOF_TerminateWorker = "+++ terminating +++"; // signal worker termination in MarkBad
const char* const kPROOF_WorkerIdleTO    = "+++ idle-timeout +++"; // signal worker idle timeout in MarkBad
const char* const kPROOF_InputDataFile   = "inputdata.root";      // Default input data file name
const char* const kPROOF_MissingFiles    = "MissingFiles";  // Missingfile list name
const Long64_t    kPROOF_DynWrkPollInt_s = 10;  // minimum number of seconds between two polls for dyn wrks

#ifndef R__WIN32
const char* const kCP     = "/bin/cp -fp";
const char* const kRM     = "/bin/rm -rf";
const char* const kLS     = "/bin/ls -l";
const char* const kUNTAR  = "%s -c %s/%s | (cd %s; tar xf -)";
const char* const kUNTAR2 = "%s -c %s | (cd %s; tar xf -)";
const char* const kUNTAR3 = "%s -c %s | (tar xf -)";
const char* const kGUNZIP = "gunzip";
#else
const char* const kCP     = "copy";
const char* const kRM     = "delete";
const char* const kLS     = "dir";
const char* const kUNTAR  = "...";
const char* const kUNTAR2 = "...";
const char* const kUNTAR3 = "...";
const char* const kGUNZIP = "gunzip";
#endif

R__EXTERN TVirtualMutex *gProofMutex;

typedef void (*PrintProgress_t)(Long64_t tot, Long64_t proc, Float_t proctime, Long64_t bytes);

// Structure for the progress information
class TProofProgressInfo : public TObject {
public:
   Long64_t  fTotal;       // Total number of events to process
   Long64_t  fProcessed;   // Number of events processed
   Long64_t  fBytesRead;   // Number of bytes read
   Float_t   fInitTime;    // Time for initialization
   Float_t   fProcTime;    // Time for processing
   Float_t   fEvtRateI;    // Instantaneous event rate
   Float_t   fMBRateI;     // Instantaneous byte read rate
   Int_t     fActWorkers;  // Numebr of workers still active
   Int_t     fTotSessions; // Numebr of PROOF sessions running currently on the clusters
   Float_t   fEffSessions; // Number of effective sessions running on the machines allocated to this session
   TProofProgressInfo(Long64_t tot = 0, Long64_t proc = 0, Long64_t bytes = 0,
                      Float_t initt = -1., Float_t proct = -1.,
                      Float_t evts = -1., Float_t mbs = -1.,
                      Int_t actw = 0, Int_t tsess = 0, Float_t esess = 0.) :
                      fTotal(tot), fProcessed(proc), fBytesRead(bytes),
                      fInitTime(initt), fProcTime(proct), fEvtRateI(evts), fMBRateI(mbs),
                      fActWorkers(actw), fTotSessions(tsess), fEffSessions(esess) { }
   virtual ~TProofProgressInfo() { }
   ClassDef(TProofProgressInfo, 1); // Progress information
};

// PROOF Interrupt signal handler
class TProofInterruptHandler : public TSignalHandler {
private:
   TProof *fProof;

   TProofInterruptHandler(const TProofInterruptHandler&); // Not implemented
   TProofInterruptHandler& operator=(const TProofInterruptHandler&); // Not implemented
public:
   TProofInterruptHandler(TProof *p)
      : TSignalHandler(kSigInterrupt, kFALSE), fProof(p) { }
   Bool_t Notify();
};

// Input handler for messages from TProofServ
class TProofInputHandler : public TFileHandler {
private:
   TSocket *fSocket;
   TProof  *fProof;

   TProofInputHandler(const TProofInputHandler&); // Not implemented
   TProofInputHandler& operator=(const TProofInputHandler&); // Not implemented
public:
   TProofInputHandler(TProof *p, TSocket *s);
   Bool_t Notify();
   Bool_t ReadNotify() { return Notify(); }
};

// Slaves info class
class TSlaveInfo : public TObject {
public:
   enum ESlaveStatus { kActive, kNotActive, kBad };

   TString      fOrdinal;      //slave ordinal
   TString      fHostName;     //hostname this slave is running on
   TString      fMsd;          //mass storage domain slave is in
   TString      fDataDir;      //directory for user data
   Int_t        fPerfIndex;    //relative performance of this slave
   SysInfo_t    fSysInfo;      //Infomation about its hardware
   ESlaveStatus fStatus;       //slave status

   TSlaveInfo(const char *ordinal = "", const char *host = "", Int_t perfidx = 0,
              const char *msd = "", const char *datadir = "") :
              fOrdinal(ordinal), fHostName(host), fMsd(msd), fDataDir(datadir),
              fPerfIndex(perfidx), fSysInfo(), fStatus(kNotActive) { }

   const char *GetDataDir() const { return fDataDir; }
   const char *GetMsd() const { return fMsd; }
   const char *GetName() const { return fHostName; }
   const char *GetOrdinal() const { return fOrdinal; }
   SysInfo_t   GetSysInfo() const { return fSysInfo; }
   void        SetStatus(ESlaveStatus stat) { fStatus = stat; }
   void        SetSysInfo(SysInfo_t si);
   void        SetOrdinal(const char *ord) { fOrdinal = ord; }

   Int_t  Compare(const TObject *obj) const;
   Bool_t IsSortable() const { return kTRUE; }
   void   Print(Option_t *option="") const;
   Bool_t IsEqual(const TObject* obj) const;

   ClassDef(TSlaveInfo,4) //basic info on workers
};

// Merger info class
class TMergerInfo : public TObject {
private:

   TSlave      *fMerger;         // Slave that acts as merger
   Int_t        fPort;           // Port number, on which it accepts outputs from other workers
   Int_t        fMergedObjects;  // Total number of objects it must accept from other workers
                                 // (-1 == not set yet)
   Int_t        fWorkersToMerge; // Number of workers that are merged on this merger
                                 // (does not change during time)
   Int_t        fMergedWorkers;  // Current number of already merged workers
                                 // (does change during time as workers are being merged)

   TList       *fWorkers;        // List of already assigned workers
   Bool_t       fIsActive;       // Merger state

   TMergerInfo(const TMergerInfo&); // Not implemented
   TMergerInfo& operator=(const TMergerInfo&); // Not implemented

public:
   TMergerInfo(TSlave *t, Int_t port, Int_t forHowManyWorkers) :
               fMerger(t), fPort(port), fMergedObjects(0), fWorkersToMerge(forHowManyWorkers),
               fMergedWorkers(0), fWorkers(0), fIsActive(kTRUE) { }
   virtual ~TMergerInfo();

   void        AddWorker(TSlave *sl);
   TList      *GetWorkers() { return fWorkers; }

   TSlave     *GetMerger() { return fMerger; }
   Int_t       GetPort() { return fPort; }

   Int_t       GetWorkersToMerge() { return fWorkersToMerge; }
   Int_t       GetMergedWorkers() { return fMergedWorkers; }
   Int_t       GetMergedObjects() { return fMergedObjects; }

   void        SetMergedWorker();
   void        AddMergedObjects(Int_t objects) { fMergedObjects += objects; }

   Bool_t      AreAllWorkersAssigned();
   Bool_t      AreAllWorkersMerged();

   void Deactivate() { fIsActive = kFALSE; }
   Bool_t      IsActive() { return fIsActive; }

   ClassDef(TMergerInfo,0)          // Basic info on merger, i.e. worker serving as merger
};

// Small auxiliary class for merging progress notification
class TProofMergePrg {
private:
   TString      fExp;
   Int_t        fIdx;
   Int_t        fNWrks;
   Int_t        fLastNWrks;
   static char  fgCr[4];
public:
   TProofMergePrg() : fExp(), fIdx(-1), fNWrks(-1), fLastNWrks(-1) { }

   const char  *Export(Bool_t &changed) {
                  fExp.Form("%c (%d workers still sending)   ", fgCr[fIdx], fNWrks);
                  changed = (fLastNWrks != fNWrks || fLastNWrks == -1) ? kTRUE : kFALSE;
                  fLastNWrks = fNWrks;
                  return fExp.Data(); }
   void         DecreaseNWrks() { fNWrks--; }
   void         IncreaseNWrks() { fNWrks++; }
   void         IncreaseIdx() { fIdx++; if (fIdx == 4) fIdx = 0; }
   void         Reset(Int_t n = -1) { fIdx = -1; SetNWrks(n); }
   void         SetNWrks(Int_t n) { fNWrks = n; }
};

class TProof : public TNamed, public TQObject {

friend class TPacketizer;
friend class TPacketizerDev;
friend class TPacketizerAdaptive;
friend class TProofLite;
friend class TDataSetManager;
friend class TProofServ;
friend class TProofInputHandler;
friend class TProofInterruptHandler;
friend class TProofPlayer;
friend class TProofPlayerLite;
friend class TProofPlayerRemote;
friend class TProofProgressDialog;
friend class TSlave;
friend class TSlaveLite;
friend class TVirtualPacketizer;
friend class TXSlave;
friend class TXSocket;        // to access kPing
friend class TXSocketHandler; // to access fCurrentMonitor and CollectInputFrom
friend class TXProofMgr;      // to access EUrgent
friend class TXProofServ;     // to access EUrgent

public:
   // PROOF status bits
   enum EStatusBits {
      kUsingSessionGui     = BIT(14),
      kNewInputData        = BIT(15),
      kIsClient            = BIT(16),
      kIsMaster            = BIT(17),
      kIsTopMaster         = BIT(18),
      kUseProgressDialog   = BIT(19)
   };
   enum EQueryMode {
      kSync                = 0,
      kAsync               = 1
   };
   enum EUploadOpt {
      kAppend              = 0x1,
      kOverwriteDataSet    = 0x2,
      kNoOverwriteDataSet  = 0x4,
      kOverwriteAllFiles   = 0x8,
      kOverwriteNoFiles    = 0x10,
      kAskUser             = 0x0
   };
   enum ERegisterOpt {
      kFailIfExists        = 0,
      kOverwriteIfExists   = 1,
      kMergeIfExists       = 2
   };
   enum EUploadPackageOpt {
      kUntar               = 0x0,  //Untar over existing dir [default]
      kRemoveOld           = 0x1   //Remove existing dir with same name
   };
   enum ERunStatus {
      kRunning             = 0,    // Normal status
      kStopped             = 1,    // After the stop button has been pressed
      kAborted             = 2     // After the abort button has been pressed
   };

   enum ESubMerger {
      kOutputSize     = 1,         //Number of objects in worker's output list
      kSendOutput     = 2,         //Naster asks worker for its output list
      kBeMerger       = 3,         //Master tells worker to be a merger
      kMergerDown     = 4,         //Merger cannot serve
      kStopMerging    = 5,         //Master tells worker to stop merging (and return output)
      kOutputSent     = 6          //Worker reports sending its output to given worker
   };

   enum EProofClearData {
      kPurge        = 0x1,
      kUnregistered = 0x2,
      kDataset      = 0x4,
      kForceClear   = 0x8
   };

private:
   enum EUrgent {
      kLocalInterrupt      = -1,
      kPing                = 0,
      kHardInterrupt       = 1,
      kSoftInterrupt,
      kShutdownInterrupt
   };
   enum EProofCacheCommands {
      kShowCache           = 1,
      kClearCache          = 2,
      kShowPackages        = 3,
      kClearPackages       = 4,
      kClearPackage        = 5,
      kBuildPackage        = 6,
      kLoadPackage         = 7,
      kShowEnabledPackages = 8,
      kShowSubCache        = 9,
      kClearSubCache       = 10,
      kShowSubPackages     = 11,
      kDisableSubPackages  = 12,
      kDisableSubPackage   = 13,
      kBuildSubPackage     = 14,
      kUnloadPackage       = 15,
      kDisablePackage      = 16,
      kUnloadPackages      = 17,
      kDisablePackages     = 18,
      kListPackages        = 19,
      kListEnabledPackages = 20,
      kLoadMacro           = 21
   };
   enum EProofDataSetCommands {
      kUploadDataSet       = 1,  //Upload a dataset
      kCheckDataSetName    = 2,  //Check wheter dataset of this name exists
      kGetDataSets         = 3,  //List datasets saved on  the master node
      kRegisterDataSet     = 4,  //Save a TList object as a dataset
      kGetDataSet          = 5,  //Get a TFileCollection of TFileInfo objects
      kVerifyDataSet       = 6,  //Try open all files from a dataset and report results
      kRemoveDataSet       = 7,  //Remove a dataset but leave files belonging to it
      kMergeDataSet        = 8,  //Add new files to an existing dataset
      kShowDataSets        = 9,  //Shows datasets, returns formatted output
      kGetQuota            = 10, //Get quota info per group
      kShowQuota           = 11, //Show quotas
      kSetDefaultTreeName  = 12, //Set the default tree name
      kCache               = 13, //Show/clear cache
      kRequestStaging      = 14, //Request staging of a dataset
      kStagingStatus       = 15, //Obtain staging status for the given dataset
      kCancelStaging       = 16  //Cancels dataset staging request
   };
   enum ESendFileOpt {
      kAscii               = 0x0,
      kBinary              = 0x1,
      kForce               = 0x2,
      kForward             = 0x4,
      kCpBin               = 0x8,
      kCp                  = 0x10
   };
   enum EProofWrkListAction {
      kActivateWorker      = 1,
      kDeactivateWorker    = 2
   };
   enum EBuildPackageOpt {
      kDontBuildOnClient   = -2,
      kBuildOnSlavesNoWait = -1,
      kBuildAll            = 0,
      kCollectBuildResults = 1
   };
   enum EParCheckVersionOpt {
      kDontCheck   = 0,
      kCheckROOT    = 1,
      kCheckSVN     = 2
   };
   enum EProofShowQuotaOpt {
      kPerGroup = 0x1,
      kPerUser = 0x2
   };

   Bool_t          fValid;           //is this a valid proof object
   Bool_t          fTty;             //TRUE if connected to a terminal
   TString         fMaster;          //master server ("" if a master); used in the browser
   TString         fWorkDir;         //current work directory on remote servers
   TString         fGroup;           //PROOF group of this user
   Int_t           fLogLevel;        //server debug logging level
   Int_t           fStatus;          //remote return status (part of kPROOF_LOGDONE)
   Int_t           fCheckFileStatus; //remote return status after kPROOF_CHECKFILE
   TList          *fRecvMessages;    //Messages received during collect not yet processed
   TList          *fSlaveInfo;       //!list returned by kPROOF_GETSLAVEINFO
   Bool_t          fSendGroupView;   //if true send new group view
   Bool_t          fIsPollingWorkers;  //will be set to kFALSE to prevent recursive dyn workers check in dyn mode
   Long64_t        fLastPollWorkers_s;  //timestamp (in seconds) of last poll for workers, -1 if never checked
   TList          *fActiveSlaves;    //list of active slaves (subset of all slaves)
   TString         fActiveSlavesSaved;// comma-separated list of active slaves (before last call to
                                      // SetParallel or Activate/DeactivateWorkers)
   TList          *fInactiveSlaves;  //list of inactive slaves (good but not used for processing)
   TList          *fUniqueSlaves;    //list of all active slaves with unique file systems
   TList          *fAllUniqueSlaves;  //list of all active slaves with unique file systems, including all submasters
   TList          *fNonUniqueMasters; //list of all active masters with a nonunique file system
   TMonitor       *fActiveMonitor;   //monitor activity on all active slave sockets
   TMonitor       *fUniqueMonitor;   //monitor activity on all unique slave sockets
   TMonitor       *fAllUniqueMonitor; //monitor activity on all unique slave sockets, including all submasters
   TMonitor       *fCurrentMonitor;  //currently active monitor
   Long64_t        fBytesRead;       //bytes read by all slaves during the session
   Float_t         fRealTime;        //realtime spent by all slaves during the session
   Float_t         fCpuTime;         //CPU time spent by all slaves during the session
   TSignalHandler *fIntHandler;      //interrupt signal handler (ctrl-c)
   TPluginHandler *fProgressDialog;  //progress dialog plugin
   Bool_t          fProgressDialogStarted; //indicates if the progress dialog is up
   TVirtualProofPlayer *fPlayer;     //current player
   TList          *fFeedback;        //list of names to be returned as feedback
   TList          *fChains;          //chains with this proof set
   struct MD5Mod_t {
      TMD5   fMD5;                   //file's md5
      Long_t fModtime;               //file's modification time
   };
   typedef std::map<TString, MD5Mod_t> FileMap_t;
   FileMap_t       fFileMap;         //map keeping track of a file's md5 and mod time
   TDSet          *fDSet;            //current TDSet being validated

   Int_t           fNotIdle;         //Number of non-idle sub-nodes
   Bool_t          fSync;            //true if type of currently processed query is sync
   ERunStatus      fRunStatus;       //run status
   Bool_t          fIsWaiting;       //true if queries have been enqueued

   Bool_t          fRedirLog;        //redirect received log info
   TString         fLogFileName;     //name of the temp file for redirected logs
   FILE           *fLogFileW;        //temp file to redirect logs
   FILE           *fLogFileR;        //temp file to read redirected logs
   Bool_t          fLogToWindowOnly; //send log to window only

   Bool_t          fSaveLogToMacro;  // Whether to save received logs to TMacro fMacroLog (use with care)
   TMacro          fMacroLog;        // Macro with the saved (last) log

   TProofMergePrg  fMergePrg;        //Merging progress

   TList          *fWaitingSlaves;   //stores a TPair of the slaves's TSocket and TMessage
   TList          *fQueries;         //list of TProofQuery objects
   Int_t           fOtherQueries;    //number of queries in list from previous sessions
   Int_t           fDrawQueries;     //number of draw queries during this sessions
   Int_t           fMaxDrawQueries;  //max number of draw queries kept
   Int_t           fSeqNum;          //Remote sequential # of the last query submitted

   Int_t           fSessionID;       //remote ID of the session

   Bool_t          fEndMaster;       //true for a master in direct contact only with workers

   TString         fPackageDir;      //package directory (used on client)
   THashList      *fGlobalPackageDirList;//list of directories containing global packages libs
   TProofLockPath *fPackageLock;     //package lock
   TList          *fEnabledPackagesOnClient; //list of packages enabled on client
   TList          *fEnabledPackagesOnCluster;  //list of enabled packages

   TList          *fInputData;       //Input data objects sent over via file
   TString         fInputDataFile;   //File with input data objects

   TProofOutputList fOutputList;     // TList implementation filtering ls(...) and Print(...)

   PrintProgress_t fPrintProgress;   //Function function to display progress info in batch mode

   TVirtualMutex  *fCloseMutex;      // Avoid crashes in MarkBad or alike while closing

   TList          *fLoadedMacros;    // List of loaded macros (just file names)
   static TList   *fgProofEnvList;   // List of TNameds defining environment
                                     // variables to pass to proofserv

   Bool_t          fMergersSet;      // Indicates, if the following variables have been initialized properly
   Bool_t          fMergersByHost;   // Mergers assigned by host name
   Int_t           fMergersCount;
   Int_t           fWorkersToMerge;  // Current total number of workers, which have not been yet assigned to any merger
   Int_t           fLastAssignedMerger;
   TList          *fMergers;
   Bool_t          fFinalizationRunning;
   Int_t           fRedirectNext;

   TString         fPerfTree;        // If non-null triggers saving of the performance info into fPerfTree

   TList          *fWrksOutputReady; // List of workers ready to send output (in control output sending mode)

   static TPluginHandler *fgLogViewer;  // Log dialog box plugin

protected:
   enum ESlaves { kAll, kActive, kUnique, kAllUnique };

   Bool_t          fMasterServ;     //true if we are a master server
   TUrl            fUrl;            //Url of the master
   TString         fConfFile;       //file containing config information
   TString         fConfDir;        //directory containing cluster config information
   TString         fImage;          //master's image name
   Int_t           fProtocol;       //remote PROOF server protocol version number
   TList          *fSlaves;         //list of all slave servers as in config file
   TList          *fTerminatedSlaveInfos; //list of unique infos of terminated slaves
   TList          *fBadSlaves;      //dead slaves (subset of all slaves)
   TMonitor       *fAllMonitor;     //monitor activity on all valid slave sockets
   Bool_t          fDataReady;      //true if data is ready to be analyzed
   Long64_t        fBytesReady;     //number of bytes staged
   Long64_t        fTotalBytes;     //number of bytes to be analyzed
   TList          *fAvailablePackages; //list of available packages
   TList          *fEnabledPackages;   //list of enabled packages
   TList          *fRunningDSets;   // Temporary datasets used for async running

   Int_t           fCollectTimeout; // Timeout for (some) collect actions

   TString         fDataPoolUrl;    // default data pool entry point URL
   TProofMgr::EServType fServType;  // type of server: proofd, XrdProofd
   TProofMgr      *fManager;        // manager to which this session belongs (if any)
   EQueryMode      fQueryMode;      // default query mode
   Bool_t          fDynamicStartup; // are the workers started dynamically?

   TSelector       *fSelector;      // Selector to be processed, if any

   TStopwatch      fQuerySTW;       // Stopwatch to measure query times
   Float_t         fPrepTime;       // Preparation time

   static TSemaphore *fgSemaphore;   //semaphore to control no of parallel startup threads

private:
   TProof(const TProof &);           // not implemented
   void operator=(const TProof &);   // idem

   void     CleanGDirectory(TList *ol);

   Int_t    Exec(const char *cmd, ESlaves list, Bool_t plusMaster);
   Int_t    SendCommand(const char *cmd, ESlaves list = kActive);
   Int_t    SendCurrentState(ESlaves list = kActive);
   Int_t    SendCurrentState(TList *list);
   Bool_t   CheckFile(const char *file, TSlave *sl, Long_t modtime, Int_t cpopt = (kCp | kCpBin));
   Int_t    SendObject(const TObject *obj, ESlaves list = kActive);
   Int_t    SendGroupView();
   Int_t    SendInitialState();
   Int_t    SendPrint(Option_t *option="");
   Int_t    Ping(ESlaves list);
   void     Interrupt(EUrgent type, ESlaves list = kActive);
   void     AskStatistics();
   void     AskParallel();
   Int_t    GoParallel(Int_t nodes, Bool_t accept = kFALSE, Bool_t random = kFALSE);
   Int_t    GoMoreParallel(Int_t nWorkersToAdd);
   Int_t    SetParallelSilent(Int_t nodes, Bool_t random = kFALSE);
   void     RecvLogFile(TSocket *s, Int_t size);
   void     NotifyLogMsg(const char *msg, const char *sfx = "\n");
   Int_t    BuildPackage(const char *package, EBuildPackageOpt opt = kBuildAll, Int_t chkveropt = kCheckROOT, TList *workers = 0);
   Int_t    BuildPackageOnClient(const char *package, Int_t opt = 0, TString *path = 0, Int_t chkveropt = kCheckROOT);
   Int_t    LoadPackage(const char *package, Bool_t notOnClient = kFALSE, TList *loadopts = 0, TList *workers = 0);
   Int_t    LoadPackageOnClient(const char *package, TList *loadopts = 0);
   Int_t    UnloadPackage(const char *package);
   Int_t    UnloadPackageOnClient(const char *package);
   Int_t    UnloadPackages();
   Int_t    UploadPackageOnClient(const char *package, EUploadPackageOpt opt, TMD5 *md5);
   Int_t    DisablePackage(const char *package);
   Int_t    DisablePackageOnClient(const char *package);
   Int_t    DisablePackages();

   void     Activate(TList *slaves = 0);
   Int_t    Broadcast(const TMessage &mess, TList *slaves);
   Int_t    Broadcast(const TMessage &mess, ESlaves list = kActive);
   Int_t    Broadcast(const char *mess, Int_t kind, TList *slaves);
   Int_t    Broadcast(const char *mess, Int_t kind = kMESS_STRING, ESlaves list = kActive);
   Int_t    Broadcast(Int_t kind, TList *slaves) { return Broadcast(0, kind, slaves); }
   Int_t    Broadcast(Int_t kind, ESlaves list = kActive) { return Broadcast(0, kind, list); }
   Int_t    BroadcastFile(const char *file, Int_t opt, const char *rfile, TList *wrks);
   Int_t    BroadcastFile(const char *file, Int_t opt, const char *rfile = 0, ESlaves list = kAllUnique);
   Int_t    BroadcastGroupPriority(const char *grp, Int_t priority, ESlaves list = kAllUnique);
   Int_t    BroadcastGroupPriority(const char *grp, Int_t priority, TList *workers);
   Int_t    BroadcastObject(const TObject *obj, Int_t kind, TList *slaves);
   Int_t    BroadcastObject(const TObject *obj, Int_t kind = kMESS_OBJECT, ESlaves list = kActive);
   Int_t    BroadcastRaw(const void *buffer, Int_t length, TList *slaves);
   Int_t    BroadcastRaw(const void *buffer, Int_t length, ESlaves list = kActive);
   Int_t    Collect(const TSlave *sl, Long_t timeout = -1, Int_t endtype = -1, Bool_t deactonfail = kFALSE);
   Int_t    Collect(TMonitor *mon, Long_t timeout = -1, Int_t endtype = -1, Bool_t deactonfail = kFALSE);
   Int_t    CollectInputFrom(TSocket *s, Int_t endtype = -1, Bool_t deactonfail = kFALSE);
   Int_t    HandleInputMessage(TSlave *wrk, TMessage *m, Bool_t deactonfail = kFALSE);
   void     HandleSubmerger(TMessage *mess, TSlave *sl);
   void     SetMonitor(TMonitor *mon = 0, Bool_t on = kTRUE);

   void     ReleaseMonitor(TMonitor *mon);

   virtual  void FindUniqueSlaves();
   TSlave  *FindSlave(TSocket *s) const;
   TList   *GetListOfSlaves() const { return fSlaves; }
   TList   *GetListOfInactiveSlaves() const { return fInactiveSlaves; }
   TList   *GetListOfUniqueSlaves() const { return fUniqueSlaves; }
   TList   *GetListOfBadSlaves() const { return fBadSlaves; }
   Int_t    GetNumberOfSlaves() const;
   Int_t    GetNumberOfActiveSlaves() const;
   Int_t    GetNumberOfInactiveSlaves() const;
   Int_t    GetNumberOfUniqueSlaves() const;
   Int_t    GetNumberOfBadSlaves() const;

   Bool_t   IsEndMaster() const { return fEndMaster; }
   Int_t    ModifyWorkerLists(const char *ord, Bool_t add, Bool_t save);
   Int_t    RestoreActiveList();
   void     SaveActiveList();

   Bool_t   IsSync() const { return fSync; }
   void     InterruptCurrentMonitor();

   void     SetRunStatus(ERunStatus rst) { fRunStatus = rst; }

   void     MarkBad(TSlave *wrk, const char *reason = 0);
   void     MarkBad(TSocket *s, const char *reason = 0);
   void     TerminateWorker(TSlave *wrk);
   void     TerminateWorker(const char *ord);

   void     ActivateAsyncInput();
   void     DeActivateAsyncInput();

   Int_t    GetQueryReference(Int_t qry, TString &ref);
   void     PrintProgress(Long64_t total, Long64_t processed,
                          Float_t procTime = -1.,  Long64_t bytesread = -1);

   // Managing mergers
   Bool_t   CreateMerger(TSlave *sl, Int_t port);
   void     RedirectWorker(TSocket *s, TSlave * sl, Int_t output_size);
   Int_t    GetActiveMergersCount();
   Int_t    FindNextFreeMerger();
   void     ResetMergers() { fMergersSet = kFALSE; }
   void     AskForOutput(TSlave *sl);

   void     FinalizationDone() { fFinalizationRunning = kFALSE; }

   void     ResetMergePrg();
   void     ParseConfigField(const char *config);

   Bool_t   Prompt(const char *p);
   void     ClearDataProgress(Int_t r, Int_t t);

   static TList *GetDataSetSrvMaps(const TString &srvmaps);

protected:
   TProof(); // For derived classes to use
   void  InitMembers();
   Int_t Init(const char *masterurl, const char *conffile,
              const char *confdir, Int_t loglevel,
              const char *alias = 0);
   virtual Bool_t  StartSlaves(Bool_t attach = kFALSE);
   Int_t AddWorkers(TList *wrks);
   Int_t RemoveWorkers(TList *wrks);
   void  SetupWorkersEnv(TList *wrks, Bool_t increasingpool = kFALSE);

   void                         SetPlayer(TVirtualProofPlayer *player);
   TVirtualProofPlayer         *GetPlayer() const { return fPlayer; }
   virtual TVirtualProofPlayer *MakePlayer(const char *player = 0, TSocket *s = 0);

   void    UpdateDialog();

   void    HandleLibIncPath(const char *what, Bool_t add, const char *dirs);

   TList  *GetListOfActiveSlaves() const { return fActiveSlaves; }
   TSlave *CreateSlave(const char *url, const char *ord,
                       Int_t perf, const char *image, const char *workdir);
   TSlave *CreateSubmaster(const char *url, const char *ord,
                           const char *image, const char *msd, Int_t nwk = 1);

   virtual Int_t PollForNewWorkers();
   virtual void SaveWorkerInfo();

   Int_t    Collect(ESlaves list = kActive, Long_t timeout = -1, Int_t endtype = -1, Bool_t deactonfail = kFALSE);
   Int_t    Collect(TList *slaves, Long_t timeout = -1, Int_t endtype = -1, Bool_t deactonfail = kFALSE);

   TList   *GetEnabledPackages() const { return fEnabledPackagesOnCluster; }

   void         SetDSet(TDSet *dset) { fDSet = dset; }
   virtual void ValidateDSet(TDSet *dset);

   Int_t   VerifyDataSetParallel(const char *uri, const char *optStr);

   TPluginHandler *GetProgressDialog() const { return fProgressDialog; }

   Int_t AssertPath(const char *path, Bool_t writable);
   Int_t GetSandbox(TString &sb, Bool_t assert = kFALSE, const char *rc = 0);

   void PrepareInputDataFile(TString &dataFile);
   virtual void  SendInputDataFile();
   Int_t SendFile(const char *file, Int_t opt = (kBinary | kForward | kCp | kCpBin),
                  const char *rfile = 0, TSlave *sl = 0);

   // Fast enable/disable feedback from Process
   void SetFeedback(TString &opt, TString &optfb, Int_t action);
   // Output file handling during Process
   Int_t HandleOutputOptions(TString &opt, TString &target, Int_t action);

   static void *SlaveStartupThread(void *arg);

   static Int_t AssertDataSet(TDSet *dset, TList *input,
                              TDataSetManager *mgr, TString &emsg);
   // Input data handling
   static Int_t GetInputData(TList *input, const char *cachedir, TString &emsg);
   static Int_t SaveInputData(TQueryResult *qr, const char *cachedir, TString &emsg);
   static Int_t SendInputData(TQueryResult *qr, TProof *p, TString &emsg);

   // Parse CINT commands
   static Bool_t GetFileInCmd(const char *cmd, TString &fn);

   // Pipe execution of commands
   static void SystemCmd(const char *cmd, Int_t fdout);

public:
   TProof(const char *masterurl, const char *conffile = kPROOF_ConfFile,
          const char *confdir = kPROOF_ConfDir, Int_t loglevel = 0,
          const char *alias = 0, TProofMgr *mgr = 0);
   virtual ~TProof();

   void        cd(Int_t id = -1);

   Int_t       Ping();
   void        Touch();
   Int_t       Exec(const char *cmd, Bool_t plusMaster = kFALSE);
   Int_t       Exec(const char *cmd, const char *ord, Bool_t logtomacro = kFALSE);

   TString     Getenv(const char *env, const char *ord = "0");
   Int_t       GetRC(const char *RCenv, Int_t &env, const char *ord = "0");
   Int_t       GetRC(const char *RCenv, Double_t &env, const char *ord = "0");
   Int_t       GetRC(const char *RCenv, TString &env, const char *ord = "0");

   virtual Long64_t Process(TDSet *dset, const char *selector,
                            Option_t *option = "", Long64_t nentries = -1,
                            Long64_t firstentry = 0);
   virtual Long64_t Process(TFileCollection *fc, const char *selector,
                            Option_t *option = "", Long64_t nentries = -1,
                            Long64_t firstentry = 0);
   virtual Long64_t Process(const char *dsetname, const char *selector,
                            Option_t *option = "", Long64_t nentries = -1,
                            Long64_t firstentry = 0, TObject *enl = 0);
   virtual Long64_t Process(const char *selector, Long64_t nentries,
                            Option_t *option = "");
   // Process via TSelector
   virtual Long64_t Process(TDSet *dset, TSelector *selector,
                            Option_t *option = "", Long64_t nentries = -1,
                            Long64_t firstentry = 0);
   virtual Long64_t Process(TFileCollection *fc, TSelector *selector,
                            Option_t *option = "", Long64_t nentries = -1,
                            Long64_t firstentry = 0);
   virtual Long64_t Process(const char *dsetname, TSelector *selector,
                            Option_t *option = "", Long64_t nentries = -1,
                            Long64_t firstentry = 0, TObject *enl = 0);
   virtual Long64_t Process(TSelector *selector, Long64_t nentries,
                            Option_t *option = "");

   virtual Long64_t DrawSelect(TDSet *dset, const char *varexp,
                          const char *selection = "",
                          Option_t *option = "", Long64_t nentries = -1,
                          Long64_t firstentry = 0);
   Long64_t    DrawSelect(const char *dsetname, const char *varexp,
                          const char *selection = "",
                          Option_t *option = "", Long64_t nentries = -1,
                          Long64_t firstentry = 0, TObject *enl = 0);
   Int_t       Archive(Int_t query, const char *url);
   Int_t       Archive(const char *queryref, const char *url = 0);
   Int_t       CleanupSession(const char *sessiontag);
   Long64_t    Finalize(Int_t query = -1, Bool_t force = kFALSE);
   Long64_t    Finalize(const char *queryref, Bool_t force = kFALSE);
   Int_t       Remove(Int_t query, Bool_t all = kFALSE);
   Int_t       Remove(const char *queryref, Bool_t all = kFALSE);
   Int_t       Retrieve(Int_t query, const char *path = 0);
   Int_t       Retrieve(const char *queryref, const char *path = 0);

   void        DisableGoAsyn();
   void        GoAsynchronous();
   void        StopProcess(Bool_t abort, Int_t timeout = -1);
   void        Browse(TBrowser *b);

   virtual Int_t Echo(const TObject *obj);
   virtual Int_t Echo(const char *str);

   Int_t       SetParallel(Int_t nodes = -1, Bool_t random = kFALSE);
   void        SetLogLevel(Int_t level, UInt_t mask = TProofDebug::kAll);

   void        Close(Option_t *option="");
   virtual void Print(Option_t *option="") const;

   //-- cache and package management
   virtual void  ShowCache(Bool_t all = kFALSE);
   virtual void  ClearCache(const char *file = 0);
   TList        *GetListOfPackages();
   TList        *GetListOfEnabledPackages();
   void          ShowPackages(Bool_t all = kFALSE, Bool_t redirlog = kFALSE);
   void          ShowEnabledPackages(Bool_t all = kFALSE);
   Int_t         ClearPackages();
   Int_t         ClearPackage(const char *package);
   Int_t         DownloadPackage(const char *par, const char *dstdir = 0);
   Int_t         EnablePackage(const char *package, Bool_t notOnClient = kFALSE, TList *workers = 0);
   Int_t         EnablePackage(const char *package, const char *loadopts,
                               Bool_t notOnClient = kFALSE, TList *workers = 0);
   Int_t         EnablePackage(const char *package, TList *loadopts,
                               Bool_t notOnClient = kFALSE, TList *workers = 0);
   Int_t         UploadPackage(const char *par, EUploadPackageOpt opt = kUntar, TList *workers = 0);
   virtual Int_t Load(const char *macro, Bool_t notOnClient = kFALSE, Bool_t uniqueOnly = kTRUE,
                      TList *wrks = 0);

   Int_t       AddDynamicPath(const char *libpath, Bool_t onClient = kFALSE, TList *wrks = 0, Bool_t doCollect = kTRUE);
   Int_t       AddIncludePath(const char *incpath, Bool_t onClient = kFALSE, TList *wrks = 0, Bool_t doCollect = kTRUE);
   Int_t       RemoveDynamicPath(const char *libpath, Bool_t onClient = kFALSE);
   Int_t       RemoveIncludePath(const char *incpath, Bool_t onClient = kFALSE);

   //-- dataset management
   Int_t       UploadDataSet(const char *, TList *, const char * = 0, Int_t = 0, TList * = 0);
   Int_t       UploadDataSet(const char *, const char *, const char * = 0, Int_t = 0, TList * = 0);
   Int_t       UploadDataSetFromFile(const char *, const char *, const char * = 0, Int_t = 0, TList * = 0);
   virtual Bool_t  RegisterDataSet(const char *name,
                               TFileCollection *dataset, const char* optStr = "");
   virtual TMap *GetDataSets(const char *uri = "", const char* optStr = "");
   virtual void  ShowDataSets(const char *uri = "", const char* optStr = "");

   TMap       *GetDataSetQuota(const char* optStr = "");
   void        ShowDataSetQuota(Option_t* opt = 0);

   virtual Bool_t ExistsDataSet(const char *dataset);
   void           ShowDataSet(const char *dataset = "", const char* opt = "filter:SsCc");
   virtual Int_t  RemoveDataSet(const char *dataset, const char* optStr = "");
   virtual Int_t  VerifyDataSet(const char *dataset, const char* optStr = "");
   virtual TFileCollection *GetDataSet(const char *dataset, const char* optStr = "");
   TList         *FindDataSets(const char *searchString, const char* optStr = "");
   virtual Bool_t RequestStagingDataSet(const char *dataset);
   virtual TFileCollection *GetStagingStatusDataSet(const char *dataset);
   virtual void   ShowStagingStatusDataSet(const char *dataset, const char *optStr = "filter:SsCc");
   virtual Bool_t CancelStagingDataSet(const char *dataset);

   virtual Int_t SetDataSetTreeName( const char *dataset, const char *treename);

   virtual void ShowDataSetCache(const char *dataset = 0);
   virtual void ClearDataSetCache(const char *dataset = 0);

   virtual void ShowData();
   void         ClearData(UInt_t what = kUnregistered, const char *dsname = 0);

   const char *GetMaster() const { return fMaster; }
   const char *GetConfDir() const { return fConfDir; }
   const char *GetConfFile() const { return fConfFile; }
   const char *GetUser() const { return fUrl.GetUser(); }
   const char *GetGroup() const { return fGroup; }
   const char *GetWorkDir() const { return fWorkDir; }
   const char *GetSessionTag() const { return GetName(); }
   const char *GetImage() const { return fImage; }
   const char *GetUrl() { return fUrl.GetUrl(); }
   Int_t       GetPort() const { return fUrl.GetPort(); }
   Int_t       GetRemoteProtocol() const { return fProtocol; }
   Int_t       GetClientProtocol() const { return kPROOF_Protocol; }
   Int_t       GetStatus() const { return fStatus; }
   Int_t       GetLogLevel() const { return fLogLevel; }
   Int_t       GetParallel() const;
   Int_t       GetSeqNum() const { return fSeqNum; }
   Int_t       GetSessionID() const { return fSessionID; }
   TList      *GetListOfSlaveInfos();
   Bool_t      UseDynamicStartup() const { return fDynamicStartup; }

   EQueryMode  GetQueryMode(Option_t *mode = 0) const;
   void        SetQueryMode(EQueryMode mode);

   void        SetRealTimeLog(Bool_t on = kTRUE);

   void        GetStatistics(Bool_t verbose = kFALSE);
   Long64_t    GetBytesRead() const { return fBytesRead; }
   Float_t     GetRealTime() const { return fRealTime; }
   Float_t     GetCpuTime() const { return fCpuTime; }

   Bool_t      IsLite() const { return (fServType == TProofMgr::kProofLite) ? kTRUE : kFALSE; }
   Bool_t      IsProofd() const { return (fServType == TProofMgr::kProofd) ? kTRUE : kFALSE; }
   Bool_t      IsFolder() const { return kTRUE; }
   Bool_t      IsMaster() const { return fMasterServ; }
   Bool_t      IsValid() const { return fValid; }
   Bool_t      IsTty() const { return fTty; }
   Bool_t      IsParallel() const { return GetParallel() > 0 ? kTRUE : kFALSE; }
   Bool_t      IsIdle() const { return (fNotIdle <= 0) ? kTRUE : kFALSE; }
   Bool_t      IsWaiting() const { return fIsWaiting; }

   ERunStatus  GetRunStatus() const { return fRunStatus; }
   TList      *GetLoadedMacros() const { return fLoadedMacros; }

   //-- input list parameter handling
   void        SetParameter(const char *par, const char *value);
   void        SetParameter(const char *par, Int_t value);
   void        SetParameter(const char *par, Long_t value);
   void        SetParameter(const char *par, Long64_t value);
   void        SetParameter(const char *par, Double_t value);
   TObject    *GetParameter(const char *par) const;
   void        DeleteParameters(const char *wildcard);
   void        ShowParameters(const char *wildcard = "PROOF_*") const;

   void        AddInput(TObject *obj);
   void        ClearInput();
   TList      *GetInputList();
   TObject    *GetOutput(const char *name);
   TList      *GetOutputList();
   static TObject *GetOutput(const char *name, TList *out);

   void        ShowMissingFiles(TQueryResult *qr = 0);
   TFileCollection *GetMissingFiles(TQueryResult *qr = 0);

   void        AddInputData(TObject *obj, Bool_t push = kFALSE);
   void        SetInputDataFile(const char *datafile);
   void        ClearInputData(TObject *obj = 0);
   void        ClearInputData(const char *name);

   void        AddFeedback(const char *name);
   void        RemoveFeedback(const char *name);
   void        ClearFeedback();
   void        ShowFeedback() const;
   TList      *GetFeedbackList() const;

   virtual TList *GetListOfQueries(Option_t *opt = "");
   Int_t       GetNumberOfQueries();
   Int_t       GetNumberOfDrawQueries() { return fDrawQueries; }
   TList      *GetQueryResults();
   TQueryResult *GetQueryResult(const char *ref = 0);
   void        GetMaxQueries();
   void        SetMaxDrawQueries(Int_t max);
   void        ShowQueries(Option_t *opt = "");

   Bool_t      IsDataReady(Long64_t &totalbytes, Long64_t &bytesready);

   void        SetActive(Bool_t /*active*/ = kTRUE) { }

   void        LogMessage(const char *msg, Bool_t all); //*SIGNAL*
   void        Progress(Long64_t total, Long64_t processed); //*SIGNAL*
   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(Long64_t total, Long64_t processed, Long64_t bytesread,
                        Float_t initTime, Float_t procTime,
                        Float_t evtrti, Float_t mbrti,
                        Int_t actw, Int_t tses, Float_t eses); // *SIGNAL*
   void        Feedback(TList *objs); //*SIGNAL*
   void        QueryResultReady(const char *ref); //*SIGNAL*
   void        CloseProgressDialog(); //*SIGNAL*
   void        ResetProgressDialog(const char *sel, Int_t sz,
                                   Long64_t fst, Long64_t ent); //*SIGNAL*
   void        StartupMessage(const char *msg, Bool_t status, Int_t done,
                              Int_t total); //*SIGNAL*
   void        DataSetStatus(const char *msg, Bool_t status,
                             Int_t done, Int_t total); //*SIGNAL*

   void        SendDataSetStatus(const char *msg, UInt_t n, UInt_t tot, Bool_t st);

   void        GetLog(Int_t start = -1, Int_t end = -1);
   TMacro     *GetLastLog();
   void        PutLog(TQueryResult *qr);
   void        ShowLog(Int_t qry = -1);
   void        ShowLog(const char *queryref);
   Bool_t      SendingLogToWindow() const { return fLogToWindowOnly; }
   void        SendLogToWindow(Bool_t mode) { fLogToWindowOnly = mode; }

   TMacro     *GetMacroLog() { return &fMacroLog; }

   void        ResetProgressDialogStatus() { fProgressDialogStarted = kFALSE; }

   virtual TTree *GetTreeHeader(TDSet *tdset);
   TList      *GetOutputNames();

   void        AddChain(TChain *chain);
   void        RemoveChain(TChain *chain);

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

   void        Detach(Option_t *opt = "");

   virtual void SetAlias(const char *alias="");

   TProofMgr  *GetManager() { return fManager; }
   void        SetManager(TProofMgr *mgr);

   Int_t       ActivateWorker(const char *ord, Bool_t save = kTRUE);
   Int_t       DeactivateWorker(const char *ord, Bool_t save = kTRUE);

   const char *GetDataPoolUrl() const { return fManager ? fManager->GetMssUrl() : 0; }
   void        SetDataPoolUrl(const char *url) { if (fManager) fManager->SetMssUrl(url); }

   void        SetPrintProgress(PrintProgress_t pp) { fPrintProgress = pp; }

   void        SetProgressDialog(Bool_t on = kTRUE);

   // Enable the performance tree
   Int_t       SavePerfTree(const char *pf = 0, const char *qref = 0);
   void        SetPerfTree(const char *pf = "perftree.root", Bool_t withWrks = kFALSE);

   // Opening and managing PROOF connections
   static TProof       *Open(const char *url = 0, const char *conffile = 0,
                             const char *confdir = 0, Int_t loglevel = 0);
   static void          LogViewer(const char *url = 0, Int_t sessionidx = 0);
   static TProofMgr    *Mgr(const char *url);
   static void          Reset(const char *url, Bool_t hard = kFALSE);

   static void          AddEnvVar(const char *name, const char *value);
   static void          DelEnvVar(const char *name);
   static const TList  *GetEnvVars();
   static void          ResetEnvVars();

   // Input/output list utilities
   static Int_t         GetParameter(TCollection *c, const char *par, TString &value);
   static Int_t         GetParameter(TCollection *c, const char *par, Int_t &value);
   static Int_t         GetParameter(TCollection *c, const char *par, Long_t &value);
   static Int_t         GetParameter(TCollection *c, const char *par, Long64_t &value);
   static Int_t         GetParameter(TCollection *c, const char *par, Double_t &value);

   ClassDef(TProof,0)  //PROOF control class
};

// Global object with default PROOF session
R__EXTERN TProof *gProof;

#endif
 TProof.h:1
 TProof.h:2
 TProof.h:3
 TProof.h:4
 TProof.h:5
 TProof.h:6
 TProof.h:7
 TProof.h:8
 TProof.h:9
 TProof.h:10
 TProof.h:11
 TProof.h:12
 TProof.h:13
 TProof.h:14
 TProof.h:15
 TProof.h:16
 TProof.h:17
 TProof.h:18
 TProof.h:19
 TProof.h:20
 TProof.h:21
 TProof.h:22
 TProof.h:23
 TProof.h:24
 TProof.h:25
 TProof.h:26
 TProof.h:27
 TProof.h:28
 TProof.h:29
 TProof.h:30
 TProof.h:31
 TProof.h:32
 TProof.h:33
 TProof.h:34
 TProof.h:35
 TProof.h:36
 TProof.h:37
 TProof.h:38
 TProof.h:39
 TProof.h:40
 TProof.h:41
 TProof.h:42
 TProof.h:43
 TProof.h:44
 TProof.h:45
 TProof.h:46
 TProof.h:47
 TProof.h:48
 TProof.h:49
 TProof.h:50
 TProof.h:51
 TProof.h:52
 TProof.h:53
 TProof.h:54
 TProof.h:55
 TProof.h:56
 TProof.h:57
 TProof.h:58
 TProof.h:59
 TProof.h:60
 TProof.h:61
 TProof.h:62
 TProof.h:63
 TProof.h:64
 TProof.h:65
 TProof.h:66
 TProof.h:67
 TProof.h:68
 TProof.h:69
 TProof.h:70
 TProof.h:71
 TProof.h:72
 TProof.h:73
 TProof.h:74
 TProof.h:75
 TProof.h:76
 TProof.h:77
 TProof.h:78
 TProof.h:79
 TProof.h:80
 TProof.h:81
 TProof.h:82
 TProof.h:83
 TProof.h:84
 TProof.h:85
 TProof.h:86
 TProof.h:87
 TProof.h:88
 TProof.h:89
 TProof.h:90
 TProof.h:91
 TProof.h:92
 TProof.h:93
 TProof.h:94
 TProof.h:95
 TProof.h:96
 TProof.h:97
 TProof.h:98
 TProof.h:99
 TProof.h:100
 TProof.h:101
 TProof.h:102
 TProof.h:103
 TProof.h:104
 TProof.h:105
 TProof.h:106
 TProof.h:107
 TProof.h:108
 TProof.h:109
 TProof.h:110
 TProof.h:111
 TProof.h:112
 TProof.h:113
 TProof.h:114
 TProof.h:115
 TProof.h:116
 TProof.h:117
 TProof.h:118
 TProof.h:119
 TProof.h:120
 TProof.h:121
 TProof.h:122
 TProof.h:123
 TProof.h:124
 TProof.h:125
 TProof.h:126
 TProof.h:127
 TProof.h:128
 TProof.h:129
 TProof.h:130
 TProof.h:131
 TProof.h:132
 TProof.h:133
 TProof.h:134
 TProof.h:135
 TProof.h:136
 TProof.h:137
 TProof.h:138
 TProof.h:139
 TProof.h:140
 TProof.h:141
 TProof.h:142
 TProof.h:143
 TProof.h:144
 TProof.h:145
 TProof.h:146
 TProof.h:147
 TProof.h:148
 TProof.h:149
 TProof.h:150
 TProof.h:151
 TProof.h:152
 TProof.h:153
 TProof.h:154
 TProof.h:155
 TProof.h:156
 TProof.h:157
 TProof.h:158
 TProof.h:159
 TProof.h:160
 TProof.h:161
 TProof.h:162
 TProof.h:163
 TProof.h:164
 TProof.h:165
 TProof.h:166
 TProof.h:167
 TProof.h:168
 TProof.h:169
 TProof.h:170
 TProof.h:171
 TProof.h:172
 TProof.h:173
 TProof.h:174
 TProof.h:175
 TProof.h:176
 TProof.h:177
 TProof.h:178
 TProof.h:179
 TProof.h:180
 TProof.h:181
 TProof.h:182
 TProof.h:183
 TProof.h:184
 TProof.h:185
 TProof.h:186
 TProof.h:187
 TProof.h:188
 TProof.h:189
 TProof.h:190
 TProof.h:191
 TProof.h:192
 TProof.h:193
 TProof.h:194
 TProof.h:195
 TProof.h:196
 TProof.h:197
 TProof.h:198
 TProof.h:199
 TProof.h:200
 TProof.h:201
 TProof.h:202
 TProof.h:203
 TProof.h:204
 TProof.h:205
 TProof.h:206
 TProof.h:207
 TProof.h:208
 TProof.h:209
 TProof.h:210
 TProof.h:211
 TProof.h:212
 TProof.h:213
 TProof.h:214
 TProof.h:215
 TProof.h:216
 TProof.h:217
 TProof.h:218
 TProof.h:219
 TProof.h:220
 TProof.h:221
 TProof.h:222
 TProof.h:223
 TProof.h:224
 TProof.h:225
 TProof.h:226
 TProof.h:227
 TProof.h:228
 TProof.h:229
 TProof.h:230
 TProof.h:231
 TProof.h:232
 TProof.h:233
 TProof.h:234
 TProof.h:235
 TProof.h:236
 TProof.h:237
 TProof.h:238
 TProof.h:239
 TProof.h:240
 TProof.h:241
 TProof.h:242
 TProof.h:243
 TProof.h:244
 TProof.h:245
 TProof.h:246
 TProof.h:247
 TProof.h:248
 TProof.h:249
 TProof.h:250
 TProof.h:251
 TProof.h:252
 TProof.h:253
 TProof.h:254
 TProof.h:255
 TProof.h:256
 TProof.h:257
 TProof.h:258
 TProof.h:259
 TProof.h:260
 TProof.h:261
 TProof.h:262
 TProof.h:263
 TProof.h:264
 TProof.h:265
 TProof.h:266
 TProof.h:267
 TProof.h:268
 TProof.h:269
 TProof.h:270
 TProof.h:271
 TProof.h:272
 TProof.h:273
 TProof.h:274
 TProof.h:275
 TProof.h:276
 TProof.h:277
 TProof.h:278
 TProof.h:279
 TProof.h:280
 TProof.h:281
 TProof.h:282
 TProof.h:283
 TProof.h:284
 TProof.h:285
 TProof.h:286
 TProof.h:287
 TProof.h:288
 TProof.h:289
 TProof.h:290
 TProof.h:291
 TProof.h:292
 TProof.h:293
 TProof.h:294
 TProof.h:295
 TProof.h:296
 TProof.h:297
 TProof.h:298
 TProof.h:299
 TProof.h:300
 TProof.h:301
 TProof.h:302
 TProof.h:303
 TProof.h:304
 TProof.h:305
 TProof.h:306
 TProof.h:307
 TProof.h:308
 TProof.h:309
 TProof.h:310
 TProof.h:311
 TProof.h:312
 TProof.h:313
 TProof.h:314
 TProof.h:315
 TProof.h:316
 TProof.h:317
 TProof.h:318
 TProof.h:319
 TProof.h:320
 TProof.h:321
 TProof.h:322
 TProof.h:323
 TProof.h:324
 TProof.h:325
 TProof.h:326
 TProof.h:327
 TProof.h:328
 TProof.h:329
 TProof.h:330
 TProof.h:331
 TProof.h:332
 TProof.h:333
 TProof.h:334
 TProof.h:335
 TProof.h:336
 TProof.h:337
 TProof.h:338
 TProof.h:339
 TProof.h:340
 TProof.h:341
 TProof.h:342
 TProof.h:343
 TProof.h:344
 TProof.h:345
 TProof.h:346
 TProof.h:347
 TProof.h:348
 TProof.h:349
 TProof.h:350
 TProof.h:351
 TProof.h:352
 TProof.h:353
 TProof.h:354
 TProof.h:355
 TProof.h:356
 TProof.h:357
 TProof.h:358
 TProof.h:359
 TProof.h:360
 TProof.h:361
 TProof.h:362
 TProof.h:363
 TProof.h:364
 TProof.h:365
 TProof.h:366
 TProof.h:367
 TProof.h:368
 TProof.h:369
 TProof.h:370
 TProof.h:371
 TProof.h:372
 TProof.h:373
 TProof.h:374
 TProof.h:375
 TProof.h:376
 TProof.h:377
 TProof.h:378
 TProof.h:379
 TProof.h:380
 TProof.h:381
 TProof.h:382
 TProof.h:383
 TProof.h:384
 TProof.h:385
 TProof.h:386
 TProof.h:387
 TProof.h:388
 TProof.h:389
 TProof.h:390
 TProof.h:391
 TProof.h:392
 TProof.h:393
 TProof.h:394
 TProof.h:395
 TProof.h:396
 TProof.h:397
 TProof.h:398
 TProof.h:399
 TProof.h:400
 TProof.h:401
 TProof.h:402
 TProof.h:403
 TProof.h:404
 TProof.h:405
 TProof.h:406
 TProof.h:407
 TProof.h:408
 TProof.h:409
 TProof.h:410
 TProof.h:411
 TProof.h:412
 TProof.h:413
 TProof.h:414
 TProof.h:415
 TProof.h:416
 TProof.h:417
 TProof.h:418
 TProof.h:419
 TProof.h:420
 TProof.h:421
 TProof.h:422
 TProof.h:423
 TProof.h:424
 TProof.h:425
 TProof.h:426
 TProof.h:427
 TProof.h:428
 TProof.h:429
 TProof.h:430
 TProof.h:431
 TProof.h:432
 TProof.h:433
 TProof.h:434
 TProof.h:435
 TProof.h:436
 TProof.h:437
 TProof.h:438
 TProof.h:439
 TProof.h:440
 TProof.h:441
 TProof.h:442
 TProof.h:443
 TProof.h:444
 TProof.h:445
 TProof.h:446
 TProof.h:447
 TProof.h:448
 TProof.h:449
 TProof.h:450
 TProof.h:451
 TProof.h:452
 TProof.h:453
 TProof.h:454
 TProof.h:455
 TProof.h:456
 TProof.h:457
 TProof.h:458
 TProof.h:459
 TProof.h:460
 TProof.h:461
 TProof.h:462
 TProof.h:463
 TProof.h:464
 TProof.h:465
 TProof.h:466
 TProof.h:467
 TProof.h:468
 TProof.h:469
 TProof.h:470
 TProof.h:471
 TProof.h:472
 TProof.h:473
 TProof.h:474
 TProof.h:475
 TProof.h:476
 TProof.h:477
 TProof.h:478
 TProof.h:479
 TProof.h:480
 TProof.h:481
 TProof.h:482
 TProof.h:483
 TProof.h:484
 TProof.h:485
 TProof.h:486
 TProof.h:487
 TProof.h:488
 TProof.h:489
 TProof.h:490
 TProof.h:491
 TProof.h:492
 TProof.h:493
 TProof.h:494
 TProof.h:495
 TProof.h:496
 TProof.h:497
 TProof.h:498
 TProof.h:499
 TProof.h:500
 TProof.h:501
 TProof.h:502
 TProof.h:503
 TProof.h:504
 TProof.h:505
 TProof.h:506
 TProof.h:507
 TProof.h:508
 TProof.h:509
 TProof.h:510
 TProof.h:511
 TProof.h:512
 TProof.h:513
 TProof.h:514
 TProof.h:515
 TProof.h:516
 TProof.h:517
 TProof.h:518
 TProof.h:519
 TProof.h:520
 TProof.h:521
 TProof.h:522
 TProof.h:523
 TProof.h:524
 TProof.h:525
 TProof.h:526
 TProof.h:527
 TProof.h:528
 TProof.h:529
 TProof.h:530
 TProof.h:531
 TProof.h:532
 TProof.h:533
 TProof.h:534
 TProof.h:535
 TProof.h:536
 TProof.h:537
 TProof.h:538
 TProof.h:539
 TProof.h:540
 TProof.h:541
 TProof.h:542
 TProof.h:543
 TProof.h:544
 TProof.h:545
 TProof.h:546
 TProof.h:547
 TProof.h:548
 TProof.h:549
 TProof.h:550
 TProof.h:551
 TProof.h:552
 TProof.h:553
 TProof.h:554
 TProof.h:555
 TProof.h:556
 TProof.h:557
 TProof.h:558
 TProof.h:559
 TProof.h:560
 TProof.h:561
 TProof.h:562
 TProof.h:563
 TProof.h:564
 TProof.h:565
 TProof.h:566
 TProof.h:567
 TProof.h:568
 TProof.h:569
 TProof.h:570
 TProof.h:571
 TProof.h:572
 TProof.h:573
 TProof.h:574
 TProof.h:575
 TProof.h:576
 TProof.h:577
 TProof.h:578
 TProof.h:579
 TProof.h:580
 TProof.h:581
 TProof.h:582
 TProof.h:583
 TProof.h:584
 TProof.h:585
 TProof.h:586
 TProof.h:587
 TProof.h:588
 TProof.h:589
 TProof.h:590
 TProof.h:591
 TProof.h:592
 TProof.h:593
 TProof.h:594
 TProof.h:595
 TProof.h:596
 TProof.h:597
 TProof.h:598
 TProof.h:599
 TProof.h:600
 TProof.h:601
 TProof.h:602
 TProof.h:603
 TProof.h:604
 TProof.h:605
 TProof.h:606
 TProof.h:607
 TProof.h:608
 TProof.h:609
 TProof.h:610
 TProof.h:611
 TProof.h:612
 TProof.h:613
 TProof.h:614
 TProof.h:615
 TProof.h:616
 TProof.h:617
 TProof.h:618
 TProof.h:619
 TProof.h:620
 TProof.h:621
 TProof.h:622
 TProof.h:623
 TProof.h:624
 TProof.h:625
 TProof.h:626
 TProof.h:627
 TProof.h:628
 TProof.h:629
 TProof.h:630
 TProof.h:631
 TProof.h:632
 TProof.h:633
 TProof.h:634
 TProof.h:635
 TProof.h:636
 TProof.h:637
 TProof.h:638
 TProof.h:639
 TProof.h:640
 TProof.h:641
 TProof.h:642
 TProof.h:643
 TProof.h:644
 TProof.h:645
 TProof.h:646
 TProof.h:647
 TProof.h:648
 TProof.h:649
 TProof.h:650
 TProof.h:651
 TProof.h:652
 TProof.h:653
 TProof.h:654
 TProof.h:655
 TProof.h:656
 TProof.h:657
 TProof.h:658
 TProof.h:659
 TProof.h:660
 TProof.h:661
 TProof.h:662
 TProof.h:663
 TProof.h:664
 TProof.h:665
 TProof.h:666
 TProof.h:667
 TProof.h:668
 TProof.h:669
 TProof.h:670
 TProof.h:671
 TProof.h:672
 TProof.h:673
 TProof.h:674
 TProof.h:675
 TProof.h:676
 TProof.h:677
 TProof.h:678
 TProof.h:679
 TProof.h:680
 TProof.h:681
 TProof.h:682
 TProof.h:683
 TProof.h:684
 TProof.h:685
 TProof.h:686
 TProof.h:687
 TProof.h:688
 TProof.h:689
 TProof.h:690
 TProof.h:691
 TProof.h:692
 TProof.h:693
 TProof.h:694
 TProof.h:695
 TProof.h:696
 TProof.h:697
 TProof.h:698
 TProof.h:699
 TProof.h:700
 TProof.h:701
 TProof.h:702
 TProof.h:703
 TProof.h:704
 TProof.h:705
 TProof.h:706
 TProof.h:707
 TProof.h:708
 TProof.h:709
 TProof.h:710
 TProof.h:711
 TProof.h:712
 TProof.h:713
 TProof.h:714
 TProof.h:715
 TProof.h:716
 TProof.h:717
 TProof.h:718
 TProof.h:719
 TProof.h:720
 TProof.h:721
 TProof.h:722
 TProof.h:723
 TProof.h:724
 TProof.h:725
 TProof.h:726
 TProof.h:727
 TProof.h:728
 TProof.h:729
 TProof.h:730
 TProof.h:731
 TProof.h:732
 TProof.h:733
 TProof.h:734
 TProof.h:735
 TProof.h:736
 TProof.h:737
 TProof.h:738
 TProof.h:739
 TProof.h:740
 TProof.h:741
 TProof.h:742
 TProof.h:743
 TProof.h:744
 TProof.h:745
 TProof.h:746
 TProof.h:747
 TProof.h:748
 TProof.h:749
 TProof.h:750
 TProof.h:751
 TProof.h:752
 TProof.h:753
 TProof.h:754
 TProof.h:755
 TProof.h:756
 TProof.h:757
 TProof.h:758
 TProof.h:759
 TProof.h:760
 TProof.h:761
 TProof.h:762
 TProof.h:763
 TProof.h:764
 TProof.h:765
 TProof.h:766
 TProof.h:767
 TProof.h:768
 TProof.h:769
 TProof.h:770
 TProof.h:771
 TProof.h:772
 TProof.h:773
 TProof.h:774
 TProof.h:775
 TProof.h:776
 TProof.h:777
 TProof.h:778
 TProof.h:779
 TProof.h:780
 TProof.h:781
 TProof.h:782
 TProof.h:783
 TProof.h:784
 TProof.h:785
 TProof.h:786
 TProof.h:787
 TProof.h:788
 TProof.h:789
 TProof.h:790
 TProof.h:791
 TProof.h:792
 TProof.h:793
 TProof.h:794
 TProof.h:795
 TProof.h:796
 TProof.h:797
 TProof.h:798
 TProof.h:799
 TProof.h:800
 TProof.h:801
 TProof.h:802
 TProof.h:803
 TProof.h:804
 TProof.h:805
 TProof.h:806
 TProof.h:807
 TProof.h:808
 TProof.h:809
 TProof.h:810
 TProof.h:811
 TProof.h:812
 TProof.h:813
 TProof.h:814
 TProof.h:815
 TProof.h:816
 TProof.h:817
 TProof.h:818
 TProof.h:819
 TProof.h:820
 TProof.h:821
 TProof.h:822
 TProof.h:823
 TProof.h:824
 TProof.h:825
 TProof.h:826
 TProof.h:827
 TProof.h:828
 TProof.h:829
 TProof.h:830
 TProof.h:831
 TProof.h:832
 TProof.h:833
 TProof.h:834
 TProof.h:835
 TProof.h:836
 TProof.h:837
 TProof.h:838
 TProof.h:839
 TProof.h:840
 TProof.h:841
 TProof.h:842
 TProof.h:843
 TProof.h:844
 TProof.h:845
 TProof.h:846
 TProof.h:847
 TProof.h:848
 TProof.h:849
 TProof.h:850
 TProof.h:851
 TProof.h:852
 TProof.h:853
 TProof.h:854
 TProof.h:855
 TProof.h:856
 TProof.h:857
 TProof.h:858
 TProof.h:859
 TProof.h:860
 TProof.h:861
 TProof.h:862
 TProof.h:863
 TProof.h:864
 TProof.h:865
 TProof.h:866
 TProof.h:867
 TProof.h:868
 TProof.h:869
 TProof.h:870
 TProof.h:871
 TProof.h:872
 TProof.h:873
 TProof.h:874
 TProof.h:875
 TProof.h:876
 TProof.h:877
 TProof.h:878
 TProof.h:879
 TProof.h:880
 TProof.h:881
 TProof.h:882
 TProof.h:883
 TProof.h:884
 TProof.h:885
 TProof.h:886
 TProof.h:887
 TProof.h:888
 TProof.h:889
 TProof.h:890
 TProof.h:891
 TProof.h:892
 TProof.h:893
 TProof.h:894
 TProof.h:895
 TProof.h:896
 TProof.h:897
 TProof.h:898
 TProof.h:899
 TProof.h:900
 TProof.h:901
 TProof.h:902
 TProof.h:903
 TProof.h:904
 TProof.h:905
 TProof.h:906
 TProof.h:907
 TProof.h:908
 TProof.h:909
 TProof.h:910
 TProof.h:911
 TProof.h:912
 TProof.h:913
 TProof.h:914
 TProof.h:915
 TProof.h:916
 TProof.h:917
 TProof.h:918
 TProof.h:919
 TProof.h:920
 TProof.h:921
 TProof.h:922
 TProof.h:923
 TProof.h:924
 TProof.h:925
 TProof.h:926
 TProof.h:927
 TProof.h:928
 TProof.h:929
 TProof.h:930
 TProof.h:931
 TProof.h:932
 TProof.h:933
 TProof.h:934
 TProof.h:935
 TProof.h:936
 TProof.h:937
 TProof.h:938
 TProof.h:939
 TProof.h:940
 TProof.h:941
 TProof.h:942
 TProof.h:943
 TProof.h:944
 TProof.h:945
 TProof.h:946
 TProof.h:947
 TProof.h:948
 TProof.h:949
 TProof.h:950
 TProof.h:951
 TProof.h:952
 TProof.h:953
 TProof.h:954
 TProof.h:955
 TProof.h:956
 TProof.h:957
 TProof.h:958
 TProof.h:959
 TProof.h:960
 TProof.h:961
 TProof.h:962
 TProof.h:963
 TProof.h:964
 TProof.h:965
 TProof.h:966
 TProof.h:967
 TProof.h:968
 TProof.h:969
 TProof.h:970
 TProof.h:971
 TProof.h:972
 TProof.h:973
 TProof.h:974
 TProof.h:975
 TProof.h:976
 TProof.h:977
 TProof.h:978
 TProof.h:979
 TProof.h:980
 TProof.h:981
 TProof.h:982
 TProof.h:983
 TProof.h:984
 TProof.h:985
 TProof.h:986
 TProof.h:987
 TProof.h:988
 TProof.h:989
 TProof.h:990
 TProof.h:991
 TProof.h:992
 TProof.h:993
 TProof.h:994
 TProof.h:995
 TProof.h:996
 TProof.h:997
 TProof.h:998
 TProof.h:999
 TProof.h:1000
 TProof.h:1001
 TProof.h:1002
 TProof.h:1003
 TProof.h:1004
 TProof.h:1005
 TProof.h:1006
 TProof.h:1007
 TProof.h:1008
 TProof.h:1009
 TProof.h:1010
 TProof.h:1011
 TProof.h:1012
 TProof.h:1013
 TProof.h:1014
 TProof.h:1015
 TProof.h:1016
 TProof.h:1017
 TProof.h:1018
 TProof.h:1019
 TProof.h:1020
 TProof.h:1021
 TProof.h:1022
 TProof.h:1023
 TProof.h:1024
 TProof.h:1025
 TProof.h:1026
 TProof.h:1027
 TProof.h:1028
 TProof.h:1029
 TProof.h:1030
 TProof.h:1031
 TProof.h:1032
 TProof.h:1033
 TProof.h:1034
 TProof.h:1035
 TProof.h:1036
 TProof.h:1037
 TProof.h:1038
 TProof.h:1039
 TProof.h:1040
 TProof.h:1041
 TProof.h:1042
 TProof.h:1043
 TProof.h:1044
 TProof.h:1045
 TProof.h:1046
 TProof.h:1047
 TProof.h:1048
 TProof.h:1049
 TProof.h:1050
 TProof.h:1051
 TProof.h:1052
 TProof.h:1053
 TProof.h:1054
 TProof.h:1055
 TProof.h:1056
 TProof.h:1057
 TProof.h:1058
 TProof.h:1059
 TProof.h:1060
 TProof.h:1061
 TProof.h:1062
 TProof.h:1063
 TProof.h:1064
 TProof.h:1065
 TProof.h:1066
 TProof.h:1067
 TProof.h:1068
 TProof.h:1069
 TProof.h:1070
 TProof.h:1071
 TProof.h:1072
 TProof.h:1073
 TProof.h:1074
 TProof.h:1075
 TProof.h:1076
 TProof.h:1077
 TProof.h:1078
 TProof.h:1079
 TProof.h:1080
 TProof.h:1081
 TProof.h:1082
 TProof.h:1083
 TProof.h:1084
 TProof.h:1085
 TProof.h:1086
 TProof.h:1087
 TProof.h:1088
 TProof.h:1089
 TProof.h:1090
 TProof.h:1091
 TProof.h:1092
 TProof.h:1093
 TProof.h:1094
 TProof.h:1095
 TProof.h:1096
 TProof.h:1097
 TProof.h:1098
 TProof.h:1099
 TProof.h:1100
 TProof.h:1101
 TProof.h:1102
 TProof.h:1103
 TProof.h:1104
 TProof.h:1105
 TProof.h:1106
 TProof.h:1107
 TProof.h:1108
 TProof.h:1109
 TProof.h:1110
 TProof.h:1111
 TProof.h:1112
 TProof.h:1113
 TProof.h:1114
 TProof.h:1115
 TProof.h:1116
 TProof.h:1117
 TProof.h:1118
 TProof.h:1119
 TProof.h:1120