ROOT logo
// @(#)root/proof:$Id: TProof.cxx 31744 2009-12-09 19:15:19Z brun $
// 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.             *
 *************************************************************************/

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// 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.                   //
//                                                                      //
//////////////////////////////////////////////////////////////////////////

#include <stdlib.h>
#include <fcntl.h>
#include <errno.h>
#ifdef WIN32
#   include <io.h>
#   include <sys/stat.h>
#   include <sys/types.h>
#   include "snprintf.h"
#else
#   include <unistd.h>
#endif
#include <vector>

#include "RConfigure.h"
#include "Riostream.h"
#include "Getline.h"
#include "TBrowser.h"
#include "TChain.h"
#include "TCondor.h"
#include "TDSet.h"
#include "TError.h"
#include "TEnv.h"
#include "TEventList.h"
#include "TFile.h"
#include "TFileInfo.h"
#include "TFTP.h"
#include "THashList.h"
#include "TInterpreter.h"
#include "TKey.h"
#include "TMap.h"
#include "TMath.h"
#include "TMessage.h"
#include "TMonitor.h"
#include "TMutex.h"
#include "TObjArray.h"
#include "TObjString.h"
#include "TParameter.h"
#include "TProof.h"
#include "TProofNodeInfo.h"
#include "TVirtualProofPlayer.h"
#include "TVirtualPacketizer.h"
#include "TProofServ.h"
#include "TPluginManager.h"
#include "TQueryResult.h"
#include "TRandom.h"
#include "TRegexp.h"
#include "TROOT.h"
#include "TSemaphore.h"
#include "TSlave.h"
#include "TSocket.h"
#include "TSortedList.h"
#include "TSystem.h"
#include "TThread.h"
#include "TTree.h"
#include "TUrl.h"
#include "TFileCollection.h"
#include "TDataSetManager.h"

TProof *gProof = 0;
TVirtualMutex *gProofMutex = 0;

// Rotating indicator
char TProofMergePrg::fgCr[4] = {'-', '\\', '|', '/'};

TList   *TProof::fgProofEnvList = 0;  // List of env vars for proofserv
TPluginHandler *TProof::fgLogViewer = 0;      // Log viewer handler

ClassImp(TProof)

//----- PROOF Interrupt signal handler -----------------------------------------
//______________________________________________________________________________
Bool_t TProofInterruptHandler::Notify()
{
   // TProof interrupt handler.

   if (isatty(0) == 0 || isatty(1) == 0 || fProof->GetRemoteProtocol() < 22) {

      // Cannot ask the user : abort any remote processing
      fProof->StopProcess(kTRUE);

   } else {
      // Real stop or request to switch to asynchronous?
      char *a = 0;
      if (fProof->GetRemoteProtocol() < 22) {
         a = Getline("\nSwith to asynchronous mode not supported remotely:"
                     "\nEnter S/s to stop, Q/q to quit, any other key to continue: ");
      } else {
         a = Getline("\nEnter A/a to switch asynchronous, S/s to stop, Q/q to quit,"
                     " any other key to continue: ");
      }
      if (a[0] == 'Q' || a[0] == 'S' || a[0] == 'q' || a[0] == 's') {

         Info("Notify","Processing interrupt signal ... %c", a[0]);

         // Stop or abort any remote processing
         Bool_t abort = (a[0] == 'Q' || a[0] == 'q') ? kTRUE : kFALSE;
         fProof->StopProcess(abort);

      } else if ((a[0] == 'A' || a[0] == 'a') && fProof->GetRemoteProtocol() >= 22) {
         // Stop any remote processing
         fProof->GoAsynchronous();
      }
   }

   return kTRUE;
}

//----- Input handler for messages from TProofServ -----------------------------
//______________________________________________________________________________
TProofInputHandler::TProofInputHandler(TProof *p, TSocket *s)
                   : TFileHandler(s->GetDescriptor(),1),
                     fSocket(s), fProof(p)
{
   // Constructor
}

//______________________________________________________________________________
Bool_t TProofInputHandler::Notify()
{
   // Handle input

   fProof->CollectInputFrom(fSocket);
   return kTRUE;
}


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

ClassImp(TSlaveInfo)

//______________________________________________________________________________
Int_t TSlaveInfo::Compare(const TObject *obj) const
{
   // Used to sort slaveinfos by ordinal.

   if (!obj) return 1;

   const TSlaveInfo *si = dynamic_cast<const TSlaveInfo*>(obj);

   if (!si) return fOrdinal.CompareTo(obj->GetName());

   const char *myord = GetOrdinal();
   const char *otherord = si->GetOrdinal();
   while (myord && otherord) {
      Int_t myval = atoi(myord);
      Int_t otherval = atoi(otherord);
      if (myval < otherval) return 1;
      if (myval > otherval) return -1;
      myord = strchr(myord, '.');
      if (myord) myord++;
      otherord = strchr(otherord, '.');
      if (otherord) otherord++;
   }
   if (myord) return -1;
   if (otherord) return 1;
   return 0;
}

//______________________________________________________________________________
void TSlaveInfo::Print(Option_t *opt) const
{
   // Print slave info. If opt = "active" print only the active
   // slaves, if opt="notactive" print only the not active slaves,
   // if opt = "bad" print only the bad slaves, else
   // print all slaves.

   TString stat = fStatus == kActive ? "active" :
                  fStatus == kBad ? "bad" :
                  "not active";

   Bool_t newfmt = kFALSE;
   TString oo(opt);
   if (oo.Contains("N")) {
      newfmt = kTRUE;
      oo.ReplaceAll("N","");
   }
   if (oo == "active" && fStatus != kActive) return;
   if (oo == "notactive" && fStatus != kNotActive) return;
   if (oo == "bad" && fStatus != kBad) return;

   if (newfmt) {
      TString msd, si;
      if (!(fMsd.IsNull())) msd.Form("| msd: %s ", fMsd.Data());
      if (fSysInfo.fCpus > 0) {
         si.Form("| %s, %d cores, %d MB ram", fHostName.Data(),
               fSysInfo.fCpus, fSysInfo.fPhysRam);
      } else {
         si.Form("| %s", fHostName.Data());
      }
      Printf("Worker: %9s %s %s| %s", fOrdinal.Data(), si.Data(), msd.Data(), stat.Data());

   } else {
      TString msd  = fMsd.IsNull() ? "<null>" : fMsd.Data();

      cout << "Slave: "          << fOrdinal
         << "  hostname: "     << fHostName
         << "  msd: "          << msd
         << "  perf index: "   << fPerfIndex
         << "  "               << stat
         << endl;
   }
}

//______________________________________________________________________________
void TSlaveInfo::SetSysInfo(SysInfo_t si)
{
   // Setter for fSysInfo

   fSysInfo.fOS       = si.fOS;          // OS
   fSysInfo.fModel    = si.fModel;       // computer model
   fSysInfo.fCpuType  = si.fCpuType;     // type of cpu
   fSysInfo.fCpus     = si.fCpus;        // number of cpus
   fSysInfo.fCpuSpeed = si.fCpuSpeed;    // cpu speed in MHz
   fSysInfo.fBusSpeed = si.fBusSpeed;    // bus speed in MHz
   fSysInfo.fL2Cache  = si.fL2Cache;     // level 2 cache size in KB
   fSysInfo.fPhysRam  = si.fPhysRam;     // Physical RAM
}

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

//______________________________________________________________________________
static char *CollapseSlashesInPath(const char *path)
{
   // Get rid of spare slashes in a path. Returned path must be deleted[]
   // by the user.

   if (path) {
      Int_t i = 1; // current index as we go along the string
      Int_t j = 0; // current end of new path in newPath
      char *newPath = new char [strlen(path) + 1];
      newPath[0] = path[0];
      while (path[i]) {
         if (path[i] != '/' || newPath[j] != '/') {
            j++;
            newPath[j] = path[i];
         }
         i++;
      }
      if (newPath[j] != '/')
         j++;
      newPath[j] = 0; // We have to terminate the new path.
      return newPath;
   }
   return 0;
}

ClassImp(TProof)

TSemaphore    *TProof::fgSemaphore = 0;

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

//______________________________________________________________________________
TMergerInfo::~TMergerInfo()
{
   // Destructor

   // Just delete the list, the objects are owned by other list
   if (fWorkers) {
      fWorkers->SetOwner(kFALSE);
      SafeDelete(fWorkers);
   }
}
//______________________________________________________________________________
void TMergerInfo::SetMergedWorker()
{
   // Increase number of already merged workers by 1

   if (AreAllWorkersMerged())
      Error("SetMergedWorker", "all workers have been already merged before!"); 	
   else
      fMergedWorkers++;
}

//______________________________________________________________________________
void TMergerInfo::AddWorker(TSlave *sl)
{
   // Add new worker to the list of workers to be merged by this merger

   if (!fWorkers)
      fWorkers = new TList();
   if (fWorkersToMerge == fWorkers->GetSize()) {
      Error("AddWorker", "all workers have been already assigned to this merger");
      return;
   }
   fWorkers->Add(sl);
}

//______________________________________________________________________________
Bool_t TMergerInfo::AreAllWorkersMerged()
{
   // Return if merger has already merged all workers, i.e. if it has finished its merging job

   return (fWorkersToMerge == fMergedWorkers); 
}

//______________________________________________________________________________
Bool_t TMergerInfo::AreAllWorkersAssigned()
{
      // Return if the determined number of workers has been already assigned to this merger

      if (!fWorkers)
         return kFALSE;

      return (fWorkers->GetSize() == fWorkersToMerge);
}

//------------------------------------------------------------------------------
TProof::TProof(const char *masterurl, const char *conffile, const char *confdir,
               Int_t loglevel, const char *alias, TProofMgr *mgr)
       : fUrl(masterurl)
{
   // Create a PROOF environment. Starting PROOF involves either connecting
   // to a master server, which in turn will start a set of slave servers, or
   // directly starting as master server (if master = ""). Masterurl is of
   // the form: [proof[s]://]host[:port]. Conffile is the name of the config
   // file describing the remote PROOF cluster (this argument alows you to
   // describe different cluster configurations).
   // The default is proof.conf. Confdir is the directory where the config
   // file and other PROOF related files are (like motd and noproof files).
   // Loglevel is the log level (default = 1). User specified custom config
   // files will be first looked for in $HOME/.conffile.

   // Synchronize closing with actions like MarkBad
   fCloseMutex = 0;

   // This may be needed during init
   fManager = mgr;

   // Default server type
   fServType = TProofMgr::kXProofd;

   // Default query mode
   fQueryMode = kSync;

   // Parse the main URL, adjusting the missing fields and setting the relevant
   // bits
   ResetBit(TProof::kIsClient);
   ResetBit(TProof::kIsMaster);

   // Protocol and Host
   if (!masterurl || strlen(masterurl) <= 0) {
      fUrl.SetProtocol("proof");
      fUrl.SetHost("__master__");
   } else if (!(strstr(masterurl, "://"))) {
      fUrl.SetProtocol("proof");
   }

   // Port
   if (fUrl.GetPort() == TUrl(" ").GetPort())
      fUrl.SetPort(TUrl("proof:// ").GetPort());

   // User
   if (strlen(fUrl.GetUser()) <= 0) {
      // Get user logon name
      UserGroup_t *pw = gSystem->GetUserInfo();
      if (pw) {
         fUrl.SetUser(pw->fUser);
         delete pw;
      }
   }

   // Make sure to store the FQDN, so to get a solid reference for subsequent checks
   if (!strcmp(fUrl.GetHost(), "__master__"))
      fMaster = fUrl.GetHost();
   else if (!strlen(fUrl.GetHost()))
      fMaster = gSystem->GetHostByName(gSystem->HostName()).GetHostName();
   else
      fMaster = gSystem->GetHostByName(fUrl.GetHost()).GetHostName();

   // Server type
   if (strlen(fUrl.GetOptions()) > 0) {
      TString opts(fUrl.GetOptions());
      if (!(strncmp(fUrl.GetOptions(),"std",3))) {
         fServType = TProofMgr::kProofd;
         opts.Remove(0,3);
         fUrl.SetOptions(opts.Data());
      } else if (!(strncmp(fUrl.GetOptions(),"lite",4))) {
         fServType = TProofMgr::kProofLite;
         opts.Remove(0,4);
         fUrl.SetOptions(opts.Data());
      }
   }

   // Instance type
   fMasterServ = kFALSE;
   SetBit(TProof::kIsClient);
   ResetBit(TProof::kIsMaster);
   if (fMaster == "__master__") {
      fMasterServ = kTRUE;
      ResetBit(TProof::kIsClient);
      SetBit(TProof::kIsMaster);
   } else if (fMaster == "prooflite") {
      // Client and master are merged
      fMasterServ = kTRUE;
      SetBit(TProof::kIsMaster);
   }

   Init(masterurl, conffile, confdir, loglevel, alias);

   // If called by a manager, make sure it stays in last position
   // for cleaning
   if (mgr) {
      R__LOCKGUARD2(gROOTMutex);
      gROOT->GetListOfSockets()->Remove(mgr);
      gROOT->GetListOfSockets()->Add(mgr);
   }

   // Old-style server type: we add this to the list and set the global pointer
   if (IsProofd() || TestBit(TProof::kIsMaster))
      if (!gROOT->GetListOfProofs()->FindObject(this))
         gROOT->GetListOfProofs()->Add(this);

   // Still needed by the packetizers: needs to be changed
   gProof = this;
}

//______________________________________________________________________________
TProof::TProof() : fUrl(""), fServType(TProofMgr::kXProofd)
{
   // Protected constructor to be used by classes deriving from TProof
   // (they have to call Init themselves and override StartSlaves
   // appropriately).
   //
   // This constructor simply closes any previous gProof and sets gProof
   // to this instance.

   fValid = kFALSE;
   fRecvMessages = 0;
   fSlaveInfo = 0;
   fMasterServ = kFALSE;
   fSendGroupView = kFALSE;
   fActiveSlaves = 0;
   fInactiveSlaves = 0;
   fUniqueSlaves = 0;
   fAllUniqueSlaves = 0;
   fNonUniqueMasters = 0;
   fActiveMonitor = 0;
   fUniqueMonitor = 0;
   fAllUniqueMonitor = 0;
   fCurrentMonitor = 0;
   fBytesRead = 0;
   fRealTime = 0;
   fCpuTime = 0;
   fIntHandler = 0;
   fProgressDialog = 0;
   fProgressDialogStarted = kFALSE;
   fPlayer = 0;
   fFeedback = 0;
   fChains = 0;
   fDSet = 0;
   fNotIdle = 0;
   fSync = kTRUE;
   fRunStatus = kRunning;
   fIsWaiting = kFALSE;
   fRedirLog = kFALSE;
   fLogFileW = 0;
   fLogFileR = 0;
   fLogToWindowOnly = kFALSE;

   fWaitingSlaves = 0;
   fQueries = 0;
   fOtherQueries = 0;
   fDrawQueries = 0;
   fMaxDrawQueries = 1;
   fSeqNum = 0;

   fSessionID = -1;
   fEndMaster = kFALSE;

   fGlobalPackageDirList = 0;
   fPackageLock = 0;
   fEnabledPackagesOnClient = 0;

   fInputData = 0;

   fPrintProgress = 0;

   fLoadedMacros = 0;

   fProtocol = -1;
   fSlaves = 0;
   fBadSlaves = 0;
   fAllMonitor = 0;
   fDataReady = kFALSE;
   fBytesReady = 0;
   fTotalBytes = 0;
   fAvailablePackages = 0;
   fEnabledPackages = 0;
   fRunningDSets = 0;

   fCollectTimeout = -1;

   fManager = 0;
   fQueryMode = kSync;
   fDynamicStartup = kFALSE;

   fCloseMutex = 0;

   fMergersSet = kFALSE;
   fMergers = 0;
   fMergersCount = -1;
   fLastAssignedMerger = 0;
   fWorkersToMerge = 0;
   fFinalizationRunning = kFALSE;

   if (!gROOT->GetListOfProofs()->FindObject(this))
      gROOT->GetListOfProofs()->Add(this);

   gProof = this;
}

//______________________________________________________________________________
TProof::~TProof()
{
   // Clean up PROOF environment.

   if (fChains) {
      while (TChain *chain = dynamic_cast<TChain*> (fChains->First()) ) {
         // remove "chain" from list
         chain->SetProof(0);
         RemoveChain(chain);
      }
   }

   // remove links to packages enabled on the client
   if (TestBit(TProof::kIsClient)) {
      // iterate over all packages
      TIter nextpackage(fEnabledPackagesOnClient);
      while (TObjString *package = dynamic_cast<TObjString*>(nextpackage())) {
         FileStat_t stat;
         gSystem->GetPathInfo(package->String(), stat);
         // check if symlink, if so unlink
         // NOTE: GetPathInfo() returns 1 in case of symlink that does not point to
         // existing file or to a directory, but if fIsLink is true the symlink exists
         if (stat.fIsLink)
            gSystem->Unlink(package->String());
      }
   }

   Close();
   SafeDelete(fIntHandler);
   SafeDelete(fSlaves);
   SafeDelete(fActiveSlaves);
   SafeDelete(fInactiveSlaves);
   SafeDelete(fUniqueSlaves);
   SafeDelete(fAllUniqueSlaves);
   SafeDelete(fNonUniqueMasters);
   SafeDelete(fBadSlaves);
   SafeDelete(fAllMonitor);
   SafeDelete(fActiveMonitor);
   SafeDelete(fUniqueMonitor);
   SafeDelete(fAllUniqueMonitor);
   SafeDelete(fSlaveInfo);
   SafeDelete(fChains);
   SafeDelete(fPlayer);
   SafeDelete(fFeedback);
   SafeDelete(fWaitingSlaves);
   SafeDelete(fAvailablePackages);
   SafeDelete(fEnabledPackages);
   SafeDelete(fEnabledPackagesOnClient);
   SafeDelete(fLoadedMacros);
   SafeDelete(fPackageLock);
   SafeDelete(fGlobalPackageDirList);
   SafeDelete(fRecvMessages);
   SafeDelete(fInputData);
   SafeDelete(fRunningDSets);
   SafeDelete(fCloseMutex);

   // remove file with redirected logs
   if (TestBit(TProof::kIsClient)) {
      if (fLogFileR)
         fclose(fLogFileR);
      if (fLogFileW)
         fclose(fLogFileW);
      if (fLogFileName.Length() > 0)
         gSystem->Unlink(fLogFileName);
   }

   // Remove for the global list
   gROOT->GetListOfProofs()->Remove(this);
   // ... and from the manager list
   if (fManager && fManager->IsValid())
      fManager->DiscardSession(this);

   if (gProof && gProof == this) {
      // Set previous as default
      TIter pvp(gROOT->GetListOfProofs(), kIterBackward);
      while ((gProof = (TProof *)pvp())) {
         if (gProof->InheritsFrom("TProof"))
            break;
      }
   }

   // For those interested in our destruction ...
   Emit("~TProof()");
}

//______________________________________________________________________________
Int_t TProof::Init(const char *, const char *conffile,
                   const char *confdir, Int_t loglevel, const char *alias)
{
   // Start the PROOF environment. Starting PROOF involves either connecting
   // to a master server, which in turn will start a set of slave servers, or
   // directly starting as master server (if master = ""). For a description
   // of the arguments see the TProof ctor. Returns the number of started
   // master or slave servers, returns 0 in case of error, in which case
   // fValid remains false.

   R__ASSERT(gSystem);

   fValid = kFALSE;

   // If in attach mode, options is filled with additiona info
   Bool_t attach = kFALSE;
   if (strlen(fUrl.GetOptions()) > 0) {
      attach = kTRUE;
      // A flag from the GUI
      TString opts = fUrl.GetOptions();
      if (opts.Contains("GUI")) {
         SetBit(TProof::kUsingSessionGui);
         opts.Remove(opts.Index("GUI"));
         fUrl.SetOptions(opts);
      }
   }

   if (TestBit(TProof::kIsMaster)) {
      // Fill default conf file and conf dir
      if (!conffile || strlen(conffile) == 0)
         fConfFile = kPROOF_ConfFile;
      if (!confdir  || strlen(confdir) == 0)
         fConfDir  = kPROOF_ConfDir;
      // The group; the client receives it in the kPROOF_SESSIONTAG message
      if (gProofServ) fGroup = gProofServ->GetGroup();
   } else {
      fConfDir     = confdir;
      fConfFile    = conffile;
   }

   // Analysise the conffile field
   ParseConfigField(fConfFile);

   fWorkDir        = gSystem->WorkingDirectory();
   fLogLevel       = loglevel;
   fProtocol       = kPROOF_Protocol;
   fSendGroupView  = kTRUE;
   fImage          = fMasterServ ? "" : "<local>";
   fIntHandler     = 0;
   fStatus         = 0;
   fRecvMessages   = new TList;
   fRecvMessages->SetOwner(kTRUE);
   fSlaveInfo      = 0;
   fChains         = new TList;
   fAvailablePackages = 0;
   fEnabledPackages = 0;
   fRunningDSets   = 0;
   fEndMaster      = TestBit(TProof::kIsMaster) ? kTRUE : kFALSE;
   fInputData      = 0;
   ResetBit(TProof::kNewInputData);
   fPrintProgress  = 0;

   // Timeout for some collect actions
   fCollectTimeout = gEnv->GetValue("Proof.CollectTimeout", -1);

   // Should the workers be started dynamically; default: no
   fDynamicStartup = gEnv->GetValue("Proof.DynamicStartup", kFALSE);

   // Default entry point for the data pool is the master
   if (TestBit(TProof::kIsClient))
      fDataPoolUrl.Form("root://%s", fMaster.Data());
   else
      fDataPoolUrl = "";

   fProgressDialog        = 0;
   fProgressDialogStarted = kFALSE;

   // Default alias is the master name
   TString      al = (alias) ? alias : fMaster.Data();
   SetAlias(al);

   // Client logging of messages from the master and slaves
   fRedirLog = kFALSE;
   if (TestBit(TProof::kIsClient)) {
      fLogFileName.Form("%s/ProofLog_%d", gSystem->TempDirectory(), gSystem->GetPid());
      if ((fLogFileW = fopen(fLogFileName, "w")) == 0)
         Error("Init", "could not create temporary logfile");
      if ((fLogFileR = fopen(fLogFileName, "r")) == 0)
         Error("Init", "could not open temp logfile for reading");
   }
   fLogToWindowOnly = kFALSE;

   // Status of cluster
   fNotIdle = 0;
   // Query type
   fSync = (attach) ? kFALSE : kTRUE;
   // Not enqueued
   fIsWaiting = kFALSE;

   // Counters
   fBytesRead = 0;
   fRealTime = 0;
   fCpuTime = 0;

   // List of queries
   fQueries = 0;
   fOtherQueries = 0;
   fDrawQueries = 0;
   fMaxDrawQueries = 1;
   fSeqNum = 0;

   // Remote ID of the session
   fSessionID = -1;

   // Part of active query
   fWaitingSlaves = 0;

   // Make remote PROOF player
   fPlayer = 0;
   MakePlayer();

   fFeedback = new TList;
   fFeedback->SetOwner();
   fFeedback->SetName("FeedbackList");
   AddInput(fFeedback);

   // sort slaves by descending performance index
   fSlaves           = new TSortedList(kSortDescending);
   fActiveSlaves     = new TList;
   fInactiveSlaves   = new TList;
   fUniqueSlaves     = new TList;
   fAllUniqueSlaves  = new TList;
   fNonUniqueMasters = new TList;
   fBadSlaves        = new TList;
   fAllMonitor       = new TMonitor;
   fActiveMonitor    = new TMonitor;
   fUniqueMonitor    = new TMonitor;
   fAllUniqueMonitor = new TMonitor;
   fCurrentMonitor   = 0;

   fPackageLock             = 0;
   fEnabledPackagesOnClient = 0;
   fLoadedMacros            = 0;
   fGlobalPackageDirList    = 0;

   // Enable optimized sending of streamer infos to use embedded backward/forward
   // compatibility support between different ROOT versions and different versions of
   // users classes
   Bool_t enableSchemaEvolution = gEnv->GetValue("Proof.SchemaEvolution",1);
   if (enableSchemaEvolution) {
      TMessage::EnableSchemaEvolutionForAll();
   } else {
      Info("TProof", "automatic schema evolution in TMessage explicitely disabled");
   }

   if (IsMaster()) {
      // to make UploadPackage() method work on the master as well.
      fPackageDir = gProofServ->GetPackageDir();
   } else {

      TString sandbox = gEnv->GetValue("Proof.Sandbox", "");
      if (sandbox.IsNull()) {
         sandbox.Form("~/%s", kPROOF_WorkDir);
      }
      gSystem->ExpandPathName(sandbox);
      if (AssertPath(sandbox, kTRUE) != 0) {
         Error("Init", "failure asserting directory %s", sandbox.Data());
         return 0;
      }

      // Package Dir
      fPackageDir = gEnv->GetValue("Proof.PackageDir", "");
      if (fPackageDir.IsNull())
         fPackageDir.Form("%s/%s", sandbox.Data(), kPROOF_PackDir);
      if (AssertPath(fPackageDir, kTRUE) != 0) {
         Error("Init", "failure asserting directory %s", fPackageDir.Data());
         return 0;
      }
   }

   if (!IsMaster()) {
      // List of directories where to look for global packages
      TString globpack = gEnv->GetValue("Proof.GlobalPackageDirs","");
      if (globpack.Length() > 0) {
         Int_t ng = 0;
         Int_t from = 0;
         TString ldir;
         while (globpack.Tokenize(ldir, from, ":")) {
            if (gSystem->AccessPathName(ldir, kReadPermission)) {
               Warning("Init", "directory for global packages %s does not"
                               " exist or is not readable", ldir.Data());
            } else {
               // Add to the list, key will be "G<ng>", i.e. "G0", "G1", ...
               TString key = Form("G%d", ng++);
               if (!fGlobalPackageDirList) {
                  fGlobalPackageDirList = new THashList();
                  fGlobalPackageDirList->SetOwner();
               }
               fGlobalPackageDirList->Add(new TNamed(key,ldir));
            }
         }
      }

      TString lockpath(fPackageDir);
      lockpath.ReplaceAll("/", "%");
      lockpath.Insert(0, Form("%s/%s", gSystem->TempDirectory(), kPROOF_PackageLockFile));
      fPackageLock = new TProofLockPath(lockpath.Data());

      fEnabledPackagesOnClient = new TList;
      fEnabledPackagesOnClient->SetOwner();
   }

   // Master may want dynamic startup
   if (fDynamicStartup) {
      if (!IsMaster()) {
         // If on client - start the master
         if (!StartSlaves(attach))
            return 0;
      }
   } else {

      // Master Only mode (for operations requiring only the master, e.g. dataset browsing,
      // result retrieving, ...)
      Bool_t masterOnly = gEnv->GetValue("Proof.MasterOnly", kFALSE);
      if (!IsMaster() || !masterOnly) {
         // Start slaves (the old, static, per-session way)
         if (!StartSlaves(attach))
            return 0;
      }
   }

   if (fgSemaphore)
      SafeDelete(fgSemaphore);

   // we are now properly initialized
   fValid = kTRUE;

   // De-activate monitor (will be activated in Collect)
   fAllMonitor->DeActivateAll();

   // By default go into parallel mode
   GoParallel(9999, attach);

   // Send relevant initial state to slaves
   if (!attach)
      SendInitialState();
   else if (!IsIdle())
      // redirect log
      fRedirLog = kTRUE;

   // Done at this point, the alias will be communicated to the coordinator, if any
   if (TestBit(TProof::kIsClient))
      SetAlias(al);

   SetActive(kFALSE);

   if (IsValid()) {

      // Activate input handler
      ActivateAsyncInput();

      R__LOCKGUARD2(gROOTMutex);
      gROOT->GetListOfSockets()->Add(this);
   }
   return fActiveSlaves->GetSize();
}

//______________________________________________________________________________
void TProof::ParseConfigField(const char *config)
{
   // The config file field may contain special instructions which need to be
   // parsed at the beginning, e.g. for debug runs with valgrind.

   TString sconf(config);

   // Analysise the field
   const char *cq = (IsLite()) ? "\"" : "";
   Int_t ivg = kNPOS;
   if ((ivg = sconf.Index("valgrind")) != kNPOS) {
      Int_t jvg = sconf.Index(',', ivg);
      Int_t lvg = (jvg != kNPOS) ? (jvg-ivg) : sconf.Length();
      TString vgconf = sconf(ivg, lvg);
      // Any existing valgrind setting? User can give full settings, which we fully respect,
      // or pass additional options for valgrind by prefixing 'valgrind_opts:'. For example,
      //    TProof::AddEnvVar("PROOF_MASTER_WRAPPERCMD", "valgrind_opts:--time-stamp --leak-check=full"
      // will add option "--time-stamp --leak-check=full" to our default options
      TString mst, wrk, all;
      TList *envs = fgProofEnvList;
      TNamed *n = 0;
      if (envs) {
         if ((n = (TNamed *) envs->FindObject("PROOF_WRAPPERCMD")))
            all = n->GetTitle();
         if ((n = (TNamed *) envs->FindObject("PROOF_MASTER_WRAPPERCMD")))
            mst = n->GetTitle();
         if ((n = (TNamed *) envs->FindObject("PROOF_SLAVE_WRAPPERCMD")))
            wrk = n->GetTitle();
      }
      if (all != "" && mst == "") mst = all;
      if (all != "" && wrk == "") wrk = all;
      if (all != "" && all.BeginsWith("valgrind_opts:")) {
         // The field is used to add an option Reset the setting
         Info("ParseConfigField","valgrind run: resetting 'PROOF_WRAPPERCMD':"
                                 " must be set again for next run , if any");
         TProof::DelEnvVar("PROOF_WRAPPERCMD");
      }
      TString var, cmd;
      cmd.Form("%svalgrind -v --suppressions=<rootsys>/etc/valgrind-root.supp", cq);
      TString mstlab("NO"), wrklab("NO");
      if (vgconf == "valgrind" || vgconf.Contains("master")) {
         // Check if we have to add a var
         if (mst == "" || mst.BeginsWith("valgrind_opts:")) {
            mst.ReplaceAll("valgrind_opts:","");
            var.Form("%s --log-file=<logfilemst>.valgrind.log %s", cmd.Data(), mst.Data());
            TProof::AddEnvVar("PROOF_MASTER_WRAPPERCMD", var);
            mstlab = "YES";
         } else if (mst != "") {
            mstlab = "YES";
         }
      }
      if (vgconf.Contains("=workers") || vgconf.Contains("+workers")) {
         // Check if we have to add a var
         if (wrk == "" || wrk.BeginsWith("valgrind_opts:")) {
            wrk.ReplaceAll("valgrind_opts:","");
            var.Form("%s --log-file=<logfilewrk>.valgrind.log %s%s", cmd.Data(), wrk.Data(), cq);
            TProof::AddEnvVar("PROOF_SLAVE_WRAPPERCMD", var);
            TString nwrks("2");
            Int_t inw = vgconf.Index('#');
            if (inw != kNPOS) {
               nwrks = vgconf(inw+1, vgconf.Length());
               if (!nwrks.IsDigit()) nwrks = "2";
            }
            TProof::AddEnvVar("PROOF_NWORKERS", nwrks);
            wrklab = nwrks;
            // Register the additional worker log in the session file
            // (for the master is done automatically)
            TProof::AddEnvVar("PROOF_ADDITIONALLOG", "valgrind.log*");
         } else if (wrk != "") {
            wrklab = "ALL";
         }
      }
      // Increase the relevant timeouts
      if (!IsLite()) {
         TProof::AddEnvVar("PROOF_INTWAIT", "5000");
         gEnv->SetValue("Proof.SocketActivityTimeout", 6000);
      } else {
         gEnv->SetValue("ProofLite.StartupTimeOut", 5000);
      }
      // Warn for slowness
      Printf(" ");
      if (!IsLite()) {
         Printf(" ---> Starting a debug run with valgrind (master:%s, workers:%s)", mstlab.Data(), wrklab.Data());
      } else {
         Printf(" ---> Starting a debug run with valgrind (workers:%s)", wrklab.Data());
      }
      Printf(" ---> Please be patient: startup may be VERY slow ...");
      Printf(" ---> Logs will be available as special tags in the log window (from the progress dialog or TProof::LogViewer()) ");
      Printf(" ---> (Reminder: this debug run makes sense only if you are running a debug version of ROOT)");
      Printf(" ");

   } else if (sconf.BeginsWith("workers=")) {

      // Request for a given number of workers (within the max) or worker
      // startup combination:
      //      workers=5         start max 5 workers (or less, if less are assigned)
      //      workers=2x        start max 2 workers (or less, if less are assigned)
      sconf.ReplaceAll("workers=","");
      TProof::AddEnvVar("PROOF_NWORKERS", sconf);
   }
}

//______________________________________________________________________________
Int_t TProof::AssertPath(const char *inpath, Bool_t writable)
{
   // Make sure that 'path' exists; if 'writable' is kTRUE, make also sure
   // that the path is writable

   if (!inpath || strlen(inpath) <= 0) {
      Error("AssertPath", "undefined input path");
      return -1;
   }

   TString path(inpath);
   gSystem->ExpandPathName(path);

   if (gSystem->AccessPathName(path, kFileExists)) {
      if (gSystem->mkdir(path, kTRUE) != 0) {
         Error("AssertPath", "could not create path %s", path.Data());
         return -1;
      }
   }
   // It must be writable
   if (gSystem->AccessPathName(path, kWritePermission) && writable) {
      if (gSystem->Chmod(path, 0666) != 0) {
         Error("AssertPath", "could not make path %s writable", path.Data());
         return -1;
      }
   }

   // Done
   return 0;
}

//______________________________________________________________________________
void TProof::SetManager(TProofMgr *mgr)
{
   // Set manager and schedule its destruction after this for clean
   // operations.

   fManager = mgr;

   if (mgr) {
      R__LOCKGUARD2(gROOTMutex);
      gROOT->GetListOfSockets()->Remove(mgr);
      gROOT->GetListOfSockets()->Add(mgr);
   }
}

//______________________________________________________________________________
Int_t TProof::AddWorkers(TList *workerList)
{
   // Works on the master node only.
   // It starts workers on the machines in workerList and sets the paths,
   // packages and macros as on the master.
   // It is a subbstitute for StartSlaves(...)
   // The code is mostly the master part of StartSlaves,
   // with the parallel startup removed.

   if (!IsMaster()) {
      Error("AddWorkers", "AddWorkers can only be called on the master!");
      return -1;
   }

   if (!workerList || !(workerList->GetSize())) {
      Error("AddWorkers", "The list of workers should not be empty; NULL: %d",
            workerList == 0);
      return -2;
   }

   // Code taken from master part of StartSlaves with the parllel part removed

   fImage = gProofServ->GetImage();
   if (fImage.IsNull())
      fImage = Form("%s:%s", TUrl(gSystem->HostName()).GetHostFQDN(),
                    gProofServ->GetWorkDir());

   // Get all workers
   UInt_t nSlaves = workerList->GetSize();
   UInt_t nSlavesDone = 0;
   Int_t ord = 0;

   // Loop over all workers and start them

   // a list of TSlave objects for workers that are being added
   TList *addedWorkers = new TList();
   addedWorkers->SetOwner(kFALSE);
   TListIter next(workerList);
   TObject *to;
   TProofNodeInfo *worker;
   while ((to = next())) {
      // Get the next worker from the list
      worker = (TProofNodeInfo *)to;

      // Read back worker node info
      const Char_t *image = worker->GetImage().Data();
      const Char_t *workdir = worker->GetWorkDir().Data();
      Int_t perfidx = worker->GetPerfIndex();
      Int_t sport = worker->GetPort();
      if (sport == -1)
         sport = fUrl.GetPort();

      // create slave server
      TString fullord;
      if (worker->GetOrdinal().Length() > 0) {
         fullord.Form("%s.%s", gProofServ->GetOrdinal(), worker->GetOrdinal().Data());
      } else {
         fullord.Form("%s.%d", gProofServ->GetOrdinal(), ord);
      }

      // create slave server
      TUrl u(Form("%s:%d",worker->GetNodeName().Data(), sport));
      // Add group info in the password firdl, if any
      if (strlen(gProofServ->GetGroup()) > 0) {
         // Set also the user, otherwise the password is not exported
         if (strlen(u.GetUser()) <= 0)
            u.SetUser(gProofServ->GetUser());
         u.SetPasswd(gProofServ->GetGroup());
      }
      TSlave *slave = CreateSlave(u.GetUrl(), fullord, perfidx,
                                  image, workdir);

      // Add to global list (we will add to the monitor list after
      // finalizing the server startup)
      Bool_t slaveOk = kTRUE;
      if (slave->IsValid()) {
         fSlaves->Add(slave);
         addedWorkers->Add(slave);
      } else {
         slaveOk = kFALSE;
         fBadSlaves->Add(slave);
      }

      PDB(kGlobal,3)
         Info("StartSlaves", "worker on host %s created"
              " and added to list", worker->GetNodeName().Data());

      // Notify opening of connection
      nSlavesDone++;
      TMessage m(kPROOF_SERVERSTARTED);
      m << TString("Opening connections to workers") << nSlaves
        << nSlavesDone << slaveOk;
      gProofServ->GetSocket()->Send(m);

      ord++;
   } //end of the worker loop

   // Cleanup
   SafeDelete(workerList);

   nSlavesDone = 0;

   // Here we finalize the server startup: in this way the bulk
   // of remote operations are almost parallelized
   TIter nxsl(addedWorkers);
   TSlave *sl = 0;
   while ((sl = (TSlave *) nxsl())) {

      // Finalize setup of the server
      if (sl->IsValid())
          sl->SetupServ(TSlave::kSlave, 0);

      // Monitor good slaves
      Bool_t slaveOk = kTRUE;
      if (sl->IsValid()) {
         fAllMonitor->Add(sl->GetSocket());
      } else {
         slaveOk = kFALSE;
         fBadSlaves->Add(sl);
      }

      // Notify end of startup operations
      nSlavesDone++;
      TMessage m(kPROOF_SERVERSTARTED);
      m << TString("Setting up worker servers") << nSlaves
        << nSlavesDone << slaveOk;
      gProofServ->GetSocket()->Send(m);
   }

   // Now set new state on the added workers (on all workers for simplicity)
   // use fEnabledPackages, fLoadedMacros,
   // gSystem->GetDynamicPath() and gSystem->GetIncludePath()
   // no need to load packages that are only loaded and not enabled (dyn mode)

   SetParallel(99999, 0);

   TList *tmpEnabledPackages = gProofServ->GetEnabledPackages();

   if (tmpEnabledPackages && tmpEnabledPackages->GetSize() > 0) {
      TIter nxp(tmpEnabledPackages);
      TObjString *os = 0;
      while ((os = (TObjString *) nxp())) {
         // Upload and Enable methods are intelligent and avoid
         // re-uploading or re-enabling of a package to a node that has it.
         UploadPackage(os->GetName());
         EnablePackage(os->GetName(), kTRUE);
      }
   }


   if (fLoadedMacros) {
      TIter nxp(fLoadedMacros);
      TObjString *os = 0;
      while ((os = (TObjString *) nxp())) {
         Printf("Loading a macro : %s", os->GetName());
         Load(os->GetName(), kTRUE, kTRUE, addedWorkers);
      }
   }

   TString dyn = gSystem->GetDynamicPath();
   dyn.ReplaceAll(":", " ");
   dyn.ReplaceAll("\"", " ");
   AddDynamicPath(dyn, addedWorkers);
   TString inc = gSystem->GetIncludePath();
   inc.ReplaceAll("-I", " ");
   inc.ReplaceAll("\"", " ");
   AddIncludePath(inc, addedWorkers);

   // Cleanup
   delete addedWorkers;

   // Inform the client that the number of workers is changed
   if (fDynamicStartup && gProofServ)
      gProofServ->SendParallel(kTRUE);

   return 0;
}

//______________________________________________________________________________
Int_t TProof::RemoveWorkers(TList *workerList)
{
   // Used for shuting down the workres after a query is finished.
   // Sends each of the workers from the workerList, a kPROOF_STOP message.
   // If the workerList == 0, shutdown all the workers.

   if (!IsMaster()) {
      Error("RemoveWorkers", "RemoveWorkers can only be called on the master!");
      return -1;
   }

   fFileMap.clear(); // This could be avoided if CopyFromCache was used in SendFile

   if (!workerList) {
      // shutdown all the workers
      TIter nxsl(fSlaves);
      TSlave *sl = 0;
      while ((sl = (TSlave *) nxsl())) {
         // Shut down the worker assumig that it is not processing
         TerminateWorker(sl);
      }

   } else {
      if (!(workerList->GetSize())) {
         Error("RemoveWorkers", "The list of workers should not be empty!");
         return -2;
      }

      // Loop over all the workers and stop them
      TListIter next(workerList);
      TObject *to;
      TProofNodeInfo *worker;
      while ((to = next())) {
         TSlave *sl = 0;
         if (!strcmp(to->ClassName(), "TProofNodeInfo")) {
            // Get the next worker from the list
            worker = (TProofNodeInfo *)to;
            TIter nxsl(fSlaves);
            while ((sl = (TSlave *) nxsl())) {
               // Shut down the worker assumig that it is not processing
               if (sl->GetName() == worker->GetNodeName())
                  break;
            }
         } else if (to->InheritsFrom("TSlave")) {
            sl = (TSlave *) to;
         } else {
            Warning("RemoveWorkers","unknown object type: %s - it should be"
                  " TProofNodeInfo or inheriting from TSlave", to->ClassName());
         }
         // Shut down the worker assumig that it is not processing
         if (sl) {
            if (gDebug > 0)
               Info("RemoveWorkers","terminating worker %s", sl->GetOrdinal());
            TerminateWorker(sl);
         }
      }
   }

   // Update also the master counter
   if (gProofServ && fSlaves->GetSize() <= 0) gProofServ->ReleaseWorker("master");

   return 0;
}

//______________________________________________________________________________
Bool_t TProof::StartSlaves(Bool_t attach)
{
   // Start up PROOF slaves.

   // If this is a master server, find the config file and start slave
   // servers as specified in the config file
   if (TestBit(TProof::kIsMaster)) {

      Int_t pc = 0;
      TList *workerList = new TList;
      // Get list of workers
      if (gProofServ->GetWorkers(workerList, pc) == TProofServ::kQueryStop) {
         TString emsg("no resource currently available for this session: please retry later");
         if (gDebug > 0) Info("StartSlaves", emsg.Data());
         gProofServ->SendAsynMessage(emsg.Data());
         return kFALSE;
      }

      // Setup the workers
      if (AddWorkers(workerList) < 0)
         return kFALSE;

   } else {

      // create master server
      Printf("Starting master: opening connection ...");
      TSlave *slave = CreateSubmaster(fUrl.GetUrl(), "0", "master", 0);

      if (slave->IsValid()) {

         // Notify
         fprintf(stderr,"Starting master:"
                        " connection open: setting up server ...             \r");
         StartupMessage("Connection to master opened", kTRUE, 1, 1);

         if (!attach) {

            // Set worker interrupt handler
            slave->SetInterruptHandler(kTRUE);

            // Finalize setup of the server
            slave->SetupServ(TSlave::kMaster, fConfFile);

            if (slave->IsValid()) {

               // Notify
               Printf("Starting master: OK                                     ");
               StartupMessage("Master started", kTRUE, 1, 1);

               // check protocol compatibility
               // protocol 1 is not supported anymore
               if (fProtocol == 1) {
                  Error("StartSlaves",
                        "client and remote protocols not compatible (%d and %d)",
                        kPROOF_Protocol, fProtocol);
                  slave->Close("S");
                  delete slave;
                  return kFALSE;
               }

               fSlaves->Add(slave);
               fAllMonitor->Add(slave->GetSocket());

               // Unset worker interrupt handler
               slave->SetInterruptHandler(kFALSE);

               // Set interrupt PROOF handler from now on
               fIntHandler = new TProofInterruptHandler(this);

               // Give-up after 5 minutes
               Int_t rc = Collect(slave, 300);
               Int_t slStatus = slave->GetStatus();
               if (slStatus == -99 || slStatus == -98 || rc == 0) {
                  fSlaves->Remove(slave);
                  fAllMonitor->Remove(slave->GetSocket());
                  if (slStatus == -99)
                     Error("StartSlaves", "no resources available or problems setting up workers (check logs)");
                  else if (slStatus == -98)
                     Error("StartSlaves", "could not setup output redirection on master");
                  else
                     Error("StartSlaves", "setting up master");
                  slave->Close("S");
                  delete slave;
                  return 0;
               }

               if (!slave->IsValid()) {
                  fSlaves->Remove(slave);
                  fAllMonitor->Remove(slave->GetSocket());
                  slave->Close("S");
                  delete slave;
                  Error("StartSlaves",
                        "failed to setup connection with PROOF master server");
                  return kFALSE;
               }

               if (!gROOT->IsBatch()) {
                  if ((fProgressDialog =
                     gROOT->GetPluginManager()->FindHandler("TProofProgressDialog")))
                     if (fProgressDialog->LoadPlugin() == -1)
                        fProgressDialog = 0;
               }
            } else {
               // Notify
               Printf("Starting master: failure");
            }
         } else {

            // Notify
            Printf("Starting master: OK                                     ");
            StartupMessage("Master attached", kTRUE, 1, 1);

            if (!gROOT->IsBatch()) {
               if ((fProgressDialog =
                  gROOT->GetPluginManager()->FindHandler("TProofProgressDialog")))
                  if (fProgressDialog->LoadPlugin() == -1)
                     fProgressDialog = 0;
            }

            fSlaves->Add(slave);
            fIntHandler = new TProofInterruptHandler(this);
         }

      } else {
         delete slave;
         // Notify only if verbosity is on: most likely the failure has already been notified
         if (gDebug > 0)
            Error("StartSlaves", "failed to create (or connect to) the PROOF master server");
         return kFALSE;
      }
   }

   return kTRUE;
}

//______________________________________________________________________________
void TProof::Close(Option_t *opt)
{
   // Close all open slave servers.
   // Client can decide to shutdown the remote session by passing option is 'S'
   // or 's'. Default for clients is detach, if supported. Masters always
   // shutdown the remote counterpart.

   {  R__LOCKGUARD2(fCloseMutex);

      fValid = kFALSE;
      if (fSlaves) {
         if (fIntHandler)
            fIntHandler->Remove();

         TIter nxs(fSlaves);
         TSlave *sl = 0;
         while ((sl = (TSlave *)nxs()))
            sl->Close(opt);

         fActiveSlaves->Clear("nodelete");
         fUniqueSlaves->Clear("nodelete");
         fAllUniqueSlaves->Clear("nodelete");
         fNonUniqueMasters->Clear("nodelete");
         fBadSlaves->Clear("nodelete");
         fSlaves->Delete();
      }
   }

   {
      R__LOCKGUARD2(gROOTMutex);
      gROOT->GetListOfSockets()->Remove(this);

      if (IsProofd()) {

         gROOT->GetListOfProofs()->Remove(this);
         if (gProof && gProof == this) {
            // Set previous proofd-related as default
            TIter pvp(gROOT->GetListOfProofs(), kIterBackward);
            while ((gProof = (TProof *)pvp())) {
               if (gProof->IsProofd())
                  break;
            }
         }
      }
   }
}

//______________________________________________________________________________
TSlave *TProof::CreateSlave(const char *url, const char *ord,
                            Int_t perf, const char *image, const char *workdir)
{
   // Create a new TSlave of type TSlave::kSlave.
   // Note: creation of TSlave is private with TProof as a friend.
   // Derived classes must use this function to create slaves.

   TSlave* sl = TSlave::Create(url, ord, perf, image,
                               this, TSlave::kSlave, workdir, 0);

   if (sl->IsValid()) {
      sl->SetInputHandler(new TProofInputHandler(this, sl->GetSocket()));
      // must set fParallel to 1 for slaves since they do not
      // report their fParallel with a LOG_DONE message
      sl->fParallel = 1;
   }

   return sl;
}


//______________________________________________________________________________
TSlave *TProof::CreateSubmaster(const char *url, const char *ord,
                                const char *image, const char *msd)
{
   // Create a new TSlave of type TSlave::kMaster.
   // Note: creation of TSlave is private with TProof as a friend.
   // Derived classes must use this function to create slaves.

   TSlave *sl = TSlave::Create(url, ord, 100, image, this,
                               TSlave::kMaster, 0, msd);

   if (sl->IsValid()) {
      sl->SetInputHandler(new TProofInputHandler(this, sl->GetSocket()));
   }

   return sl;
}

//______________________________________________________________________________
TSlave *TProof::FindSlave(TSocket *s) const
{
   // Find slave that has TSocket s. Returns 0 in case slave is not found.

   TSlave *sl;
   TIter   next(fSlaves);

   while ((sl = (TSlave *)next())) {
      if (sl->IsValid() && sl->GetSocket() == s)
         return sl;
   }
   return 0;
}

//______________________________________________________________________________
void TProof::FindUniqueSlaves()
{
   // Add to the fUniqueSlave list the active slaves that have a unique
   // (user) file system image. This information is used to transfer files
   // only once to nodes that share a file system (an image). Submasters
   // which are not in fUniqueSlaves are put in the fNonUniqueMasters
   // list. That list is used to trigger the transferring of files to
   // the submaster's unique slaves without the need to transfer the file
   // to the submaster.

   fUniqueSlaves->Clear();
   fUniqueMonitor->RemoveAll();
   fAllUniqueSlaves->Clear();
   fAllUniqueMonitor->RemoveAll();
   fNonUniqueMasters->Clear();

   TIter next(fActiveSlaves);

   while (TSlave *sl = dynamic_cast<TSlave*>(next())) {
      if (fImage == sl->fImage) {
         if (sl->GetSlaveType() == TSlave::kMaster) {
            fNonUniqueMasters->Add(sl);
            fAllUniqueSlaves->Add(sl);
            fAllUniqueMonitor->Add(sl->GetSocket());
         }
         continue;
      }

      TIter next2(fUniqueSlaves);
      TSlave *replace_slave = 0;
      Bool_t add = kTRUE;
      while (TSlave *sl2 = dynamic_cast<TSlave*>(next2())) {
         if (sl->fImage == sl2->fImage) {
            add = kFALSE;
            if (sl->GetSlaveType() == TSlave::kMaster) {
               if (sl2->GetSlaveType() == TSlave::kSlave) {
                  // give preference to master
                  replace_slave = sl2;
                  add = kTRUE;
               } else if (sl2->GetSlaveType() == TSlave::kMaster) {
                  fNonUniqueMasters->Add(sl);
                  fAllUniqueSlaves->Add(sl);
                  fAllUniqueMonitor->Add(sl->GetSocket());
               } else {
                  Error("FindUniqueSlaves", "TSlave is neither Master nor Slave");
                  R__ASSERT(0);
               }
            }
            break;
         }
      }

      if (add) {
         fUniqueSlaves->Add(sl);
         fAllUniqueSlaves->Add(sl);
         fUniqueMonitor->Add(sl->GetSocket());
         fAllUniqueMonitor->Add(sl->GetSocket());
         if (replace_slave) {
            fUniqueSlaves->Remove(replace_slave);
            fAllUniqueSlaves->Remove(replace_slave);
            fUniqueMonitor->Remove(replace_slave->GetSocket());
            fAllUniqueMonitor->Remove(replace_slave->GetSocket());
         }
      }
   }

   // will be actiavted in Collect()
   fUniqueMonitor->DeActivateAll();
   fAllUniqueMonitor->DeActivateAll();
}

//______________________________________________________________________________
Int_t TProof::GetNumberOfSlaves() const
{
   // Return number of slaves as described in the config file.

   return fSlaves->GetSize();
}

//______________________________________________________________________________
Int_t TProof::GetNumberOfActiveSlaves() const
{
   // Return number of active slaves, i.e. slaves that are valid and in
   // the current computing group.

   return fActiveSlaves->GetSize();
}

//______________________________________________________________________________
Int_t TProof::GetNumberOfInactiveSlaves() const
{
   // Return number of inactive slaves, i.e. slaves that are valid but not in
   // the current computing group.

   return fInactiveSlaves->GetSize();
}

//______________________________________________________________________________
Int_t TProof::GetNumberOfUniqueSlaves() const
{
   // Return number of unique slaves, i.e. active slaves that have each a
   // unique different user files system.

   return fUniqueSlaves->GetSize();
}

//______________________________________________________________________________
Int_t TProof::GetNumberOfBadSlaves() const
{
   // Return number of bad slaves. This are slaves that we in the config
   // file, but refused to startup or that died during the PROOF session.

   return fBadSlaves->GetSize();
}

//______________________________________________________________________________
void TProof::AskStatistics()
{
   // Ask the for the statistics of the slaves.

   if (!IsValid()) return;

   Broadcast(kPROOF_GETSTATS, kActive);
   Collect(kActive, fCollectTimeout);
}

//______________________________________________________________________________
void TProof::AskParallel()
{
   // Ask the for the number of parallel slaves.

   if (!IsValid()) return;

   Broadcast(kPROOF_GETPARALLEL, kActive);
   Collect(kActive, fCollectTimeout);
}

//______________________________________________________________________________
TList *TProof::GetListOfQueries(Option_t *opt)
{
   // Ask the master for the list of queries.

   if (!IsValid() || TestBit(TProof::kIsMaster)) return (TList *)0;

   Bool_t all = ((strchr(opt,'A') || strchr(opt,'a'))) ? kTRUE : kFALSE;
   TMessage m(kPROOF_QUERYLIST);
   m << all;
   Broadcast(m, kActive);
   Collect(kActive, fCollectTimeout);

   // This should have been filled by now
   return fQueries;
}

//______________________________________________________________________________
Int_t TProof::GetNumberOfQueries()
{
   // Number of queries processed by this session

   if (fQueries)
      return fQueries->GetSize() - fOtherQueries;
   return 0;
}

//______________________________________________________________________________
void TProof::SetMaxDrawQueries(Int_t max)
{
   // Set max number of draw queries whose results are saved

   if (max > 0) {
      if (fPlayer)
         fPlayer->SetMaxDrawQueries(max);
      fMaxDrawQueries = max;
   }
}

//______________________________________________________________________________
void TProof::GetMaxQueries()
{
   // Get max number of queries whose full results are kept in the
   // remote sandbox

   TMessage m(kPROOF_MAXQUERIES);
   m << kFALSE;
   Broadcast(m, kActive);
   Collect(kActive, fCollectTimeout);
}

//______________________________________________________________________________
TList *TProof::GetQueryResults()
{
   // Return pointer to the list of query results in the player

   return (fPlayer ? fPlayer->GetListOfResults() : (TList *)0);
}

//______________________________________________________________________________
TQueryResult *TProof::GetQueryResult(const char *ref)
{
   // Return pointer to the full TQueryResult instance owned by the player
   // and referenced by 'ref'. If ref = 0 or "", return the last query result.

   return (fPlayer ? fPlayer->GetQueryResult(ref) : (TQueryResult *)0);
}

//______________________________________________________________________________
void TProof::ShowQueries(Option_t *opt)
{
   // Ask the master for the list of queries.
   // Options:
   //           "A"     show information about all the queries known to the
   //                   server, i.e. even those processed by other sessions
   //           "L"     show only information about queries locally available
   //                   i.e. already retrieved. If "L" is specified, "A" is
   //                   ignored.
   //           "F"     show all details available about queries
   //           "H"     print help menu
   // Default ""

   Bool_t help = ((strchr(opt,'H') || strchr(opt,'h'))) ? kTRUE : kFALSE;
   if (help) {

      // Help

      Printf("+++");
      Printf("+++ Options: \"A\" show all queries known to server");
      Printf("+++          \"L\" show retrieved queries");
      Printf("+++          \"F\" full listing of query info");
      Printf("+++          \"H\" print this menu");
      Printf("+++");
      Printf("+++ (case insensitive)");
      Printf("+++");
      Printf("+++ Use Retrieve(<#>) to retrieve the full"
             " query results from the master");
      Printf("+++     e.g. Retrieve(8)");

      Printf("+++");

      return;
   }

   if (!IsValid()) return;

   Bool_t local = ((strchr(opt,'L') || strchr(opt,'l'))) ? kTRUE : kFALSE;

   TObject *pq = 0;
   if (!local) {
      GetListOfQueries(opt);

      if (!fQueries) return;

      TIter nxq(fQueries);

      // Queries processed by other sessions
      if (fOtherQueries > 0) {
         Printf("+++");
         Printf("+++ Queries processed during other sessions: %d", fOtherQueries);
         Int_t nq = 0;
         while (nq++ < fOtherQueries && (pq = nxq()))
            pq->Print(opt);
      }

      // Queries processed by this session
      Printf("+++");
      Printf("+++ Queries processed during this session: selector: %d, draw: %d",
              GetNumberOfQueries(), fDrawQueries);
      while ((pq = nxq()))
         pq->Print(opt);

   } else {

      // Queries processed by this session
      Printf("+++");
      Printf("+++ Queries processed during this session: selector: %d, draw: %d",
              GetNumberOfQueries(), fDrawQueries);

      // Queries available locally
      TList *listlocal = fPlayer ? fPlayer->GetListOfResults() : (TList *)0;
      if (listlocal) {
         Printf("+++");
         Printf("+++ Queries available locally: %d", listlocal->GetSize());
         TIter nxlq(listlocal);
         while ((pq = nxlq()))
            pq->Print(opt);
      }
   }
   Printf("+++");
}

//______________________________________________________________________________
Bool_t TProof::IsDataReady(Long64_t &totalbytes, Long64_t &bytesready)
{
   // See if the data is ready to be analyzed.

   if (!IsValid()) return kFALSE;

   TList submasters;
   TIter nextSlave(GetListOfActiveSlaves());
   while (TSlave *sl = dynamic_cast<TSlave*>(nextSlave())) {
      if (sl->GetSlaveType() == TSlave::kMaster) {
         submasters.Add(sl);
      }
   }

   fDataReady = kTRUE; //see if any submasters set it to false
   fBytesReady = 0;
   fTotalBytes = 0;
   //loop over submasters and see if data is ready
   if (submasters.GetSize() > 0) {
      Broadcast(kPROOF_DATA_READY, &submasters);
      Collect(&submasters);
   }

   bytesready = fBytesReady;
   totalbytes = fTotalBytes;

   EmitVA("IsDataReady(Long64_t,Long64_t)", 2, totalbytes, bytesready);

   //PDB(kGlobal,2)
   Info("IsDataReady", "%lld / %lld (%s)",
        bytesready, totalbytes, fDataReady?"READY":"NOT READY");

   return fDataReady;
}

//______________________________________________________________________________
void TProof::Interrupt(EUrgent type, ESlaves list)
{
   // Send interrupt to master or slave servers.

   if (!IsValid()) return;

   TList *slaves = 0;
   if (list == kAll)       slaves = fSlaves;
   if (list == kActive)    slaves = fActiveSlaves;
   if (list == kUnique)    slaves = fUniqueSlaves;
   if (list == kAllUnique) slaves = fAllUniqueSlaves;

   if (slaves->GetSize() == 0) return;

   TSlave *sl;
   TIter   next(slaves);

   while ((sl = (TSlave *)next())) {
      if (sl->IsValid()) {

         // Ask slave to progate the interrupt request
         sl->Interrupt((Int_t)type);
      }
   }
}

//______________________________________________________________________________
Int_t TProof::GetParallel() const
{
   // Returns number of slaves active in parallel mode. Returns 0 in case
   // there are no active slaves. Returns -1 in case of error.

   if (!IsValid()) return -1;

   // iterate over active slaves and return total number of slaves
   TIter nextSlave(GetListOfActiveSlaves());
   Int_t nparallel = 0;
   while (TSlave* sl = dynamic_cast<TSlave*>(nextSlave()))
      if (sl->GetParallel() >= 0)
         nparallel += sl->GetParallel();

   return nparallel;
}

//______________________________________________________________________________
TList *TProof::GetListOfSlaveInfos()
{
   // Returns list of TSlaveInfo's. In case of error return 0.

   if (!IsValid()) return 0;

   if (fSlaveInfo == 0) {
      fSlaveInfo = new TSortedList(kSortDescending);
      fSlaveInfo->SetOwner();
   } else {
      fSlaveInfo->Delete();
   }

   TList masters;
   TIter next(GetListOfSlaves());
   TSlave *slave;

   while ((slave = (TSlave *) next()) != 0) {
      if (slave->GetSlaveType() == TSlave::kSlave) {
         TSlaveInfo *slaveinfo = new TSlaveInfo(slave->GetOrdinal(),
                                                slave->GetName(),
                                                slave->GetPerfIdx());
         fSlaveInfo->Add(slaveinfo);

         TIter nextactive(GetListOfActiveSlaves());
         TSlave *activeslave;
         while ((activeslave = (TSlave *) nextactive())) {
            if (TString(slaveinfo->GetOrdinal()) == activeslave->GetOrdinal()) {
               slaveinfo->SetStatus(TSlaveInfo::kActive);
               break;
            }
         }

         TIter nextbad(GetListOfBadSlaves());
         TSlave *badslave;
         while ((badslave = (TSlave *) nextbad())) {
            if (TString(slaveinfo->GetOrdinal()) == badslave->GetOrdinal()) {
               slaveinfo->SetStatus(TSlaveInfo::kBad);
               break;
            }
         }
         // Get system info if supported
         if (slave->IsValid()) {
            if (slave->GetSocket()->Send(kPROOF_GETSLAVEINFO) == -1)
               MarkBad(slave, "could not send kPROOF_GETSLAVEINFO message");
            else
               masters.Add(slave);
         }

      } else if (slave->GetSlaveType() == TSlave::kMaster) {
         if (slave->IsValid()) {
            if (slave->GetSocket()->Send(kPROOF_GETSLAVEINFO) == -1)
               MarkBad(slave, "could not send kPROOF_GETSLAVEINFO message");
            else
               masters.Add(slave);
         }
      } else {
         Error("GetSlaveInfo", "TSlave is neither Master nor Slave");
         R__ASSERT(0);
      }
   }
   if (masters.GetSize() > 0) Collect(&masters);

   return fSlaveInfo;
}

//______________________________________________________________________________
void TProof::Activate(TList *slaves)
{
   // Activate slave server list.

   TMonitor *mon = fAllMonitor;
   mon->DeActivateAll();

   slaves = !slaves ? fActiveSlaves : slaves;

   TIter next(slaves);
   TSlave *sl;
   while ((sl = (TSlave*) next())) {
      if (sl->IsValid())
         mon->Activate(sl->GetSocket());
   }
}

//______________________________________________________________________________
void TProof::SetMonitor(TMonitor *mon, Bool_t on)
{
   // Activate (on == TRUE) or deactivate (on == FALSE) all sockets
   // monitored by 'mon'.

   TMonitor *m = (mon) ? mon : fCurrentMonitor;
   if (m) {
      if (on)
         m->ActivateAll();
      else
         m->DeActivateAll();
   }
}

//______________________________________________________________________________
Int_t TProof::BroadcastGroupPriority(const char *grp, Int_t priority, TList *workers)
{
   // Broadcast the group priority to all workers in the specified list. Returns
   // the number of workers the message was successfully sent to.
   // Returns -1 in case of error.

   if (!IsValid()) return -1;

   if (workers->GetSize() == 0) return 0;

   int   nsent = 0;
   TIter next(workers);

   TSlave *wrk;
   while ((wrk = (TSlave *)next())) {
      if (wrk->IsValid()) {
         if (wrk->SendGroupPriority(grp, priority) == -1)
            MarkBad(wrk, "could not send group priority");
         else
            nsent++;
      }
   }

   return nsent;
}

//______________________________________________________________________________
Int_t TProof::BroadcastGroupPriority(const char *grp, Int_t priority, ESlaves list)
{
   // Broadcast the group priority to all workers in the specified list. Returns
   // the number of workers the message was successfully sent to.
   // Returns -1 in case of error.

   TList *workers = 0;
   if (list == kAll)       workers = fSlaves;
   if (list == kActive)    workers = fActiveSlaves;
   if (list == kUnique)    workers = fUniqueSlaves;
   if (list == kAllUnique) workers = fAllUniqueSlaves;

   return BroadcastGroupPriority(grp, priority, workers);
}

//______________________________________________________________________________
void TProof::ResetMergePrg()
{
   // Reset the merge progress notificator

   fMergePrg.Reset(fActiveSlaves->GetSize());
}

//______________________________________________________________________________
Int_t TProof::Broadcast(const TMessage &mess, TList *slaves)
{
   // Broadcast a message to all slaves in the specified list. Returns
   // the number of slaves the message was successfully sent to.
   // Returns -1 in case of error.

   if (!IsValid()) return -1;

   if (!slaves || slaves->GetSize() == 0) return 0;

   int   nsent = 0;
   TIter next(slaves);

   TSlave *sl;
   while ((sl = (TSlave *)next())) {
      if (sl->IsValid()) {
         if (sl->GetSocket()->Send(mess) == -1)
            MarkBad(sl, "could not broadcast request");
         else
            nsent++;
      }
   }

   return nsent;
}

//______________________________________________________________________________
Int_t TProof::Broadcast(const TMessage &mess, ESlaves list)
{
   // Broadcast a message to all slaves in the specified list (either
   // all slaves or only the active slaves). Returns the number of slaves
   // the message was successfully sent to. Returns -1 in case of error.

   TList *slaves = 0;
   if (list == kAll)       slaves = fSlaves;
   if (list == kActive)    slaves = fActiveSlaves;
   if (list == kUnique)    slaves = fUniqueSlaves;
   if (list == kAllUnique) slaves = fAllUniqueSlaves;

   return Broadcast(mess, slaves);
}

//______________________________________________________________________________
Int_t TProof::Broadcast(const char *str, Int_t kind, TList *slaves)
{
   // Broadcast a character string buffer to all slaves in the specified
   // list. Use kind to set the TMessage what field. Returns the number of
   // slaves the message was sent to. Returns -1 in case of error.

   TMessage mess(kind);
   if (str) mess.WriteString(str);
   return Broadcast(mess, slaves);
}

//______________________________________________________________________________
Int_t TProof::Broadcast(const char *str, Int_t kind, ESlaves list)
{
   // Broadcast a character string buffer to all slaves in the specified
   // list (either all slaves or only the active slaves). Use kind to
   // set the TMessage what field. Returns the number of slaves the message
   // was sent to. Returns -1 in case of error.

   TMessage mess(kind);
   if (str) mess.WriteString(str);
   return Broadcast(mess, list);
}

//______________________________________________________________________________
Int_t TProof::BroadcastObject(const TObject *obj, Int_t kind, TList *slaves)
{
   // Broadcast an object to all slaves in the specified list. Use kind to
   // set the TMEssage what field. Returns the number of slaves the message
   // was sent to. Returns -1 in case of error.

   TMessage mess(kind);
   mess.WriteObject(obj);
   return Broadcast(mess, slaves);
}

//______________________________________________________________________________
Int_t TProof::BroadcastObject(const TObject *obj, Int_t kind, ESlaves list)
{
   // Broadcast an object to all slaves in the specified list. Use kind to
   // set the TMEssage what field. Returns the number of slaves the message
   // was sent to. Returns -1 in case of error.

   TMessage mess(kind);
   mess.WriteObject(obj);
   return Broadcast(mess, list);
}

//______________________________________________________________________________
Int_t TProof::BroadcastRaw(const void *buffer, Int_t length, TList *slaves)
{
   // Broadcast a raw buffer of specified length to all slaves in the
   // specified list. Returns the number of slaves the buffer was sent to.
   // Returns -1 in case of error.

   if (!IsValid()) return -1;

   if (slaves->GetSize() == 0) return 0;

   int   nsent = 0;
   TIter next(slaves);

   TSlave *sl;
   while ((sl = (TSlave *)next())) {
      if (sl->IsValid()) {
         if (sl->GetSocket()->SendRaw(buffer, length) == -1)
            MarkBad(sl, "could not send broadcast-raw request");
         else
            nsent++;
      }
   }

   return nsent;
}

//______________________________________________________________________________
Int_t TProof::BroadcastRaw(const void *buffer, Int_t length, ESlaves list)
{
   // Broadcast a raw buffer of specified length to all slaves in the
   // specified list. Returns the number of slaves the buffer was sent to.
   // Returns -1 in case of error.

   TList *slaves = 0;
   if (list == kAll)       slaves = fSlaves;
   if (list == kActive)    slaves = fActiveSlaves;
   if (list == kUnique)    slaves = fUniqueSlaves;
   if (list == kAllUnique) slaves = fAllUniqueSlaves;

   return BroadcastRaw(buffer, length, slaves);
}

//______________________________________________________________________________
Int_t TProof::BroadcastFile(const char *file, Int_t opt, const char *rfile, TList *wrks)
{
   // Broadcast file to all workers in the specified list. Returns the number of workers
   // the buffer was sent to.
   // Returns -1 in case of error.

   if (!IsValid()) return -1;

   if (wrks->GetSize() == 0) return 0;

   int   nsent = 0;
   TIter next(wrks);

   TSlave *wrk;
   while ((wrk = (TSlave *)next())) {
      if (wrk->IsValid()) {
         if (SendFile(file, opt, rfile, wrk) < 0)
            Error("BroadcastFile",
                  "problems sending file to worker %s (%s)",
                  wrk->GetOrdinal(), wrk->GetName());
         else
            nsent++;
      }
   }

   return nsent;
}

//______________________________________________________________________________
Int_t TProof::BroadcastFile(const char *file, Int_t opt, const char *rfile, ESlaves list)
{
   // Broadcast file to all workers in the specified list. Returns the number of workers
   // the buffer was sent to.
   // Returns -1 in case of error.

   TList *wrks = 0;
   if (list == kAll)       wrks = fSlaves;
   if (list == kActive)    wrks = fActiveSlaves;
   if (list == kUnique)    wrks = fUniqueSlaves;
   if (list == kAllUnique) wrks = fAllUniqueSlaves;

   return BroadcastFile(file, opt, rfile, wrks);
}

//______________________________________________________________________________
void TProof::ReleaseMonitor(TMonitor *mon)
{
   // Release the used monitor to be used, making sure to delete newly created
   // monitors.

   if (mon && (mon != fAllMonitor) && (mon != fActiveMonitor)
           && (mon != fUniqueMonitor) && (mon != fAllUniqueMonitor)) {
      delete mon;
   }
}

//______________________________________________________________________________
Int_t TProof::Collect(const TSlave *sl, Long_t timeout, Int_t endtype)
{
   // Collect responses from slave sl. Returns the number of slaves that
   // responded (=1).
   // If timeout >= 0, wait at most timeout seconds (timeout = -1 by default,
   // which means wait forever).
   // If defined (>= 0) endtype is the message that stops this collection.

   Int_t rc = 0;

   TMonitor *mon = 0;
   if (!sl->IsValid()) return 0;

   if (fCurrentMonitor == fAllMonitor) {
      mon = new TMonitor;
   } else {
      mon = fAllMonitor;
      mon->DeActivateAll();
   }
   mon->Activate(sl->GetSocket());

   rc = Collect(mon, timeout, endtype);
   ReleaseMonitor(mon);
   return rc;
}

//______________________________________________________________________________
Int_t TProof::Collect(TList *slaves, Long_t timeout, Int_t endtype)
{
   // Collect responses from the slave servers. Returns the number of slaves
   // that responded.
   // If timeout >= 0, wait at most timeout seconds (timeout = -1 by default,
   // which means wait forever).
   // If defined (>= 0) endtype is the message that stops this collection.

   Int_t rc = 0;

   TMonitor *mon = 0;

   if (fCurrentMonitor == fAllMonitor) {
      mon = new TMonitor;
   } else {
      mon = fAllMonitor;
      mon->DeActivateAll();
   }
   TIter next(slaves);
   TSlave *sl;
   while ((sl = (TSlave*) next())) {
      if (sl->IsValid())
         mon->Activate(sl->GetSocket());
   }

   rc = Collect(mon, timeout, endtype);
   ReleaseMonitor(mon);
   return rc;
}

//______________________________________________________________________________
Int_t TProof::Collect(ESlaves list, Long_t timeout, Int_t endtype)
{
   // Collect responses from the slave servers. Returns the number of slaves
   // that responded.
   // If timeout >= 0, wait at most timeout seconds (timeout = -1 by default,
   // which means wait forever).
   // If defined (>= 0) endtype is the message that stops this collection.

   Int_t rc = 0;
   TMonitor *mon = 0;

   if (list == kAll)       mon = fAllMonitor;
   if (list == kActive)    mon = fActiveMonitor;
   if (list == kUnique)    mon = fUniqueMonitor;
   if (list == kAllUnique) mon = fAllUniqueMonitor;
   if (fCurrentMonitor == mon) {
      // Get a copy
      mon = new TMonitor(*mon);
   }
   mon->ActivateAll();

   rc = Collect(mon, timeout, endtype);
   ReleaseMonitor(mon);
   return rc;
}

//______________________________________________________________________________
Int_t TProof::Collect(TMonitor *mon, Long_t timeout, Int_t endtype)
{
   // Collect responses from the slave servers. Returns the number of messages
   // received. Can be 0 if there are no active slaves.
   // If timeout >= 0, wait at most timeout seconds (timeout = -1 by default,
   // which means wait forever).
   // If defined (>= 0) endtype is the message that stops this collection.

   // Reset the status flag and clear the messages in the list, if any
   fStatus = 0;
   fRecvMessages->Clear();

   Long_t actto = (Long_t)(gEnv->GetValue("Proof.SocketActivityTimeout", -1) * 1000);

   if (!mon->GetActive(actto)) return 0;

   DeActivateAsyncInput();

   // Used by external code to know what we are monitoring
   TMonitor *savedMonitor = 0;
   if (fCurrentMonitor) {
      savedMonitor = fCurrentMonitor;
      fCurrentMonitor = mon;
   } else {
      fCurrentMonitor = mon;
      fBytesRead = 0;
      fRealTime  = 0.0;
      fCpuTime   = 0.0;
   }

   // We want messages on the main window during synchronous collection,
   // but we save the present status to restore it at the end
   Bool_t saveRedirLog = fRedirLog;
   if (!IsIdle() && !IsSync())
      fRedirLog = kFALSE;

   int cnt = 0, rc = 0;

   // Timeout counter
   Long_t nto = timeout;
   PDB(kCollect, 2)
      Info("Collect","active: %d", mon->GetActive());

   // On clients, handle Ctrl-C during collection
   if (fIntHandler)
      fIntHandler->Add();

   // Sockets w/o activity during the last 'sto' millisecs are deactivated
   Int_t nact = 0;
   Long_t sto = -1;
   Int_t nsto = 60;
   mon->ResetInterrupt();
   while ((nact = mon->GetActive(sto)) && (nto < 0 || nto > 0)) {

      // Dump last waiting sockets, if in debug mode
      PDB(kCollect, 2) {
         if (nact < 4) {
            TList *al = mon->GetListOfActives();
            if (al && al->GetSize() > 0) {
               Info("Collect"," %d node(s) still active:", al->GetSize());
               TIter nxs(al);
               TSocket *xs = 0;
               while ((xs = (TSocket *)nxs())) {
                  TSlave *wrk = FindSlave(xs);
                  if (wrk)
                     Info("Collect","   %s", wrk->GetName());
                  else
                     Info("Collect","   %p: %s:%d", xs, xs->GetInetAddress().GetHostName(),
                                                      xs->GetInetAddress().GetPort());
               }
            }
         }
      }

      // Wait for a ready socket
      TSocket *s = mon->Select(1000);

      if (s && s != (TSocket *)(-1)) {
         // Get and analyse the info it did receive
         rc = CollectInputFrom(s, endtype);
         if (rc  == 1 || (rc == 2 && !savedMonitor)) {
            // Deactivate it if we are done with it
            mon->DeActivate(s);
            PDB(kCollect, 2)
               Info("Collect","deactivating %p (active: %d, %p)",
                              s, mon->GetActive(),
                              mon->GetListOfActives()->First());
         } else if (rc == 2) {
            // This end message was for the saved monitor
            // Deactivate it if we are done with it
            if (savedMonitor) {
               savedMonitor->DeActivate(s);
               PDB(kCollect, 2)
                  Info("Collect","save monitor: deactivating %p (active: %d, %p)",
                                 s, savedMonitor->GetActive(),
                                 savedMonitor->GetListOfActives()->First());
            }
         }

         // Update counter (if no error occured)
         if (rc >= 0)
            cnt++;
      } else {
         // If not timed-out, exit if not stopped or not aborted
         // (player exits status is finished in such a case); otherwise,
         // we still need to collect the partial output info
         if (!s)
            if (fPlayer && (fPlayer->GetExitStatus() == TVirtualProofPlayer::kFinished))
               mon->DeActivateAll();
         // Decrease the timeout counter if requested
         if (s == (TSocket *)(-1) && nto > 0)
            nto--;
      }
      // Check if we need to check the socket activity (we do it every 10 cycles ~ 10 sec)
      sto = -1;
      if (--nsto <= 0) {
         sto = (Long_t) actto;
         nsto = 60;
      }
   }

   // If timed-out, deactivate the remaining sockets
   if (nto == 0) {
      TList *al = mon->GetListOfActives();
      if (al && al->GetSize() > 0) {
         // Notify the name of those which did timeout
         Info("Collect"," %d node(s) went in timeout:", al->GetSize());
         TIter nxs(al);
         TSocket *xs = 0;
         while ((xs = (TSocket *)nxs())) {
            TSlave *wrk = FindSlave(xs);
            if (wrk)
               Info("Collect","   %s", wrk->GetName());
            else
               Info("Collect","   %p: %s:%d", xs, xs->GetInetAddress().GetHostName(),
                                                  xs->GetInetAddress().GetPort());
         }
      }
      mon->DeActivateAll();
   }

   // Deactivate Ctrl-C special handler
   if (fIntHandler)
      fIntHandler->Remove();

   // make sure group view is up to date
   SendGroupView();

   // Restore redirection setting
   fRedirLog = saveRedirLog;

   // Restore the monitor
   fCurrentMonitor = savedMonitor;

   ActivateAsyncInput();

   return cnt;
}

//______________________________________________________________________________
void TProof::CleanGDirectory(TList *ol)
{
   // Remove links to objects in list 'ol' from gDirectory

   if (ol) {
      TIter nxo(ol);
      TObject *o = 0;
      while ((o = nxo()))
         gDirectory->RecursiveRemove(o);
   }
}

//______________________________________________________________________________
Int_t TProof::CollectInputFrom(TSocket *s, Int_t endtype)
{
   // Collect and analyze available input from socket s.
   // Returns 0 on success, -1 if any failure occurs.

   TMessage *mess;

   Int_t recvrc = 0;
   if ((recvrc = s->Recv(mess)) < 0) {
      PDB(kCollect,2)
         Info("CollectInputFrom","%p: got %d from Recv()", s, recvrc);
      Bool_t bad = kTRUE;
      if (recvrc == -5) {
         // Broken connection: try reconnection
         if (fCurrentMonitor) fCurrentMonitor->Remove(s);
         if (s->Reconnect() == 0) {
            if (fCurrentMonitor) fCurrentMonitor->Add(s);
            bad = kFALSE;
         }
      }
      if (bad)
         MarkBad(s, "problems receiving a message in TProof::CollectInputFrom(...)");
      // Ignore this wake up
      return -1;
   }
   if (!mess) {
      // we get here in case the remote server died
      MarkBad(s, "undefined message in TProof::CollectInputFrom(...)");
      return -1;
   }
   Int_t rc = 0;

   Int_t what = mess->What();
   TSlave *sl = FindSlave(s);
   rc = HandleInputMessage(sl, mess);
   if (rc == 1 && (endtype >= 0) && (what != endtype))
      // This message was for the base monitor in recursive case
      rc = 2;

   // We are done successfully
   return rc;
}

//______________________________________________________________________________
Int_t TProof::HandleInputMessage(TSlave *sl, TMessage *mess)
{
   // Analyze the received message.
   // Returns 0 on success (1 if this the last message from this socket), -1 if
   // any failure occurs.

   char str[512];
   TObject *obj;
   Int_t rc = 0;

   if (!mess || !sl) {
      Warning("HandleInputMessage", "given an empty message or undefined worker");
      return -1;
   }
   Bool_t delete_mess = kTRUE;
   TSocket *s = sl->GetSocket();
   if (!s) {
      Warning("HandleInputMessage", "worker socket is undefined");
      return -1;
   }

   // The message type
   Int_t what = mess->What();

   PDB(kCollect,3)
      Info("HandleInputMessage", "got type %d from '%s'", what, sl->GetOrdinal());

   switch (what) {

      case kMESS_OK:
         // Add the message to the list
         fRecvMessages->Add(mess);
         delete_mess = kFALSE;
         break;

      case kMESS_OBJECT:
         if (fPlayer) fPlayer->HandleRecvHisto(mess);
         break;

      case kPROOF_FATAL:
         MarkBad(s, "received kPROOF_FATAL");
         if (fProgressDialogStarted) {
            // Finalize the progress dialog
            Emit("StopProcess(Bool_t)", kTRUE);
         }
         break;

      case kPROOF_STOP:
         // Stop collection from this worker
         Info("HandleInputMessage", "received kPROOF_STOP from %s: disabling any further collection this worker",
                                    (sl ? sl->GetOrdinal() : "undef"));
         rc = 1;
         break;

      case kPROOF_GETTREEHEADER:
         // Add the message to the list
         fRecvMessages->Add(mess);
         delete_mess = kFALSE;
         rc = 1;
         break;

      case kPROOF_TOUCH:
         // send a request for touching the remote admin file
         {
            sl->Touch();
         }
         break;

      case kPROOF_GETOBJECT:
         // send slave object it asks for
         mess->ReadString(str, sizeof(str));
         obj = gDirectory->Get(str);
         if (obj)
            s->SendObject(obj);
         else
            s->Send(kMESS_NOTOK);
         break;

      case kPROOF_GETPACKET:
         {
            TDSetElement *elem = 0;
            elem = fPlayer ? fPlayer->GetNextPacket(sl, mess) : 0;

            if (elem != (TDSetElement*) -1) {
               TMessage answ(kPROOF_GETPACKET);
               answ << elem;
               s->Send(answ);

               while (fWaitingSlaves != 0 && fWaitingSlaves->GetSize()) {
                  TPair *p = (TPair*) fWaitingSlaves->First();
                  s = (TSocket*) p->Key();
                  TMessage *m = (TMessage*) p->Value();

                  elem = fPlayer ? fPlayer->GetNextPacket(sl, m) : 0;
                  if (elem != (TDSetElement*) -1) {
                     TMessage a(kPROOF_GETPACKET);
                     a << elem;
                     s->Send(a);
                     // remove has to happen via Links because TPair does not have
                     // a Compare() function and therefore RemoveFirst() and
                     // Remove(TObject*) do not work
                     fWaitingSlaves->Remove(fWaitingSlaves->FirstLink());
                     delete p;
                     delete m;
                  } else {
                     break;
                  }
               }
            } else {
               if (fWaitingSlaves == 0) fWaitingSlaves = new TList;
               fWaitingSlaves->Add(new TPair(s, mess));
               delete_mess = kFALSE;
            }
         }
         break;

      case kPROOF_LOGFILE:
         {
            Int_t size;
            (*mess) >> size;
            PDB(kGlobal,2)
               Info("HandleInputMessage","kPROOF_LOGFILE: size: %d", size);
            RecvLogFile(s, size);
         }
         break;

      case kPROOF_LOGDONE:
         (*mess) >> sl->fStatus >> sl->fParallel;
         PDB(kCollect,2)
            Info("HandleInputMessage","kPROOF_LOGDONE:%s: status %d  parallel %d",
                 sl->GetOrdinal(), sl->fStatus, sl->fParallel);
         if (sl->fStatus != 0) fStatus = sl->fStatus; //return last nonzero status
         rc = 1;
         break;

      case kPROOF_GETSTATS:
         {
            (*mess) >> sl->fBytesRead >> sl->fRealTime >> sl->fCpuTime
                  >> sl->fWorkDir >> sl->fProofWorkDir;
            TString img;
            if ((mess->BufferSize() > mess->Length()))
               (*mess) >> img;
            // Set image
            if (img.IsNull()) {
               if (sl->fImage.IsNull())
                  sl->fImage = Form("%s:%s", TUrl(sl->fName).GetHostFQDN(),
                                             sl->fProofWorkDir.Data());
            } else {
               sl->fImage = img;
            }
            PDB(kGlobal,2)
               Info("HandleInputMessage",
                        "kPROOF_GETSTATS:%s image: %s", sl->GetOrdinal(), sl->GetImage());

            fBytesRead += sl->fBytesRead;
            fRealTime  += sl->fRealTime;
            fCpuTime   += sl->fCpuTime;
            rc = 1;
         }
         break;

      case kPROOF_GETPARALLEL:
         {
            Bool_t async = kFALSE;
            (*mess) >> sl->fParallel;
            if ((mess->BufferSize() > mess->Length()))
               (*mess) >> async;
            rc = (async) ? 0 : 1;
         }
         break;

      case kPROOF_CHECKFILE:
         {  // New servers (>= 5.22) send the status
            if ((mess->BufferSize() > mess->Length())) {
               (*mess) >> fCheckFileStatus;
            } else {
               // Form old servers this meant success (failure was signaled with the
               // dangerous kPROOF_FATAL)
               fCheckFileStatus = 1;
            }
            rc = 1;
         }
         break;

      case kPROOF_SENDFILE:
         {  // New server: signals ending of sendfile operation
            rc = 1;
         }
         break;

      case kPROOF_PACKAGE_LIST:
         {
            PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_PACKAGE_LIST: enter");
            Int_t type = 0;
            (*mess) >> type;
            switch (type) {
            case TProof::kListEnabledPackages:
               SafeDelete(fEnabledPackages);
               fEnabledPackages = (TList *) mess->ReadObject(TList::Class());
               if (fEnabledPackages) {
                  fEnabledPackages->SetOwner();
               } else {
                  Error("HandleInputMessage",
                        "kPROOF_PACKAGE_LIST: kListEnabledPackages: TList not found in message!");
               }
               break;
            case TProof::kListPackages:
               SafeDelete(fAvailablePackages);
               fAvailablePackages = (TList *) mess->ReadObject(TList::Class());
               if (fAvailablePackages) {
                  fAvailablePackages->SetOwner();
               } else {
                  Error("HandleInputMessage",
                        "kPROOF_PACKAGE_LIST: kListPackages: TList not found in message!");
               }
               break;
            default:
               Error("HandleInputMessage", "kPROOF_PACKAGE_LIST: unknown type: %d", type);
            }
         }
         break;

      case kPROOF_OUTPUTOBJECT:
         {
            PDB(kGlobal,2)
               Info("HandleInputMessage","kPROOF_OUTPUTOBJECT: enter");
            Int_t type = 0;
            
           if (!TestBit(TProof::kIsClient) && !fMergersSet && !fFinalizationRunning) {
               Info("HandleInputMessage","finalization on %s started ...", gProofServ->GetPrefix());
               fFinalizationRunning = kTRUE;
            }
            
            while ((mess->BufferSize() > mess->Length())) {
               (*mess) >> type;
               // If a query result header, add it to the player list
               if (fPlayer) {
                  if (type == 0) {
                     // Retrieve query result instance (output list not filled)
                     TQueryResult *pq =
                        (TQueryResult *) mess->ReadObject(TQueryResult::Class());
                     if (pq) {
                        // Add query to the result list in TProofPlayer
                        fPlayer->AddQueryResult(pq);
                        fPlayer->SetCurrentQuery(pq);
                        // And clear the output list, as we start merging a new set of results
                        if (fPlayer->GetOutputList())
                           fPlayer->GetOutputList()->Clear();
                        // Add the unique query tag as TNamed object to the input list
                        // so that it is available in TSelectors for monitoring
                        fPlayer->AddInput(new TNamed("PROOF_QueryTag",
                                          Form("%s:%s",pq->GetTitle(),pq->GetName())));
                     } else {
                        Warning("HandleInputMessage","kPROOF_OUTPUTOBJECT: query result missing");
                     }
                  } else if (type > 0) {
                     // Read object
                     TObject *o = mess->ReadObject(TObject::Class());
                     // Increment counter on the client side
                     if (gProofServ) {
                        fMergePrg.IncreaseIdx();
                        TString msg;
                        msg.Form("%s: merging output objects ... %s", gProofServ->GetPrefix(), fMergePrg.Export());
                        gProofServ->SendAsynMessage(msg.Data(), kFALSE);
                     }
                     // Add or merge it
                     if ((fPlayer->AddOutputObject(o) == 1)) {
                        // Remove the object if it has been merged
                        SafeDelete(o);
                     }
                     if (type > 1) {
                        // Update the merger progress info
                        fMergePrg.DecreaseNWrks();
                        if (TestBit(TProof::kIsClient) && !IsLite()) {
                           // In PROOFLite this has to be done once only in TProofLite::Process
                           TQueryResult *pq = fPlayer->GetCurrentQuery();
                           pq->SetOutputList(fPlayer->GetOutputList(), kFALSE);
                           pq->SetInputList(fPlayer->GetInputList(), kFALSE);
                           // If the last object, notify the GUI that the result arrived
                           QueryResultReady(Form("%s:%s", pq->GetTitle(), pq->GetName()));
                           // Processing is over
                           UpdateDialog();
                        }
                     }
                  }
               } else {
                  Warning("HandleInputMessage", "kPROOF_OUTPUTOBJECT: player undefined!");
               }
            }
         }
         break;

      case kPROOF_OUTPUTLIST:
         {
            PDB(kGlobal,2)
               Info("HandleInputMessage","kPROOF_OUTPUTLIST: enter");
            TList *out = 0;
            if (fPlayer) {
               if (TestBit(TProof::kIsMaster) || fProtocol < 7) {
                  out = (TList *) mess->ReadObject(TList::Class());
               } else {
                  TQueryResult *pq =
                     (TQueryResult *) mess->ReadObject(TQueryResult::Class());
                  if (pq) {
                     // Add query to the result list in TProofPlayer
                     fPlayer->AddQueryResult(pq);
                     fPlayer->SetCurrentQuery(pq);
                     // To avoid accidental cleanups from anywhere else
                     // remove objects from gDirectory and clone the list
                     out = pq->GetOutputList();
                     CleanGDirectory(out);
                     out = (TList *) out->Clone();
                     // Notify the GUI that the result arrived
                     QueryResultReady(Form("%s:%s", pq->GetTitle(), pq->GetName()));
                  } else {
                     PDB(kGlobal,2)
                        Info("HandleInputMessage","kPROOF_OUTPUTLIST: query result missing");
                  }
               }
               if (out) {
                  out->SetOwner();
                  fPlayer->AddOutput(out); // Incorporate the list
                  SafeDelete(out);
               } else {
                  PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_OUTPUTLIST: ouputlist is empty");
               }
            } else {
               Warning("HandleInputMessage", "kPROOF_OUTPUTLIST: player undefined!");
            }
            // On clients at this point processing is over
            if (TestBit(TProof::kIsClient) && !IsLite())
               UpdateDialog();
         }
         break;

      case kPROOF_QUERYLIST:
         {
            PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_QUERYLIST: enter");
            (*mess) >> fOtherQueries >> fDrawQueries;
            if (fQueries) {
               fQueries->Delete();
               delete fQueries;
               fQueries = 0;
            }
            fQueries = (TList *) mess->ReadObject(TList::Class());
         }
         break;

      case kPROOF_RETRIEVE:
         {
            PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_RETRIEVE: enter");
            TQueryResult *pq =
               (TQueryResult *) mess->ReadObject(TQueryResult::Class());
            if (pq && fPlayer) {
               fPlayer->AddQueryResult(pq);
               // Notify the GUI that the result arrived
               QueryResultReady(Form("%s:%s", pq->GetTitle(), pq->GetName()));
            } else {
               PDB(kGlobal,2)
                  Info("HandleInputMessage","kPROOF_RETRIEVE: query result missing or player undefined");
            }
         }
         break;

      case kPROOF_MAXQUERIES:
         {
            PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_MAXQUERIES: enter");
            Int_t max = 0;

            (*mess) >> max;
            Printf("Number of queries fully kept remotely: %d", max);
         }
         break;

      case kPROOF_SERVERSTARTED:
         {
            PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_SERVERSTARTED: enter");

            UInt_t tot = 0, done = 0;
            TString action;
            Bool_t st = kTRUE;

            (*mess) >> action >> tot >> done >> st;

            if (TestBit(TProof::kIsClient)) {
               if (tot) {
                  TString type = (action.Contains("submas")) ? "submasters"
                                                             : "workers";
                  Int_t frac = (Int_t) (done*100.)/tot;
                  char msg[512] = {0};
                  if (frac >= 100) {
                     snprintf(msg, 512, "%s: OK (%d %s)                 \n",
                             action.Data(),tot, type.Data());
                  } else {
                     snprintf(msg, 512, "%s: %d out of %d (%d %%)\r",
                             action.Data(), done, tot, frac);
                  }
                  if (fSync)
                     fprintf(stderr,"%s", msg);
                  else
                     NotifyLogMsg(msg, 0);
               }
               // Notify GUIs
               StartupMessage(action.Data(), st, (Int_t)done, (Int_t)tot);
            } else {

               // Just send the message one level up
               TMessage m(kPROOF_SERVERSTARTED);
               m << action << tot << done << st;
               gProofServ->GetSocket()->Send(m);
            }
         }
         break;

      case kPROOF_DATASET_STATUS:
         {
            PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_DATASET_STATUS: enter");

            UInt_t tot = 0, done = 0;
            TString action;
            Bool_t st = kTRUE;

            (*mess) >> action >> tot >> done >> st;

            if (TestBit(TProof::kIsClient)) {
               if (tot) {
                  TString type = "files";
                  Int_t frac = (Int_t) (done*100.)/tot;
                  char msg[512] = {0};
                  if (frac >= 100) {
                     sprintf(msg,"%s: OK (%d %s)                 \n",
                             action.Data(),tot, type.Data());
                  } else {
                     sprintf(msg,"%s: %d out of %d (%d %%)\r",
                             action.Data(), done, tot, frac);
                  }
                  if (fSync)
                     fprintf(stderr,"%s", msg);
                  else
                     NotifyLogMsg(msg, 0);
               }
               // Notify GUIs
               DataSetStatus(action.Data(), st, (Int_t)done, (Int_t)tot);
            } else {

               // Just send the message one level up
               TMessage m(kPROOF_DATASET_STATUS);
               m << action << tot << done << st;
               gProofServ->GetSocket()->Send(m);
            }
         }
         break;

      case kPROOF_STARTPROCESS:
         {
            PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_STARTPROCESS: enter");

            // For Proof-Lite this variable is the number of workers and is set
            // by the player
            if (!IsLite()) {
               fNotIdle = 1;
               fIsWaiting = kFALSE;
            }

            // Redirect the output, if needed
            fRedirLog = (fSync) ? fRedirLog : kTRUE;

            // The signal is used on masters by XrdProofdProtocol to catch
            // the start of processing; on clients it allows to update the
            // progress dialog
            if (!TestBit(TProof::kIsMaster)) {
               TString selec;
               Int_t dsz = -1;
               Long64_t first = -1, nent = -1;
               (*mess) >> selec >> dsz >> first >> nent;
               // Start or reset the progress dialog
               if (!gROOT->IsBatch()) {
                  if (fProgressDialog && !TestBit(kUsingSessionGui)) {
                     if (!fProgressDialogStarted) {
                        fProgressDialog->ExecPlugin(5, this,
                                                   selec.Data(), dsz, first, nent);
                        fProgressDialogStarted = kTRUE;
                     } else {
                        ResetProgressDialog(selec, dsz, first, nent);
                     }
                  }
                  ResetBit(kUsingSessionGui);
               }
            }
         }
         break;

      case kPROOF_ENDINIT:
         {
            PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_ENDINIT: enter");

            if (TestBit(TProof::kIsMaster)) {
               if (fPlayer)
                  fPlayer->SetInitTime();
            }
         }
         break;

      case kPROOF_SETIDLE:
         {
            PDB(kGlobal,2)
               Info("HandleInputMessage","kPROOF_SETIDLE: enter");

            // The session is idle
            if (IsLite()) {
               if (fNotIdle > 0) {
                  fNotIdle--;
               } else {
                  Warning("HandleInputMessage", "got kPROOF_SETIDLE but no running workers ! protocol error?");
               }
            } else {
               fNotIdle = 0;
               // Check if the query has been enqueued
               if ((mess->BufferSize() > mess->Length()))
                  (*mess) >> fIsWaiting;
            }
         }
         break;

      case kPROOF_QUERYSUBMITTED:
         {
            PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_QUERYSUBMITTED: enter");

            // We have received the sequential number
            (*mess) >> fSeqNum;
            Bool_t sync = fSync;
            if ((mess->BufferSize() > mess->Length()))
               (*mess) >> sync;
            if (sync !=  fSync && fSync) {
               // The server required to switch to asynchronous mode
               Activate();
               fSync = kFALSE;
            }
            DisableGoAsyn();
            // Check if the query has been enqueued
            fIsWaiting = kTRUE;
            // For Proof-Lite this variable is the number of workers and is set by the player
            if (!IsLite())
               fNotIdle = 1;

            rc = 1;
         }
         break;

      case kPROOF_SESSIONTAG:
         {
            PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_SESSIONTAG: enter");

            // We have received the unique tag and save it as name of this object
            TString stag;
            (*mess) >> stag;
            SetName(stag);
            // New servers send also the group
            if ((mess->BufferSize() > mess->Length()))
               (*mess) >> fGroup;
         }
         break;

      case kPROOF_FEEDBACK:
         {
            PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_FEEDBACK: enter");
            TList *out = (TList *) mess->ReadObject(TList::Class());
            out->SetOwner();
            if (fPlayer)
               fPlayer->StoreFeedback(sl, out); // Adopts the list
            else
               // Not yet ready: stop collect asap
               rc = 1;
         }
         break;

      case kPROOF_AUTOBIN:
         {
            PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_AUTOBIN: enter");

            TString name;
            Double_t xmin, xmax, ymin, ymax, zmin, zmax;

            (*mess) >> name >> xmin >> xmax >> ymin >> ymax >> zmin >> zmax;

            if (fPlayer) fPlayer->UpdateAutoBin(name,xmin,xmax,ymin,ymax,zmin,zmax);

            TMessage answ(kPROOF_AUTOBIN);

            answ << name << xmin << xmax << ymin << ymax << zmin << zmax;

            s->Send(answ);
         }
         break;

      case kPROOF_PROGRESS:
         {
            PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_PROGRESS: enter");

            if (GetRemoteProtocol() > 25) {
               // New format
               TProofProgressInfo *pi = 0;
               (*mess) >> pi;
               fPlayer->Progress(sl,pi);
            } else if (GetRemoteProtocol() > 11) {
               Long64_t total, processed, bytesread;
               Float_t initTime, procTime, evtrti, mbrti;
               (*mess) >> total >> processed >> bytesread
                     >> initTime >> procTime
                     >> evtrti >> mbrti;
               if (fPlayer)
                  fPlayer->Progress(sl, total, processed, bytesread,
                                    initTime, procTime, evtrti, mbrti);

            } else {
               // Old format
               Long64_t total, processed;
               (*mess) >> total >> processed;
               if (fPlayer)
                  fPlayer->Progress(sl, total, processed);
            }
         }
         break;

      case kPROOF_STOPPROCESS:
         {
            // This message is sent from a worker that finished processing.
            // We determine whether it was asked to finish by the
            // packetizer or stopped during processing a packet
            // (by TProof::RemoveWorkers() or by an external signal).
            // In the later case call packetizer->MarkBad.
            PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_STOPPROCESS: enter");

            Long64_t events = 0;
            Bool_t abort = kFALSE;
            TProofProgressStatus *status = 0;

            if ((mess->BufferSize() > mess->Length()) && (fProtocol > 18)) {
               (*mess) >> status >> abort;
            } else if ((mess->BufferSize() > mess->Length()) && (fProtocol > 8)) {
               (*mess) >> events >> abort;
            } else {
               (*mess) >> events;
            }
            if (!abort && fPlayer) {
               if (fProtocol > 18) {
                  TList *listOfMissingFiles = 0;
                  if (!(listOfMissingFiles = (TList *)GetOutput("MissingFiles"))) {
                     listOfMissingFiles = new TList();
                     listOfMissingFiles->SetName("MissingFiles");
                     if (fPlayer)
                        fPlayer->AddOutputObject(listOfMissingFiles);
                  }
                  if (fPlayer->GetPacketizer()) {
                     Int_t ret =
                        fPlayer->GetPacketizer()->AddProcessed(sl, status, 0, &listOfMissingFiles);
                     if (ret > 0)
                        fPlayer->GetPacketizer()->MarkBad(sl, status, &listOfMissingFiles);
                     // This object is now owned by the packetizer
                     status = 0;
                  }
               } else {
                  fPlayer->AddEventsProcessed(events);
               }
            }
            SafeDelete(status);
            if (!TestBit(TProof::kIsMaster))
               Emit("StopProcess(Bool_t)", abort);
            break;
         }

      case kPROOF_SUBMERGER:
         {
            PDB(kGlobal,2) Info("HandleInputMessage", "kPROOF_SUBMERGER: enter");
            HandleSubmerger(mess, sl);
         }
         break;

      case kPROOF_GETSLAVEINFO:
         {
            PDB(kGlobal,2) Info("HandleInputMessage", "kPROOF_GETSLAVEINFO: enter");

            Bool_t active = (GetListOfActiveSlaves()->FindObject(sl) != 0);
            Bool_t bad = (GetListOfBadSlaves()->FindObject(sl) != 0);
            TList* tmpinfo = 0;
            (*mess) >> tmpinfo;
            if (tmpinfo == 0) {
               Error("HandleInputMessage", "kPROOF_GETSLAVEINFO: no list received!");
            } else {
               tmpinfo->SetOwner(kFALSE);
               Int_t nentries = tmpinfo->GetSize();
               for (Int_t i=0; i<nentries; i++) {
                  TSlaveInfo* slinfo =
                     dynamic_cast<TSlaveInfo*>(tmpinfo->At(i));
                  if (slinfo) {
                     // Check if we have already a instance for this worker
                     TIter nxw(fSlaveInfo);
                     TSlaveInfo *ourwi = 0;
                     while ((ourwi = (TSlaveInfo *)nxw())) {
                        if (!strcmp(ourwi->GetOrdinal(), slinfo->GetOrdinal())) {
                           ourwi->SetSysInfo(slinfo->GetSysInfo());
                           break;
                        }
                     }
                     if (!ourwi) {
                        fSlaveInfo->Add(slinfo);
                     } else {
                        slinfo = ourwi;
                     }
                     if (slinfo->fStatus != TSlaveInfo::kBad) {
                        if (!active) slinfo->SetStatus(TSlaveInfo::kNotActive);
                        if (bad) slinfo->SetStatus(TSlaveInfo::kBad);
                     }
                     if (sl->GetMsd() && (strlen(sl->GetMsd()) > 0))
                        slinfo->fMsd = sl->GetMsd();
                  }
               }
               delete tmpinfo;
               rc = 1;
            }
         }
         break;

      case kPROOF_VALIDATE_DSET:
         {
            PDB(kGlobal,2)
               Info("HandleInputMessage", "kPROOF_VALIDATE_DSET: enter");
            TDSet* dset = 0;
            (*mess) >> dset;
            if (!fDSet)
               Error("HandleInputMessage", "kPROOF_VALIDATE_DSET: fDSet not set");
            else
               fDSet->Validate(dset);
            delete dset;
         }
         break;

      case kPROOF_DATA_READY:
         {
            PDB(kGlobal,2) Info("HandleInputMessage", "kPROOF_DATA_READY: enter");
            Bool_t dataready = kFALSE;
            Long64_t totalbytes, bytesready;
            (*mess) >> dataready >> totalbytes >> bytesready;
            fTotalBytes += totalbytes;
            fBytesReady += bytesready;
            if (dataready == kFALSE) fDataReady = dataready;
         }
         break;

      case kPROOF_PING:
         // do nothing (ping is already acknowledged)
         break;

      case kPROOF_MESSAGE:
         {
            PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_MESSAGE: enter");

            // We have received the unique tag and save it as name of this object
            TString msg;
            (*mess) >> msg;
            Bool_t lfeed = kTRUE;
            if ((mess->BufferSize() > mess->Length()))
               (*mess) >> lfeed;

            if (TestBit(TProof::kIsClient)) {

               if (fSync) {
                  // Notify locally
                  fprintf(stderr,"%s%c", msg.Data(), (lfeed ? '\n' : '\r'));
               } else {
                  // Notify locally taking care of redirection, windows logs, ...
                  NotifyLogMsg(msg, (lfeed ? "\n" : "\r"));
               }
            } else {

               // The message is logged for debugging purposes.
               fprintf(stderr,"%s%c", msg.Data(), (lfeed ? '\n' : '\r'));
               if (gProofServ) {
                  // We hide it during normal operations
                  gProofServ->FlushLogFile();

                  // And send the message one level up
                  gProofServ->SendAsynMessage(msg, lfeed);
               }
            }
         }
         break;

      case kPROOF_VERSARCHCOMP:
         {
            TString vac;
            (*mess) >> vac;
            PDB(kGlobal,2) Info("HandleInputMessage","kPROOF_VERSARCHCOMP: %s", vac.Data());
            Int_t from = 0;
            TString vers, archcomp;
            if (vac.Tokenize(vers, from, "|"))
               vac.Tokenize(archcomp, from, "|");
            sl->SetArchCompiler(archcomp);
            vers.ReplaceAll(":","|");
            sl->SetROOTVersion(vers);
         }
         break;

      default:
         {
            Error("HandleInputMessage", "unknown command received from '%s' (what = %d)",
                                      (sl ? sl->GetOrdinal() : "undef"), what);
         }
         break;
   }

   // Cleanup
   if (delete_mess)
      delete mess;

   // We are done successfully
   return rc;
}

//______________________________________________________________________________
void TProof::HandleSubmerger(TMessage *mess, TSlave *sl)
{
   // Process a message of type kPROOF_SUBMERGER

   // Message sub-type
   Int_t type = 0;
   (*mess) >> type;
   TSocket *s = sl->GetSocket();

   switch (type) {
      case kOutputSent:
         {
            if (IsEndMaster()) {
               Int_t  merger_id = -1;
               (*mess) >> merger_id;

               PDB(kSubmerger, 2)
                  Info("HandleSubmerger", "kOutputSent: Worker %s:%d:%s had sent its output to merger #%d", 
                                          sl->GetName(), sl->GetPort(), sl->GetOrdinal(), merger_id);

               if (!fMergers || fMergers->GetSize() <= merger_id) {
                  Error("HandleSubmerger", "kOutputSize: #%d not in list ", merger_id);
                  break;
               }
               TMergerInfo * mi = (TMergerInfo *) fMergers->At(merger_id);
               mi->SetMergedWorker();
               if (mi->AreAllWorkersMerged()) {
                  mi->Deactivate();
                  if (GetActiveMergersCount() == 0) {
                     fMergers->Clear();
                     delete fMergers;
                     fMergersSet = kFALSE;
                     fMergersCount = -1;
                     fLastAssignedMerger = 0;
                     PDB(kSubmerger, 2) Info("HandleSubmerger", "all mergers removed ... ");
                  }
               }
            } else {
               PDB(kSubmerger, 2) Error("HandleSubmerger","kOutputSent: received not on endmaster!");
            }
         }
         break;

      case kMergerDown:
         {
            Int_t  merger_id = -1;
            (*mess) >> merger_id;

            PDB(kSubmerger, 2) Info("HandleSubmerger", "kMergerDown: #%d ", merger_id);

            if (!fMergers || fMergers->GetSize() <= merger_id) {
               Error("HandleSubmerger", "kOutputSize: #%d not in list ", merger_id);
               break;
            }

            TMergerInfo * mi = (TMergerInfo *) fMergers->At(merger_id);
            if (!mi->IsActive()) {
               break;
            } else {
               mi->Deactivate();
            }

            // Stop the invalid merger in the case it is still listening
            TMessage stop(kPROOF_SUBMERGER);
            stop << Int_t(kStopMerging);
            stop <<  0;
            s->Send(stop);

            // Ask for results from merger (only original results from this node as worker are returned)
            AskForOutput(mi->GetMerger());

            // Ask for results from all workers assigned to this merger
            TIter nxo(mi->GetWorkers());
            TObject * o = 0;
            while ((o = nxo())) {
               AskForOutput((TSlave *)o);
            }
            PDB(kSubmerger, 2) Info("HandleSubmerger", "kMergerDown: exit", merger_id);
         }
         break;

      case kOutputSize:
         {
            if (IsEndMaster()) {
               PDB(kSubmerger, 2)
                  Info("HandleSubmerger", "worker %s reported as finished ", sl->GetOrdinal());

               if (!fFinalizationRunning) {
                  Info("HandleSubmerger", "finalization on %s started ...", gProofServ->GetPrefix());
                  fFinalizationRunning = kTRUE;
               }

               Int_t  output_size = 0;
               Int_t  merging_port = 0;
               (*mess) >> output_size >> merging_port;

               PDB(kSubmerger, 2) Info("HandleSubmerger",
                                       "kOutputSize: Worker %s:%d:%s reports %d output objects (+ available port %d)",
                                       sl->GetName(), sl->GetPort(), sl->GetOrdinal(), output_size, merging_port);
               TString msg;
               if (!fMergersSet) {

                  // First pass - setting number of mergers according to user or dynamically
                  fMergersCount = -1; // No mergers used if not set by user
                  TParameter<Int_t> *mc = dynamic_cast<TParameter<Int_t> *>(GetParameter("PROOF_UseMergers"));
                  if (mc) fMergersCount = mc->GetVal(); // Value set by user

                  // Mergers count specified by user but not valid
                  if (fMergersCount < 0 || (fMergersCount > (GetNumberOfSlaves()/2) )) {
                     msg.Form("%s: Invalid request: cannot start %d mergers for %d workers",
                              gProofServ->GetPrefix(), fMergersCount, GetNumberOfSlaves());
                     gProofServ->SendAsynMessage(msg);
                     fMergersCount = 0;
                  }
                  // Mergers count will be set dynamically
                  if (fMergersCount == 0) {
                     if (GetNumberOfSlaves() > 1)
                        fMergersCount = TMath::Nint(TMath::Sqrt(GetNumberOfSlaves()));
                     if (fMergersCount > 1)
                        msg.Form("%s: Number of mergers set dynamically to %d (for %d workers)",
                                 gProofServ->GetPrefix(), fMergersCount, GetNumberOfSlaves());
                     else {
                        msg.Form("%s: No mergers will be used for %d workers",
                                 gProofServ->GetPrefix(), GetNumberOfSlaves()); 
                        fMergersCount = -1;
                     }
                     gProofServ->SendAsynMessage(msg);
                  } else {
                     msg.Form("%s: Number of mergers set by user to %d (for %d workers)",
                              gProofServ->GetPrefix(), fMergersCount, GetNumberOfSlaves());
                     gProofServ->SendAsynMessage(msg);
                  }
                  if (fMergersCount > 0) {

                     fMergers = new TList();
                     fLastAssignedMerger = 0;
                     // Total number of workers, which will not act as mergers ('pure workers')
                     fWorkersToMerge = (GetNumberOfSlaves() - fMergersCount);
                     // Establish the first merger
                     if (!CreateMerger(sl, merging_port)) {
                        // Cannot establish first merger
                        AskForOutput(sl);
                        fWorkersToMerge--;
                        fMergersCount--;
                     }
                  } else {
                     AskForOutput(sl);
                  }
                  fMergersSet = kTRUE;
               } else {
                  // Multiple pass
                  if (fMergersCount == -1) {
                     // No mergers. Workers send their outputs directly to master
                     AskForOutput(sl);
                  } else {
                     if (fRedirectNext > 0 ) {
                        RedirectWorker(s, sl, output_size);
                        fRedirectNext--;
                     } else {
                        if (fMergersCount > fMergers->GetSize()) {
                           // Still not enough mergers established
                           if (!CreateMerger(sl, merging_port)) {
                              // Cannot establish a merger
                              AskForOutput(sl);
                              fWorkersToMerge--;
                              fMergersCount--;
                           }
                        } else
                           RedirectWorker(s, sl, output_size);
                     }
                  }
               }
            } else {
               Error("HandleSubMerger","kOutputSize received not on endmaster!");
            }
         }
      break;
   }
}

//______________________________________________________________________________
void TProof::RedirectWorker(TSocket *s, TSlave * sl, Int_t output_size)
{
   // Redirect output of worker sl to some merger

   Int_t merger_id = FindNextFreeMerger();
   if (merger_id == -1) {
      // No free merger (probably it had crashed before)
      AskForOutput(sl);
   } else {
      TMessage sendoutput(kPROOF_SUBMERGER);
      sendoutput << Int_t(kSendOutput);
      PDB(kSubmerger, 2)
         Info("RedirectWorker", "redirecting worker %s to merger %d", sl->GetOrdinal(), merger_id);

       PDB(kSubmerger, 2) Info("RedirectWorker", "redirecting output to merger #%d",  merger_id);
       if (!fMergers || fMergers->GetSize() <= merger_id) {
          Error("RedirectWorker", "#%d not in list ", merger_id);
          return;
       }
       TMergerInfo * mi = (TMergerInfo *) fMergers->At(merger_id);

       sendoutput <<  merger_id;
       sendoutput << TString(mi->GetMerger()->GetName());
       sendoutput << mi->GetPort();
       s->Send(sendoutput);
       mi->AddMergedObjects(output_size);
       mi->AddWorker(sl);
   }
}

//______________________________________________________________________________
Int_t TProof::FindNextFreeMerger()
{
   // Return a merger, which is both active and still accepts some workers to be
   // assigned to it. It works on the 'round-robin' basis.

   while (fLastAssignedMerger < fMergers->GetSize() &&
         (!((TMergerInfo*)fMergers->At(fLastAssignedMerger))->IsActive() ||
           ((TMergerInfo*)fMergers->At(fLastAssignedMerger))->AreAllWorkersAssigned())) {
      fLastAssignedMerger++;
   }

   if (fLastAssignedMerger == fMergers->GetSize()) {
      fLastAssignedMerger = 0;
   } else {
      return fLastAssignedMerger++;
   }

   while (fLastAssignedMerger < fMergers->GetSize() &&
         (!((TMergerInfo*)fMergers->At(fLastAssignedMerger))->IsActive() ||
           ((TMergerInfo*)fMergers->At(fLastAssignedMerger))->AreAllWorkersAssigned())) {
      fLastAssignedMerger++;
   }

   if (fLastAssignedMerger == fMergers->GetSize()) {
      return -1;
   } else {
      return fLastAssignedMerger++;
   }
}

//______________________________________________________________________________
void TProof::AskForOutput(TSlave *sl)
{
   // Master asks for output from worker sl

   TMessage sendoutput(kPROOF_SUBMERGER);
   sendoutput << Int_t(kSendOutput);

   PDB(kSubmerger, 2) Info("AskForOutput",
                           "worker %s was asked for sending its output to master",
                            sl->GetOrdinal());

   sendoutput << 0;
   sendoutput << TString("master");
   sendoutput << 0;
   sl->GetSocket()->Send(sendoutput);
}

//______________________________________________________________________________
void TProof::UpdateDialog()
{
   // Final update of the progress dialog

   if (!fPlayer) return;

   // Handle abort ...
   if (fPlayer->GetExitStatus() == TVirtualProofPlayer::kAborted) {
      if (fSync)
         Info("UpdateDialog",
              "processing was aborted - %lld events processed",
              fPlayer->GetEventsProcessed());

      if (GetRemoteProtocol() > 11) {
         // New format
         Progress(-1, fPlayer->GetEventsProcessed(), -1, -1., -1., -1., -1.);
      } else {
         Progress(-1, fPlayer->GetEventsProcessed());
      }
      Emit("StopProcess(Bool_t)", kTRUE);
   }

   // Handle stop ...
   if (fPlayer->GetExitStatus() == TVirtualProofPlayer::kStopped) {
      if (fSync)
         Info("UpdateDialog",
              "processing was stopped - %lld events processed",
              fPlayer->GetEventsProcessed());

      if (GetRemoteProtocol() > 25) {
         // New format
         Progress(-1, fPlayer->GetEventsProcessed(), -1, -1., -1., -1., -1., -1, -1, -1.);
      } else if (GetRemoteProtocol() > 11) {
         Progress(-1, fPlayer->GetEventsProcessed(), -1, -1., -1., -1., -1.);
      } else {
         Progress(-1, fPlayer->GetEventsProcessed());
      }
      Emit("StopProcess(Bool_t)", kFALSE);
   }

   // Final update of the dialog box
   if (GetRemoteProtocol() > 25) {
      // New format
      EmitVA("Progress(Long64_t,Long64_t,Long64_t,Float_t,Float_t,Float_t,Float_t,Int_t,Int_t,Float_t)",
              10, (Long64_t)(-1), (Long64_t)(-1), (Long64_t)(-1),(Float_t)(-1.),(Float_t)(-1.),
                  (Float_t)(-1.),(Float_t)(-1.),(Int_t)(-1),(Int_t)(-1),(Float_t)(-1.));
   } else if (GetRemoteProtocol() > 11) {
      // New format
      EmitVA("Progress(Long64_t,Long64_t,Long64_t,Float_t,Float_t,Float_t,Float_t)",
               7, (Long64_t)(-1), (Long64_t)(-1), (Long64_t)(-1),
                  (Float_t)(-1.),(Float_t)(-1.),(Float_t)(-1.),(Float_t)(-1.));
   } else {
      EmitVA("Progress(Long64_t,Long64_t)", 2, (Long64_t)(-1), (Long64_t)(-1));
   }
}

//______________________________________________________________________________
void TProof::ActivateAsyncInput()
{
   // Activate the a-sync input handler.

   TIter next(fSlaves);
   TSlave *sl;

   while ((sl = (TSlave*) next()))
      if (sl->GetInputHandler())
         sl->GetInputHandler()->Add();
}

//______________________________________________________________________________
void TProof::DeActivateAsyncInput()
{
   // De-activate a-sync input handler.

   TIter next(fSlaves);
   TSlave *sl;

   while ((sl = (TSlave*) next()))
      if (sl->GetInputHandler())
         sl->GetInputHandler()->Remove();
}

//______________________________________________________________________________
Int_t TProof::GetActiveMergersCount()
{
   // Get the active mergers count

   if (!fMergers) return 0;

   Int_t active_mergers = 0;

   TIter mergers(fMergers);
   TMergerInfo *mi = 0;
   while ((mi = (TMergerInfo *)mergers())) {
      if (mi->IsActive()) active_mergers++;
   }

   return active_mergers;
}

//______________________________________________________________________________
Bool_t TProof::CreateMerger(TSlave *sl, Int_t port)
{
   // Create a new merger

   PDB(kSubmerger, 2)
      Info("CreateMerger", "worker %s will be merger ", sl->GetOrdinal());

   PDB(kSubmerger, 2) Info("CreateMerger","Begin");

   if (port <= 0) {
      PDB(kSubmerger,2)
         Info("CreateMerger", "cannot create merger on port %d - exit", port);
      return kFALSE;
   }
   Int_t mergersToCreate = fMergersCount - fMergers->GetSize();

   // Number of pure workers, which are not simply divisible by mergers
   Int_t rest = fWorkersToMerge % mergersToCreate;

   // We add one more worker for each of the first 'rest' mergers being established
   if (rest > 0 && fMergers->GetSize() < rest) {
      rest = 1;
   } else {
      rest = 0;
   }

   Int_t workers = (fWorkersToMerge / mergersToCreate) + rest;

   TMergerInfo * merger = new TMergerInfo(sl, port, workers);

   TMessage bemerger(kPROOF_SUBMERGER);
   bemerger << Int_t(kBeMerger);
   bemerger <<  fMergers->GetSize();
   bemerger <<  workers;
   sl->GetSocket()->Send(bemerger);

   PDB(kSubmerger,2) Info("CreateMerger",
                          "merger #%d (port: %d) for %d workers started",
                          fMergers->GetSize(), port, workers);

   fMergers->Add(merger);	
   fWorkersToMerge = fWorkersToMerge - workers;

   fRedirectNext = workers / 2;

   PDB(kSubmerger, 2) Info("CreateMerger", "exit");
   return kTRUE;
}

//______________________________________________________________________________
void TProof::MarkBad(TSlave *wrk, const char *reason)
{
   // Add a bad slave server to the bad slave list and remove it from
   // the active list and from the two monitor objects. Assume that the work
   // done by this worker was lost and ask packerizer to reassign it.

   R__LOCKGUARD2(fCloseMutex);


   // We may have been invalidated in the meanwhile: nothing to do in such a case
   if (!IsValid()) return;

   if (!wrk) {
      Error("MarkBad", "worker instance undefined: protocol error? ");
      return;
   }

   // Local URL
   static TString thisurl;
   if (thisurl.IsNull()) {
      if (IsMaster()) {
         Int_t port = gEnv->GetValue("ProofServ.XpdPort",-1);
         thisurl = (port > 0) ? Form("%s:%d", TUrl(gSystem->HostName()).GetHostFQDN(), port)
                              : TUrl(gSystem->HostName()).GetHostFQDN();
      } else {
         thisurl = Form("%s@%s:%d", fUrl.GetUser(), fUrl.GetHost(), fUrl.GetPort());
      }
   }

   if (!reason || strcmp(reason, kPROOF_TerminateWorker)) {
      // Message for notification
      const char *mastertype = (gProofServ && gProofServ->IsTopMaster()) ? "top master" : "master";
      TString src = IsMaster() ? Form("%s at %s", mastertype, thisurl.Data()) : "local session";
      TString msg(Form("\n +++ Message from %s : ", src.Data()));
      msg += Form("marking %s:%d (%s) as bad\n +++ Reason: %s",
                  wrk->GetName(), wrk->GetPort(), wrk->GetOrdinal(),
                  (reason && strlen(reason)) ? reason : "unknown");
      Info("MarkBad", "%s", msg.Data());
      // Notify one level up, if the case
      // Add some hint for diagnostics
      if (gProofServ) {
         msg += Form("\n\n +++ Most likely your code crashed on worker %s at %s:%d.\n",
                     wrk->GetOrdinal(), wrk->GetName(), wrk->GetPort());
      } else {
         msg = Form("\n\n +++ Most likely your code crashed\n");
      }
      msg += Form(" +++ Please check the session logs for error messages either using\n");
      msg += Form(" +++ the 'Show logs' button or executing\n");
      msg += Form(" +++\n");
      if (gProofServ) {
         msg += Form(" +++ root [] TProof::Mgr(\"%s\")->GetSessionLogs()->Display(\"%s\",0)\n\n",
                     thisurl.Data(), wrk->GetOrdinal());
         gProofServ->SendAsynMessage(msg, kTRUE);
      } else {
         msg += Form(" +++ root [] TProof::Mgr(\"%s\")->GetSessionLogs()->Display(\"*\")\n\n",
                     thisurl.Data());
         Printf("%s", msg.Data());
      }
   } else if (reason) {
      if (gDebug > 0) {
         Info("MarkBad", "worker %s at %s:%d asked to terminate",
                         wrk->GetOrdinal(), wrk->GetName(), wrk->GetPort());
      }
   }

   if (IsMaster() && reason) {
      if (strcmp(reason, kPROOF_TerminateWorker)) {
         // if the reason was not a planned termination
         TList *listOfMissingFiles = 0;
         if (!(listOfMissingFiles = (TList *)GetOutput("MissingFiles"))) {
            listOfMissingFiles = new TList();
            listOfMissingFiles->SetName("MissingFiles");
            if (fPlayer)
               fPlayer->AddOutputObject(listOfMissingFiles);
         }
         // If a query is being processed, assume that the work done by
         // the worker was lost and needs to be reassigned.
         TVirtualPacketizer *packetizer = fPlayer ? fPlayer->GetPacketizer() : 0;
         if (packetizer) {
            // the worker was lost so do resubmit the packets
            packetizer->MarkBad(wrk, 0, &listOfMissingFiles);
         }
      } else {
         // Tell the coordinator that we are gone
         if (gProofServ) {
            TString ord(wrk->GetOrdinal());
            Int_t id = ord.Last('.');
            if (id != kNPOS) ord.Remove(0, id+1);
            gProofServ->ReleaseWorker(ord.Data());
         }
      }
   }

   fActiveSlaves->Remove(wrk);
   FindUniqueSlaves();

   fAllMonitor->Remove(wrk->GetSocket());
   fActiveMonitor->Remove(wrk->GetSocket());

   fSendGroupView = kTRUE;

   if (IsMaster()) {
      if (reason && !strcmp(reason, kPROOF_TerminateWorker)) {
         // if the reason was a planned termination then delete the worker and
         // remove it from all the lists
         fSlaves->Remove(wrk);
         fBadSlaves->Remove(wrk);
         fActiveSlaves->Remove(wrk);
         fInactiveSlaves->Remove(wrk);
         fUniqueSlaves->Remove(wrk);
         fAllUniqueSlaves->Remove(wrk);
         fNonUniqueMasters->Remove(wrk);
         delete wrk;
      } else {
         fBadSlaves->Add(wrk);
         wrk->Close();
      }

      // Update session workers files
      SaveWorkerInfo();
   } else {
      // On clients the proof session should be removed from the lists
      // and deleted, since it is not valid anymore
      fSlaves->Remove(wrk);
      if (fManager)
         fManager->DiscardSession(this);
   }
}

//______________________________________________________________________________
void TProof::MarkBad(TSocket *s, const char *reason)
{
   // Add slave with socket s to the bad slave list and remove if from
   // the active list and from the two monitor objects.

   R__LOCKGUARD2(fCloseMutex);

   // We may have been invalidated in the meanwhile: nothing to do in such a case
   if (!IsValid()) return;

   TSlave *wrk = FindSlave(s);
   MarkBad(wrk, reason);
}

//______________________________________________________________________________
void TProof::TerminateWorker(TSlave *wrk)
{
   // Ask an active worker 'wrk' to terminate, i.e. to shutdown

   if (!wrk) {
      Warning("TerminateWorker", "worker instance undefined: protocol error? ");
      return;
   }

   // Send stop message
   if (wrk->GetSocket() && wrk->GetSocket()->IsValid()) {
      TMessage mess(kPROOF_STOP);
      wrk->GetSocket()->Send(mess);
   } else {
      if (gDebug > 0)
         Info("TerminateWorker", "connection to worker is already down: cannot"
                                 " send termination message");
   }

   // This is a bad worker from now on
   MarkBad(wrk, kPROOF_TerminateWorker);
}

//______________________________________________________________________________
void TProof::TerminateWorker(const char *ord)
{
   // Ask an active worker 'ord' to terminate, i.e. to shutdown

   if (ord && strlen(ord) > 0) {
      Bool_t all = (ord[0] == '*') ? kTRUE : kFALSE;
      if (IsMaster()) {
         TIter nxw(fSlaves);
         TSlave *wrk = 0;
         while ((wrk = (TSlave *)nxw())) {
            if (all || !strcmp(wrk->GetOrdinal(), ord)) {
               TerminateWorker(wrk);
               if (!all) break;
            }
         }
      } else {
         TMessage mess(kPROOF_STOP);
         mess << TString(ord);
         Broadcast(mess);
      }
   }
}

//______________________________________________________________________________
Int_t TProof::Ping()
{
   // Ping PROOF. Returns 1 if master server responded.

   return Ping(kActive);
}

//______________________________________________________________________________
Int_t TProof::Ping(ESlaves list)
{
   // Ping PROOF slaves. Returns the number of slaves that responded.

   TList *slaves = 0;
   if (list == kAll)       slaves = fSlaves;
   if (list == kActive)    slaves = fActiveSlaves;
   if (list == kUnique)    slaves = fUniqueSlaves;
   if (list == kAllUnique) slaves = fAllUniqueSlaves;

   if (slaves->GetSize() == 0) return 0;

   int   nsent = 0;
   TIter next(slaves);

   TSlave *sl;
   while ((sl = (TSlave *)next())) {
      if (sl->IsValid()) {
         if (sl->Ping() == -1) {
            MarkBad(sl, "ping unsuccessful");
         } else {
            nsent++;
         }
      }
   }

   return nsent;
}

//______________________________________________________________________________
void TProof::Touch()
{
   // Ping PROOF slaves. Returns the number of slaves that responded.

   TList *slaves = fSlaves;

   if (slaves->GetSize() == 0) return;

   TIter next(slaves);

   TSlave *sl;
   while ((sl = (TSlave *)next())) {
      if (sl->IsValid()) {
         sl->Touch();
      }
   }

   return;
}

//______________________________________________________________________________
void TProof::Print(Option_t *option) const
{
   // Print status of PROOF cluster.

   TString secCont;

   if (TestBit(TProof::kIsClient)) {
      Printf("Connected to:             %s (%s)", GetMaster(),
                                             IsValid() ? "valid" : "invalid");
      Printf("Port number:              %d", GetPort());
      Printf("User:                     %s", GetUser());
      if (gROOT->GetSvnRevision() > 0)
         Printf("ROOT version|rev:         %s|r%d", gROOT->GetVersion(), gROOT->GetSvnRevision());
      else
         Printf("ROOT version:             %s", gROOT->GetVersion());
      Printf("Architecture-Compiler:    %s-%s", gSystem->GetBuildArch(),
                                                gSystem->GetBuildCompilerVersion());
      TSlave *sl = (TSlave *)fActiveSlaves->First();
      if (sl) {
         TString sc;
         if (sl->GetSocket()->GetSecContext())
            Printf("Security context:         %s",
                                      sl->GetSocket()->GetSecContext()->AsString(sc));
         Printf("Proofd protocol version:  %d", sl->GetSocket()->GetRemoteProtocol());
      } else {
         Printf("Security context:         Error - No connection");
         Printf("Proofd protocol version:  Error - No connection");
      }
      Printf("Client protocol version:  %d", GetClientProtocol());
      Printf("Remote protocol version:  %d", GetRemoteProtocol());
      Printf("Log level:                %d", GetLogLevel());
      Printf("Session unique tag:       %s", IsValid() ? GetSessionTag() : "");
      Printf("Default data pool:        %s", IsValid() ? GetDataPoolUrl() : "");
      if (IsValid())
         const_cast<TProof*>(this)->SendPrint(option);
   } else {
      const_cast<TProof*>(this)->AskStatistics();
      if (IsParallel())
         Printf("*** Master server %s (parallel mode, %d workers):",
                gProofServ->GetOrdinal(), GetParallel());
      else
         Printf("*** Master server %s (sequential mode):",
                gProofServ->GetOrdinal());

      Printf("Master host name:           %s", gSystem->HostName());
      Printf("Port number:                %d", GetPort());
      if (strlen(gProofServ->GetGroup()) > 0) {
         Printf("User/Group:                 %s/%s", GetUser(), gProofServ->GetGroup());
      } else {
         Printf("User:                       %s", GetUser());
      }
      TString ver(gROOT->GetVersion());
      if (gROOT->GetSvnRevision() > 0)
         ver += Form("|r%d", gROOT->GetSvnRevision());
      if (gSystem->Getenv("ROOTVERSIONTAG"))
         ver += Form("|%s", gSystem->Getenv("ROOTVERSIONTAG"));
      Printf("ROOT version|rev|tag:       %s", ver.Data());
      Printf("Architecture-Compiler:      %s-%s", gSystem->GetBuildArch(),
                                                  gSystem->GetBuildCompilerVersion());
      Printf("Protocol version:           %d", GetClientProtocol());
      Printf("Image name:                 %s", GetImage());
      Printf("Working directory:          %s", gSystem->WorkingDirectory());
      Printf("Config directory:           %s", GetConfDir());
      Printf("Config file:                %s", GetConfFile());
      Printf("Log level:                  %d", GetLogLevel());
      Printf("Number of workers:          %d", GetNumberOfSlaves());
      Printf("Number of active workers:   %d", GetNumberOfActiveSlaves());
      Printf("Number of unique workers:   %d", GetNumberOfUniqueSlaves());
      Printf("Number of inactive workers: %d", GetNumberOfInactiveSlaves());
      Printf("Number of bad workers:      %d", GetNumberOfBadSlaves());
      Printf("Total MB's processed:       %.2f", float(GetBytesRead())/(1024*1024));
      Printf("Total real time used (s):   %.3f", GetRealTime());
      Printf("Total CPU time used (s):    %.3f", GetCpuTime());
      if (TString(option).Contains("a", TString::kIgnoreCase) && GetNumberOfSlaves()) {
         Printf("List of workers:");
         TList masters;
         TIter nextslave(fSlaves);
         while (TSlave* sl = dynamic_cast<TSlave*>(nextslave())) {
            if (!sl->IsValid()) continue;

            if (sl->GetSlaveType() == TSlave::kSlave) {
               sl->Print(option);
            } else if (sl->GetSlaveType() == TSlave::kMaster) {
               TMessage mess(kPROOF_PRINT);
               mess.WriteString(option);
               if (sl->GetSocket()->Send(mess) == -1)
                  const_cast<TProof*>(this)->MarkBad(sl, "could not send kPROOF_PRINT request");
               else
                  masters.Add(sl);
            } else {
               Error("Print", "TSlave is neither Master nor Worker");
               R__ASSERT(0);
            }
         }
         const_cast<TProof*>(this)->Collect(&masters, fCollectTimeout);
      }
   }
}

//______________________________________________________________________________
Long64_t TProof::Process(TDSet *dset, const char *selector, Option_t *option,
                         Long64_t nentries, Long64_t first)
{
   // Process a data set (TDSet) using the specified selector (.C) file.
   // Entry- or event-lists should be set in the data set object using
   // TDSet::SetEntryList.
   // The return value is -1 in case of error and TSelector::GetStatus() in
   // in case of success.

   if (!IsValid() || !fPlayer) return -1;

   // Set PROOF to running state
   SetRunStatus(TProof::kRunning);

   // Resolve query mode
   fSync = (GetQueryMode(option) == kSync);

   TString opt(option);
   if (fSync && (!IsIdle() || IsWaiting())) {
      // Already queued or processing queries: switch to asynchronous mode
      Info("Process", "session is in waiting or processing status: switch to asynchronous mode");
      fSync = kFALSE;
      opt.ReplaceAll("SYNC","");
      opt += "ASYN";
   }

   // Cleanup old temporary datasets
   if ((IsIdle() && !IsWaiting()) && fRunningDSets && fRunningDSets->GetSize() > 0) {
      fRunningDSets->SetOwner(kTRUE);
      fRunningDSets->Delete();
   }

   // deactivate the default application interrupt handler
   // ctrl-c's will be forwarded to PROOF to stop the processing
   TSignalHandler *sh = 0;
   if (fSync) {
      if (gApplication)
         sh = gSystem->RemoveSignalHandler(gApplication->GetSignalHandler());
   }

   Long64_t rv = fPlayer->Process(dset, selector, opt.Data(), nentries, first);

   if (fSync) {
      // reactivate the default application interrupt handler
      if (sh)
         gSystem->AddSignalHandler(sh);
   }

   return rv;
}

//______________________________________________________________________________
Long64_t TProof::Process(TFileCollection *fc, const char *selector,
                         Option_t *option, Long64_t nentries, Long64_t first)
{
   // Process a data set (TFileCollection) using the specified selector (.C) file.
   // The default tree is analyzed (i.e. the first one found). To specify another
   // tree, the default tree can be changed using TFileCollection::SetDefaultMetaData .
   // The return value is -1 in case of error and TSelector::GetStatus() in
   // in case of success.

   if (!IsValid() || !fPlayer) return -1;

   if (fProtocol < 17) {
      Info("Process", "server version < 5.18/00:"
                      " processing of TFileCollection not supported");
      return -1;
   }

   // We include the TFileCollection to the input list and we create a
   // fake TDSet with infor about it
   TDSet *dset = new TDSet(Form("TFileCollection:%s", fc->GetName()), 0, 0, "");
   fPlayer->AddInput(fc);
   Long64_t retval = Process(dset, selector, option, nentries, first);
   fPlayer->GetInputList()->Remove(fc); // To avoid problems in future

   // Cleanup
   if (IsLite() && !fSync) {
      if (!fRunningDSets) fRunningDSets = new TList;
      fRunningDSets->Add(dset);
   } else {
      delete dset;
   }

   return retval;
}

//______________________________________________________________________________
Long64_t TProof::Process(const char *dsetname, const char *selector,
                         Option_t *option, Long64_t nentries,
                         Long64_t first, TObject *enl)
{
   // Process a dataset which is stored on the master with name 'dsetname'.
   // The syntax for dsetname is name[#[dir/]objname], e.g.
   //   "mydset"       analysis of the first tree in the top dir of the dataset
   //                  named "mydset"
   //   "mydset#T"     analysis tree "T" in the top dir of the dataset
   //                  named "mydset"
   //   "mydset#adir/T" analysis tree "T" in the dir "adir" of the dataset
   //                  named "mydset"
   //   "mydset#adir/" analysis of the first tree in the dir "adir" of the
   //                  dataset named "mydset"
   // The last argument 'enl' specifies an entry- or event-list to be used as
   // event selection.
   // The return value is -1 in case of error and TSelector::GetStatus() in
   // in case of success.

   if (fProtocol < 13) {
      Info("Process", "processing 'by name' not supported by the server");
      return -1;
   }

   TString name(dsetname);
   TString obj;
   TString dir = "/";
   Int_t idxc = name.Index("#");
   if (idxc != kNPOS) {
      Int_t idxs = name.Index("/", 1, idxc, TString::kExact);
      if (idxs != kNPOS) {
         obj = name(idxs+1, name.Length());
         dir = name(idxc+1, name.Length());
         dir.Remove(dir.Index("/") + 1);
         name.Remove(idxc);
      } else {
         obj = name(idxc+1, name.Length());
         name.Remove(idxc);
      }
   } else if (name.Index(":") != kNPOS && name.Index("://") == kNPOS) {
      // protection against using ':' instead of '#'
      Error("Process", "bad name syntax (%s): please use"
                       " a '#' after the dataset name", dsetname);
      return -1;
   }

   TDSet *dset = new TDSet(name, obj, dir);
   // Set entry list
   dset->SetEntryList(enl);
   Long64_t retval = Process(dset, selector, option, nentries, first);
   // Cleanup
   if (IsLite() && !fSync) {
      if (!fRunningDSets) fRunningDSets = new TList;
      fRunningDSets->Add(dset);
   } else {
      delete dset;
   }
   return retval;
}

//______________________________________________________________________________
Long64_t TProof::Process(const char *selector, Long64_t n, Option_t *option)
{
   // Generic (non-data based) selector processing: the Process() method of the
   // specified selector (.C) is called 'n' times.
   // The return value is -1 in case of error and TSelector::GetStatus() in
   // in case of success.

   if (!IsValid()) return -1;

   if (fProtocol < 16) {
      Info("Process", "server version < 5.17/04: generic processing not supported");
      return -1;
   }

   // Fake data set
   TDSet *dset = new TDSet;
   dset->SetBit(TDSet::kEmpty);

   Long64_t retval = Process(dset, selector, option, n);

   // Cleanup
   if (IsLite() && !fSync) {
      if (!fRunningDSets) fRunningDSets = new TList;
      fRunningDSets->Add(dset);
   } else {
      delete dset;
   }
   return retval;
}

//______________________________________________________________________________
Int_t TProof::GetQueryReference(Int_t qry, TString &ref)
{
   // Get reference for the qry-th query in fQueries (as
   // displayed by ShowQueries).

   ref = "";
   if (qry > 0) {
      if (!fQueries)
         GetListOfQueries();
      if (fQueries) {
         TIter nxq(fQueries);
         TQueryResult *qr = 0;
         while ((qr = (TQueryResult *) nxq()))
            if (qr->GetSeqNum() == qry) {
               ref = Form("%s:%s", qr->GetTitle(), qr->GetName());
               return 0;
            }
      }
   }
   return -1;
}

//______________________________________________________________________________
Long64_t TProof::Finalize(Int_t qry, Bool_t force)
{
   // Finalize the qry-th query in fQueries.
   // If force, force retrieval if the query is found in the local list
   // but has already been finalized (default kFALSE).
   // If query < 0, finalize current query.
   // Return 0 on success, -1 on error

   if (fPlayer) {
      if (qry > 0) {
         TString ref;
         if (GetQueryReference(qry, ref) == 0) {
            return Finalize(ref, force);
         } else {
            Info("Finalize", "query #%d not found", qry);
         }
      } else {
         // The last query
         return Finalize("", force);
      }
   }
   return -1;
}

//______________________________________________________________________________
Long64_t TProof::Finalize(const char *ref, Bool_t force)
{
   // Finalize query with reference ref.
   // If force, force retrieval if the query is found in the local list
   // but has already been finalized (default kFALSE).
   // If ref = 0, finalize current query.
   // Return 0 on success, -1 on error

   if (fPlayer) {
      // Get the pointer to the query
      TQueryResult *qr = (ref && strlen(ref) > 0) ? fPlayer->GetQueryResult(ref)
                                                  : GetQueryResult();
      Bool_t retrieve = kFALSE;
      TString xref(ref);
      if (!qr) {
         if (!xref.IsNull()) {
            retrieve =  kTRUE;
         }
      } else {
         if (qr->IsFinalized()) {
            if (force) {
               retrieve = kTRUE;
            } else {
               Info("Finalize","query already finalized:"
                     " use Finalize(<qry>,kTRUE) to force new retrieval");
               qr = 0;
            }
         } else {
            retrieve = kTRUE;
            xref.Form("%s:%s", qr->GetTitle(), qr->GetName());
         }
      }
      if (retrieve) {
         Retrieve(xref.Data());
         qr = fPlayer->GetQueryResult(xref.Data());
      }
      if (qr)
         return fPlayer->Finalize(qr);
   }
   return -1;
}

//______________________________________________________________________________
Int_t TProof::Retrieve(Int_t qry, const char *path)
{
   // Send retrieve request for the qry-th query in fQueries.
   // If path is defined save it to path.

   if (qry > 0) {
      TString ref;
      if (GetQueryReference(qry, ref) == 0)
         return Retrieve(ref, path);
      else
         Info("Retrieve", "query #%d not found", qry);
   } else {
      Info("Retrieve","positive argument required - do nothing");
   }
   return -1;
}

//______________________________________________________________________________
Int_t TProof::Retrieve(const char *ref, const char *path)
{
   // Send retrieve request for the query specified by ref.
   // If path is defined save it to path.
   // Generic method working for all queries known by the server.

   if (ref) {
      TMessage m(kPROOF_RETRIEVE);
      m << TString(ref);
      Broadcast(m, kActive);
      Collect(kActive, fCollectTimeout);

      // Archive it locally, if required
      if (path) {

         // Get pointer to query
         TQueryResult *qr = fPlayer ? fPlayer->GetQueryResult(ref) : 0;

         if (qr) {

            TFile *farc = TFile::Open(path,"UPDATE");
            if (!(farc->IsOpen())) {
               Info("Retrieve", "archive file cannot be open (%s)", path);
               return 0;
            }
            farc->cd();

            // Update query status
            qr->SetArchived(path);

            // Write to file
            qr->Write();

            farc->Close();
            SafeDelete(farc);

         } else {
            Info("Retrieve", "query not found after retrieve");
            return -1;
         }
      }

      return 0;
   }
   return -1;
}

//______________________________________________________________________________
Int_t TProof::Remove(Int_t qry, Bool_t all)
{
   // Send remove request for the qry-th query in fQueries.

   if (qry > 0) {
      TString ref;
      if (GetQueryReference(qry, ref) == 0)
         return Remove(ref, all);
      else
         Info("Remove", "query #%d not found", qry);
   } else {
      Info("Remove","positive argument required - do nothing");
   }
   return -1;
}

//______________________________________________________________________________
Int_t TProof::Remove(const char *ref, Bool_t all)
{
   // Send remove request for the query specified by ref.
   // If all = TRUE remove also local copies of the query, if any.
   // Generic method working for all queries known by the server.
   // This method can be also used to reset the list of queries
   // waiting to be processed: for that purpose use ref == "cleanupqueue".

   if (all) {
      // Remove also local copies, if any
      if (fPlayer)
         fPlayer->RemoveQueryResult(ref);
   }

   if (IsLite()) return 0;

   if (ref) {
      TMessage m(kPROOF_REMOVE);
      m << TString(ref);
      Broadcast(m, kActive);
      Collect(kActive, fCollectTimeout);
      return 0;
   }
   return -1;
}

//______________________________________________________________________________
Int_t TProof::Archive(Int_t qry, const char *path)
{
   // Send archive request for the qry-th query in fQueries.

   if (qry > 0) {
      TString ref;
      if (GetQueryReference(qry, ref) == 0)
         return Archive(ref, path);
      else
         Info("Archive", "query #%d not found", qry);
   } else {
      Info("Archive","positive argument required - do nothing");
   }
   return -1;
}

//______________________________________________________________________________
Int_t TProof::Archive(const char *ref, const char *path)
{
   // Send archive request for the query specified by ref.
   // Generic method working for all queries known by the server.
   // If ref == "Default", path is understood as a default path for
   // archiving.

   if (ref) {
      TMessage m(kPROOF_ARCHIVE);
      m << TString(ref) << TString(path);
      Broadcast(m, kActive);
      Collect(kActive, fCollectTimeout);
      return 0;
   }
   return -1;
}

//______________________________________________________________________________
Int_t TProof::CleanupSession(const char *sessiontag)
{
   // Send cleanup request for the session specified by tag.

   if (sessiontag) {
      TMessage m(kPROOF_CLEANUPSESSION);
      m << TString(sessiontag);
      Broadcast(m, kActive);
      Collect(kActive, fCollectTimeout);
      return 0;
   }
   return -1;
}

//_____________________________________________________________________________
void TProof::SetQueryMode(EQueryMode mode)
{
   // Change query running mode to the one specified by 'mode'.

   fQueryMode = mode;

   if (gDebug > 0)
      Info("SetQueryMode","query mode is set to: %s", fQueryMode == kSync ?
           "Sync" : "Async");
}

//______________________________________________________________________________
TProof::EQueryMode TProof::GetQueryMode(Option_t *mode) const
{
   // Find out the query mode based on the current setting and 'mode'.

   EQueryMode qmode = fQueryMode;

   if (mode && (strlen(mode) > 0)) {
      TString m(mode);
      m.ToUpper();
      if (m.Contains("ASYN")) {
         qmode = kAsync;
      } else if (m.Contains("SYNC")) {
         qmode = kSync;
      }
   }

   if (gDebug > 0)
      Info("GetQueryMode","query mode is set to: %s", qmode == kSync ?
           "Sync" : "Async");

   return qmode;
}

//______________________________________________________________________________
Long64_t TProof::DrawSelect(TDSet *dset, const char *varexp,
                            const char *selection, Option_t *option,
                            Long64_t nentries, Long64_t first)
{
   // Execute the specified drawing action on a data set (TDSet).
   // Event- or Entry-lists should be set in the data set object using
   // TDSet::SetEntryList.
   // Returns -1 in case of error or number of selected events otherwise.

   if (!IsValid() || !fPlayer) return -1;

   // Make sure that asynchronous processing is not active
   if (!IsIdle()) {
      Info("DrawSelect","not idle, asynchronous Draw not supported");
      return -1;
   }
   TString opt(option);
   Int_t idx = opt.Index("ASYN", 0, TString::kIgnoreCase);
   if (idx != kNPOS)
      opt.Replace(idx,4,"");

   return fPlayer->DrawSelect(dset, varexp, selection, opt, nentries, first);
}

//______________________________________________________________________________
Long64_t TProof::DrawSelect(const char *dsetname, const char *varexp,
                            const char *selection, Option_t *option,
                            Long64_t nentries, Long64_t first, TObject *enl)
{
   // Execute the specified drawing action on a data set which is stored on the
   // master with name 'dsetname'.
   // The syntax for dsetname is name[#[dir/]objname], e.g.
   //   "mydset"       analysis of the first tree in the top dir of the dataset
   //                  named "mydset"
   //   "mydset#T"     analysis tree "T" in the top dir of the dataset
   //                  named "mydset"
   //   "mydset#adir/T" analysis tree "T" in the dir "adir" of the dataset
   //                  named "mydset"
   //   "mydset#adir/" analysis of the first tree in the dir "adir" of the
   //                  dataset named "mydset"
   // The last argument 'enl' specifies an entry- or event-list to be used as
   // event selection.
   // The return value is -1 in case of error and TSelector::GetStatus() in
   // in case of success.

   if (fProtocol < 13) {
      Info("Process", "processing 'by name' not supported by the server");
      return -1;
   }

   TString name(dsetname);
   TString obj;
   TString dir = "/";
   Int_t idxc = name.Index("#");
   if (idxc != kNPOS) {
      Int_t idxs = name.Index("/", 1, idxc, TString::kExact);
      if (idxs != kNPOS) {
         obj = name(idxs+1, name.Length());
         dir = name(idxc+1, name.Length());
         dir.Remove(dir.Index("/") + 1);
         name.Remove(idxc);
      } else {
         obj = name(idxc+1, name.Length());
         name.Remove(idxc);
      }
   } else if (name.Index(":") != kNPOS && name.Index("://") == kNPOS) {
      // protection against using ':' instead of '#'
      Error("DrawSelect", "bad name syntax (%s): please use"
                       " a '#' after the dataset name", dsetname);
      return -1;
   }

   TDSet *dset = new TDSet(name, obj, dir);
   // Set entry-list, if required
   dset->SetEntryList(enl);
   Long64_t retval = DrawSelect(dset, varexp, selection, option, nentries, first);
   delete dset;
   return retval;
}

//______________________________________________________________________________
void TProof::StopProcess(Bool_t abort, Int_t timeout)
{
   // Send STOPPROCESS message to master and workers.

   PDB(kGlobal,2)
      Info("StopProcess","enter %d", abort);

   if (!IsValid())
      return;

   // Flag that we have been stopped
   ERunStatus rst = abort ? TProof::kAborted : TProof::kStopped;
   SetRunStatus(rst);

   if (fPlayer)
      fPlayer->StopProcess(abort, timeout);

   // Stop any blocking 'Collect' request; on masters we do this only if
   // aborting; when stopping, we still need to receive the results
   if (TestBit(TProof::kIsClient) || abort)
      InterruptCurrentMonitor();

   if (fSlaves->GetSize() == 0)
      return;

   // Notify the remote counterpart
   TSlave *sl;
   TIter   next(fSlaves);
   while ((sl = (TSlave *)next()))
      if (sl->IsValid())
         // Ask slave to progate the stop/abort request
         sl->StopProcess(abort, timeout);
}

//______________________________________________________________________________
void TProof::DisableGoAsyn()
{
   // Signal to disable related switches

   Emit("DisableGoAsyn()");
}

//______________________________________________________________________________
void TProof::GoAsynchronous()
{
   // Send GOASYNC message to the master.

   if (!IsValid()) return;

   if (GetRemoteProtocol() < 22) {
      Info("GoAsynchronous", "functionality not supported by the server - ignoring");
      return;
   }

   if (fSync && !IsIdle()) {
      TMessage m(kPROOF_GOASYNC);
      Broadcast(m);
   } else {
      Info("GoAsynchronous", "either idle or already in asynchronous mode - ignoring");
   }
}

//______________________________________________________________________________
void TProof::RecvLogFile(TSocket *s, Int_t size)
{
   // Receive the log file of the slave with socket s.

   const Int_t kMAXBUF = 16384;  //32768  //16384  //65536;
   char buf[kMAXBUF];

   // Append messages to active logging unit
   Int_t fdout = -1;
   if (!fLogToWindowOnly) {
      fdout = (fRedirLog) ? fileno(fLogFileW) : fileno(stdout);
      if (fdout < 0) {
         Warning("RecvLogFile", "file descriptor for outputs undefined (%d):"
                 " will not log msgs", fdout);
         return;
      }
      lseek(fdout, (off_t) 0, SEEK_END);
   }

   Int_t  left, rec, r;
   Long_t filesize = 0;

   while (filesize < size) {
      left = Int_t(size - filesize);
      if (left > kMAXBUF)
         left = kMAXBUF;
      rec = s->RecvRaw(&buf, left);
      filesize = (rec > 0) ? (filesize + rec) : filesize;
      if (!fLogToWindowOnly) {
         if (rec > 0) {

            char *p = buf;
            r = rec;
            while (r) {
               Int_t w;

               w = write(fdout, p, r);

               if (w < 0) {
                  SysError("RecvLogFile", "error writing to unit: %d", fdout);
                  break;
               }
               r -= w;
               p += w;
            }
         } else if (rec < 0) {
            Error("RecvLogFile", "error during receiving log file");
            break;
         }
      }
      if (rec > 0) {
         buf[rec] = 0;
         EmitVA("LogMessage(const char*,Bool_t)", 2, buf, kFALSE);
      }
   }

   // If idle restore logs to main session window
   if (fRedirLog && IsIdle() && !TestBit(TProof::kIsMaster))
      fRedirLog = kFALSE;
}

//______________________________________________________________________________
void TProof::NotifyLogMsg(const char *msg, const char *sfx)
{
   // Notify locally 'msg' to the appropriate units (file, stdout, window)
   // If defined, 'sfx' is added after 'msg' (typically a line-feed);

   // Must have somenthing to notify
   Int_t len = 0;
   if (!msg || (len = strlen(msg)) <= 0)
      return;

   // Get suffix length if any
   Int_t lsfx = (sfx) ? strlen(sfx) : 0;

   // Append messages to active logging unit
   Int_t fdout = -1;
   if (!fLogToWindowOnly) {
      fdout = (fRedirLog) ? fileno(fLogFileW) : fileno(stdout);
      if (fdout < 0) {
         Warning("NotifyLogMsg", "file descriptor for outputs undefined (%d):"
                 " will not notify msgs", fdout);
         return;
      }
      lseek(fdout, (off_t) 0, SEEK_END);
   }

   if (!fLogToWindowOnly) {
      // Write to output unit (stdout or a log file)
      if (len > 0) {
         char *p = (char *)msg;
         Int_t r = len;
         while (r) {
            Int_t w = write(fdout, p, r);
            if (w < 0) {
               SysError("NotifyLogMsg", "error writing to unit: %d", fdout);
               break;
            }
            r -= w;
            p += w;
         }
         // Add a suffix, if requested
         if (lsfx > 0)
            if (write(fdout, sfx, lsfx) != lsfx)
               SysError("NotifyLogMsg", "error writing to unit: %d", fdout);
      }
   }
   if (len > 0) {
      // Publish the message to the separate window (if the latter is missing
      // the message will just get lost)
      EmitVA("LogMessage(const char*,Bool_t)", 2, msg, kFALSE);
   }

   // If idle restore logs to main session window
   if (fRedirLog && IsIdle())
      fRedirLog = kFALSE;
}

//______________________________________________________________________________
void TProof::LogMessage(const char *msg, Bool_t all)
{
   // Log a message into the appropriate window by emitting a signal.

   PDB(kGlobal,1)
      Info("LogMessage","Enter ... %s, 'all: %s", msg ? msg : "",
           all ? "true" : "false");

   if (gROOT->IsBatch()) {
      PDB(kGlobal,1) Info("LogMessage","GUI not started - use TProof::ShowLog()");
      return;
   }

   if (msg)
      EmitVA("LogMessage(const char*,Bool_t)", 2, msg, all);

   // Re-position at the beginning of the file, if requested.
   // This is used by the dialog when it re-opens the log window to
   // provide all the session messages
   if (all)
      lseek(fileno(fLogFileR), (off_t) 0, SEEK_SET);

   const Int_t kMAXBUF = 32768;
   char buf[kMAXBUF];
   Int_t len;
   do {
      while ((len = read(fileno(fLogFileR), buf, kMAXBUF-1)) < 0 &&
             TSystem::GetErrno() == EINTR)
         TSystem::ResetErrno();

      if (len < 0) {
         Error("LogMessage", "error reading log file");
         break;
      }

      if (len > 0) {
         buf[len] = 0;
         EmitVA("LogMessage(const char*,Bool_t)", 2, buf, kFALSE);
      }

   } while (len > 0);
}

//______________________________________________________________________________
Int_t TProof::SendGroupView()
{
   // Send to all active slaves servers the current slave group size
   // and their unique id. Returns number of active slaves.
   // Returns -1 in case of error.

   if (!IsValid()) return -1;
   if (TestBit(TProof::kIsClient)) return 0;
   if (!fSendGroupView) return 0;
   fSendGroupView = kFALSE;

   TIter   next(fActiveSlaves);
   TSlave *sl;

   int  bad = 0, cnt = 0, size = GetNumberOfActiveSlaves();
   char str[32];

   while ((sl = (TSlave *)next())) {
      snprintf(str, 32, "%d %d", cnt, size);
      if (sl->GetSocket()->Send(str, kPROOF_GROUPVIEW) == -1) {
         MarkBad(sl, "could not send kPROOF_GROUPVIEW message");
         bad++;
      } else
         cnt++;
   }

   // Send the group view again in case there was a change in the
   // group size due to a bad slave

   if (bad) SendGroupView();

   return GetNumberOfActiveSlaves();
}

//______________________________________________________________________________
Bool_t TProof::GetFileInCmd(const char *cmd, TString &fn)
{
   // Static method to extract the filename (if any) form a CINT command.
   // Returns kTRUE and the filename in 'fn'; returns kFALSE if not found or not
   // appliable.

   TString s = cmd;
   s = s.Strip(TString::kBoth);

   if (s.Length() > 0 &&
      (s.BeginsWith(".L") || s.BeginsWith(".x") || s.BeginsWith(".X"))) {
      TString file = s(2, s.Length());
      TString acm, arg, io;
      fn = gSystem->SplitAclicMode(file, acm, arg, io);
      if (!fn.IsNull())
         return kTRUE;
   }

   // Not found
   return kFALSE;
}

//______________________________________________________________________________
Int_t TProof::Exec(const char *cmd, Bool_t plusMaster)
{
   // Send command to be executed on the PROOF master and/or slaves.
   // If plusMaster is kTRUE then exeucte on slaves and master too.
   // Command can be any legal command line command. Commands like
   // ".x file.C" or ".L file.C" will cause the file file.C to be send
   // to the PROOF cluster. Returns -1 in case of error, >=0 in case of
   // succes.

   return Exec(cmd, kActive, plusMaster);
}

//______________________________________________________________________________
Int_t TProof::Exec(const char *cmd, ESlaves list, Bool_t plusMaster)
{
   // Send command to be executed on the PROOF master and/or slaves.
   // Command can be any legal command line command. Commands like
   // ".x file.C" or ".L file.C" will cause the file file.C to be send
   // to the PROOF cluster. Returns -1 in case of error, >=0 in case of
   // succes.

   if (!IsValid()) return -1;

   TString s = cmd;
   s = s.Strip(TString::kBoth);

   if (!s.Length()) return 0;

   // check for macro file and make sure the file is available on all slaves
   TString filename;
   if (TProof::GetFileInCmd(s.Data(), filename)) {
      char *fn = gSystem->Which(TROOT::GetMacroPath(), filename, kReadPermission);
      if (fn) {
         if (GetNumberOfUniqueSlaves() > 0) {
            if (SendFile(fn, kAscii | kForward | kCpBin) < 0) {
               Error("Exec", "file %s could not be transfered", fn);
               delete [] fn;
               return -1;
            }
         } else {
            TString scmd = s(0,3) + fn;
            Int_t n = SendCommand(scmd, list);
            delete [] fn;
            return n;
         }
      } else {
         Error("Exec", "macro %s not found", filename.Data());
         return -1;
      }
      delete [] fn;
   }

   if (plusMaster) {
      if (IsLite()) {
         gROOT->ProcessLine(cmd);
      } else {
         Int_t n = GetParallel();
         SetParallelSilent(0);
         Int_t res = SendCommand(cmd, list);
         SetParallelSilent(n);
         if (res < 0)
            return res;
      }
   }
   return SendCommand(cmd, list);
}

//______________________________________________________________________________
Int_t TProof::SendCommand(const char *cmd, ESlaves list)
{
   // Send command to be executed on the PROOF master and/or slaves.
   // Command can be any legal command line command, however commands
   // like ".x file.C" or ".L file.C" will not cause the file.C to be
   // transfered to the PROOF cluster. In that case use TProof::Exec().
   // Returns the status send by the remote server as part of the
   // kPROOF_LOGDONE message. Typically this is the return code of the
   // command on the remote side. Returns -1 in case of error.

   if (!IsValid()) return -1;

   Broadcast(cmd, kMESS_CINT, list);
   Collect(list);

   return fStatus;
}

//______________________________________________________________________________
Int_t TProof::SendCurrentState(ESlaves list)
{
   // Transfer the current state of the master to the active slave servers.
   // The current state includes: the current working directory, etc.
   // Returns the number of active slaves. Returns -1 in case of error.

   if (!IsValid()) return -1;

   // Go to the new directory, reset the interpreter environment and
   // tell slave to delete all objects from its new current directory.
   Broadcast(gDirectory->GetPath(), kPROOF_RESET, list);

   return GetParallel();
}

//______________________________________________________________________________
Int_t TProof::SendInitialState()
{
   // Transfer the initial (i.e. current) state of the master to all
   // slave servers. Currently the initial state includes: log level.
   // Returns the number of active slaves. Returns -1 in case of error.

   if (!IsValid()) return -1;

   SetLogLevel(fLogLevel, gProofDebugMask);

   return GetNumberOfActiveSlaves();
}

//______________________________________________________________________________
Bool_t TProof::CheckFile(const char *file, TSlave *slave, Long_t modtime, Int_t cpopt)
{
   // Check if a file needs to be send to the slave. Use the following
   // algorithm:
   //   - check if file appears in file map
   //     - if yes, get file's modtime and check against time in map,
   //       if modtime not same get md5 and compare against md5 in map,
   //       if not same return kTRUE.
   //     - if no, get file's md5 and modtime and store in file map, ask
   //       slave if file exists with specific md5, if yes return kFALSE,
   //       if no return kTRUE.
   // The options 'cpopt' define if to copy things from cache to sandbox and what.
   // To retrieve from the cache the binaries associated with the file TProof::kCpBin
   // must be set in cpopt; the default is copy everything.
   // Returns kTRUE in case file needs to be send, returns kFALSE in case
   // file is already on remote node.

   Bool_t sendto = kFALSE;

   // create slave based filename
   TString sn = slave->GetName();
   sn += ":";
   sn += slave->GetOrdinal();
   sn += ":";
   sn += gSystem->BaseName(file);

   // check if file is in map
   FileMap_t::const_iterator it;
   if ((it = fFileMap.find(sn)) != fFileMap.end()) {
      // file in map
      MD5Mod_t md = (*it).second;
      if (md.fModtime != modtime) {
         TMD5 *md5 = TMD5::FileChecksum(file);
         if (md5) {
            if ((*md5) != md.fMD5) {
               sendto       = kTRUE;
               md.fMD5      = *md5;
               md.fModtime  = modtime;
               fFileMap[sn] = md;
               // When on the master, the master and/or slaves may share
               // their file systems and cache. Therefore always make a
               // check for the file. If the file already exists with the
               // expected md5 the kPROOF_CHECKFILE command will cause the
               // file to be copied from cache to slave sandbox.
               if (TestBit(TProof::kIsMaster)) {
                  sendto = kFALSE;
                  TMessage mess(kPROOF_CHECKFILE);
                  mess << TString(gSystem->BaseName(file)) << md.fMD5 << cpopt;
                  slave->GetSocket()->Send(mess);

                  fCheckFileStatus = 0;
                  Collect(slave, fCollectTimeout, kPROOF_CHECKFILE);
                  sendto = (fCheckFileStatus == 0) ? kTRUE : kFALSE;
               }
            }
            delete md5;
         } else {
            Error("CheckFile", "could not calculate local MD5 check sum - dont send");
            return kFALSE;
         }
      }
   } else {
      // file not in map
      TMD5 *md5 = TMD5::FileChecksum(file);
      MD5Mod_t md;
      if (md5) {
         md.fMD5      = *md5;
         md.fModtime  = modtime;
         fFileMap[sn] = md;
         delete md5;
      } else {
         Error("CheckFile", "could not calculate local MD5 check sum - dont send");
         return kFALSE;
      }
      TMessage mess(kPROOF_CHECKFILE);
      mess << TString(gSystem->BaseName(file)) << md.fMD5 << cpopt;
      slave->GetSocket()->Send(mess);

      fCheckFileStatus = 0;
      Collect(slave, fCollectTimeout, kPROOF_CHECKFILE);
      sendto = (fCheckFileStatus == 0) ? kTRUE : kFALSE;
   }

   return sendto;
}

//______________________________________________________________________________
Int_t TProof::SendFile(const char *file, Int_t opt, const char *rfile, TSlave *wrk)
{
   // Send a file to master or slave servers. Returns number of slaves
   // the file was sent to, maybe 0 in case master and slaves have the same
   // file system image, -1 in case of error.
   // If defined, send to worker 'wrk' only.
   // If defined, the full path of the remote path will be rfile.
   // If rfile = "cache" the file is copied to the remote cache instead of the sandbox
   // (to copy to the cache on a different name use rfile = "cache:newname").
   // The mask 'opt' is an or of ESendFileOpt:
   //
   //       kAscii  (0x0)      if set true ascii file transfer is used
   //       kBinary (0x1)      if set true binary file transfer is used
   //       kForce  (0x2)      if not set an attempt is done to find out
   //                          whether the file really needs to be downloaded
   //                          (a valid copy may already exist in the cache
   //                          from a previous run); the bit is set by
   //                          UploadPackage, since the check is done elsewhere.
   //       kForward (0x4)     if set, ask server to forward the file to slave
   //                          or submaster (meaningless for slave servers).
   //       kCpBin   (0x8)     Retrieve from the cache the binaries associated
   //                          with the file
   //       kCp      (0x10)    Retrieve the files from the cache
   //

   if (!IsValid()) return -1;

   // Use the active slaves list ...
   TList *slaves = (rfile && !strcmp(rfile, "cache")) ? fUniqueSlaves : fActiveSlaves;
   // ... or the specified slave, if any
   if (wrk) {
      slaves = new TList();
      slaves->Add(wrk);
   }

   if (slaves->GetSize() == 0) return 0;

#ifndef R__WIN32
   Int_t fd = open(file, O_RDONLY);
#else
   Int_t fd = open(file, O_RDONLY | O_BINARY);
#endif
   if (fd < 0) {
      SysError("SendFile", "cannot open file %s", file);
      return -1;
   }

   // Get info about the file
   Long64_t size;
   Long_t id, flags, modtime;
   if (gSystem->GetPathInfo(file, &id, &size, &flags, &modtime) == 1) {
      Error("SendFile", "cannot stat file %s", file);
      return -1;
   }
   if (size == 0) {
      Error("SendFile", "empty file %s", file);
      return -1;
   }

   // Decode options
   Bool_t bin   = (opt & kBinary)  ? kTRUE : kFALSE;
   Bool_t force = (opt & kForce)   ? kTRUE : kFALSE;
   Bool_t fw    = (opt & kForward) ? kTRUE : kFALSE;

   // Copy options
   Int_t cpopt  = 0;
   if ((opt & kCp)) cpopt |= kCp;
   if ((opt & kCpBin)) cpopt |= (kCp | kCpBin);

   const Int_t kMAXBUF = 32768;  //16384  //65536;
   char buf[kMAXBUF];
   Int_t nsl = 0;

   TIter next(slaves);
   TSlave *sl;
   TString fnam(rfile);
   if (fnam == "cache") {
      fnam += Form(":%s", gSystem->BaseName(file));
   } else if (fnam.IsNull()) {
      fnam = gSystem->BaseName(file);
   }
   // List on which we will collect the results
   while ((sl = (TSlave *)next())) {
      if (!sl->IsValid())
         continue;

      Bool_t sendto = force ? kTRUE : CheckFile(file, sl, modtime, cpopt);
      // Don't send the kPROOF_SENDFILE command to real slaves when sendto
      // is false. Masters might still need to send the file to newly added
      // slaves.
      PDB(kPackage,2) {
         const char *snd = (sl->fSlaveType == TSlave::kSlave && sendto) ? "" : "not";
         Info("SendFile", "%s sending file %s to: %s:%s (%d)", snd,
                    file, sl->GetName(), sl->GetOrdinal(), sendto);
      }
      if (sl->fSlaveType == TSlave::kSlave && !sendto)
         continue;
      // The value of 'size' is used as flag remotely, so we need to
      // reset it to 0 if we are not going to send the file
      Long64_t siz = sendto ? size : 0;
      snprintf(buf, kMAXBUF, "%s %d %lld %d", fnam.Data(), bin, siz, fw);
      if (sl->GetSocket()->Send(buf, kPROOF_SENDFILE) == -1) {
         MarkBad(sl, "could not send kPROOF_SENDFILE request");
         continue;
      }

      if (sendto) {

         lseek(fd, 0, SEEK_SET);

         Int_t len;
         do {
            while ((len = read(fd, buf, kMAXBUF)) < 0 && TSystem::GetErrno() == EINTR)
               TSystem::ResetErrno();

            if (len < 0) {
               SysError("SendFile", "error reading from file %s", file);
               Interrupt(kSoftInterrupt, kActive);
               close(fd);
               return -1;
            }

            if (len > 0 && sl->GetSocket()->SendRaw(buf, len) == -1) {
               SysError("SendFile", "error writing to slave %s:%s (now offline)",
                        sl->GetName(), sl->GetOrdinal());
               MarkBad(sl, "sendraw failure");
               sl = 0;
               break;
            }

         } while (len > 0);

         nsl++;
      }
      // Wait for the operation to be done
      if (sl)
         Collect(sl, fCollectTimeout, kPROOF_SENDFILE);
   }

   close(fd);

   // Cleanup temporary list, if any
   if (slaves != fActiveSlaves && slaves != fUniqueSlaves)
      SafeDelete(slaves);

   return nsl;
}

//______________________________________________________________________________
Int_t TProof::SendObject(const TObject *obj, ESlaves list)
{
   // Send object to master or slave servers. Returns number of slaves object
   // was sent to, -1 in case of error.

   if (!IsValid() || !obj) return -1;

   TMessage mess(kMESS_OBJECT);

   mess.WriteObject(obj);
   return Broadcast(mess, list);
}

//______________________________________________________________________________
Int_t TProof::SendPrint(Option_t *option)
{
   // Send print command to master server. Returns number of slaves message
   // was sent to. Returns -1 in case of error.

   if (!IsValid()) return -1;

   Broadcast(option, kPROOF_PRINT, kActive);
   return Collect(kActive, fCollectTimeout);
}

//______________________________________________________________________________
void TProof::SetLogLevel(Int_t level, UInt_t mask)
{
   // Set server logging level.

   char str[32];
   fLogLevel        = level;
   gProofDebugLevel = level;
   gProofDebugMask  = (TProofDebug::EProofDebugMask) mask;
   snprintf(str, 32, "%d %u", level, mask);
   Broadcast(str, kPROOF_LOGLEVEL, kAll);
}

//______________________________________________________________________________
void TProof::SetRealTimeLog(Bool_t on)
{
   // Switch ON/OFF the real-time logging facility. When this option is
   // ON, log messages from processing are sent back as they come, instead of
   // being sent back at the end in one go. This may help debugging or monitoring
   // in some cases, but, depending on the amount of log, it may have significant
   // consequencies on the load over the network, so it must be used with care.

   if (IsValid()) {
      TMessage mess(kPROOF_REALTIMELOG);
      mess << on;
      Broadcast(mess);
   } else {
      Warning("SetRealTimeLog","session is invalid - do nothing");
   }
}

//______________________________________________________________________________
Int_t TProof::SetParallelSilent(Int_t nodes, Bool_t random)
{
   // Tell PROOF how many slaves to use in parallel. If random is TRUE a random
   // selection is done (if nodes is less than the available nodes).
   // Returns the number of parallel slaves. Returns -1 in case of error.

   if (!IsValid()) return -1;

   if (TestBit(TProof::kIsMaster)) {
      GoParallel(nodes, kFALSE, random);
      return SendCurrentState();
   } else {
      PDB(kGlobal,1) Info("SetParallelSilent", "request %d node%s", nodes,
          nodes == 1 ? "" : "s");
      TMessage mess(kPROOF_PARALLEL);
      mess << nodes << random;
      Broadcast(mess);
      Collect(kActive, fCollectTimeout);
      Int_t n = GetParallel();
      PDB(kGlobal,1) Info("SetParallelSilent", "got %d node%s", n, n == 1 ? "" : "s");
      return n;
   }
}

//______________________________________________________________________________
Int_t TProof::SetParallel(Int_t nodes, Bool_t random)
{
   // Tell PROOF how many slaves to use in parallel. Returns the number of
   // parallel slaves. Returns -1 in case of error.

   Int_t n = SetParallelSilent(nodes, random);
   if (TestBit(TProof::kIsClient)) {
      if (n < 1) {
         Printf("PROOF set to sequential mode");
      } else {
         TString subfix = (n == 1) ? "" : "s";
         if (random)
            subfix += ", randomly selected";
         Printf("PROOF set to parallel mode (%d worker%s)", n, subfix.Data());
      }
   }
   return n;
}

//______________________________________________________________________________
Int_t TProof::GoParallel(Int_t nodes, Bool_t attach, Bool_t random)
{
   // Go in parallel mode with at most "nodes" slaves. Since the fSlaves
   // list is sorted by slave performace the active list will contain first
   // the most performant nodes. Returns the number of active slaves.
   // If random is TRUE, and nodes is less than the number of available workers,
   // a random selection is done.
   // Returns -1 in case of error.

   if (!IsValid()) return -1;

   if (nodes < 0) nodes = 0;

   fActiveSlaves->Clear();
   fActiveMonitor->RemoveAll();

   // Prepare the list of candidates first.
   // Algorithm depends on random option.
   TSlave *sl = 0;
   TList *wlst = new TList;
   TIter nxt(fSlaves);
   fInactiveSlaves->Clear();
   while ((sl = (TSlave *)nxt())) {
      if (sl->IsValid() && !fBadSlaves->FindObject(sl)) {
         if (strcmp("IGNORE", sl->GetImage()) == 0) continue;
         if ((sl->GetSlaveType() != TSlave::kSlave) &&
             (sl->GetSlaveType() != TSlave::kMaster)) {
            Error("GoParallel", "TSlave is neither Master nor Slave");
            R__ASSERT(0);
         }
         // Good candidate
         wlst->Add(sl);
         // Set it inactive
         fInactiveSlaves->Add(sl);
         sl->SetStatus(TSlave::kInactive);
      }
   }
   Int_t nwrks = (nodes > wlst->GetSize()) ? wlst->GetSize() : nodes;
   int cnt = 0;
   fEndMaster = TestBit(TProof::kIsMaster) ? kTRUE : kFALSE;
   while (cnt < nwrks) {
      // Random choice, if requested
      if (random) {
         Int_t iwrk = (Int_t) (gRandom->Rndm() * wlst->GetSize());
         sl = (TSlave *) wlst->At(iwrk);
      } else {
         // The first available
         sl = (TSlave *) wlst->First();
      }
      if (!sl) {
         Error("GoParallel", "attaching to candidate!");
         break;
      }
      // Remove from the list
      wlst->Remove(sl);

      Int_t slavenodes = 0;
      if (sl->GetSlaveType() == TSlave::kSlave) {
         sl->SetStatus(TSlave::kActive);
         fActiveSlaves->Add(sl);
         fInactiveSlaves->Remove(sl);
         fActiveMonitor->Add(sl->GetSocket());
         slavenodes = 1;
      } else if (sl->GetSlaveType() == TSlave::kMaster) {
         fEndMaster = kFALSE;
         TMessage mess(kPROOF_PARALLEL);
         if (!attach) {
            mess << nodes-cnt;
         } else {
            // To get the number of slaves
            mess.SetWhat(kPROOF_LOGFILE);
            mess << -1 << -1;
         }
         if (sl->GetSocket()->Send(mess) == -1) {
            MarkBad(sl, "could not send kPROOF_PARALLEL or kPROOF_LOGFILE request");
            slavenodes = 0;
         } else {
            Collect(sl, fCollectTimeout);
            if (sl->IsValid()) {
               sl->SetStatus(TSlave::kActive);
               fActiveSlaves->Add(sl);
               fInactiveSlaves->Remove(sl);
               fActiveMonitor->Add(sl->GetSocket());
               if (sl->GetParallel() > 0) {
                  slavenodes = sl->GetParallel();
               } else {
                  slavenodes = 0;
               }
            } else {
               MarkBad(sl, "collect failed after kPROOF_PARALLEL or kPROOF_LOGFILE request");
               slavenodes = 0;
            }
         }
      }
      // 'slavenodes' may be different than 1 in multimaster setups
      cnt += slavenodes;
   }

   // Cleanup list
   wlst->SetOwner(0);
   SafeDelete(wlst);

   // Get slave status (will set the slaves fWorkDir correctly)
   AskStatistics();

   // Find active slaves with unique image
   FindUniqueSlaves();

   // Send new group-view to slaves
   if (!attach)
      SendGroupView();

   Int_t n = GetParallel();

   if (TestBit(TProof::kIsClient)) {
      if (n < 1)
         printf("PROOF set to sequential mode\n");
      else
         printf("PROOF set to parallel mode (%d worker%s)\n",
                n, n == 1 ? "" : "s");
   }

   PDB(kGlobal,1) Info("GoParallel", "got %d node%s", n, n == 1 ? "" : "s");
   return n;
}

//______________________________________________________________________________
void TProof::ShowData()
{
   // List contents of the data directory in the sandbox.
   // This is the place where files produced by the client queries are kept

   if (!IsValid() || !fManager) return;

   // This is run via the manager
   fManager->Find("~/data", "-type f", "all");
}

//______________________________________________________________________________
void TProof::ClearData(UInt_t what, const char *dsname)
{
   // Remove files for the data directory.
   // The option 'what' can take the values:
   //     kPurge                 remove all files and directories under '~/data' 
   //     kUnregistered          remove only files not in registered datasets (default)
   //     kDataset               remove files belonging to dataset 'dsname'
   // User is prompt for confirmation, unless kForceClear is ORed with the option

   if (!IsValid() || !fManager) return;

   // Check whether we need to prompt
   TString prompt, a("Y");
   Bool_t force = (what & kForceClear) ? kTRUE : kFALSE;
   Bool_t doask = (!force && isatty(0) != 0 && isatty(1) != 0) ? kTRUE : kFALSE;

   // If all just send the request
   if ((what & TProof::kPurge)) {
      // Prompt, if requested
      if (doask && !Prompt("Do you really want to remove all data files")) return;
      fManager->Rm("~/data/*", "-rf", "all");
      return;
   } else if ((what & TProof::kDataset)) {
      // We must have got a name
      if (!dsname || strlen(dsname) <= 0) {
         Error("ClearData", "dataset name mandatory when removing a full dataset");
         return;
      }
      // Check if the dataset is registered
      if (!ExistsDataSet(dsname)) {
         Error("ClearData", "dataset '%s' does not exists", dsname);
         return;
      }
      // Get the file content
      TFileCollection *fc = GetDataSet(dsname);
      if (!fc) {
         Error("ClearData", "could not retrieve info about dataset '%s'", dsname);
         return;
      }
      // Prompt, if requested
      if (doask && !Prompt(TString::Format("Do you really want to remove all data files"
                                           " of dataset '%s'", dsname))) return;
      // Loop through the files
      Bool_t rmds = kTRUE;
      TIter nxf(fc->GetList());
      TFileInfo *fi = 0;
      Int_t rfiles = 0, nfiles = fc->GetList()->GetSize();
      while ((fi = (TFileInfo *) nxf())) {
         // Fill the host info
         TString host, file;
         // Take info from the current url
         TUrl uf(*(fi->GetFirstUrl()));
         file = uf.GetFile();
         host = uf.GetHost();
         // Now search for any "file:" url
         Int_t nurl = fi->GetNUrls();
         fi->ResetUrl();
         TUrl *up = 0;
         while (nurl-- && fi->NextUrl()) {
            up = fi->GetCurrentUrl();
            if (!strcmp(up->GetProtocol(), "file")) {
               TString opt(up->GetOptions());
               if (opt.BeginsWith("node=")) {
                  host=opt;
                  host.ReplaceAll("node=","");
                  file = up->GetFile();
                  break;
               }
            }
         }
         // Issue a remove request now
         if (fManager->Rm(file.Data(), "-f", host.Data()) != 0) {
            Error("ClearData", "problems removing '%s'", file.Data());
            // Some files not removed: keep the meta info about this dataset
            rmds = kFALSE;
         }
         rfiles++;
         ClearDataProgress(rfiles, nfiles);
      }
      fprintf(stderr, "\n");
      if (rmds) {
         // All files were removed successfully: remove also the dataset meta info
         RemoveDataSet(dsname);
      }
   } else if (what &TProof::kUnregistered) {

      // Get the existing files
      TString outtmp("ProofClearData_");
      FILE *ftmp = gSystem->TempFileName(outtmp);
      if (!ftmp) {
         Error("ClearData", "cannot create temp file for logs");
         return;
      }
      fclose(ftmp);
      RedirectHandle_t h;
      gSystem->RedirectOutput(outtmp.Data(), "w", &h);
      ShowData();
      gSystem->RedirectOutput(0, 0, &h);
      // Parse the output file now
      ifstream in;
      in.open(outtmp.Data());
      if (!in.is_open()) {
         Error("ClearData", "could not open temp file for logs: %s", outtmp.Data());
         gSystem->Unlink(outtmp);
         return;
      }
      // Go through
      Int_t nfiles = 0;
      TMap *afmap = new TMap;
      TString line, host, file;
      Int_t from = 0;
      while (in.good()) {
         line.ReadLine(in);
         if (line.IsNull()) continue;
         while (line.EndsWith("\n")) { line.Strip(TString::kTrailing, '\n'); }
         from = 0;
         if (line.Tokenize(host, from, "| ")) line.Tokenize(file, from, "| ");
         if (!host.IsNull() && !file.IsNull()) {
            TList *fl = (TList *) afmap->GetValue(host.Data());
            if (!fl) {
               fl = new TList();
               fl->SetName(host);
               afmap->Add(new TObjString(host), fl);
            }
            fl->Add(new TObjString(file));
            nfiles++;
            PDB(kDataset,2)
               Info("ClearData", "added info for: h:%s, f:%s", host.Data(), file.Data());
         } else {
            Warning("ClearData", "found incomplete line: '%s'", line.Data());
         }
      }
      // Close and remove the file 
      in.close();
      gSystem->Unlink(outtmp);

      // Get registered data files
      TString sel = TString::Format("/%s/%s/", GetGroup(), GetUser());
      TMap *fcmap = GetDataSets(sel);
      if (!fcmap || fcmap->GetSize() <= 0) {
         PDB(kDataset,1)
            Info("ClearData", "no dataset beloning to '%s'", sel.Data());
         SafeDelete(fcmap);
         return;
      }

      // Go thorugh and prepare the lists per node
      TString opt;
      TIter nxfc(fcmap);
      TObjString *os = 0;
      while ((os = (TObjString *) nxfc())) {
         TFileCollection *fc = 0;
         if ((fc = (TFileCollection *) fcmap->GetValue(os))) {
            TFileInfo *fi = 0;
            TIter nxfi(fc->GetList());
            while ((fi = (TFileInfo *) nxfi())) {
               // Get special "file:" url
               fi->ResetUrl();
               Int_t nurl = fi->GetNUrls();
               TUrl *up = 0;
               while (nurl-- && fi->NextUrl()) {
                  up = fi->GetCurrentUrl();
                  if (!strcmp(up->GetProtocol(), "file")) {
                     opt = up->GetOptions();
                     if (opt.BeginsWith("node=")) {
                        host=opt;
                        host.ReplaceAll("node=","");
                        file = up->GetFile();
                        PDB(kDataset,2)
                           Info("ClearData", "found: host: %s, file: %s", host.Data(), file.Data());
                        // Remove this from the full list, if there
                        TList *fl = (TList *) afmap->GetValue(host.Data());
                        if (fl) {
                           TObjString *fn = (TObjString *) fl->FindObject(file.Data());
                           if (fn) {
                              fl->Remove(fn);
                              SafeDelete(fn);
                              nfiles--;
                           } else {
                              Warning("ClearData",
                                      "registered file '%s' not found in the full list!", file.Data());
                           }
                        }
                        break;
                     }
                  }
               }
            }
         }
      }
      // Clean up the the received map
      fcmap->SetOwner(kTRUE);
      SafeDelete(fcmap);
      // List of the files to be removed
      Info("ClearData", "%d unregistered files to be removed:", nfiles);
      afmap->Print();
      // Prompt, if requested
      if (doask && !Prompt(TString::Format("Do you really want to remove all %d"
                                           " unregistered data files", nfiles))) return;
      // Remove one by one; we may implement a bloc remove in the future
      Int_t rfiles = 0;
      TIter nxls(afmap);
      while ((os = (TObjString *) nxls())) {
         TList *fl = 0;
         if ((fl = (TList *) afmap->GetValue(os))) {
            TIter nxf(fl);
            TObjString *fn = 0;
            while ((fn = (TObjString *) nxf())) {
               // Issue a remove request now
               if (fManager->Rm(fn->GetName(), "-f", os->GetName()) != 0) {
                  Error("ClearData", "problems removing '%s' on host '%s'", fn->GetName(), os->GetName());
               }
               rfiles++;
               ClearDataProgress(rfiles, nfiles);
            }
         }
      }
      fprintf(stderr, "\n");
      // Final cleanup
      afmap->SetOwner(kTRUE);
      SafeDelete(afmap);
   }
}

//______________________________________________________________________________
Bool_t TProof::Prompt(const char *p)
{
   // Prompt the question 'p' requiring an answer y,Y,n,N
   // Return kTRUE is the answer was y or Y, kFALSE in all other cases.

   TString pp(p);
   if (!pp.Contains("?")) pp += "?";
   if (!pp.Contains("[y/N]")) pp += " [y/N]";
   TString a = Getline(pp.Data());
   if (a != "\n" && a[0] != 'y' &&  a[0] != 'Y' &&  a[0] != 'n' &&  a[0] != 'N') {
      Printf("Please answer y, Y, n or N");
      // Unclear answer: assume negative
      return kFALSE;
   } else if (a == "\n" || a[0] == 'n' ||  a[0] == 'N') {
      // Explicitly Negative answer
      return kFALSE;
   }
   // Explicitly Positive answer
   return kTRUE;
}

//______________________________________________________________________________
void TProof::ClearDataProgress(Int_t r, Int_t t)
{
   // Progress bar for clear data

   fprintf(stderr, "[TProof::ClearData] Total %5d files\t|", t);
   for (Int_t l = 0; l < 20; l++) {
      if (r > 0 && t > 0) {
         if (l < 20*r/t)
            fprintf(stderr, "=");
         else if (l == 20*r/t)
            fprintf(stderr, ">");
         else if (l > 20*r/t)
            fprintf(stderr, ".");
      } else
         fprintf(stderr, "=");
   }
   fprintf(stderr, "| %.02f %%      \r", 100.0*(t ? (r/t) : 1));
}

//______________________________________________________________________________
void TProof::ShowCache(Bool_t all)
{
   // List contents of file cache. If all is true show all caches also on
   // slaves. If everything is ok all caches are to be the same.

   if (!IsValid()) return;

   TMessage mess(kPROOF_CACHE);
   mess << Int_t(kShowCache) << all;
   Broadcast(mess, kUnique);

   if (all) {
      TMessage mess2(kPROOF_CACHE);
      mess2 << Int_t(kShowSubCache) << all;
      Broadcast(mess2, fNonUniqueMasters);

      Collect(kAllUnique, fCollectTimeout);
   } else {
      Collect(kUnique, fCollectTimeout);
   }
}

//______________________________________________________________________________
void TProof::ClearCache(const char *file)
{
   // Remove file from all file caches. If file is 0 or "" or "*", remove all
   // the files

   if (!IsValid()) return;

   TMessage mess(kPROOF_CACHE);
   mess << Int_t(kClearCache) << TString(file);
   Broadcast(mess, kUnique);

   TMessage mess2(kPROOF_CACHE);
   mess2 << Int_t(kClearSubCache) << TString(file);
   Broadcast(mess2, fNonUniqueMasters);

   Collect(kAllUnique);

   // clear file map so files get send again to remote nodes
   fFileMap.clear();
}

//______________________________________________________________________________
void TProof::ShowPackages(Bool_t all)
{
   // List contents of package directory. If all is true show all package
   // directries also on slaves. If everything is ok all package directories
   // should be the same.

   if (!IsValid()) return;

   if (TestBit(TProof::kIsClient)) {
      if (fGlobalPackageDirList && fGlobalPackageDirList->GetSize() > 0) {
         // Scan the list of global packages dirs
         TIter nxd(fGlobalPackageDirList);
         TNamed *nm = 0;
         while ((nm = (TNamed *)nxd())) {
            printf("*** Global Package cache %s client:%s ***\n",
                   nm->GetName(), nm->GetTitle());
            fflush(stdout);
            gSystem->Exec(Form("%s %s", kLS, nm->GetTitle()));
            printf("\n");
            fflush(stdout);
         }
      }
      printf("*** Package cache client:%s ***\n", fPackageDir.Data());
      fflush(stdout);
      gSystem->Exec(Form("%s %s", kLS, fPackageDir.Data()));
   }

   // Nothing more to do if we are a Lite-session
   if (IsLite()) return;

   TMessage mess(kPROOF_CACHE);
   mess << Int_t(kShowPackages) << all;
   Broadcast(mess, kUnique);

   if (all) {
      TMessage mess2(kPROOF_CACHE);
      mess2 << Int_t(kShowSubPackages) << all;
      Broadcast(mess2, fNonUniqueMasters);

      Collect(kAllUnique, fCollectTimeout);
   } else {
      Collect(kUnique, fCollectTimeout);
   }
}

//______________________________________________________________________________
void TProof::ShowEnabledPackages(Bool_t all)
{
   // List which packages are enabled. If all is true show enabled packages
   // for all active slaves. If everything is ok all active slaves should
   // have the same packages enabled.

   if (!IsValid()) return;

   if (TestBit(TProof::kIsClient)) {
      printf("*** Enabled packages on client on %s\n", gSystem->HostName());
      TIter next(fEnabledPackagesOnClient);
      while (TObjString *str = (TObjString*) next())
         printf("%s\n", str->GetName());
   }

   // Nothing more to do if we are a Lite-session
   if (IsLite()) return;

   TMessage mess(kPROOF_CACHE);
   mess << Int_t(kShowEnabledPackages) << all;
   Broadcast(mess);
   Collect(kActive, fCollectTimeout);
}

//______________________________________________________________________________
Int_t TProof::ClearPackages()
{
   // Remove all packages.
   // Returns 0 in case of success and -1 in case of error.

   if (!IsValid()) return -1;

   if (UnloadPackages() == -1)
      return -1;

   if (DisablePackages() == -1)
      return -1;

   return fStatus;
}

//______________________________________________________________________________
Int_t TProof::ClearPackage(const char *package)
{
   // Remove a specific package.
   // Returns 0 in case of success and -1 in case of error.

   if (!IsValid()) return -1;

   if (!package || !strlen(package)) {
      Error("ClearPackage", "need to specify a package name");
      return -1;
   }

   // if name, erroneously, is a par pathname strip off .par and path
   TString pac = package;
   if (pac.EndsWith(".par"))
      pac.Remove(pac.Length()-4);
   pac = gSystem->BaseName(pac);

   if (UnloadPackage(pac) == -1)
      return -1;

   if (DisablePackage(pac) == -1)
      return -1;

   return fStatus;
}

//______________________________________________________________________________
Int_t TProof::DisablePackage(const char *package)
{
   // Remove a specific package.
   // Returns 0 in case of success and -1 in case of error.

   if (!IsValid()) return -1;

   if (!package || !strlen(package)) {
      Error("DisablePackage", "need to specify a package name");
      return -1;
   }

   // if name, erroneously, is a par pathname strip off .par and path
   TString pac = package;
   if (pac.EndsWith(".par"))
      pac.Remove(pac.Length()-4);
   pac = gSystem->BaseName(pac);

   if (DisablePackageOnClient(pac) == -1)
      return -1;

   // Nothing more to do if we are a Lite-session
   if (IsLite()) return 0;

   Int_t st = -1;
   Bool_t done = kFALSE;
   if (fManager) {
      // Try to do it via XROOTD (new way)
      TString path;
      path.Form("~/packages/%s", package);
      if (fManager->Rm(path, "-rf", "all") != -1) {
         path.Append(".par");
         if (fManager->Rm(path, "-f", "all") != -1) {
            done = kTRUE;
            st = 0;
         }
      }
   }
   if (!done) {
      // Try via TProofServ (old way)
      TMessage mess(kPROOF_CACHE);
      mess << Int_t(kDisablePackage) << pac;
      Broadcast(mess, kUnique);

      TMessage mess2(kPROOF_CACHE);
      mess2 << Int_t(kDisableSubPackage) << pac;
      Broadcast(mess2, fNonUniqueMasters);

      Collect(kAllUnique);
      st = fStatus;
   }

   // Done
   return st;
}

//______________________________________________________________________________
Int_t TProof::DisablePackageOnClient(const char *package)
{
   // Remove a specific package from the client.
   // Returns 0 in case of success and -1 in case of error.

   if (TestBit(TProof::kIsClient)) {
      // Remove the package directory and the par file locally
      fPackageLock->Lock();
      gSystem->Exec(Form("%s %s/%s", kRM, fPackageDir.Data(), package));
      gSystem->Exec(Form("%s %s/%s.par", kRM, fPackageDir.Data(), package));
      fPackageLock->Unlock();
      if (!gSystem->AccessPathName(Form("%s/%s.par", fPackageDir.Data(), package)))
         Warning("DisablePackageOnClient", "unable to remove package PAR file for %s", package);
      if (!gSystem->AccessPathName(Form("%s/%s", fPackageDir.Data(), package)))
         Warning("DisablePackageOnClient", "unable to remove package directory for %s", package);
   }

   return 0;
}

//______________________________________________________________________________
Int_t TProof::DisablePackages()
{
   // Remove all packages.
   // Returns 0 in case of success and -1 in case of error.

   if (!IsValid()) return -1;

   // remove all packages on client
   if (TestBit(TProof::kIsClient)) {
      fPackageLock->Lock();
      gSystem->Exec(Form("%s %s/*", kRM, fPackageDir.Data()));
      fPackageLock->Unlock();
   }

   // Nothing more to do if we are a Lite-session
   if (IsLite()) return 0;

   TMessage mess(kPROOF_CACHE);
   mess << Int_t(kDisablePackages);
   Broadcast(mess, kUnique);

   TMessage mess2(kPROOF_CACHE);
   mess2 << Int_t(kDisableSubPackages);
   Broadcast(mess2, fNonUniqueMasters);

   Collect(kAllUnique);

   return fStatus;
}

//______________________________________________________________________________
Int_t TProof::BuildPackage(const char *package, EBuildPackageOpt opt)
{
   // Build specified package. Executes the PROOF-INF/BUILD.sh
   // script if it exists on all unique nodes. If opt is kBuildOnSlavesNoWait
   // then submit build command to slaves, but don't wait
   // for results. If opt is kCollectBuildResults then collect result
   // from slaves. To be used on the master.
   // If opt = kBuildAll (default) then submit and wait for results
   // (to be used on the client).
   // Returns 0 in case of success and -1 in case of error.

   if (!IsValid()) return -1;

   if (!package || !strlen(package)) {
      Error("BuildPackage", "need to specify a package name");
      return -1;
   }

   // if name, erroneously, is a par pathname strip off .par and path
   TString pac = package;
   if (pac.EndsWith(".par"))
      pac.Remove(pac.Length()-4);
   pac = gSystem->BaseName(pac);

   Bool_t buildOnClient = kTRUE;
   if (opt == kDontBuildOnClient) {
      buildOnClient = kFALSE;
      opt = kBuildAll;
   }

   if (opt <= kBuildAll && !IsLite()) {
      TMessage mess(kPROOF_CACHE);
      mess << Int_t(kBuildPackage) << pac;
      Broadcast(mess, kUnique);

      TMessage mess2(kPROOF_CACHE);
      mess2 << Int_t(kBuildSubPackage) << pac;
      Broadcast(mess2, fNonUniqueMasters);
   }

   if (opt >= kBuildAll) {
      // by first forwarding the build commands to the master and slaves
      // and only then building locally we build in parallel
      Int_t st = 0;
      if (buildOnClient)
         st = BuildPackageOnClient(pac);

      fStatus = 0;
      if (!IsLite())
         Collect(kAllUnique);

      if (fStatus < 0 || st < 0)
         return -1;
   }

   return 0;
}

//______________________________________________________________________________
Int_t TProof::BuildPackageOnClient(const TString &package)
{
   // Build specified package on the client. Executes the PROOF-INF/BUILD.sh
   // script if it exists on the client.
   // Returns 0 in case of success and -1 in case of error.
   // The code is equivalent to the one in TProofServ.cxx (TProof::kBuildPackage
   // case). Keep in sync in case of changes.

   if (TestBit(TProof::kIsClient)) {
      Int_t status = 0;
      TString pdir, ocwd;

      // Package path
      pdir = fPackageDir + "/" + package;
      if (gSystem->AccessPathName(pdir, kReadPermission) ||
         gSystem->AccessPathName(pdir + "/PROOF-INF", kReadPermission)) {
         // Is there a global package with this name?
         if (fGlobalPackageDirList && fGlobalPackageDirList->GetSize() > 0) {
            // Scan the list of global packages dirs
            TIter nxd(fGlobalPackageDirList);
            TNamed *nm = 0;
            while ((nm = (TNamed *)nxd())) {
               pdir = Form("%s/%s", nm->GetTitle(), package.Data());
               if (!gSystem->AccessPathName(pdir, kReadPermission) &&
                   !gSystem->AccessPathName(pdir + "/PROOF-INF", kReadPermission)) {
                  // Package found, stop searching
                  break;
               }
               pdir = "";
            }
            if (pdir.Length() <= 0) {
               // Package not found
               Error("BuildPackageOnClient", "failure locating %s ...", package.Data());
               return -1;
            } else {
               // Package is in the global dirs
               if (gDebug > 0)
                  Info("BuildPackageOnClient", "found global package: %s", pdir.Data());
               return 0;
            }
         }
      }
      PDB(kPackage, 1)
         Info("BuildPackageOnCLient",
              "package %s exists and has PROOF-INF directory", package.Data());

      fPackageLock->Lock();

      ocwd = gSystem->WorkingDirectory();
      gSystem->ChangeDirectory(pdir);

      // check for BUILD.sh and execute
      if (!gSystem->AccessPathName("PROOF-INF/BUILD.sh")) {

         // read version from file proofvers.txt, and if current version is
         // not the same do a "BUILD.sh clean"
         Bool_t savever = kFALSE;
         Int_t rev = -1;
         TString v;
         FILE *f = fopen("PROOF-INF/proofvers.txt", "r");
         if (f) {
            TString r;
            v.Gets(f);
            r.Gets(f);
            rev = (!r.IsNull() && r.IsDigit()) ? r.Atoi() : -1;
            fclose(f);
         }
         if (!f || v != gROOT->GetVersion() ||
            (gROOT->GetSvnRevision() > 0 && rev != gROOT->GetSvnRevision())) {
            savever = kTRUE;
            Info("BuildPackageOnCLient",
                 "%s: version change (current: %s:%d, build: %s:%d): cleaning ... ",
                 package.Data(), gROOT->GetVersion(), gROOT->GetSvnRevision(), v.Data(), rev);
            // Hard cleanup: go up the dir tree
            gSystem->ChangeDirectory(fPackageDir);
            // remove package directory
            gSystem->Exec(Form("%s %s", kRM, pdir.Data()));
            // find gunzip...
            char *gunzip = gSystem->Which(gSystem->Getenv("PATH"), kGUNZIP, kExecutePermission);
            if (gunzip) {
               TString par = Form("%s.par", pdir.Data());
               // untar package
               TString cmd(Form(kUNTAR3, gunzip, par.Data()));
               status = gSystem->Exec(cmd);
               if ((status = gSystem->Exec(cmd))) {
                  Error("BuildPackageOnCLient", "failure executing: %s", cmd.Data());
               } else {
                  // Go down to the package directory
                  gSystem->ChangeDirectory(pdir);
               }
               delete [] gunzip;
            } else {
               Error("BuildPackageOnCLient", "%s not found", kGUNZIP);
               status = -1;
            }
         }

         if (gSystem->Exec("PROOF-INF/BUILD.sh")) {
            Error("BuildPackageOnClient", "building package %s on the client failed", package.Data());
            status = -1;
         }

         if (savever && !status) {
            f = fopen("PROOF-INF/proofvers.txt", "w");
            if (f) {
               fputs(gROOT->GetVersion(), f);
               fputs(Form("\n%d",gROOT->GetSvnRevision()), f);
               fclose(f);
            }
         }
      } else {
         PDB(kPackage, 1)
            Info("BuildPackageOnCLient",
                 "package %s exists but has no PROOF-INF/BUILD.sh script", package.Data());
      }

      gSystem->ChangeDirectory(ocwd);

      fPackageLock->Unlock();

      return status;
   }
   return 0;
}

//______________________________________________________________________________
Int_t TProof::LoadPackage(const char *package, Bool_t notOnClient)
{
   // Load specified package. Executes the PROOF-INF/SETUP.C script
   // on all active nodes. If notOnClient = true, don't load package
   // on the client. The default is to load the package also on the client.
   // Returns 0 in case of success and -1 in case of error.

   if (!IsValid()) return -1;

   if (!package || !strlen(package)) {
      Error("LoadPackage", "need to specify a package name");
      return -1;
   }

   // if name, erroneously, is a par pathname strip off .par and path
   TString pac = package;
   if (pac.EndsWith(".par"))
      pac.Remove(pac.Length()-4);
   pac = gSystem->BaseName(pac);

   if (!notOnClient)
      if (LoadPackageOnClient(pac) == -1)
         return -1;

   TMessage mess(kPROOF_CACHE);
   mess << Int_t(kLoadPackage) << pac;
   Broadcast(mess);
   Collect();

   return fStatus;
}

//______________________________________________________________________________
Int_t TProof::LoadPackageOnClient(const TString &package)
{
   // Load specified package in the client. Executes the PROOF-INF/SETUP.C
   // script on the client. Returns 0 in case of success and -1 in case of error.
   // The code is equivalent to the one in TProofServ.cxx (TProof::kLoadPackage
   // case). Keep in sync in case of changes.

   if (TestBit(TProof::kIsClient)) {
      Int_t status = 0;
      TString pdir, ocwd;
      // If already loaded don't do it again
      if (fEnabledPackagesOnClient->FindObject(package)) {
         Info("LoadPackageOnClient",
              "package %s already loaded", package.Data());
         return 0;
      }

      // always follows BuildPackage so no need to check for PROOF-INF
      pdir = fPackageDir + "/" + package;

      if (gSystem->AccessPathName(pdir, kReadPermission)) {
         // Is there a global package with this name?
         if (fGlobalPackageDirList && fGlobalPackageDirList->GetSize() > 0) {
            // Scan the list of global packages dirs
            TIter nxd(fGlobalPackageDirList);
            TNamed *nm = 0;
            while ((nm = (TNamed *)nxd())) {
               pdir = Form("%s/%s", nm->GetTitle(), package.Data());
               if (!gSystem->AccessPathName(pdir, kReadPermission)) {
                  // Package found, stop searching
                  break;
               }
               pdir = "";
            }
            if (pdir.Length() <= 0) {
               // Package not found
               Error("LoadPackageOnClient", "failure locating %s ...", package.Data());
               return -1;
            }
         }
      }

      ocwd = gSystem->WorkingDirectory();
      gSystem->ChangeDirectory(pdir);

      // check for SETUP.C and execute
      if (!gSystem->AccessPathName("PROOF-INF/SETUP.C")) {
         Int_t err = 0;
         Int_t errm = gROOT->Macro("PROOF-INF/SETUP.C", &err);
         if (errm < 0)
            status = -1;
         if (err > TInterpreter::kNoError && err <= TInterpreter::kFatal)
            status = -1;
      } else {
         PDB(kPackage, 1)
            Info("LoadPackageOnCLient",
                 "package %s exists but has no PROOF-INF/SETUP.C script", package.Data());
      }

      gSystem->ChangeDirectory(ocwd);

      if (!status) {
         // create link to package in working directory

         fPackageLock->Lock();

         FileStat_t stat;
         Int_t st = gSystem->GetPathInfo(package, stat);
         // check if symlink, if so unlink, if not give error
         // NOTE: GetPathnfo() returns 1 in case of symlink that does not point to
         // existing file or to a directory, but if fIsLink is true the symlink exists
         if (stat.fIsLink)
            gSystem->Unlink(package);
         else if (st == 0) {
            Error("LoadPackageOnClient", "cannot create symlink %s in %s on client, "
                  "another item with same name already exists", package.Data(), ocwd.Data());
            fPackageLock->Unlock();
            return -1;
         }
         gSystem->Symlink(pdir, package);

         fPackageLock->Unlock();

         // add package to list of include directories to be searched by ACliC
         gSystem->AddIncludePath(TString("-I") + package);

         // add package to list of include directories to be searched by CINT
         gROOT->ProcessLine(TString(".include ") + package);

         fEnabledPackagesOnClient->Add(new TObjString(package));
         PDB(kPackage, 1)
            Info("LoadPackageOnClient",
                 "package %s successfully loaded", package.Data());
      } else
         Error("LoadPackageOnClient", "loading package %s on client failed", package.Data());

      return status;
   }
   return 0;
}

//______________________________________________________________________________
Int_t TProof::UnloadPackage(const char *package)
{
   // Unload specified package.
   // Returns 0 in case of success and -1 in case of error.

   if (!IsValid()) return -1;

   if (!package || !strlen(package)) {
      Error("UnloadPackage", "need to specify a package name");
      return -1;
   }

   // if name, erroneously, is a par pathname strip off .par and path
   TString pac = package;
   if (pac.EndsWith(".par"))
      pac.Remove(pac.Length()-4);
   pac = gSystem->BaseName(pac);

   if (UnloadPackageOnClient(pac) == -1)
      return -1;

   // Nothing more to do if we are a Lite-session
   if (IsLite()) return 0;

   TMessage mess(kPROOF_CACHE);
   mess << Int_t(kUnloadPackage) << pac;
   Broadcast(mess);
   Collect();

   return fStatus;
}

//______________________________________________________________________________
Int_t TProof::UnloadPackageOnClient(const char *package)
{
   // Unload a specific package on the client.
   // Returns 0 in case of success and -1 in case of error.
   // The code is equivalent to the one in TProofServ.cxx (TProof::UnloadPackage
   // case). Keep in sync in case of changes.

   if (TestBit(TProof::kIsClient)) {
      TObjString *pack = (TObjString *) fEnabledPackagesOnClient->FindObject(package);
      if (pack) {
         // Remove entry from include path
         TString aclicincpath = gSystem->GetIncludePath();
         TString cintincpath = gInterpreter->GetIncludePath();
         // remove interpreter part of gSystem->GetIncludePath()
         aclicincpath.Remove(aclicincpath.Length() - cintincpath.Length() - 1);
         // remove package's include path
         aclicincpath.ReplaceAll(TString(" -I") + package, "");
         gSystem->SetIncludePath(aclicincpath);

         //TODO reset interpreter include path

         // remove entry from enabled packages list
         fEnabledPackagesOnClient->Remove(pack);
      }

      // cleanup the link
      if (!gSystem->AccessPathName(package))
         if (gSystem->Unlink(package) != 0)
            Warning("UnloadPackageOnClient", "unable to remove symlink to %s", package);

      // delete entry
      delete pack;
   }
   return 0;
}

//______________________________________________________________________________
Int_t TProof::UnloadPackages()
{
   // Unload all packages.
   // Returns 0 in case of success and -1 in case of error.

   if (!IsValid()) return -1;

   if (TestBit(TProof::kIsClient)) {
      // Iterate over packages on the client and remove each package
      TIter nextpackage(fEnabledPackagesOnClient);
      while (TObjString *objstr = dynamic_cast<TObjString*>(nextpackage()))
         if (UnloadPackageOnClient(objstr->String()) == -1 )
            return -1;
   }

   // Nothing more to do if we are a Lite-session
   if (IsLite()) return 0;

   TMessage mess(kPROOF_CACHE);
   mess << Int_t(kUnloadPackages);
   Broadcast(mess);
   Collect();

   return fStatus;
}

//______________________________________________________________________________
Int_t TProof::EnablePackage(const char *package, Bool_t notOnClient)
{
   // Enable specified package. Executes the PROOF-INF/BUILD.sh
   // script if it exists followed by the PROOF-INF/SETUP.C script.
   // In case notOnClient = true, don't enable the package on the client.
   // The default is to enable packages also on the client.
   // Returns 0 in case of success and -1 in case of error.

   if (!IsValid()) return -1;

   if (!package || !strlen(package)) {
      Error("EnablePackage", "need to specify a package name");
      return -1;
   }

   // if name, erroneously, is a par pathname strip off .par and path
   TString pac = package;
   if (pac.EndsWith(".par"))
      pac.Remove(pac.Length()-4);
   pac = gSystem->BaseName(pac);

   EBuildPackageOpt opt = kBuildAll;
   if (notOnClient)
      opt = kDontBuildOnClient;

   if (BuildPackage(pac, opt) == -1)
      return -1;

   if (LoadPackage(pac, notOnClient) == -1)
      return -1;

   return 0;
}

//______________________________________________________________________________
Int_t TProof::UploadPackage(const char *pack, EUploadPackageOpt opt)
{
   // Upload a PROOF archive (PAR file). A PAR file is a compressed
   // tar file with one special additional directory, PROOF-INF
   // (blatantly copied from Java's jar format). It must have the extension
   // .par. A PAR file can be directly a binary or a source with a build
   // procedure. In the PROOF-INF directory there can be a build script:
   // BUILD.sh to be called to build the package, in case of a binary PAR
   // file don't specify a build script or make it a no-op. Then there is
   // SETUP.C which sets the right environment variables to use the package,
   // like LD_LIBRARY_PATH, etc.
   // The 'opt' allows to specify whether the .PAR should be just unpacked
   // in the existing dir (opt = kUntar, default) or a remove of the existing
   // directory should be executed (opt = kRemoveOld), so triggering a full
   // re-build. The option if effective only for PROOF protocol > 8 .
   // Returns 0 in case of success and -1 in case of error.

   if (!IsValid()) return -1;

   TString par = pack;
   if (!par.EndsWith(".par"))
      // The client specified only the name: add the extension
      par += ".par";

   // Default location is the local working dir; then the package dir
   gSystem->ExpandPathName(par);
   if (gSystem->AccessPathName(par, kReadPermission)) {
      TString tried = par;
      // Try the package dir
      par = Form("%s/%s", fPackageDir.Data(), gSystem->BaseName(par));
      if (gSystem->AccessPathName(par, kReadPermission)) {
         // Is the package a global one
         if (fGlobalPackageDirList && fGlobalPackageDirList->GetSize() > 0) {
            // Scan the list of global packages dirs
            TIter nxd(fGlobalPackageDirList);
            TNamed *nm = 0;
            TString pdir;
            while ((nm = (TNamed *)nxd())) {
               pdir = Form("%s/%s", nm->GetTitle(), pack);
               if (!gSystem->AccessPathName(pdir, kReadPermission)) {
                  // Package found, stop searching
                  break;
               }
               pdir = "";
            }
            if (pdir.Length() > 0) {
               // Package is in the global dirs
               if (gDebug > 0)
                  Info("UploadPackage", "global package found (%s): no upload needed",
                                        pdir.Data());
               return 0;
            }
         }
         Error("UploadPackage", "PAR file '%s' not found; paths tried: %s, %s",
                                gSystem->BaseName(par), tried.Data(), par.Data());
         return -1;
      }
   }

   // Strategy:
   // On the client:
   // get md5 of package and check if it is different
   // from the one stored in the local package directory. If it is lock
   // the package directory and copy the package, unlock the directory.
   // On the masters:
   // get md5 of package and check if it is different from the
   // one stored on the remote node. If it is different lock the remote
   // package directory and use TFTP or SendFile to ftp the package to the
   // remote node, unlock the directory.

   TMD5 *md5 = TMD5::FileChecksum(par);

   if (UploadPackageOnClient(par, opt, md5) == -1) {
      delete md5;
      return -1;
   }

   // Nothing more to do if we are a Lite-session
   if (IsLite()) {
      delete md5;
      return 0;
   }

   TString smsg;
   smsg.Form("+%s", gSystem->BaseName(par));

   TMessage mess(kPROOF_CHECKFILE);
   mess << smsg << (*md5);
   TMessage mess2(kPROOF_CHECKFILE);
   smsg.Replace(0, 1, "-");
   mess2 << smsg << (*md5);
   TMessage mess3(kPROOF_CHECKFILE);
   smsg.Replace(0, 1, "=");
   mess3 << smsg << (*md5);

   delete md5;

   if (fProtocol > 8) {
      // Send also the option
      mess << (UInt_t) opt;
      mess2 << (UInt_t) opt;
      mess3 << (UInt_t) opt;
   }

   // loop over all selected nodes
   TIter next(fUniqueSlaves);
   TSlave *sl = 0;
   while ((sl = (TSlave *) next())) {
      if (!sl->IsValid())
         continue;

      sl->GetSocket()->Send(mess);

      fCheckFileStatus = 0;
      Collect(sl, fCollectTimeout, kPROOF_CHECKFILE);
      if (fCheckFileStatus == 0) {

         if (fProtocol > 5) {
            // remote directory is locked, upload file over the open channel
            smsg.Form("%s/%s/%s", sl->GetProofWorkDir(), kPROOF_PackDir,
                                  gSystem->BaseName(par));
            if (SendFile(par, (kBinary | kForce | kCpBin | kForward), smsg.Data(), sl) < 0) {
               Error("UploadPackage", "%s: problems uploading file %s",
                                      sl->GetOrdinal(), par.Data());
               return -1;
            }
         } else {
            // old servers receive it via TFTP
            TFTP ftp(TString("root://")+sl->GetName(), 1);
            if (!ftp.IsZombie()) {
               smsg.Form("%s/%s", sl->GetProofWorkDir(), kPROOF_PackDir);
               ftp.cd(smsg.Data());
               ftp.put(par, gSystem->BaseName(par));
            }
         }

         // install package and unlock dir
         sl->GetSocket()->Send(mess2);
         fCheckFileStatus = 0;
         Collect(sl, fCollectTimeout, kPROOF_CHECKFILE);
         if (fCheckFileStatus == 0) {
            Error("UploadPackage", "%s: unpacking of package %s failed",
                                   sl->GetOrdinal(), gSystem->BaseName(par));
            return -1;
         }
      }
   }

   // loop over all other master nodes
   TIter nextmaster(fNonUniqueMasters);
   TSlave *ma;
   while ((ma = (TSlave *) nextmaster())) {
      if (!ma->IsValid())
         continue;

      ma->GetSocket()->Send(mess3);

      fCheckFileStatus = 0;
      Collect(ma, fCollectTimeout, kPROOF_CHECKFILE);
      if (fCheckFileStatus == 0) {
         // error -> package should have been found
         Error("UploadPackage", "package %s did not exist on submaster %s",
               par.Data(), ma->GetOrdinal());
         return -1;
      }
   }

   return 0;
}

//______________________________________________________________________________
Int_t TProof::UploadPackageOnClient(const TString &par, EUploadPackageOpt opt, TMD5 *md5)
{
   // Upload a package on the client in ~/proof/packages.
   // The 'opt' allows to specify whether the .PAR should be just unpacked
   // in the existing dir (opt = kUntar, default) or a remove of the existing
   // directory should be executed (opt = kRemoveOld), thereby triggering a full
   // re-build. The option if effective only for PROOF protocol > 8 .
   // Returns 0 in case of success and -1 in case of error.

   // Strategy:
   // get md5 of package and check if it is different
   // from the one stored in the local package directory. If it is lock
   // the package directory and copy the package, unlock the directory.

   Int_t status = 0;

   if (TestBit(TProof::kIsClient)) {
      // the fPackageDir directory exists (has been created in Init())

      // create symlink to the par file in the fPackageDir (needed by
      // master in case we run on the localhost)
      fPackageLock->Lock();

      TString lpar = fPackageDir + "/" + gSystem->BaseName(par);
      FileStat_t stat;
      Int_t st = gSystem->GetPathInfo(lpar, stat);
      // check if symlink, if so unlink, if not give error
      // NOTE: GetPathInfo() returns 1 in case of symlink that does not point to
      // existing file, but if fIsLink is true the symlink exists
      if (stat.fIsLink)
         gSystem->Unlink(lpar);
      else if (st == 0) {
         Error("UploadPackageOnClient", "cannot create symlink %s on client, "
               "another item with same name already exists",
               lpar.Data());
         fPackageLock->Unlock();
         return -1;
      }
      if (!gSystem->IsAbsoluteFileName(par)) {
         TString fpar = par;
         gSystem->Symlink(gSystem->PrependPathName(gSystem->WorkingDirectory(), fpar), lpar);
      } else
         gSystem->Symlink(par, lpar);
      // TODO: On Windows need to copy instead of symlink

      // compare md5
      TString packnam = par(0, par.Length() - 4);  // strip off ".par"
      packnam = gSystem->BaseName(packnam);        // strip off path
      TString md5f = fPackageDir + "/" + packnam + "/PROOF-INF/md5.txt";
      TMD5 *md5local = TMD5::ReadChecksum(md5f);
      if (!md5local || (*md5) != (*md5local)) {
         // if not, unzip and untar package in package directory
         if ((opt & TProof::kRemoveOld)) {
            // remove any previous package directory with same name
            if (gSystem->Exec(Form("%s %s/%s", kRM, fPackageDir.Data(),
                                   packnam.Data())))
               Error("UploadPackageOnClient", "failure executing: %s %s/%s",
                     kRM, fPackageDir.Data(), packnam.Data());
         }
         // find gunzip
         char *gunzip = gSystem->Which(gSystem->Getenv("PATH"), kGUNZIP,
                                       kExecutePermission);
         if (gunzip) {
            // untar package
            if (gSystem->Exec(Form(kUNTAR2, gunzip, par.Data(), fPackageDir.Data())))
               Error("Uploadpackage", "failure executing: %s",
                     Form(kUNTAR2, gunzip, par.Data(), fPackageDir.Data()));
            delete [] gunzip;
         } else
            Error("UploadPackageOnClient", "%s not found", kGUNZIP);

         // check that fPackageDir/packnam now exists
         if (gSystem->AccessPathName(fPackageDir + "/" + packnam, kWritePermission)) {
            // par file did not unpack itself in the expected directory, failure
            Error("UploadPackageOnClient",
                  "package %s did not unpack into %s/%s", par.Data(), fPackageDir.Data(),
                  packnam.Data());
            status = -1;
         } else {
            // store md5 in package/PROOF-INF/md5.txt
            TMD5::WriteChecksum(md5f, md5);
         }
      }
      fPackageLock->Unlock();
      delete md5local;
   }
   return status;
}

//______________________________________________________________________________
Int_t TProof::Load(const char *macro, Bool_t notOnClient, Bool_t uniqueWorkers,
                   TList *wrks)
{
   // Load the specified macro on master, workers and, if notOnClient is
   // kFALSE, on the client. The macro file is uploaded if new or updated.
   // If existing, the corresponding header basename(macro).h or .hh, is also
   // uploaded. The default is to load the macro also on the client.
   // On masters, if uniqueWorkers is kTRUE, the macro is loaded on unique workers
   // only, and collection is not done; if uniqueWorkers is kFALSE, collection
   // from the previous request is done, and broadcasting + collection from the
   // other workers is done.
   // The wrks arg can be used on the master to limit the set of workers.
   // Returns 0 in case of success and -1 in case of error.

   if (!IsValid()) return -1;

   if (!macro || !strlen(macro)) {
      Error("Load", "need to specify a macro name");
      return -1;
   }

   if (TestBit(TProof::kIsClient)) {
      if (wrks) {
         Error("Load", "the 'wrks' arg can be used only on the master");
         return -1;
      }

      // Extract the file implementation name first
      TString implname = macro;
      TString acmode, args, io;
      implname = gSystem->SplitAclicMode(implname, acmode, args, io);

      // Macro names must have a standard format
      Int_t dot = implname.Last('.');
      if (dot == kNPOS) {
         Info("Load", "macro '%s' does not contain a '.': do nothing", macro);
         return -1;
      }

      // Is there any associated header file
      Bool_t hasHeader = kTRUE;
      TString headname = implname;
      headname.Remove(dot);
      headname += ".h";
      if (gSystem->AccessPathName(headname, kReadPermission)) {
         TString h = headname;
         headname.Remove(dot);
         headname += ".hh";
         if (gSystem->AccessPathName(headname, kReadPermission)) {
            hasHeader = kFALSE;
            if (gDebug > 0)
               Info("Load", "no associated header file found: tried: %s %s",
                            h.Data(), headname.Data());
         }
      }

      // Send files now; the md5 check is run here; see SendFile for more
      // details.
      if (SendFile(implname, kAscii | kForward , "cache") == -1) {
         Info("Load", "problems sending implementation file %s", implname.Data());
         return -1;
      }
      if (hasHeader)
         if (SendFile(headname, kAscii | kForward , "cache") == -1) {
            Info("Load", "problems sending header file %s", headname.Data());
            return -1;
         }

      // The files are now on the workers: now we send the loading request
      TString basemacro = gSystem->BaseName(macro);
      TMessage mess(kPROOF_CACHE);
      mess << Int_t(kLoadMacro) << basemacro;
      Broadcast(mess, kActive);

      // Load locally, if required
      if (!notOnClient) {
         // by first forwarding the load command to the master and workers
         // and only then loading locally we load/build in parallel
         gROOT->ProcessLine(Form(".L %s", macro));

         // Update the macro path
         TString mp(TROOT::GetMacroPath());
         TString np(gSystem->DirName(macro));
         if (!np.IsNull()) {
            np += ":";
            Int_t ip = (mp.BeginsWith(".:")) ? 2 : 0;
            mp.Insert(ip, np);
         }
         TROOT::SetMacroPath(mp);
         if (gDebug > 0)
            Info("Load", "macro path set to '%s'", TROOT::GetMacroPath());
      }

      // Wait for master and workers to be done
      Collect(kActive);

   } else {
      // On master

      // The files are now on the workers: now we send the loading request first
      // to the unique workers, so that the eventual compilation occurs only once.
      TString basemacro = gSystem->BaseName(macro);
      TMessage mess(kPROOF_CACHE);

      if (uniqueWorkers) {
         mess << Int_t(kLoadMacro) << basemacro;
         if (wrks)
            Broadcast(mess, wrks);
         else
            Broadcast(mess, kUnique);
      } else {
         // Wait for the result of the previous sending
         Collect(kUnique);

         // We then send a tuned loading request to the other workers
         TList others;
         TSlave *wrk = 0;
         TIter nxw(fActiveSlaves);
         while ((wrk = (TSlave *)nxw())) {
            if (!fUniqueSlaves->FindObject(wrk)) {
               others.Add(wrk);
            }
         }

         // Do not force compilation, if it was requested
         Int_t ld = basemacro.Last('.');
         if (ld != kNPOS) {
            Int_t lpp = basemacro.Index("++", ld);
            if (lpp != kNPOS) basemacro.Replace(lpp, 2, "+");
         }
         mess << Int_t(kLoadMacro) << basemacro;
         Broadcast(mess, &others);
         Collect(&others);
      }

      PDB(kGlobal, 1) Info("Load", "adding loaded macro: %s", macro);
      if (!fLoadedMacros) {
         fLoadedMacros = new TList();
         fLoadedMacros->SetOwner();
      }
      // if wrks is specified the macro should already be loaded on the master.
      if (!wrks)
         fLoadedMacros->Add(new TObjString(macro));
   }

   // Done
   return 0;
}

//______________________________________________________________________________
Int_t TProof::AddDynamicPath(const char *libpath, Bool_t onClient, TList *wrks)
{
   // Add 'libpath' to the lib path search.
   // Multiple paths can be specified at once separating them with a comma or
   // a blank.
   // Return 0 on success, -1 otherwise

   if ((!libpath || !strlen(libpath))) {
      if (gDebug > 0)
         Info("AddDynamicPath", "list is empty - nothing to do");
      return 0;
   }

   // Do it also on clients, if required
   if (onClient)
      HandleLibIncPath("lib", kTRUE, libpath);

   TMessage m(kPROOF_LIB_INC_PATH);
   m << TString("lib") << (Bool_t)kTRUE;

   // Add paths
   if (libpath && strlen(libpath))
      m << TString(libpath);
   else
      m << TString("-");

   // Forward the request
   if (wrks)
      Broadcast(m, wrks);
   else
      Broadcast(m);
   Collect(kActive, fCollectTimeout);

   return 0;
}

//______________________________________________________________________________
Int_t TProof::AddIncludePath(const char *incpath, Bool_t onClient, TList *wrks)
{
   // Add 'incpath' to the inc path search.
   // Multiple paths can be specified at once separating them with a comma or
   // a blank.
   // Return 0 on success, -1 otherwise

   if ((!incpath || !strlen(incpath))) {
      if (gDebug > 0)
         Info("AddIncludePath", "list is empty - nothing to do");
      return 0;
   }

   // Do it also on clients, if required
   if (onClient)
      HandleLibIncPath("inc", kTRUE, incpath);

   TMessage m(kPROOF_LIB_INC_PATH);
   m << TString("inc") << (Bool_t)kTRUE;

   // Add paths
   if (incpath && strlen(incpath))
      m << TString(incpath);
   else
      m << TString("-");

   // Forward the request
   if (wrks)
      Broadcast(m, wrks);
   else
      Broadcast(m);
   Collect(kActive, fCollectTimeout);

   return 0;
}

//______________________________________________________________________________
Int_t TProof::RemoveDynamicPath(const char *libpath, Bool_t onClient)
{
   // Remove 'libpath' from the lib path search.
   // Multiple paths can be specified at once separating them with a comma or
   // a blank.
   // Return 0 on success, -1 otherwise

   if ((!libpath || !strlen(libpath))) {
      if (gDebug > 0)
         Info("RemoveDynamicPath", "list is empty - nothing to do");
      return 0;
   }

   // Do it also on clients, if required
   if (onClient)
      HandleLibIncPath("lib", kFALSE, libpath);

   TMessage m(kPROOF_LIB_INC_PATH);
   m << TString("lib") <<(Bool_t)kFALSE;

   // Add paths
   if (libpath && strlen(libpath))
      m << TString(libpath);
   else
      m << TString("-");

   // Forward the request
   Broadcast(m);
   Collect(kActive, fCollectTimeout);

   return 0;
}

//______________________________________________________________________________
Int_t TProof::RemoveIncludePath(const char *incpath, Bool_t onClient)
{
   // Remove 'incpath' from the inc path search.
   // Multiple paths can be specified at once separating them with a comma or
   // a blank.
   // Return 0 on success, -1 otherwise

   if ((!incpath || !strlen(incpath))) {
      if (gDebug > 0)
         Info("RemoveIncludePath", "list is empty - nothing to do");
      return 0;
   }

   // Do it also on clients, if required
   if (onClient)
      HandleLibIncPath("in", kFALSE, incpath);

   TMessage m(kPROOF_LIB_INC_PATH);
   m << TString("inc") << (Bool_t)kFALSE;

   // Add paths
   if (incpath && strlen(incpath))
      m << TString(incpath);
   else
      m << TString("-");

   // Forward the request
   Broadcast(m);
   Collect(kActive, fCollectTimeout);

   return 0;
}

//______________________________________________________________________________
void TProof::HandleLibIncPath(const char *what, Bool_t add, const char *dirs)
{
   // Handle lib, inc search paths modification request

   TString type(what);
   TString path(dirs);

   // Check type of action
   if ((type != "lib") && (type != "inc")) {
      Error("HandleLibIncPath","unknown action type: %s - protocol error?", type.Data());
      return;
   }

   // Separators can be either commas or blanks
   path.ReplaceAll(","," ");

   // Decompose lists
   TObjArray *op = 0;
   if (path.Length() > 0 && path != "-") {
      if (!(op = path.Tokenize(" "))) {
         Warning("HandleLibIncPath","decomposing path %s", path.Data());
         return;
      }
   }

   if (add) {

      if (type == "lib") {

         // Add libs
         TIter nxl(op, kIterBackward);
         TObjString *lib = 0;
         while ((lib = (TObjString *) nxl())) {
            // Expand path
            TString xlib = lib->GetName();
            gSystem->ExpandPathName(xlib);
            // Add to the dynamic lib search path if it exists and can be read
            if (!gSystem->AccessPathName(xlib, kReadPermission)) {
               TString newlibpath = gSystem->GetDynamicPath();
               // In the first position after the working dir
               Int_t pos = 0;
               if (newlibpath.BeginsWith(".:"))
                  pos = 2;
               if (newlibpath.Index(xlib) == kNPOS) {
                  newlibpath.Insert(pos,Form("%s:", xlib.Data()));
                  gSystem->SetDynamicPath(newlibpath);
               }
            } else {
               if (gDebug > 0)
                  Info("HandleLibIncPath",
                       "libpath %s does not exist or cannot be read - not added", xlib.Data());
            }
         }

      } else {

         // Add incs
         TIter nxi(op);
         TObjString *inc = 0;
         while ((inc = (TObjString *) nxi())) {
            // Expand path
            TString xinc = inc->GetName();
            gSystem->ExpandPathName(xinc);
            // Add to the dynamic lib search path if it exists and can be read
            if (!gSystem->AccessPathName(xinc, kReadPermission)) {
               TString curincpath = gSystem->GetIncludePath();
               if (curincpath.Index(xinc) == kNPOS)
                  gSystem->AddIncludePath(Form("-I%s", xinc.Data()));
            } else
               if (gDebug > 0)
                   Info("HandleLibIncPath",
                        "incpath %s does not exist or cannot be read - not added", xinc.Data());
         }
      }


   } else {

      if (type == "lib") {

         // Remove libs
         TIter nxl(op);
         TObjString *lib = 0;
         while ((lib = (TObjString *) nxl())) {
            // Expand path
            TString xlib = lib->GetName();
            gSystem->ExpandPathName(xlib);
            // Remove from the dynamic lib search path
            TString newlibpath = gSystem->GetDynamicPath();
            newlibpath.ReplaceAll(Form("%s:", xlib.Data()),"");
            gSystem->SetDynamicPath(newlibpath);
         }

      } else {

         // Remove incs
         TIter nxi(op);
         TObjString *inc = 0;
         while ((inc = (TObjString *) nxi())) {
            TString newincpath = gSystem->GetIncludePath();
            newincpath.ReplaceAll(Form("-I%s", inc->GetName()),"");
            // Remove the interpreter path (added anyhow internally)
            newincpath.ReplaceAll(gInterpreter->GetIncludePath(),"");
            gSystem->SetIncludePath(newincpath);
         }
      }
   }
}

//______________________________________________________________________________
TList *TProof::GetListOfPackages()
{
   // Get from the master the list of names of the packages available.

   if (!IsValid())
      return (TList *)0;

   TMessage mess(kPROOF_CACHE);
   mess << Int_t(kListPackages);
   Broadcast(mess);
   Collect(kActive, fCollectTimeout);

   return fAvailablePackages;
}

//______________________________________________________________________________
TList *TProof::GetListOfEnabledPackages()
{
   // Get from the master the list of names of the packages enabled.

   if (!IsValid())
      return (TList *)0;

   TMessage mess(kPROOF_CACHE);
   mess << Int_t(kListEnabledPackages);
   Broadcast(mess);
   Collect(kActive, fCollectTimeout);

   return fEnabledPackages;
}

//______________________________________________________________________________
void TProof::PrintProgress(Long64_t total, Long64_t processed, Float_t procTime)
{
   // Print a progress bar on stderr. Used in batch mode.

   if (fPrintProgress) {
      Bool_t redirlog = fRedirLog;
      fRedirLog = kFALSE;
      // Call the external function
      (*fPrintProgress)(total, processed, procTime);
      fRedirLog = redirlog;
      return;
   }

   fprintf(stderr, "[TProof::Progress] Total %lld events\t|", total);

   for (int l = 0; l < 20; l++) {
      if (total > 0) {
         if (l < 20*processed/total)
            fprintf(stderr, "=");
         else if (l == 20*processed/total)
            fprintf(stderr, ">");
         else if (l > 20*processed/total)
            fprintf(stderr, ".");
      } else
         fprintf(stderr, "=");
   }
   Float_t evtrti = (procTime > 0. && processed > 0) ? processed / procTime : -1.;
   if (evtrti > 0.)
      fprintf(stderr, "| %.02f %% [%.1f evts/s]\r",
              (total ? ((100.0*processed)/total) : 100.0), evtrti);
   else
      fprintf(stderr, "| %.02f %%\r",
              (total ? ((100.0*processed)/total) : 100.0));
   if (processed >= total)
      fprintf(stderr, "\n");
}

//______________________________________________________________________________
void TProof::Progress(Long64_t total, Long64_t processed)
{
   // Get query progress information. Connect a slot to this signal
   // to track progress.

   if (fPrintProgress) {
      // Call the external function
      return (*fPrintProgress)(total, processed, -1.);
   }

   PDB(kGlobal,1)
      Info("Progress","%2f (%lld/%lld)", 100.*processed/total, processed, total);

   if (gROOT->IsBatch()) {
      // Simple progress bar
      if (total > 0)
         PrintProgress(total, processed);
   } else {
      EmitVA("Progress(Long64_t,Long64_t)", 2, total, processed);
   }
}

//______________________________________________________________________________
void TProof::Progress(Long64_t total, Long64_t processed, Long64_t bytesread,
                      Float_t initTime, Float_t procTime,
                      Float_t evtrti, Float_t mbrti)
{
   // Get query progress information. Connect a slot to this signal
   // to track progress.

   PDB(kGlobal,1)
      Info("Progress","%lld %lld %lld %f %f %f %f", total, processed, bytesread,
                                initTime, procTime, evtrti, mbrti);

   if (gROOT->IsBatch()) {
      // Simple progress bar
      if (total > 0)
         PrintProgress(total, processed, procTime);
   } else {
      EmitVA("Progress(Long64_t,Long64_t,Long64_t,Float_t,Float_t,Float_t,Float_t)",
             7, total, processed, bytesread, initTime, procTime, evtrti, mbrti);
   }
}

//______________________________________________________________________________
void TProof::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)
{
   // Get query progress information. Connect a slot to this signal
   // to track progress.

   PDB(kGlobal,1)
      Info("Progress","%lld %lld %lld %f %f %f %f %d %f", total, processed, bytesread,
                                initTime, procTime, evtrti, mbrti, actw, eses);

   if (gROOT->IsBatch()) {
      // Simple progress bar
      if (total > 0)
         PrintProgress(total, processed, procTime);
   } else {
      EmitVA("Progress(Long64_t,Long64_t,Long64_t,Float_t,Float_t,Float_t,Float_t,Int_t,Int_t,Float_t)",
             10, total, processed, bytesread, initTime, procTime, evtrti, mbrti, actw, tses, eses);
   }
}

//______________________________________________________________________________
void TProof::Feedback(TList *objs)
{
   // Get list of feedback objects. Connect a slot to this signal
   // to monitor the feedback object.

   PDB(kGlobal,1)
      Info("Feedback","%d objects", objs->GetSize());
   PDB(kFeedback,1) {
      Info("Feedback","%d objects", objs->GetSize());
      objs->ls();
   }

   Emit("Feedback(TList *objs)", (Long_t) objs);
}

//______________________________________________________________________________
void TProof::CloseProgressDialog()
{
   // Close progress dialog.

   PDB(kGlobal,1)
      Info("CloseProgressDialog",
           "called: have progress dialog: %d", fProgressDialogStarted);

   // Nothing to do if not there
   if (!fProgressDialogStarted)
      return;

   Emit("CloseProgressDialog()");
}

//______________________________________________________________________________
void TProof::ResetProgressDialog(const char *sel, Int_t sz, Long64_t fst,
                                 Long64_t ent)
{
   // Reset progress dialog.

   PDB(kGlobal,1)
      Info("ResetProgressDialog","(%s,%d,%lld,%lld)", sel, sz, fst, ent);

   EmitVA("ResetProgressDialog(const char*,Int_t,Long64_t,Long64_t)",
          4, sel, sz, fst, ent);
}

//______________________________________________________________________________
void TProof::StartupMessage(const char *msg, Bool_t st, Int_t done, Int_t total)
{
   // Send startup message.

   PDB(kGlobal,1)
      Info("StartupMessage","(%s,%d,%d,%d)", msg, st, done, total);

   EmitVA("StartupMessage(const char*,Bool_t,Int_t,Int_t)",
          4, msg, st, done, total);
}

//______________________________________________________________________________
void TProof::DataSetStatus(const char *msg, Bool_t st, Int_t done, Int_t total)
{
   // Send dataset preparation status.

   PDB(kGlobal,1)
      Info("DataSetStatus","(%s,%d,%d,%d)", msg, st, done, total);

   EmitVA("DataSetStatus(const char*,Bool_t,Int_t,Int_t)",
          4, msg, st, done, total);
}

//______________________________________________________________________________
void TProof::SendDataSetStatus(const char *action, UInt_t done,
                               UInt_t tot, Bool_t st)
{
   // Send or notify data set status

   if (IsLite()) {
      if (tot) {
         TString type = "files";
         Int_t frac = (Int_t) (done*100.)/tot;
         char msg[512] = {0};
         if (frac >= 100) {
            snprintf(msg, 512, "%s: OK (%d %s)                 \n",
                     action,tot, type.Data());
         } else {
            snprintf(msg, 512, "%s: %d out of %d (%d %%)\r",
                     action, done, tot, frac);
         }
         if (fSync)
            fprintf(stderr,"%s", msg);
         else
            NotifyLogMsg(msg, 0);
      }
      return;
   }

   if (TestBit(TProof::kIsMaster)) {
      TMessage mess(kPROOF_DATASET_STATUS);
      mess << TString(action) << tot << done << st;
      gProofServ->GetSocket()->Send(mess);
   }
}

//______________________________________________________________________________
void TProof::QueryResultReady(const char *ref)
{
   // Notify availability of a query result.

   PDB(kGlobal,1)
      Info("QueryResultReady","ref: %s", ref);

   Emit("QueryResultReady(const char*)",ref);
}

//______________________________________________________________________________
void TProof::ValidateDSet(TDSet *dset)
{
   // Validate a TDSet.

   if (dset->ElementsValid()) return;

   TList nodes;
   nodes.SetOwner();

   TList slholder;
   slholder.SetOwner();
   TList elemholder;
   elemholder.SetOwner();

   // build nodelist with slaves and elements
   TIter nextSlave(GetListOfActiveSlaves());
   while (TSlave *sl = dynamic_cast<TSlave*>(nextSlave())) {
      TList *sllist = 0;
      TPair *p = dynamic_cast<TPair*>(nodes.FindObject(sl->GetName()));
      if (!p) {
         sllist = new TList;
         sllist->SetName(sl->GetName());
         slholder.Add(sllist);
         TList *elemlist = new TList;
         elemlist->SetName(TString(sl->GetName())+"_elem");
         elemholder.Add(elemlist);
         nodes.Add(new TPair(sllist, elemlist));
      } else {
         sllist = dynamic_cast<TList*>(p->Key());
      }
      if (sllist) sllist->Add(sl);
   }

   // add local elements to nodes
   TList nonLocal; // list of nonlocal elements
   // make two iterations - first add local elements - then distribute nonlocals
   for (Int_t i = 0; i < 2; i++) {
      Bool_t local = i>0?kFALSE:kTRUE;
      TIter nextElem(local ? dset->GetListOfElements() : &nonLocal);
      while (TDSetElement *elem = dynamic_cast<TDSetElement*>(nextElem())) {
         if (elem->GetValid()) continue;
         TPair *p = dynamic_cast<TPair*>(local?nodes.FindObject(TUrl(elem->GetFileName()).GetHost()):nodes.At(0));
         if (p) {
            TList *eli = dynamic_cast<TList*>(p->Value());
            TList *sli = dynamic_cast<TList*>(p->Key());
            if (eli && sli) {
               eli->Add(elem);

               // order list by elements/slave
               TPair *p2 = p;
               Bool_t stop = kFALSE;
               while (!stop) {
                  TPair *p3 = dynamic_cast<TPair*>(nodes.After(p2->Key()));
                  if (p3) {
                     TList *p3v = dynamic_cast<TList*>(p3->Value());
                     TList *p3k = dynamic_cast<TList*>(p3->Key());
                     if (p3v && p3k) {
                        Int_t nelem = p3v->GetSize();
                        Int_t nsl = p3k->GetSize();
                        if (nelem*sli->GetSize() < eli->GetSize()*nsl) p2 = p3;
                        else stop = kTRUE;
                     }
                  } else {
                     stop = kTRUE;
                  }
               }

               if (p2!=p) {
                  nodes.Remove(p->Key());
                  nodes.AddAfter(p2->Key(), p);
               }
            } else {
               Warning("ValidateDSet", "invalid values from TPair! Protocol error?");
               continue;
            }

         } else {
            if (local) {
               nonLocal.Add(elem);
            } else {
               Warning("ValidateDSet", "no node to allocate TDSetElement to - ignoring");
            }
         }
      }
   }

   // send to slaves
   TList usedslaves;
   TIter nextNode(&nodes);
   SetDSet(dset); // set dset to be validated in Collect()
   while (TPair *node = dynamic_cast<TPair*>(nextNode())) {
      TList *slaves = dynamic_cast<TList*>(node->Key());
      TList *setelements = dynamic_cast<TList*>(node->Value());
      if (!slaves || !setelements) continue;
      // distribute elements over the slaves
      Int_t nslaves = slaves->GetSize();
      Int_t nelements = setelements->GetSize();
      for (Int_t i=0; i<nslaves; i++) {

         TDSet copyset(dset->GetType(), dset->GetObjName(),
                       dset->GetDirectory());
         for (Int_t j = (i*nelements)/nslaves;
                    j < ((i+1)*nelements)/nslaves;
                    j++) {
            TDSetElement *elem =
               dynamic_cast<TDSetElement*>(setelements->At(j));
            if (elem) {
               copyset.Add(elem->GetFileName(), elem->GetObjName(),
                           elem->GetDirectory(), elem->GetFirst(),
                           elem->GetNum(), elem->GetMsd());
            }
         }

         if (copyset.GetListOfElements()->GetSize()>0) {
            TMessage mesg(kPROOF_VALIDATE_DSET);
            mesg << &copyset;

            TSlave *sl = dynamic_cast<TSlave*>(slaves->At(i));
            if (sl) {
               PDB(kGlobal,1) Info("ValidateDSet",
                                 "Sending TDSet with %d elements to slave %s"
                                 " to be validated",
                                 copyset.GetListOfElements()->GetSize(),
                                 sl->GetOrdinal());
               sl->GetSocket()->Send(mesg);
               usedslaves.Add(sl);
            }
         }
      }
   }

   PDB(kGlobal,1)
      Info("ValidateDSet","Calling Collect");
   Collect(&usedslaves);
   SetDSet(0);
}

//______________________________________________________________________________
void TProof::AddInputData(TObject *obj, Bool_t push)
{
   // Add data objects that might be needed during the processing of
   // the selector (see Process()). This object can be very large, so they
   // are distributed in an optimized way using a dedicated file.
   // If push is TRUE the input data are sent over even if no apparent change
   // occured to the list.

   if (obj) {
      if (!fInputData) fInputData = new TList;
      if (!fInputData->FindObject(obj)) {
         fInputData->Add(obj);
         SetBit(TProof::kNewInputData);
      }
   }
   if (push) SetBit(TProof::kNewInputData);
}

//______________________________________________________________________________
void TProof::ClearInputData(TObject *obj)
{
   // Remove obj form the input data list; if obj is null (default), clear the
   // input data info.

   if (!obj) {
      if (fInputData) {
         fInputData->SetOwner(kTRUE);
         SafeDelete(fInputData);
      }
      ResetBit(TProof::kNewInputData);

      // Also remove any info about input data in the input list
      TObject *o = 0;
      TList *in = GetInputList();
      while ((o = GetInputList()->FindObject("PROOF_InputDataFile")))
         in->Remove(o);
      while ((o = GetInputList()->FindObject("PROOF_InputData")))
         in->Remove(o);

      // ... and reset the file
      fInputDataFile = "";
      gSystem->Unlink(kPROOF_InputDataFile);

   } else if (fInputData) {
      Int_t sz = fInputData->GetSize();
      while (fInputData->FindObject(obj))
         fInputData->Remove(obj);
      // Flag for update, if anything changed
      if (sz != fInputData->GetSize())
         SetBit(TProof::kNewInputData);
   }
}

//______________________________________________________________________________
void TProof::ClearInputData(const char *name)
{
   // Remove obj 'name' form the input data list;

   TObject *obj = (fInputData && name) ? fInputData->FindObject(name) : 0;
   if (obj) ClearInputData(obj);
}

//______________________________________________________________________________
void TProof::SetInputDataFile(const char *datafile)
{
   // Set the file to be used to optimally distribute the input data objects.
   // If the file exists the object in the file are added to those in the
   // fInputData list. If the file path is null, a default file will be created
   // at the moment of sending the processing request with the content of
   // the fInputData list. See also SendInputDataFile.

   if (datafile && strlen(datafile) > 0) {
      if (fInputDataFile != datafile && strcmp(datafile, kPROOF_InputDataFile))
         SetBit(TProof::kNewInputData);
      fInputDataFile = datafile;
   } else {
      if (!fInputDataFile.IsNull())
         SetBit(TProof::kNewInputData);
      fInputDataFile = "";
   }
   // Make sure that the chosen file is readable
   if (fInputDataFile != kPROOF_InputDataFile && !fInputDataFile.IsNull() &&
      gSystem->AccessPathName(fInputDataFile, kReadPermission)) {
      fInputDataFile = "";
   }
}

//______________________________________________________________________________
void TProof::SendInputDataFile()
{
   // Send the input data objects to the master; the objects are taken from the
   // dedicated list and / or the specified file.
   // If the fInputData is empty the specified file is sent over.
   // If there is no specified file, a file named "inputdata.root" is created locally
   // with the content of fInputData and sent over to the master.
   // If both fInputData and the specified file are not empty, a copy of the file
   // is made locally and augmented with the content of fInputData.

   // Prepare the file
   TString dataFile;
   PrepareInputDataFile(dataFile);

   // Send it, if not empty
   if (dataFile.Length() > 0) {

      Info("SendInputDataFile", "broadcasting %s", dataFile.Data());
      BroadcastFile(dataFile.Data(), kBinary, "cache", kActive);

      // Set the name in the input list
      AddInput(new TNamed("PROOF_InputDataFile", Form("cache:%s", gSystem->BaseName(dataFile))));
   }
}

//______________________________________________________________________________
void TProof::PrepareInputDataFile(TString &dataFile)
{
   // Prepare the file with the input data objects to be sent the master; the
   // objects are taken from the dedicated list and / or the specified file.
   // If the fInputData is empty the specified file is sent over.
   // If there is no specified file, a file named "inputdata.root" is created locally
   // with the content of fInputData and sent over to the master.
   // If both fInputData and the specified file are not empty, a copy of the file
   // is made locally and augmented with the content of fInputData.

   // Save info about new data for usage in this call;
   Bool_t newdata = TestBit(TProof::kNewInputData) ? kTRUE : kFALSE;
   // Next time we need some change
   ResetBit(TProof::kNewInputData);

   // Check the list
   Bool_t list_ok = (fInputData && fInputData->GetSize() > 0) ? kTRUE : kFALSE;
   // Check the file
   Bool_t file_ok = kFALSE;
   if (fInputDataFile != kPROOF_InputDataFile && !fInputDataFile.IsNull() &&
      !gSystem->AccessPathName(fInputDataFile, kReadPermission)) {
      // It must contain something
      TFile *f = TFile::Open(fInputDataFile);
      if (f && f->GetListOfKeys() && f->GetListOfKeys()->GetSize() > 0)
         file_ok = kTRUE;
   }

   // Remove any info about input data in the input list
   TObject *o = 0;
   TList *in = GetInputList();
   while ((o = GetInputList()->FindObject("PROOF_InputDataFile")))
      in->Remove(o);
   while ((o = GetInputList()->FindObject("PROOF_InputData")))
      in->Remove(o);

   // We must have something to send
   dataFile = "";
   if (!list_ok && !file_ok) return;

   // Three cases:
   if (file_ok && !list_ok) {
      // Just send the file
      dataFile = fInputDataFile;
   } else if (!file_ok && list_ok) {
      fInputDataFile = kPROOF_InputDataFile;
      // Nothing to do, if no new data
      if (!newdata && !gSystem->AccessPathName(fInputDataFile)) return;
      // Create the file first
      TFile *f = TFile::Open(fInputDataFile, "RECREATE");
      if (f) {
         f->cd();
         TIter next(fInputData);
         TObject *obj;
         while ((obj = next())) {
            obj->Write(0, TObject::kSingleKey, 0);
         }
         f->Close();
         SafeDelete(f);
      } else {
         Error("PrepareInputDataFile", "could not (re-)create %s", fInputDataFile.Data());
         return;
      }
      dataFile = fInputDataFile;
   } else if (file_ok && list_ok) {
      dataFile = kPROOF_InputDataFile;
      // Create the file if not existing or there are new data
      if (newdata || gSystem->AccessPathName(dataFile)) {
         // Cleanup previous file if obsolete
         if (!gSystem->AccessPathName(dataFile))
            gSystem->Unlink(dataFile);
         if (dataFile != fInputDataFile) {
            // Make a local copy first
            if (gSystem->CopyFile(fInputDataFile, dataFile, kTRUE) != 0) {
               Error("PrepareInputDataFile", "could not make local copy of %s", fInputDataFile.Data());
               return;
            }
         }
         // Add the input data list
         TFile *f = TFile::Open(dataFile, "UPDATE");
         if (f) {
            f->cd();
            TIter next(fInputData);
            TObject *obj = 0;
            while ((obj = next())) {
               obj->Write(0, TObject::kSingleKey, 0);
            }
            f->Close();
            SafeDelete(f);
         } else {
            Error("PrepareInputDataFile", "could not open %s for updating", dataFile.Data());
            return;
         }
      }
   }

   //  Done
   return;
}

//______________________________________________________________________________
void TProof::AddInput(TObject *obj)
{
   // Add objects that might be needed during the processing of
   // the selector (see Process()).

   if (fPlayer) fPlayer->AddInput(obj);
}

//______________________________________________________________________________
void TProof::ClearInput()
{
   // Clear input object list.

   if (fPlayer) fPlayer->ClearInput();

   // the system feedback list is always in the input list
   AddInput(fFeedback);
}

//______________________________________________________________________________
TList *TProof::GetInputList()
{
   // Get input list.

   return (fPlayer ? fPlayer->GetInputList() : (TList *)0);
}

//______________________________________________________________________________
TObject *TProof::GetOutput(const char *name)
{
   // Get specified object that has been produced during the processing
   // (see Process()).

   // Can be called by MarkBad on the master before the player is initialized
   return (fPlayer) ? fPlayer->GetOutput(name) : (TObject *)0;
}

//______________________________________________________________________________
TList *TProof::GetOutputList()
{
   // Get list with all object created during processing (see Process()).

   return (fPlayer ? fPlayer->GetOutputList() : (TList *)0);
}

//______________________________________________________________________________
void TProof::SetParameter(const char *par, const char *value)
{
   // Set input list parameter. If the parameter is already
   // set it will be set to the new value.

   if (!fPlayer) {
      Warning("SetParameter", "player undefined! Ignoring");
      return;
   }

   TList *il = fPlayer->GetInputList();
   TObject *item = il->FindObject(par);
   if (item) {
      il->Remove(item);
      delete item;
   }
   il->Add(new TNamed(par, value));
}

//______________________________________________________________________________
void TProof::SetParameter(const char *par, Int_t value)
{
   // Set an input list parameter.

   if (!fPlayer) {
      Warning("SetParameter", "player undefined! Ignoring");
      return;
   }

   TList *il = fPlayer->GetInputList();
   TObject *item = il->FindObject(par);
   if (item) {
      il->Remove(item);
      delete item;
   }
   il->Add(new TParameter<Int_t>(par, value));
}

//______________________________________________________________________________
void TProof::SetParameter(const char *par, Long_t value)
{
   // Set an input list parameter.

   if (!fPlayer) {
      Warning("SetParameter", "player undefined! Ignoring");
      return;
   }

   TList *il = fPlayer->GetInputList();
   TObject *item = il->FindObject(par);
   if (item) {
      il->Remove(item);
      delete item;
   }
   il->Add(new TParameter<Long_t>(par, value));
}

//______________________________________________________________________________
void TProof::SetParameter(const char *par, Long64_t value)
{
   // Set an input list parameter.

   if (!fPlayer) {
      Warning("SetParameter", "player undefined! Ignoring");
      return;
   }

   TList *il = fPlayer->GetInputList();
   TObject *item = il->FindObject(par);
   if (item) {
      il->Remove(item);
      delete item;
   }
   il->Add(new TParameter<Long64_t>(par, value));
}

//______________________________________________________________________________
void TProof::SetParameter(const char *par, Double_t value)
{
   // Set an input list parameter.

   if (!fPlayer) {
      Warning("SetParameter", "player undefined! Ignoring");
      return;
   }

   TList *il = fPlayer->GetInputList();
   TObject *item = il->FindObject(par);
   if (item) {
      il->Remove(item);
      delete item;
   }
   il->Add(new TParameter<Double_t>(par, value));
}

//______________________________________________________________________________
TObject *TProof::GetParameter(const char *par) const
{
   // Get specified parameter. A parameter set via SetParameter() is either
   // a TParameter or a TNamed or 0 in case par is not defined.

   if (!fPlayer) {
      Warning("GetParameter", "player undefined! Ignoring");
      return (TObject *)0;
   }

   TList *il = fPlayer->GetInputList();
   return il->FindObject(par);
}

//______________________________________________________________________________
void TProof::DeleteParameters(const char *wildcard)
{
   // Delete the input list parameters specified by a wildcard (e.g. PROOF_*)
   // or exact name (e.g. PROOF_MaxSlavesPerNode).

   if (!fPlayer) return;

   if (!wildcard) wildcard = "";
   TRegexp re(wildcard, kTRUE);
   Int_t nch = strlen(wildcard);

   TList *il = fPlayer->GetInputList();
   TObject *p;
   TIter next(il);
   while ((p = next())) {
      TString s = p->GetName();
      if (nch && s != wildcard && s.Index(re) == kNPOS) continue;
      il->Remove(p);
      delete p;
   }
}

//______________________________________________________________________________
void TProof::ShowParameters(const char *wildcard) const
{
   // Show the input list parameters specified by the wildcard.
   // Default is the special PROOF control parameters (PROOF_*).

   if (!fPlayer) return;

   if (!wildcard) wildcard = "";
   TRegexp re(wildcard, kTRUE);
   Int_t nch = strlen(wildcard);

   TList *il = fPlayer->GetInputList();
   TObject *p;
   TIter next(il);
   while ((p = next())) {
      TString s = p->GetName();
      if (nch && s != wildcard && s.Index(re) == kNPOS) continue;
      if (p->IsA() == TNamed::Class()) {
         Printf("%s\t\t\t%s", s.Data(), p->GetTitle());
      } else if (p->IsA() == TParameter<Long_t>::Class()) {
         Printf("%s\t\t\t%ld", s.Data(), dynamic_cast<TParameter<Long_t>*>(p)->GetVal());
      } else if (p->IsA() == TParameter<Long64_t>::Class()) {
         Printf("%s\t\t\t%lld", s.Data(), dynamic_cast<TParameter<Long64_t>*>(p)->GetVal());
      } else if (p->IsA() == TParameter<Double_t>::Class()) {
         Printf("%s\t\t\t%f", s.Data(), dynamic_cast<TParameter<Double_t>*>(p)->GetVal());
      } else {
         Printf("%s\t\t\t%s", s.Data(), p->GetTitle());
      }
   }
}

//______________________________________________________________________________
void TProof::AddFeedback(const char *name)
{
   // Add object to feedback list.

   PDB(kFeedback, 3)
      Info("AddFeedback", "Adding object \"%s\" to feedback", name);
   if (fFeedback->FindObject(name) == 0)
      fFeedback->Add(new TObjString(name));
}

//______________________________________________________________________________
void TProof::RemoveFeedback(const char *name)
{
   // Remove object from feedback list.

   TObject *obj = fFeedback->FindObject(name);
   if (obj != 0) {
      fFeedback->Remove(obj);
      delete obj;
   }
}

//______________________________________________________________________________
void TProof::ClearFeedback()
{
   // Clear feedback list.

   fFeedback->Delete();
}

//______________________________________________________________________________
void TProof::ShowFeedback() const
{
   // Show items in feedback list.

   if (fFeedback->GetSize() == 0) {
      Info("","no feedback requested");
      return;
   }

   fFeedback->Print();
}

//______________________________________________________________________________
TList *TProof::GetFeedbackList() const
{
   // Return feedback list.

   return fFeedback;
}

//______________________________________________________________________________
TTree *TProof::GetTreeHeader(TDSet *dset)
{
   // Creates a tree header (a tree with nonexisting files) object for
   // the DataSet.

   TList *l = GetListOfActiveSlaves();
   TSlave *sl = (TSlave*) l->First();
   if (sl == 0) {
      Error("GetTreeHeader", "No connection");
      return 0;
   }

   TSocket *soc = sl->GetSocket();
   TMessage msg(kPROOF_GETTREEHEADER);

   msg << dset;

   soc->Send(msg);

   TMessage *reply;
   Int_t d = -1;
   if (fProtocol >= 20) {
      Collect(sl, fCollectTimeout, kPROOF_GETTREEHEADER);
      reply = (TMessage *) fRecvMessages->First();
   } else {
      d = soc->Recv(reply);
   }
   if (!reply) {
      Error("GetTreeHeader", "Error getting a replay from the master.Result %d", (int) d);
      return 0;
   }

   TString s1;
   TTree *t = 0;
   (*reply) >> s1;
   if (s1 == "Success")
      (*reply) >> t;

   PDB(kGlobal, 1) {
      if (t) {
         Info("GetTreeHeader", "%s, message size: %d, entries: %d",
                               s1.Data(), reply->BufferSize(), (int) t->GetMaxEntryLoop());
      } else {
         Info("GetTreeHeader", "tree header retrieval failed");
      }
   }
   delete reply;

   return t;
}

//______________________________________________________________________________
TDrawFeedback *TProof::CreateDrawFeedback()
{
   // Draw feedback creation proxy. When accessed via TProof avoids
   // link dependency on libProofPlayer.

   return (fPlayer ? fPlayer->CreateDrawFeedback(this) : (TDrawFeedback *)0);
}

//______________________________________________________________________________
void TProof::SetDrawFeedbackOption(TDrawFeedback *f, Option_t *opt)
{
   // Set draw feedback option.

   if (fPlayer) fPlayer->SetDrawFeedbackOption(f, opt);
}

//______________________________________________________________________________
void TProof::DeleteDrawFeedback(TDrawFeedback *f)
{
   // Delete draw feedback object.

   if (fPlayer) fPlayer->DeleteDrawFeedback(f);
}

//______________________________________________________________________________
TList *TProof::GetOutputNames()
{
   //   FIXME: to be written

   return 0;
/*
   TMessage msg(kPROOF_GETOUTPUTLIST);
   TList* slaves = fActiveSlaves;
   Broadcast(msg, slaves);
   TMonitor mon;
   TList* outputList = new TList();

   TIter    si(slaves);
   TSlave   *slave;
   while ((slave = (TSlave*)si.Next()) != 0) {
      PDB(kGlobal,4) Info("GetOutputNames","Socket added to monitor: %p (%s)",
          slave->GetSocket(), slave->GetName());
      mon.Add(slave->GetSocket());
   }
   mon.ActivateAll();
   ((TProof*)gProof)->DeActivateAsyncInput();
   ((TProof*)gProof)->fCurrentMonitor = &mon;

   while (mon.GetActive() != 0) {
      TSocket *sock = mon.Select();
      if (!sock) {
         Error("GetOutputList","TMonitor::.Select failed!");
         break;
      }
      mon.DeActivate(sock);
      TMessage *reply;
      if (sock->Recv(reply) <= 0) {
         MarkBad(slave, "receive failed after kPROOF_GETOUTPUTLIST request");
//         Error("GetOutputList","Recv failed! for slave-%d (%s)",
//               slave->GetOrdinal(), slave->GetName());
         continue;
      }
      if (reply->What() != kPROOF_GETOUTPUTNAMES ) {
//         Error("GetOutputList","unexpected message %d from slawe-%d (%s)",  reply->What(),
//               slave->GetOrdinal(), slave->GetName());
         MarkBad(slave, "wrong reply to kPROOF_GETOUTPUTLIST request");
         continue;
      }
      TList* l;

      (*reply) >> l;
      TIter next(l);
      TNamed *n;
      while ( (n = dynamic_cast<TNamed*> (next())) ) {
         if (!outputList->FindObject(n->GetName()))
            outputList->Add(n);
      }
      delete reply;
   }
   ((TProof*)gProof)->fCurrentMonitor = 0;

   return outputList;
*/
}

//______________________________________________________________________________
void TProof::Browse(TBrowser *b)
{
   // Build the PROOF's structure in the browser.

   b->Add(fActiveSlaves, fActiveSlaves->Class(), "fActiveSlaves");
   b->Add(&fMaster, fMaster.Class(), "fMaster");
   b->Add(fFeedback, fFeedback->Class(), "fFeedback");
   b->Add(fChains, fChains->Class(), "fChains");

   if (fPlayer) {
      b->Add(fPlayer->GetInputList(), fPlayer->GetInputList()->Class(), "InputList");
      if (fPlayer->GetOutputList())
         b->Add(fPlayer->GetOutputList(), fPlayer->GetOutputList()->Class(), "OutputList");
      if (fPlayer->GetListOfResults())
         b->Add(fPlayer->GetListOfResults(),
               fPlayer->GetListOfResults()->Class(), "ListOfResults");
   }
}

//______________________________________________________________________________
void TProof::SetPlayer(TVirtualProofPlayer *player)
{
   // Set a new PROOF player.

   if (fPlayer)
      delete fPlayer;
   fPlayer = player;
};

//______________________________________________________________________________
TVirtualProofPlayer *TProof::MakePlayer(const char *player, TSocket *s)
{
   // Construct a TProofPlayer object. The player string specifies which
   // player should be created: remote, slave, sm (supermaster) or base.
   // Default is remote. Socket is needed in case a slave player is created.

   if (!player)
      player = "remote";

   SetPlayer(TVirtualProofPlayer::Create(player, this, s));
   return GetPlayer();
}

//______________________________________________________________________________
void TProof::AddChain(TChain *chain)
{
   // Add chain to data set

   fChains->Add(chain);
}

//______________________________________________________________________________
void TProof::RemoveChain(TChain *chain)
{
   // Remove chain from data set

   fChains->Remove(chain);
}

//______________________________________________________________________________
void TProof::GetLog(Int_t start, Int_t end)
{
   // Ask for remote logs in the range [start, end]. If start == -1 all the
   // messages not yet received are sent back.

   if (!IsValid() || TestBit(TProof::kIsMaster)) return;

   TMessage msg(kPROOF_LOGFILE);

   msg << start << end;

   Broadcast(msg, kActive);
   Collect(kActive, fCollectTimeout);
}

//______________________________________________________________________________
void TProof::PutLog(TQueryResult *pq)
{
   // Display log of query pq into the log window frame

   if (!pq) return;

   TList *lines = pq->GetLogFile()->GetListOfLines();
   if (lines) {
      TIter nxl(lines);
      TObjString *l = 0;
      while ((l = (TObjString *)nxl()))
         EmitVA("LogMessage(const char*,Bool_t)", 2, l->GetName(), kFALSE);
   }
}

//______________________________________________________________________________
void TProof::ShowLog(const char *queryref)
{
   // Display on screen the content of the temporary log file for query
   // in reference

   // Make sure we have all info (GetListOfQueries retrieves the
   // head info only)
   Retrieve(queryref);

   if (fPlayer) {
      if (queryref) {
         if (fPlayer->GetListOfResults()) {
            TIter nxq(fPlayer->GetListOfResults());
            TQueryResult *qr = 0;
            while ((qr = (TQueryResult *) nxq()))
               if (strstr(queryref, qr->GetTitle()) &&
                   strstr(queryref, qr->GetName()))
                  break;
            if (qr) {
               PutLog(qr);
               return;
            }

         }
      }
   }
}

//______________________________________________________________________________
void TProof::ShowLog(Int_t qry)
{
   // Display on screen the content of the temporary log file.
   // If qry == -2 show messages from the last (current) query.
   // If qry == -1 all the messages not yet displayed are shown (default).
   // If qry == 0, all the messages in the file are shown.
   // If qry  > 0, only the messages related to query 'qry' are shown.
   // For qry != -1 the original file offset is restored at the end

   // Save present offset
   off_t nowlog = lseek(fileno(fLogFileR), (off_t) 0, SEEK_CUR);
   if (nowlog < 0) {
      SysError("ShowLogFile", "problem lseeking log file (errno: %d)", TSystem::GetErrno());
      return;
   }

   // Get extremes
   off_t startlog = nowlog;
   off_t endlog = lseek(fileno(fLogFileR), (off_t) 0, SEEK_END);
   if (endlog < 0) {
      SysError("ShowLogFile", "problem lseeking log file (errno: %d)", TSystem::GetErrno());
      return;
   }

   lseek(fileno(fLogFileR), nowlog, SEEK_SET);
   if (qry == 0) {
      startlog = 0;
      lseek(fileno(fLogFileR), (off_t) 0, SEEK_SET);
   } else if (qry != -1) {

      TQueryResult *pq = 0;
      if (qry == -2) {
         // Pickup the last one
         pq = (GetQueryResults()) ? ((TQueryResult *)(GetQueryResults()->Last())) : 0;
         if (!pq) {
            GetListOfQueries();
            if (fQueries)
               pq = (TQueryResult *)(fQueries->Last());
         }
      } else if (qry > 0) {
         TList *queries = GetQueryResults();
         if (queries) {
            TIter nxq(queries);
            while ((pq = (TQueryResult *)nxq()))
               if (qry == pq->GetSeqNum())
                  break;
         }
         if (!pq) {
            queries = GetListOfQueries();
            TIter nxq(queries);
            while ((pq = (TQueryResult *)nxq()))
               if (qry == pq->GetSeqNum())
                  break;
         }
      }
      if (pq) {
         PutLog(pq);
         return;
      } else {
         if (gDebug > 0)
            Info("ShowLog","query %d not found in list", qry);
         qry = -1;
      }
   }

   // Number of bytes to log
   UInt_t tolog = (UInt_t)(endlog - startlog);

   // Perhaps nothing
   if (tolog <= 0)

   // Set starting point
   lseek(fileno(fLogFileR), startlog, SEEK_SET);

   // Now we go
   Int_t np = 0;
   char line[2048];
   Int_t wanted = (tolog > sizeof(line)) ? sizeof(line) : tolog;
   while (fgets(line, wanted, fLogFileR)) {

      Int_t r = strlen(line);
      if (!SendingLogToWindow()) {
         if (line[r-1] != '\n') line[r-1] = '\n';
         if (r > 0) {
            char *p = line;
            while (r) {
               Int_t w = write(fileno(stdout), p, r);
               if (w < 0) {
                  SysError("ShowLogFile", "error writing to stdout");
                  break;
               }
               r -= w;
               p += w;
            }
         }
         tolog -= strlen(line);
         np++;

         // Ask if more is wanted
         if (!(np%10)) {
            char *opt = Getline("More (y/n)? [y]");
            if (opt[0] == 'n')
               break;
         }

         // We may be over
         if (tolog <= 0)
            break;

         // Update wanted bytes
         wanted = (tolog > sizeof(line)) ? sizeof(line) : tolog;
      } else {
         // Log to window
         if (line[r-1] == '\n') line[r-1] = 0;
         LogMessage(line, kFALSE);
      }
   }
   if (!SendingLogToWindow()) {
      // Avoid screwing up the prompt
      if (write(fileno(stdout), "\n", 1) != 1)
         SysError("ShowLogFile", "error writing to stdout");
   }

   // Restore original pointer
   if (qry > -1)
      lseek(fileno(fLogFileR), nowlog, SEEK_SET);
}

//______________________________________________________________________________
void TProof::cd(Int_t id)
{
   // Set session with 'id' the default one. If 'id' is not found in the list,
   // the current session is set as default

   if (GetManager()) {
      TProofDesc *d = GetManager()->GetProofDesc(id);
      if (d) {
         if (d->GetProof()) {
            gProof = d->GetProof();
            return;
         }
      }

      // Id not found or undefined: set as default this session
      gProof = this;
   }

   return;
}

//______________________________________________________________________________
void TProof::Detach(Option_t *opt)
{
   // Detach this instance to its proofserv.
   // If opt is 'S' or 's' the remote server is shutdown

   // Nothing to do if not in contact with proofserv
   if (!IsValid()) return;

   // Get worker and socket instances
   TSlave *sl = (TSlave *) fActiveSlaves->First();
   TSocket *s = 0;
   if (!sl || !(sl->IsValid()) || !(s = sl->GetSocket())) {
      Error("Detach","corrupted worker instance: wrk:%p, sock:%p", sl, s);
      return;
   }

   Bool_t shutdown = (strchr(opt,'s') || strchr(opt,'S')) ? kTRUE : kFALSE;

   // If processing, try to stop processing first
   if (shutdown && !IsIdle()) {
      // Remove pending requests
      Remove("cleanupqueue");
      // Do not wait for ever, but al least 20 seconds
      Long_t timeout = gEnv->GetValue("Proof.ShutdownTimeout", 60);
      timeout = (timeout > 20) ? timeout : 20;
      // Send stop signal
      StopProcess(kFALSE, (Long_t) (timeout / 2));
      // Receive results
      Collect(kActive, timeout);
   }

   // Avoid spurious messages: deactivate new inputs ...
   DeActivateAsyncInput();

   // ... and discard existing ones
   sl->FlushSocket();

   // Close session (we always close the connection)
   Close(opt);

   // Close the progress dialog, if any
   if (fProgressDialogStarted)
      CloseProgressDialog();

   // Update info in the table of our manager, if any
   if (GetManager() && GetManager()->QuerySessions("L")) {
      TIter nxd(GetManager()->QuerySessions("L"));
      TProofDesc *d = 0;
      while ((d = (TProofDesc *)nxd())) {
         if (d->GetProof() == this) {
            d->SetProof(0);
            GetManager()->QuerySessions("L")->Remove(d);
            break;
         }
      }
   }

   // Delete this instance
   if ((!fProgressDialogStarted) && !TestBit(kUsingSessionGui))
      delete this;
   else
      // ~TProgressDialog will delete this
      fValid = kFALSE;

   return;
}

//______________________________________________________________________________
void TProof::SetAlias(const char *alias)
{
   // Set an alias for this session. If reconnection is supported, the alias
   // will be communicated to the remote coordinator so that it can be recovered
   // when reconnecting

   // Set it locally
   TNamed::SetTitle(alias);
   if (TestBit(TProof::kIsMaster))
      // Set the name at the same value
      TNamed::SetName(alias);

   // Nothing to do if not in contact with coordinator
   if (!IsValid()) return;

   if (!IsProofd() && TestBit(TProof::kIsClient)) {
      TSlave *sl = (TSlave *) fActiveSlaves->First();
      if (sl)
         sl->SetAlias(alias);
   }

   return;
}

//______________________________________________________________________________
Int_t TProof::UploadDataSet(const char *dataSetName,
                            TList *files,
                            const char *desiredDest,
                            Int_t opt,
                            TList *skippedFiles)
{
   // Upload a set of files and save the list of files by name dataSetName.
   // The 'files' argument is a list of TFileInfo objects describing the files
   // as first url.
   // The mask 'opt' is a combination of EUploadOpt:
   //   kAppend             (0x1)   if set true files will be appended to
   //                               the dataset existing by given name
   //   kOverwriteDataSet   (0x2)   if dataset with given name exited it
   //                               would be overwritten
   //   kNoOverwriteDataSet (0x4)   do not overwirte if the dataset exists
   //   kOverwriteAllFiles  (0x8)   overwrite all files that may exist
   //   kOverwriteNoFiles   (0x10)  overwrite none
   //   kAskUser            (0x0)   ask user before overwriteng dataset/files
   // The default value is kAskUser.
   // The user will be asked to confirm overwriting dataset or files unless
   // specified opt provides the answer!
   // If kOverwriteNoFiles is set, then a pointer to TList must be passed as
   // skippedFiles argument. The function will add to this list TFileInfo
   // objects describing all files that existed on the cluster and were
   // not uploaded.
   //
   // Communication Summary
   // Client                             Master
   //    |------------>DataSetName----------->|
   //    |<-------kMESS_OK/kMESS_NOTOK<-------| (Name OK/file exist)
   // (*)|-------> call RegisterDataSet ------->|
   // (*) - optional

   if (fProtocol < 15) {
      Info("UploadDataSet", "functionality not available: the server has an"
                            " incompatible version of TFileInfo");
      return -1;
   }

   if (IsLite()) {
      Info("UploadDataSet", "Lite-session: functionality not needed - do nothing");
      return -1;
   }

   // check if  dataSetName is not excluded
   if (strchr(dataSetName, '/')) {
      if (strstr(dataSetName, "public") != dataSetName) {
         Error("UploadDataSet",
               "Name of public dataset should start with public/");
         return kError;
      }
   }
   if ((opt & kOverwriteAllFiles && opt & kOverwriteNoFiles) ||
       (opt & kNoOverwriteDataSet && opt & kAppend) ||
       (opt & kOverwriteDataSet && opt & kAppend) ||
       (opt & kNoOverwriteDataSet && opt & kOverwriteDataSet) ||
       (opt & kAskUser && opt & (kOverwriteDataSet | kNoOverwriteDataSet | kAppend |
                                 kOverwriteAllFiles | kOverwriteNoFiles))) {
      Error("UploadDataSet", "you specified contradicting options.");
      return kError;
   }

   // Decode options
   Int_t overwriteAll = (opt & kOverwriteAllFiles) ? kTRUE : kFALSE;
   Int_t overwriteNone = (opt & kOverwriteNoFiles) ? kTRUE : kFALSE;
   Int_t goodName = (opt & (kOverwriteDataSet | kAppend)) ? 1 : -1;
   Int_t appendToDataSet = (opt & kAppend) ? kTRUE : kFALSE;
   Int_t overwriteNoDataSet = (opt & kNoOverwriteDataSet) ? kTRUE : kFALSE;


   //If skippedFiles is not provided we can not return list of skipped files.
   if (!skippedFiles && overwriteNone) {
      Error("UploadDataSet",
            "Provide pointer to TList object as skippedFiles argument when using kOverwriteNoFiles option.");
      return kError;
   }
   //If skippedFiles is provided but did not point to a TList the have to STOP
   if (skippedFiles) {
      if (skippedFiles->Class() != TList::Class()) {
         Error("UploadDataSet",
               "Provided skippedFiles argument does not point to a TList object.");
         return kError;
      }
   }
   TSocket *master;
   if (fActiveSlaves->GetSize())
      master = ((TSlave*)(fActiveSlaves->First()))->GetSocket();
   else {
      Error("UploadDataSet", "No connection to the master!");
      return kError;
   }

   Int_t fileCount = 0; // return value
   if (goodName == -1) { // -1 for undefined
      // First check whether this dataset already exists unless
      // kAppend or kOverWriteDataSet
      TMessage nameMess(kPROOF_DATASETS);
      nameMess << Int_t(kCheckDataSetName);
      nameMess << TString(dataSetName);
      Broadcast(nameMess);
      Collect(kActive, fCollectTimeout); //after each call to HandleDataSets
      if (fStatus == -1) {
         //We ask user to agree on overwriting the dataset name
         while (goodName == -1 && !overwriteNoDataSet) {
            Info("UploadDataSet", "dataset %s already exist. ",
                   dataSetName);
            Info("UploadDataSet", "do you want to overwrite it[Yes/No/Append]?");
            TString answer;
            answer.ReadToken(cin);
            if (!strncasecmp(answer.Data(), "y", 1)) {
               goodName = 1;
            } else if (!strncasecmp(answer.Data(), "n", 1)) {
               goodName = 0;
            } else if (!strncasecmp(answer.Data(), "a", 1)) {
               goodName = 1;
               appendToDataSet = kTRUE;
            }
         }
      } else {
         goodName = 1;
      }
   } // if (goodName == -1)
   if (goodName == 1) {  //must be == 1 as -1 was used for a bad name!
      //Code for enforcing writing in user "home dir" only
      char *relativeDestDir = Form("%s/%s/",
                                   gSystem->GetUserInfo()->fUser.Data(),
                                   desiredDest?desiredDest:"");
                                   //Consider adding dataSetName to the path

      relativeDestDir = CollapseSlashesInPath(relativeDestDir);
      TString dest = Form("%s/%s", GetDataPoolUrl(), relativeDestDir);

      delete[] relativeDestDir;

      // Now we will actually copy files and create the TList object
      TFileCollection *fileList = new TFileCollection();
      TIter next(files);
      while (TFileInfo *fileInfo = ((TFileInfo*)next())) {
         TUrl *fileUrl = fileInfo->GetFirstUrl();
         if (gSystem->AccessPathName(fileUrl->GetUrl()) == kFALSE) {
            //matching dir entry
            //getting the file name from the path represented by fileUrl
            const char *ent = gSystem->BaseName(fileUrl->GetFile());

            Int_t goodFileName = 1;
            if (!overwriteAll &&
               gSystem->AccessPathName(Form("%s/%s", dest.Data(), ent), kFileExists)
                  == kFALSE) {  //Destination file exists
               goodFileName = -1;
               while (goodFileName == -1 && !overwriteAll && !overwriteNone) {
                  Info("UploadDataSet", "file %s already exists. ", Form("%s/%s", dest.Data(), ent));
                  Info("UploadDataSet", "do you want to overwrite it [Yes/No/all/none]?");
                  TString answer;
                  answer.ReadToken(cin);
                  if (!strncasecmp(answer.Data(), "y", 1))
                     goodFileName = 1;
                  else if (!strncasecmp(answer.Data(), "all", 3))
                     overwriteAll = kTRUE;
                  else if (!strncasecmp(answer.Data(), "none", 4))
                     overwriteNone = kTRUE;
                  else if (!strncasecmp(answer.Data(), "n", 1))
                     goodFileName = 0;
               }
            } //if file exists

            // Copy the file to the redirector indicated
            if (goodFileName == 1 || overwriteAll) {
               //must be == 1 as -1 was meant for bad name!
               Info("UploadDataSet", "Uploading %s to %s/%s",
                      fileUrl->GetUrl(), dest.Data(), ent);
               if (TFile::Cp(fileUrl->GetUrl(), Form("%s/%s", dest.Data(), ent))) {
                  fileList->GetList()->Add(new TFileInfo(Form("%s/%s", dest.Data(), ent)));
               } else
                  Error("UploadDataSet", "file %s was not copied", fileUrl->GetUrl());
            } else {  // don't overwrite, but file exist and must be included
               fileList->GetList()->Add(new TFileInfo(Form("%s/%s", dest.Data(), ent)));
               if (skippedFiles) {
                  // user specified the TList *skippedFiles argument so we create
                  // the list of skipped files
                  skippedFiles->Add(new TFileInfo(fileUrl->GetUrl()));
               }
            }
         } //if matching dir entry
      } //while

      if ((fileCount = fileList->GetList()->GetSize()) == 0) {
         Info("UploadDataSet", "no files were copied. The dataset will not be saved");
      } else {
         TString o = (appendToDataSet) ? "" : "O";
         if (!RegisterDataSet(dataSetName, fileList, o)) {
            Error("UploadDataSet", "Error while saving dataset: %s", dataSetName);
            fileCount = kError;
         }
      }
      delete fileList;
   } else if (overwriteNoDataSet) {
      Info("UploadDataSet", "dataset %s already exists", dataSetName);
      return kDataSetExists;
   } //if(goodName == 1)

   return fileCount;
}

//______________________________________________________________________________
Int_t TProof::UploadDataSet(const char *dataSetName,
                            const char *files,
                            const char *desiredDest,
                            Int_t opt,
                            TList *skippedFiles)
{
   // Upload a set of files and save the list of files by name dataSetName.
   // The mask 'opt' is a combination of EUploadOpt:
   //   kAppend             (0x1)   if set true files will be appended to
   //                               the dataset existing by given name
   //   kOverwriteDataSet   (0x2)   if dataset with given name exited it
   //                               would be overwritten
   //   kNoOverwriteDataSet (0x4)   do not overwirte if the dataset exists
   //   kOverwriteAllFiles  (0x8)   overwrite all files that may exist
   //   kOverwriteNoFiles   (0x10)  overwrite none
   //   kAskUser            (0x0)   ask user before overwriteng dataset/files
   // The default value is kAskUser.
   // The user will be asked to confirm overwriting dataset or files unless
   // specified opt provides the answer!
   // If kOverwriteNoFiles is set, then a pointer to TList must be passed as
   // skippedFiles argument. The function will add to this list TFileInfo
   // objects describing all files that existed on the cluster and were
   // not uploaded.
   //

   if (fProtocol < 15) {
      Info("UploadDataSet", "functionality not available: the server has an"
                            " incompatible version of TFileInfo");
      return -1;
   }

   TList fileList;
   fileList.SetOwner();
   void *dataSetDir = gSystem->OpenDirectory(gSystem->DirName(files));
   const char* ent;
   TString filesExp(gSystem->BaseName(files));
   filesExp.ReplaceAll("*",".*");
   TRegexp rg(filesExp);
   while ((ent = gSystem->GetDirEntry(dataSetDir))) {
      TString entryString(ent);
      if (entryString.Index(rg) != kNPOS) {
         // Matching dir entry: add to the list
         TString u(Form("file://%s/%s", gSystem->DirName(files), ent));
         if (gSystem->AccessPathName(u, kReadPermission) == kFALSE)
            fileList.Add(new TFileInfo(u));
      } //if matching dir entry
   } //while
   Int_t fileCount;
   if ((fileCount = fileList.GetSize()) == 0)
      Printf("No files match your selection. The dataset will not be saved");
   else
      fileCount = UploadDataSet(dataSetName, &fileList, desiredDest,
                                opt, skippedFiles);
   return fileCount;
}

//______________________________________________________________________________
Int_t TProof::UploadDataSetFromFile(const char *dataset, const char *file,
                                    const char *dest, Int_t opt,
                                    TList *skippedFiles)
{
   // Upload files listed in "file" to PROOF cluster.
   // Where file = name of file containing list of files and
   // dataset = dataset name and opt is a combination of EUploadOpt bits.
   // Each file description (line) can include wildcards.
   // Check TFileInfo compatibility

   if (fProtocol < 15) {
      Info("UploadDataSetFromFile", "functionality not available: the server has an"
                                    " incompatible version of TFileInfo");
      return -1;
   }

   Int_t fileCount = -1;
   // Create the list to feed UploadDataSet(char *dataset, TList *l, ...)
   TList fileList;
   fileList.SetOwner();
   ifstream f;
   f.open(gSystem->ExpandPathName(file), ifstream::out);
   if (f.is_open()) {
      while (f.good()) {
         TString line;
         line.ReadToDelim(f);
         line.Strip(TString::kTrailing, '\n');
         if (gSystem->AccessPathName(line, kReadPermission) == kFALSE)
            fileList.Add(new TFileInfo(line));
      }
      f.close();
      if ((fileCount = fileList.GetSize()) == 0)
         Info("UploadDataSetFromFile",
              "no files match your selection. The dataset will not be saved");
      else
         fileCount = UploadDataSet(dataset, &fileList, dest,
                                   opt, skippedFiles);
   } else {
      Error("UploadDataSetFromFile", "unable to open the specified file");
   }
   // Done
   return fileCount;
}

//______________________________________________________________________________
Bool_t TProof::RegisterDataSet(const char *dataSetName,
                               TFileCollection *dataSet, const char* optStr)
{
   // Register the 'dataSet' on the cluster under the current
   // user, group and the given 'dataSetName'.
   // Fails if a dataset named 'dataSetName' already exists, unless 'optStr'
   // contains 'O', in which case the old dataset is overwritten.
   // If 'optStr' contains 'V' the dataset files are verified (default no
   // verification).
   // Returns kTRUE on success.

   // Check TFileInfo compatibility
   if (fProtocol < 17) {
      Info("RegisterDataSet",
           "functionality not available: the server does not have dataset support");
      return kFALSE;
   }

   if (!dataSetName || strlen(dataSetName) <= 0) {
      Info("RegisterDataSet", "specifying a dataset name is mandatory");
      return kFALSE;
   }

   TSocket *master;
   if (fActiveSlaves->GetSize())
      master = ((TSlave*)(fActiveSlaves->First()))->GetSocket();
   else {
      Error("RegisterDataSet", "No connection to the master!");
      return kFALSE;
   }

   TMessage mess(kPROOF_DATASETS);
   mess << Int_t(kRegisterDataSet);
   mess << TString(dataSetName);
   mess << TString(optStr);
   mess.WriteObject(dataSet);
   Broadcast(mess);

   Bool_t result = kTRUE;
   Collect();
   if (fStatus != 0) {
      Error("RegisterDataSet", "dataset was not saved");
      result = kFALSE;
   }
   return result;
}

//______________________________________________________________________________
Int_t TProof::SetDataSetTreeName(const char *dataset, const char *treename)
{
   // Set/Change the name of the default tree. The tree name may contain
   // subdir specification in the form "subdir/name".
   // Returns 0 on success, -1 otherwise.

   // Check TFileInfo compatibility
   if (fProtocol < 23) {
      Info("SetDataSetTreeName", "functionality not supported by the server");
      return -1;
   }

   if (!dataset || strlen(dataset) <= 0) {
      Info("SetDataSetTreeName", "specifying a dataset name is mandatory");
      return -1;
   }

   if (!treename || strlen(treename) <= 0) {
      Info("SetDataSetTreeName", "specifying a tree name is mandatory");
      return -1;
   }

   TUri uri(dataset);
   TString fragment(treename);
   if (!fragment.BeginsWith("/")) fragment.Insert(0, "/");
   uri.SetFragment(fragment);

   TMessage mess(kPROOF_DATASETS);
   mess << Int_t(kSetDefaultTreeName);
   mess << uri.GetUri();
   Broadcast(mess);

   Collect();
   if (fStatus != 0) {
      Error("SetDataSetTreeName", "some error occured: default tree name not changed");
      return -1;
   }
   return 0;
}

//______________________________________________________________________________
TMap *TProof::GetDataSets(const char *uri, const char* optStr)
{
   // Lists all datasets that match given uri.

   if (fProtocol < 15) {
      Info("GetDataSets",
           "functionality not available: the server does not have dataset support");
      return 0;
   }

   TSocket *master = 0;
   if (fActiveSlaves->GetSize())
      master = ((TSlave*)(fActiveSlaves->First()))->GetSocket();
   else {
      Error("GetDataSets", "no connection to the master!");
      return 0;
   }

   TMessage mess(kPROOF_DATASETS);
   mess << Int_t(kGetDataSets);
   mess << TString(uri?uri:"");
   mess << TString(optStr?optStr:"");
   Broadcast(mess);
   Collect(kActive, fCollectTimeout);

   TMap *dataSetMap = 0;
   if (fStatus != 0) {
      Error("GetDataSets", "error receiving datasets information");
   } else {
      // Look in the list
      TMessage *retMess = (TMessage *) fRecvMessages->First();
      if (retMess && retMess->What() == kMESS_OK) {
         if (!(dataSetMap = (TMap *)(retMess->ReadObject(TMap::Class()))))
            Error("GetDataSets", "error receiving datasets");
      } else
         Error("GetDataSets", "message not found or wrong type (%p)", retMess);
   }

   return dataSetMap;
}

//______________________________________________________________________________
void TProof::ShowDataSets(const char *uri, const char* optStr)
{
   // Shows datasets in locations that match the uri.
   // By default shows the user's datasets and global ones

   if (fProtocol < 15) {
      Info("ShowDataSets",
           "functionality not available: the server does not have dataset support");
      return;
   }

   TSocket *master = 0;
   if (fActiveSlaves->GetSize())
      master = ((TSlave*)(fActiveSlaves->First()))->GetSocket();
   else {
      Error("ShowDataSets",
            "no connection to the master!");
      return;
   }

   TMessage mess(kPROOF_DATASETS);
   mess << Int_t(kShowDataSets);
   mess << TString(uri ? uri : "");
   mess << TString(optStr ? optStr : "");
   Broadcast(mess);

   Collect(kActive, fCollectTimeout);
   if (fStatus != 0)
      Error("ShowDataSets", "error receiving datasets information");
}

//______________________________________________________________________________
Bool_t TProof::ExistsDataSet(const char *dataset)
{
   // Returns kTRUE if 'dataset' exists, kFALSE otherwise

   if (fProtocol < 15) {
      Info("ExistsDataSet", "functionality not available: the server has an"
                            " incompatible version of TFileInfo");
      return kFALSE;
   }

   if (!dataset || strlen(dataset) <= 0) {
      Error("ExistsDataSet", "dataset name missing");
      return kFALSE;
   }

   TMessage msg(kPROOF_DATASETS);
   msg << Int_t(kCheckDataSetName) << TString(dataset);
   Broadcast(msg);
   Collect(kActive, fCollectTimeout);
   if (fStatus == -1) {
      // The dataset exists
      return kTRUE;
   }
   // The dataset does not exists
   return kFALSE;
}

//______________________________________________________________________________
TFileCollection *TProof::GetDataSet(const char *uri, const char* optStr)
{
   // Get a list of TFileInfo objects describing the files of the specified
   // dataset.

   if (fProtocol < 15) {
      Info("GetDataSet", "functionality not available: the server has an"
                         " incompatible version of TFileInfo");
      return 0;
   }

   if (!uri || strlen(uri) <= 0) {
      Info("GetDataSet", "specifying a dataset name is mandatory");
      return 0;
   }

   TSocket *master = 0;

   if (fActiveSlaves->GetSize())
      master = ((TSlave*)(fActiveSlaves->First()))->GetSocket();
   else {
      Error("GetDataSet", "no connection to the master!");
      return 0;
   }
   TMessage nameMess(kPROOF_DATASETS);
   nameMess << Int_t(kGetDataSet);
   nameMess << TString(uri);
   nameMess << TString(optStr ? optStr: "");
   if (Broadcast(nameMess) < 0)
      Error("GetDataSet", "sending request failed");

   Collect(kActive, fCollectTimeout);
   TFileCollection *fileList = 0;
   if (fStatus != 0) {
      Error("GetDataSet", "error receiving datasets information");
   } else {
      // Look in the list
      TMessage *retMess = (TMessage *) fRecvMessages->First();
      if (retMess && retMess->What() == kMESS_OK) {
         if (!(fileList = (TFileCollection*)(retMess->ReadObject(TFileCollection::Class()))))
            Error("GetDataSet", "error reading list of files");
      } else
         Error("GetDataSet", "message not found or wrong type (%p)", retMess);
   }

   return fileList;
}

//______________________________________________________________________________
void TProof::ShowDataSet(const char *uri, const char* opt)
{
   // display meta-info for given dataset usi

   TFileCollection *fileList = 0;
   if ((fileList = GetDataSet(uri))) {
      fileList->Print(opt);
      delete fileList;
   } else
      Warning("ShowDataSet","no such dataset: %s", uri);
}

//______________________________________________________________________________
Int_t TProof::RemoveDataSet(const char *uri, const char* optStr)
{
   // Remove the specified dataset from the PROOF cluster.
   // Files are not deleted.

   TSocket *master;
   if (fActiveSlaves->GetSize())
      master = ((TSlave*)(fActiveSlaves->First()))->GetSocket();
   else {
      Error("RemoveDataSet", "no connection to the master!");
      return kError;
   }
   TMessage nameMess(kPROOF_DATASETS);
   nameMess << Int_t(kRemoveDataSet);
   nameMess << TString(uri?uri:"");
   nameMess << TString(optStr?optStr:"");
   if (Broadcast(nameMess) < 0)
      Error("RemoveDataSet", "sending request failed");
   Collect(kActive, fCollectTimeout);

   if (fStatus != 0)
      return -1;
   else
      return 0;
}

//______________________________________________________________________________
TList* TProof::FindDataSets(const char* /*searchString*/, const char* /*optStr*/)
{
   // Find datasets, returns in a TList all found datasets.

   Error ("FindDataSets", "not yet implemented");
   return (TList *) 0;
}

//______________________________________________________________________________
Int_t TProof::VerifyDataSet(const char *uri, const char* optStr)
{
   // Verify if all files in the specified dataset are available.
   // Print a list and return the number of missing files.

   if (fProtocol < 15) {
      Info("VerifyDataSet", "functionality not available: the server has an"
                            " incompatible version of TFileInfo");
      return kError;
   }

   Int_t nMissingFiles = 0;
   TSocket *master;
   if (fActiveSlaves->GetSize())
      master = ((TSlave*)(fActiveSlaves->First()))->GetSocket();
   else {
      Error("VerifyDataSet", "no connection to the master!");
      return kError;
   }
   TMessage nameMess(kPROOF_DATASETS);
   nameMess << Int_t(kVerifyDataSet);
   nameMess << TString(uri ? uri : "");
   nameMess << TString(optStr ? optStr : "");
   Broadcast(nameMess);

   Collect(kActive, fCollectTimeout);

   if (fStatus < 0) {
      Info("VerifyDataSet", "no such dataset %s", uri);
      return  -1;
   } else
      nMissingFiles = fStatus;
   return nMissingFiles;
}

//______________________________________________________________________________
TMap *TProof::GetDataSetQuota(const char* optStr)
{
   // returns a map of the quotas of all groups

   if (IsLite()) {
      Info("UploadDataSet", "Lite-session: functionality not implemented");
      return (TMap *)0;
   }

   TSocket *master = 0;
   if (fActiveSlaves->GetSize())
      master = ((TSlave*)(fActiveSlaves->First()))->GetSocket();
   else {
      Error("GetDataSetQuota", "no connection to the master!");
      return 0;
   }

   TMessage mess(kPROOF_DATASETS);
   mess << Int_t(kGetQuota);
   mess << TString(optStr?optStr:"");
   Broadcast(mess);

   Collect(kActive, fCollectTimeout);
   TMap *groupQuotaMap = 0;
   if (fStatus < 0) {
      Info("GetDataSetQuota", "could not receive quota");
   } else {
      // Look in the list
      TMessage *retMess = (TMessage *) fRecvMessages->First();
      if (retMess && retMess->What() == kMESS_OK) {
         if (!(groupQuotaMap = (TMap*)(retMess->ReadObject(TMap::Class()))))
            Error("GetDataSetQuota", "error getting quotas");
      } else
         Error("GetDataSetQuota", "message not found or wrong type (%p)", retMess);
   }

   return groupQuotaMap;
}

//_____________________________________________________________________________
void TProof::ShowDataSetQuota(Option_t* opt)
{
   // shows the quota and usage of all groups
   // if opt contains "U" shows also distribution of usage on user-level

   if (fProtocol < 15) {
      Info("ShowDataSetQuota",
           "functionality not available: the server does not have dataset support");
      return;
   }

   if (IsLite()) {
      Info("UploadDataSet", "Lite-session: functionality not implemented");
      return;
   }

   TSocket *master = 0;
   if (fActiveSlaves->GetSize())
      master = ((TSlave*)(fActiveSlaves->First()))->GetSocket();
   else {
      Error("ShowDataSetQuota", "no connection to the master!");
      return;
   }

   TMessage mess(kPROOF_DATASETS);
   mess << Int_t(kShowQuota);
   mess << TString(opt?opt:"");
   Broadcast(mess);

   Collect();
   if (fStatus != 0)
      Error("ShowDataSetQuota", "error receiving quota information");
}

//_____________________________________________________________________________
void TProof::InterruptCurrentMonitor()
{
   // If in active in a monitor set ready state
   if (fCurrentMonitor)
      fCurrentMonitor->Interrupt();
}

//_____________________________________________________________________________
void TProof::ActivateWorker(const char *ord)
{
   // Make sure that the worker identified by the ordinal number 'ord' is
   // in the active list. The request will be forwarded to the master
   // in direct contact with the worker. If needed, this master will move
   // the worker from the inactive to the active list and rebuild the list
   // of unique workers.
   // Use ord = "*" to activate all inactive workers.

   ModifyWorkerLists(ord, kTRUE);
}

//_____________________________________________________________________________
void TProof::DeactivateWorker(const char *ord)
{
   // Remove the worker identified by the ordinal number 'ord' from the
   // the active list. The request will be forwarded to the master
   // in direct contact with the worker. If needed, this master will move
   // the worker from the active to the inactive list and rebuild the list
   // of unique workers.
   // Use ord = "*" to deactivate all active workers.

   ModifyWorkerLists(ord, kFALSE);
}

//_____________________________________________________________________________
void TProof::ModifyWorkerLists(const char *ord, Bool_t add)
{
   // Modify the worker active/inactive list by making the worker identified by
   // the ordinal number 'ord' active (add == TRUE) or inactive (add == FALSE).
   // If needed, the request will be forwarded to the master in direct contact
   // with the worker. The end-master will move the worker from one list to the
   // other active and rebuild the list of unique active workers.
   // Use ord = "*" to deactivate all active workers.

   // Make sure the input make sense
   if (!ord || strlen(ord) <= 0) {
      Info("ModifyWorkerLists",
           "An ordinal number - e.g. \"0.4\" or \"*\" for all - is required as input");
      return;
   }

   Bool_t fw = kTRUE;    // Whether to forward one step down
   Bool_t rs = kFALSE;   // Whether to rescan for unique workers

   // Appropriate list pointing
   TList *in = (add) ? fInactiveSlaves : fActiveSlaves;
   TList *out = (add) ? fActiveSlaves : fInactiveSlaves;

   if (TestBit(TProof::kIsMaster)) {
      fw = IsEndMaster() ? kFALSE : kTRUE;
      // Look for the worker in the inactive list
      if (in->GetSize() > 0) {
         TIter nxw(in);
         TSlave *wrk = 0;
         while ((wrk = (TSlave *) nxw())) {
            if (ord[0] == '*' || !strncmp(wrk->GetOrdinal(), ord, strlen(ord))) {
               // Add it to the inactive list
               if (!out->FindObject(wrk)) {
                  out->Add(wrk);
                  if (add)
                     fActiveMonitor->Add(wrk->GetSocket());
               }
               // Remove it from the active list
               in->Remove(wrk);
               if (!add) {
                  fActiveMonitor->Remove(wrk->GetSocket());
                  wrk->SetStatus(TSlave::kInactive);
               } else
                  wrk->SetStatus(TSlave::kActive);

               // Nothing to forward (ord is unique)
               fw = kFALSE;
               // Rescan for unique workers (active list modified)
               rs = kTRUE;
               // We are done, if not option 'all'
               if (ord[0] != '*')
                  break;
            }
         }
      }
   }

   // Rescan for unique workers
   if (rs)
      FindUniqueSlaves();

   // Forward the request one step down, if needed
   Int_t action = (add) ? (Int_t) kActivateWorker : (Int_t) kDeactivateWorker;
   if (fw) {
      TMessage mess(kPROOF_WORKERLISTS);
      mess << action << TString(ord);
      Broadcast(mess);
      Collect(kActive, fCollectTimeout);
   }
}

//_____________________________________________________________________________
TProof *TProof::Open(const char *cluster, const char *conffile,
                                          const char *confdir, Int_t loglevel)
{
   // Start a PROOF session on a specific cluster. If cluster is 0 (the
   // default) then the PROOF Session Viewer GUI pops up and 0 is returned.
   // If cluster is "" (empty string) then we connect to a PROOF session
   // on the localhost ("proof://localhost"). Via conffile a specific
   // PROOF config file in the confir directory can be specified.
   // Use loglevel to set the default loging level for debugging.
   // The appropriate instance of TProofMgr is created, if not
   // yet existing. The instantiated TProof object is returned.
   // Use TProof::cd() to switch between PROOF sessions.
   // For more info on PROOF see the TProof ctor.

   const char *pn = "TProof::Open";

   // Make sure libProof and dependents are loaded and TProof can be created,
   // dependents are loaded via the information in the [system].rootmap file
   if (!cluster) {

      TPluginManager *pm = gROOT->GetPluginManager();
      if (!pm) {
         ::Error(pn, "plugin manager not found");
         return 0;
      }

      if (gROOT->IsBatch()) {
         ::Error(pn, "we are in batch mode, cannot show PROOF Session Viewer");
         return 0;
      }
      // start PROOF Session Viewer
      TPluginHandler *sv = pm->FindHandler("TSessionViewer", "");
      if (!sv) {
         ::Error(pn, "no plugin found for TSessionViewer");
         return 0;
      }
      if (sv->LoadPlugin() == -1) {
         ::Error(pn, "plugin for TSessionViewer could not be loaded");
         return 0;
      }
      sv->ExecPlugin(0);
      return 0;

   } else {

      TString clst(cluster);
      if (clst.BeginsWith("workers=") || clst.BeginsWith("tunnel="))
         clst.Insert(0, "/?");

      // Parse input URL
      TUrl u(clst);

      // Parse any tunning info ("<cluster>/?tunnel=[<tunnel_host>:]tunnel_port)
      TString opts(u.GetOptions());
      if (!opts.IsNull()) {
         Int_t it = opts.Index("tunnel=");
         if (it != kNPOS) {
            TString sport = opts(it + strlen("tunnel="), opts.Length());
            TString host("127.0.0.1");
            Int_t port = -1;
            Int_t ic = sport.Index(":");
            if (ic != kNPOS) {
               // Isolate the host
               host = sport(0, ic);
               sport.Remove(0, ic + 1);
            }
            if (!sport.IsDigit()) {
               // Remove the non digit part
               TRegexp re("[^0-9]");
               Int_t ind = sport.Index(re);
               if (ind != kNPOS)
                  sport.Remove(ind);
            }
            // Set the port
            if (sport.IsDigit())
               port = sport.Atoi();
            if (port > 0) {
               // Set the relevant variables
               ::Info("TProof::Open","using tunnel at %s:%d", host.Data(), port);
               gEnv->SetValue("XNet.SOCKS4Host", host);
               gEnv->SetValue("XNet.SOCKS4Port", port);
            } else {
               // Warn parsing problems
               ::Warning("TProof::Open",
                         "problems parsing tunnelling info from options: %s", opts.Data());
            }
         }
      }

      // Find out if we are required to attach to a specific session
      Int_t locid = -1;
      Bool_t create = kFALSE;
      if (opts.Length() > 0) {
         if (opts.BeginsWith("N",TString::kIgnoreCase)) {
            create = kTRUE;
         } else if (opts.IsDigit()) {
            locid = opts.Atoi();
         }
      }

      // Attach-to or create the appropriate manager
      TProofMgr *mgr = TProofMgr::Create(u.GetUrl());

      TProof *proof = 0;
      if (mgr && mgr->IsValid()) {

         // If XProofd we always attempt an attach first (unless
         // explicitely not requested).
         Bool_t attach = (create || mgr->IsProofd() || mgr->IsLite()) ? kFALSE : kTRUE;
         if (attach) {
            TProofDesc *d = 0;
            if (locid < 0)
               // Get the list of sessions
               d = (TProofDesc *) mgr->QuerySessions("")->First();
            else
               d = (TProofDesc *) mgr->GetProofDesc(locid);
            if (d) {
               proof = (TProof*) mgr->AttachSession(d);
               if (!proof || !proof->IsValid()) {
                  if (locid)
                     ::Error(pn, "new session could not be attached");
                  SafeDelete(proof);
               }
            }
         }

         // start the PROOF session
         if (!proof) {
            proof = (TProof*) mgr->CreateSession(conffile, confdir, loglevel);
            if (!proof || !proof->IsValid()) {
               ::Error(pn, "new session could not be created");
               SafeDelete(proof);
            }
         }
      }
      return proof;
   }
}

//_____________________________________________________________________________
TProofMgr *TProof::Mgr(const char *url)
{
   // Get instance of the effective manager for 'url'
   // Return 0 on failure.

   if (!url)
      return (TProofMgr *)0;

   // Attach or create the relevant instance
   return TProofMgr::Create(url);
}

//_____________________________________________________________________________
void TProof::Reset(const char *url, Bool_t hard)
{
   // Wrapper around TProofMgr::Reset(...).

   if (url) {
      TProofMgr *mgr = TProof::Mgr(url);
      if (mgr && mgr->IsValid())
         mgr->Reset(hard);
      else
         ::Error("TProof::Reset",
                 "unable to initialize a valid manager instance");
   }
}

//_____________________________________________________________________________
const TList *TProof::GetEnvVars()
{
   // Get environemnt variables.

   return fgProofEnvList;
}

//_____________________________________________________________________________
void TProof::AddEnvVar(const char *name, const char *value)
{
   // Add an variable to the list of environment variables passed to proofserv
   // on the master and slaves

   if (gDebug > 0) ::Info("TProof::AddEnvVar","%s=%s", name, value);

   if (fgProofEnvList == 0) {
      // initialize the list if needed
      fgProofEnvList = new TList;
      fgProofEnvList->SetOwner();
   } else {
      // replace old entries with the same name
      TObject *o = fgProofEnvList->FindObject(name);
      if (o != 0) {
         fgProofEnvList->Remove(o);
      }
   }
   fgProofEnvList->Add(new TNamed(name, value));
}

//_____________________________________________________________________________
void TProof::DelEnvVar(const char *name)
{
   // Remove an variable from the list of environment variables passed to proofserv
   // on the master and slaves

   if (fgProofEnvList == 0) return;

   TObject *o = fgProofEnvList->FindObject(name);
   if (o != 0) {
      fgProofEnvList->Remove(o);
   }
}

//_____________________________________________________________________________
void TProof::ResetEnvVars()
{
   // Clear the list of environment variables passed to proofserv
   // on the master and slaves

   if (fgProofEnvList == 0) return;

   SafeDelete(fgProofEnvList);
}

//______________________________________________________________________________
void TProof::SaveWorkerInfo()
{
   // Save informations about the worker set in the file .workers in the working
   // dir. Called each time there is a change in the worker setup, e.g. by
   // TProof::MarkBad().

   // We must be masters
   if (TestBit(TProof::kIsClient))
      return;

   // We must have a server defined
   if (!gProofServ) {
      Error("SaveWorkerInfo","gProofServ undefined");
      return;
   }

   // The relevant lists must be defined
   if (!fSlaves && !fBadSlaves) {
      Warning("SaveWorkerInfo","all relevant worker lists is undefined");
      return;
   }

   // Create or truncate the file first
   TString fnwrk = Form("%s/.workers",
                        gSystem->DirName(gProofServ->GetSessionDir()));
   FILE *fwrk = fopen(fnwrk.Data(),"w");
   if (!fwrk) {
      Error("SaveWorkerInfo",
            "cannot open %s for writing (errno: %d)", fnwrk.Data(), errno);
      return;
   }

   // Do we need to register an additional line for another log?
   TString addlogext;
   if (gSystem->Getenv("PROOF_ADDITIONALLOG")) {
      addlogext = gSystem->Getenv("PROOF_ADDITIONALLOG");
      if (gDebug > 0)
         Info("SaveWorkerInfo", "request for additional line with ext: '%s'",  addlogext.Data());
   }

   // Loop over the list of workers (active is any worker not flagged as bad)
   TIter nxa(fSlaves);
   TSlave *wrk = 0;
   while ((wrk = (TSlave *) nxa())) {
      Int_t status = (fBadSlaves && fBadSlaves->FindObject(wrk)) ? 0 : 1;
      // Write out record for this worker
      fprintf(fwrk,"%s@%s:%d %d %s %s.log\n",
                   wrk->GetUser(), wrk->GetName(), wrk->GetPort(), status,
                   wrk->GetOrdinal(), wrk->GetWorkDir());
      // Additional line, if required
      if (addlogext.Length() > 0) {
         fprintf(fwrk,"%s@%s:%d %d %s %s.%s\n",
                     wrk->GetUser(), wrk->GetName(), wrk->GetPort(), status,
                     wrk->GetOrdinal(), wrk->GetWorkDir(), addlogext.Data());
      }
   }

   // Close file
   fclose(fwrk);

   // We are done
   return;
}

//______________________________________________________________________________
Int_t TProof::GetParameter(TCollection *c, const char *par, TString &value)
{
   // Get the value from the specified parameter from the specified collection.
   // Returns -1 in case of error (i.e. list is 0, parameter does not exist
   // or value type does not match), 0 otherwise.

   TObject *obj = c->FindObject(par);
   if (obj) {
      TNamed *p = dynamic_cast<TNamed*>(obj);
      if (p) {
         value = p->GetTitle();
         return 0;
      }
   }
   return -1;

}

//______________________________________________________________________________
Int_t TProof::GetParameter(TCollection *c, const char *par, Int_t &value)
{
   // Get the value from the specified parameter from the specified collection.
   // Returns -1 in case of error (i.e. list is 0, parameter does not exist
   // or value type does not match), 0 otherwise.

   TObject *obj = c->FindObject(par);
   if (obj) {
      TParameter<Int_t> *p = dynamic_cast<TParameter<Int_t>*>(obj);
      if (p) {
         value = p->GetVal();
         return 0;
      }
   }
   return -1;
}

//______________________________________________________________________________
Int_t TProof::GetParameter(TCollection *c, const char *par, Long_t &value)
{
   // Get the value from the specified parameter from the specified collection.
   // Returns -1 in case of error (i.e. list is 0, parameter does not exist
   // or value type does not match), 0 otherwise.

   TObject *obj = c->FindObject(par);
   if (obj) {
      TParameter<Long_t> *p = dynamic_cast<TParameter<Long_t>*>(obj);
      if (p) {
         value = p->GetVal();
         return 0;
      }
   }
   return -1;
}

//______________________________________________________________________________
Int_t TProof::GetParameter(TCollection *c, const char *par, Long64_t &value)
{
   // Get the value from the specified parameter from the specified collection.
   // Returns -1 in case of error (i.e. list is 0, parameter does not exist
   // or value type does not match), 0 otherwise.

   TObject *obj = c->FindObject(par);
   if (obj) {
      TParameter<Long64_t> *p = dynamic_cast<TParameter<Long64_t>*>(obj);
      if (p) {
         value = p->GetVal();
         return 0;
      }
   }
   return -1;
}

//______________________________________________________________________________
Int_t TProof::GetParameter(TCollection *c, const char *par, Double_t &value)
{
   // Get the value from the specified parameter from the specified collection.
   // Returns -1 in case of error (i.e. list is 0, parameter does not exist
   // or value type does not match), 0 otherwise.

   TObject *obj = c->FindObject(par);
   if (obj) {
      TParameter<Double_t> *p = dynamic_cast<TParameter<Double_t>*>(obj);
      if (p) {
         value = p->GetVal();
         return 0;
      }
   }
   return -1;
}

//______________________________________________________________________________
Int_t TProof::AssertDataSet(TDSet *dset, TList *input,
                            TDataSetManager *mgr, TString &emsg)
{
   // Make sure that dataset is in the form to be processed. This may mean
   // retrieving the relevant info from the dataset manager or from the
   // attached input list.
   // Returns 0 on success, -1 on error

   emsg = "";

   // We must have something to process
   if (!dset || !input || !mgr) {
      emsg.Form("invalid inputs (%p, %p, %p)", dset, input, mgr);
      return -1;
   }

   TFileCollection* dataset = 0;
   TString lookupopt;
   TString dsname(dset->GetName());
   // The dataset maybe in the form of a TFileCollection in the input list
   if (dsname.BeginsWith("TFileCollection:")) {
      // Isolate the real name
      dsname.ReplaceAll("TFileCollection:", "");
      // Get the object
      dataset = (TFileCollection *) input->FindObject(dsname);
      if (!dataset) {
         emsg.Form("TFileCollection %s not found in input list", dset->GetName());
         return -1;
      }
      // Remove from everywhere
      input->RecursiveRemove(dataset);
      // Make sure we lookup everything (unless the client or the administartor
      // required something else)
      if (TProof::GetParameter(input, "PROOF_LookupOpt", lookupopt) != 0) {
         lookupopt = gEnv->GetValue("Proof.LookupOpt", "all");
         input->Add(new TNamed("PROOF_LookupOpt", lookupopt.Data()));
      }
   }

   // The received message included an empty dataset, with only the name
   // defined: assume that a dataset, stored on the PROOF master by that
   // name, should be processed.
   if (!dataset) {
      dataset = mgr->GetDataSet(dsname.Data());
      if (!dataset) {
         emsg.Form("no such dataset on the master: %s", dsname.Data());
         return -1;
      }

      // Apply the lookup option requested by the client or the administartor
      // (by default we trust the information in the dataset)
      if (TProof::GetParameter(input, "PROOF_LookupOpt", lookupopt) != 0) {
         lookupopt = gEnv->GetValue("Proof.LookupOpt", "stagedOnly");
         input->Add(new TNamed("PROOF_LookupOpt", lookupopt.Data()));
      }
   }

   // Logic for the subdir/obj names: try first to see if the dataset name contains
   // some info; if not check the settings in the TDSet object itself; if still empty
   // check the default tree name / path in the TFileCollection object; if still empty
   // use the default as the flow will determine
   TString dsTree;
   // Get the [subdir/]tree, if any
   mgr->ParseUri(dsname.Data(), 0, 0, 0, &dsTree);
   if (dsTree.IsNull()) {
      // Use what we have in the original dataset; we need this to locate the
      // meta data information
      dsTree += dset->GetDirectory();
      dsTree += dset->GetObjName();
   }
   if (!dsTree.IsNull() && dsTree != "/") {
      TString tree(dsTree);
      Int_t idx = tree.Index("/");
      if (idx != kNPOS) {
         TString dir = tree(0, idx+1);
         tree.Remove(0, idx);
         dset->SetDirectory(dir);
      }
      dset->SetObjName(tree);
   } else {
      // Use the default obj name from the TFileCollection
      dsTree = dataset->GetDefaultTreeName();
   }

   // Transfer the list now
   if (dataset) {
      TList *missingFiles = new TList;
      TSeqCollection* files = dataset->GetList();
      if (gDebug > 0) files->Print();
      Bool_t availableOnly = (lookupopt != "all") ? kTRUE : kFALSE;
      if (!dset->Add(files, dsTree, availableOnly, missingFiles)) {
         emsg.Form("error retrieving dataset %s", dset->GetName());
         delete dataset;
         return -1;
      }
      if (missingFiles) {
         // The missing files objects have to be removed from the dataset
         // before delete.
         TIter next(missingFiles);
         TObject *file;
         while ((file = next()))
            dataset->GetList()->Remove(file);
      }
      delete dataset;

      // Make sure it will be sent back merged with other similar lists created
      // during processing; this list will be transferred by the player to the
      // output list, once the latter has been created (see TProofPlayerRemote::Process)
      if (missingFiles && missingFiles->GetSize() > 0) {
         missingFiles->SetName("MissingFiles");
         input->Add(missingFiles);
      }
   }

   // Done
   return 0;
}

//______________________________________________________________________________
Int_t TProof::SaveInputData(TQueryResult *qr, const char *cachedir, TString &emsg)
{
   // Save input data file from 'cachedir' into the sandbox or create a the file
   // with input data objects

   TList *input = 0;

   // We must have got something to process
   if (!qr || !(input = qr->GetInputList()) ||
       !cachedir || strlen(cachedir) <= 0) return 0;

   // There must be some input data or input data file
   TNamed *data = (TNamed *) input->FindObject("PROOF_InputDataFile");
   TList *inputdata = (TList *) input->FindObject("PROOF_InputData");
   if (!data && !inputdata) return 0;
   // Default dstination filename
   if (!data)
      input->Add((data = new TNamed("PROOF_InputDataFile", kPROOF_InputDataFile)));

   TString dstname(data->GetTitle()), srcname;
   Bool_t fromcache = kFALSE;
   if (dstname.BeginsWith("cache:")) {
      fromcache = kTRUE;
      dstname.ReplaceAll("cache:", "");
      srcname.Form("%s/%s", cachedir, dstname.Data());
      if (gSystem->AccessPathName(srcname)) {
         emsg.Form("input data file not found in cache (%s)", srcname.Data());
         return -1;
      }
   }

   // If from cache, just move the cache file
   if (fromcache) {
      if (gSystem->CopyFile(srcname, dstname, kTRUE) != 0) {
         emsg.Form("problems copying %s to %s", srcname.Data(), dstname.Data());
         return -1;
      }
   } else {
      // Create the file
      if (inputdata && inputdata->GetSize() > 0) {
         TFile *f = TFile::Open(dstname.Data(), "RECREATE");
         if (f) {
            f->cd();
            inputdata->Write();
            f->Close();
            delete f;
         } else {
            emsg.Form("could not create %s", dstname.Data());
            return -1;
         }
      } else {
         emsg.Form("no input data!");
         return -1;
      }
   }
   ::Info("TProof::SaveInputData", "input data saved to %s", dstname.Data());

   // Save the file name and clean up the data list
   data->SetTitle(dstname);
   if (inputdata) {
      input->Remove(inputdata);
      inputdata->SetOwner();
      delete inputdata;
   }

   // Done
   return 0;
}

//______________________________________________________________________________
Int_t TProof::SendInputData(TQueryResult *qr, TProof *p, TString &emsg)
{
   // Send the input data file to the workers

   TList *input = 0;

   // We must have got something to process
   if (!qr || !(input = qr->GetInputList())) return 0;

   // There must be some input data or input data file
   TNamed *inputdata = (TNamed *) input->FindObject("PROOF_InputDataFile");
   if (!inputdata) return 0;

   TString fname(inputdata->GetTitle());
   if (gSystem->AccessPathName(fname)) {
      emsg.Form("input data file not found in sandbox (%s)", fname.Data());
      return -1;
   }

   // PROOF session must available
   if (!p || !p->IsValid()) {
      emsg.Form("TProof object undefined or invalid: protocol error!");
      return -1;
   }

   // Send to unique workers and submasters
   p->BroadcastFile(fname, TProof::kBinary, "cache");

   // Done
   return 0;
}

//______________________________________________________________________________
Int_t TProof::GetInputData(TList *input, const char *cachedir, TString &emsg)
{
   // Get the input data from the file defined in the input list

   // We must have got something to process
   if (!input || !cachedir || strlen(cachedir) <= 0) return 0;

   // There must be some input data or input data file
   TNamed *inputdata = (TNamed *) input->FindObject("PROOF_InputDataFile");
   if (!inputdata) return 0;

   TString fname;
   fname.Form("%s/%s", cachedir, inputdata->GetTitle());
   if (gSystem->AccessPathName(fname)) {
      emsg.Form("input data file not found in cache (%s)", fname.Data());
      return -1;
   }

   // Read the input data into the input list
   TFile *f = TFile::Open(fname.Data());
   if (f) {
      TList *keys = (TList *) f->GetListOfKeys();
      if (!keys) {
         emsg.Form("could not get list of object keys from file");
         return -1;
      }
      TIter nxk(keys);
      TKey *k = 0;
      while ((k = (TKey *)nxk())) {
         TObject *o = f->Get(k->GetName());
         if (o) input->Add(o);
      }
      f->Close();
      delete f;
   } else {
      emsg.Form("could not open %s", fname.Data());
      return -1;
   }

   // Done
   return 0;
}

//______________________________________________________________________________
void TProof::LogViewer(const char *url, Int_t idx)
{
   // Start the log viewer window usign the plugin manager

   if (!gROOT->IsBatch()) {
      // Get the handler, if not yet done
      if (!fgLogViewer) {
         if ((fgLogViewer =
            gROOT->GetPluginManager()->FindHandler("TProofProgressLog"))) {
            if (fgLogViewer->LoadPlugin() == -1) {
               fgLogViewer = 0;
               ::Error("TProof::LogViewer", "cannot load the relevant plug-in");
               return;
            }
         }
      }
      if (fgLogViewer) {
         // Execute the plug-in
         fgLogViewer->ExecPlugin(2, url, idx);
      }
   } else {
      if (url && strlen(url) > 0) {
         ::Info("TProof::LogViewer",
                "batch mode: use TProofLog *pl = TProof::Mgr(\"%s\")->GetSessionLogs(%d)", url, idx);
      } else {
         ::Info("TProof::LogViewer",
                "batch mode: use TProofLog *pl = TProof::Mgr(\"<master>\")->GetSessionLogs(%d)", idx);
      }
   }
   // Done
   return;
}

 TProof.cxx:1
 TProof.cxx:2
 TProof.cxx:3
 TProof.cxx:4
 TProof.cxx:5
 TProof.cxx:6
 TProof.cxx:7
 TProof.cxx:8
 TProof.cxx:9
 TProof.cxx:10
 TProof.cxx:11
 TProof.cxx:12
 TProof.cxx:13
 TProof.cxx:14
 TProof.cxx:15
 TProof.cxx:16
 TProof.cxx:17
 TProof.cxx:18
 TProof.cxx:19
 TProof.cxx:20
 TProof.cxx:21
 TProof.cxx:22
 TProof.cxx:23
 TProof.cxx:24
 TProof.cxx:25
 TProof.cxx:26
 TProof.cxx:27
 TProof.cxx:28
 TProof.cxx:29
 TProof.cxx:30
 TProof.cxx:31
 TProof.cxx:32
 TProof.cxx:33
 TProof.cxx:34
 TProof.cxx:35
 TProof.cxx:36
 TProof.cxx:37
 TProof.cxx:38
 TProof.cxx:39
 TProof.cxx:40
 TProof.cxx:41
 TProof.cxx:42
 TProof.cxx:43
 TProof.cxx:44
 TProof.cxx:45
 TProof.cxx:46
 TProof.cxx:47
 TProof.cxx:48
 TProof.cxx:49
 TProof.cxx:50
 TProof.cxx:51
 TProof.cxx:52
 TProof.cxx:53
 TProof.cxx:54
 TProof.cxx:55
 TProof.cxx:56
 TProof.cxx:57
 TProof.cxx:58
 TProof.cxx:59
 TProof.cxx:60
 TProof.cxx:61
 TProof.cxx:62
 TProof.cxx:63
 TProof.cxx:64
 TProof.cxx:65
 TProof.cxx:66
 TProof.cxx:67
 TProof.cxx:68
 TProof.cxx:69
 TProof.cxx:70
 TProof.cxx:71
 TProof.cxx:72
 TProof.cxx:73
 TProof.cxx:74
 TProof.cxx:75
 TProof.cxx:76
 TProof.cxx:77
 TProof.cxx:78
 TProof.cxx:79
 TProof.cxx:80
 TProof.cxx:81
 TProof.cxx:82
 TProof.cxx:83
 TProof.cxx:84
 TProof.cxx:85
 TProof.cxx:86
 TProof.cxx:87
 TProof.cxx:88
 TProof.cxx:89
 TProof.cxx:90
 TProof.cxx:91
 TProof.cxx:92
 TProof.cxx:93
 TProof.cxx:94
 TProof.cxx:95
 TProof.cxx:96
 TProof.cxx:97
 TProof.cxx:98
 TProof.cxx:99
 TProof.cxx:100
 TProof.cxx:101
 TProof.cxx:102
 TProof.cxx:103
 TProof.cxx:104
 TProof.cxx:105
 TProof.cxx:106
 TProof.cxx:107
 TProof.cxx:108
 TProof.cxx:109
 TProof.cxx:110
 TProof.cxx:111
 TProof.cxx:112
 TProof.cxx:113
 TProof.cxx:114
 TProof.cxx:115
 TProof.cxx:116
 TProof.cxx:117
 TProof.cxx:118
 TProof.cxx:119
 TProof.cxx:120
 TProof.cxx:121
 TProof.cxx:122
 TProof.cxx:123
 TProof.cxx:124
 TProof.cxx:125
 TProof.cxx:126
 TProof.cxx:127
 TProof.cxx:128
 TProof.cxx:129
 TProof.cxx:130
 TProof.cxx:131
 TProof.cxx:132
 TProof.cxx:133
 TProof.cxx:134
 TProof.cxx:135
 TProof.cxx:136
 TProof.cxx:137
 TProof.cxx:138
 TProof.cxx:139
 TProof.cxx:140
 TProof.cxx:141
 TProof.cxx:142
 TProof.cxx:143
 TProof.cxx:144
 TProof.cxx:145
 TProof.cxx:146
 TProof.cxx:147
 TProof.cxx:148
 TProof.cxx:149
 TProof.cxx:150
 TProof.cxx:151
 TProof.cxx:152
 TProof.cxx:153
 TProof.cxx:154
 TProof.cxx:155
 TProof.cxx:156
 TProof.cxx:157
 TProof.cxx:158
 TProof.cxx:159
 TProof.cxx:160
 TProof.cxx:161
 TProof.cxx:162
 TProof.cxx:163
 TProof.cxx:164
 TProof.cxx:165
 TProof.cxx:166
 TProof.cxx:167
 TProof.cxx:168
 TProof.cxx:169
 TProof.cxx:170
 TProof.cxx:171
 TProof.cxx:172
 TProof.cxx:173
 TProof.cxx:174
 TProof.cxx:175
 TProof.cxx:176
 TProof.cxx:177
 TProof.cxx:178
 TProof.cxx:179
 TProof.cxx:180
 TProof.cxx:181
 TProof.cxx:182
 TProof.cxx:183
 TProof.cxx:184
 TProof.cxx:185
 TProof.cxx:186
 TProof.cxx:187
 TProof.cxx:188
 TProof.cxx:189
 TProof.cxx:190
 TProof.cxx:191
 TProof.cxx:192
 TProof.cxx:193
 TProof.cxx:194
 TProof.cxx:195
 TProof.cxx:196
 TProof.cxx:197
 TProof.cxx:198
 TProof.cxx:199
 TProof.cxx:200
 TProof.cxx:201
 TProof.cxx:202
 TProof.cxx:203
 TProof.cxx:204
 TProof.cxx:205
 TProof.cxx:206
 TProof.cxx:207
 TProof.cxx:208
 TProof.cxx:209
 TProof.cxx:210
 TProof.cxx:211
 TProof.cxx:212
 TProof.cxx:213
 TProof.cxx:214
 TProof.cxx:215
 TProof.cxx:216
 TProof.cxx:217
 TProof.cxx:218
 TProof.cxx:219
 TProof.cxx:220
 TProof.cxx:221
 TProof.cxx:222
 TProof.cxx:223
 TProof.cxx:224
 TProof.cxx:225
 TProof.cxx:226
 TProof.cxx:227
 TProof.cxx:228
 TProof.cxx:229
 TProof.cxx:230
 TProof.cxx:231
 TProof.cxx:232
 TProof.cxx:233
 TProof.cxx:234
 TProof.cxx:235
 TProof.cxx:236
 TProof.cxx:237
 TProof.cxx:238
 TProof.cxx:239
 TProof.cxx:240
 TProof.cxx:241
 TProof.cxx:242
 TProof.cxx:243
 TProof.cxx:244
 TProof.cxx:245
 TProof.cxx:246
 TProof.cxx:247
 TProof.cxx:248
 TProof.cxx:249
 TProof.cxx:250
 TProof.cxx:251
 TProof.cxx:252
 TProof.cxx:253
 TProof.cxx:254
 TProof.cxx:255
 TProof.cxx:256
 TProof.cxx:257
 TProof.cxx:258
 TProof.cxx:259
 TProof.cxx:260
 TProof.cxx:261
 TProof.cxx:262
 TProof.cxx:263
 TProof.cxx:264
 TProof.cxx:265
 TProof.cxx:266
 TProof.cxx:267
 TProof.cxx:268
 TProof.cxx:269
 TProof.cxx:270
 TProof.cxx:271
 TProof.cxx:272
 TProof.cxx:273
 TProof.cxx:274
 TProof.cxx:275
 TProof.cxx:276
 TProof.cxx:277
 TProof.cxx:278
 TProof.cxx:279
 TProof.cxx:280
 TProof.cxx:281
 TProof.cxx:282
 TProof.cxx:283
 TProof.cxx:284
 TProof.cxx:285
 TProof.cxx:286
 TProof.cxx:287
 TProof.cxx:288
 TProof.cxx:289
 TProof.cxx:290
 TProof.cxx:291
 TProof.cxx:292
 TProof.cxx:293
 TProof.cxx:294
 TProof.cxx:295
 TProof.cxx:296
 TProof.cxx:297
 TProof.cxx:298
 TProof.cxx:299
 TProof.cxx:300
 TProof.cxx:301
 TProof.cxx:302
 TProof.cxx:303
 TProof.cxx:304
 TProof.cxx:305
 TProof.cxx:306
 TProof.cxx:307
 TProof.cxx:308
 TProof.cxx:309
 TProof.cxx:310
 TProof.cxx:311
 TProof.cxx:312
 TProof.cxx:313
 TProof.cxx:314
 TProof.cxx:315
 TProof.cxx:316
 TProof.cxx:317
 TProof.cxx:318
 TProof.cxx:319
 TProof.cxx:320
 TProof.cxx:321
 TProof.cxx:322
 TProof.cxx:323
 TProof.cxx:324
 TProof.cxx:325
 TProof.cxx:326
 TProof.cxx:327
 TProof.cxx:328
 TProof.cxx:329
 TProof.cxx:330
 TProof.cxx:331
 TProof.cxx:332
 TProof.cxx:333
 TProof.cxx:334
 TProof.cxx:335
 TProof.cxx:336
 TProof.cxx:337
 TProof.cxx:338
 TProof.cxx:339
 TProof.cxx:340
 TProof.cxx:341
 TProof.cxx:342
 TProof.cxx:343
 TProof.cxx:344
 TProof.cxx:345
 TProof.cxx:346
 TProof.cxx:347
 TProof.cxx:348
 TProof.cxx:349
 TProof.cxx:350
 TProof.cxx:351
 TProof.cxx:352
 TProof.cxx:353
 TProof.cxx:354
 TProof.cxx:355
 TProof.cxx:356
 TProof.cxx:357
 TProof.cxx:358
 TProof.cxx:359
 TProof.cxx:360
 TProof.cxx:361
 TProof.cxx:362
 TProof.cxx:363
 TProof.cxx:364
 TProof.cxx:365
 TProof.cxx:366
 TProof.cxx:367
 TProof.cxx:368
 TProof.cxx:369
 TProof.cxx:370
 TProof.cxx:371
 TProof.cxx:372
 TProof.cxx:373
 TProof.cxx:374
 TProof.cxx:375
 TProof.cxx:376
 TProof.cxx:377
 TProof.cxx:378
 TProof.cxx:379
 TProof.cxx:380
 TProof.cxx:381
 TProof.cxx:382
 TProof.cxx:383
 TProof.cxx:384
 TProof.cxx:385
 TProof.cxx:386
 TProof.cxx:387
 TProof.cxx:388
 TProof.cxx:389
 TProof.cxx:390
 TProof.cxx:391
 TProof.cxx:392
 TProof.cxx:393
 TProof.cxx:394
 TProof.cxx:395
 TProof.cxx:396
 TProof.cxx:397
 TProof.cxx:398
 TProof.cxx:399
 TProof.cxx:400
 TProof.cxx:401
 TProof.cxx:402
 TProof.cxx:403
 TProof.cxx:404
 TProof.cxx:405
 TProof.cxx:406
 TProof.cxx:407
 TProof.cxx:408
 TProof.cxx:409
 TProof.cxx:410
 TProof.cxx:411
 TProof.cxx:412
 TProof.cxx:413
 TProof.cxx:414
 TProof.cxx:415
 TProof.cxx:416
 TProof.cxx:417
 TProof.cxx:418
 TProof.cxx:419
 TProof.cxx:420
 TProof.cxx:421
 TProof.cxx:422
 TProof.cxx:423
 TProof.cxx:424
 TProof.cxx:425
 TProof.cxx:426
 TProof.cxx:427
 TProof.cxx:428
 TProof.cxx:429
 TProof.cxx:430
 TProof.cxx:431
 TProof.cxx:432
 TProof.cxx:433
 TProof.cxx:434
 TProof.cxx:435
 TProof.cxx:436
 TProof.cxx:437
 TProof.cxx:438
 TProof.cxx:439
 TProof.cxx:440
 TProof.cxx:441
 TProof.cxx:442
 TProof.cxx:443
 TProof.cxx:444
 TProof.cxx:445
 TProof.cxx:446
 TProof.cxx:447
 TProof.cxx:448
 TProof.cxx:449
 TProof.cxx:450
 TProof.cxx:451
 TProof.cxx:452
 TProof.cxx:453
 TProof.cxx:454
 TProof.cxx:455
 TProof.cxx:456
 TProof.cxx:457
 TProof.cxx:458
 TProof.cxx:459
 TProof.cxx:460
 TProof.cxx:461
 TProof.cxx:462
 TProof.cxx:463
 TProof.cxx:464
 TProof.cxx:465
 TProof.cxx:466
 TProof.cxx:467
 TProof.cxx:468
 TProof.cxx:469
 TProof.cxx:470
 TProof.cxx:471
 TProof.cxx:472
 TProof.cxx:473
 TProof.cxx:474
 TProof.cxx:475
 TProof.cxx:476
 TProof.cxx:477
 TProof.cxx:478
 TProof.cxx:479
 TProof.cxx:480
 TProof.cxx:481
 TProof.cxx:482
 TProof.cxx:483
 TProof.cxx:484
 TProof.cxx:485
 TProof.cxx:486
 TProof.cxx:487
 TProof.cxx:488
 TProof.cxx:489
 TProof.cxx:490
 TProof.cxx:491
 TProof.cxx:492
 TProof.cxx:493
 TProof.cxx:494
 TProof.cxx:495
 TProof.cxx:496
 TProof.cxx:497
 TProof.cxx:498
 TProof.cxx:499
 TProof.cxx:500
 TProof.cxx:501
 TProof.cxx:502
 TProof.cxx:503
 TProof.cxx:504
 TProof.cxx:505
 TProof.cxx:506
 TProof.cxx:507
 TProof.cxx:508
 TProof.cxx:509
 TProof.cxx:510
 TProof.cxx:511
 TProof.cxx:512
 TProof.cxx:513
 TProof.cxx:514
 TProof.cxx:515
 TProof.cxx:516
 TProof.cxx:517
 TProof.cxx:518
 TProof.cxx:519
 TProof.cxx:520
 TProof.cxx:521
 TProof.cxx:522
 TProof.cxx:523
 TProof.cxx:524
 TProof.cxx:525
 TProof.cxx:526
 TProof.cxx:527
 TProof.cxx:528
 TProof.cxx:529
 TProof.cxx:530
 TProof.cxx:531
 TProof.cxx:532
 TProof.cxx:533
 TProof.cxx:534
 TProof.cxx:535
 TProof.cxx:536
 TProof.cxx:537
 TProof.cxx:538
 TProof.cxx:539
 TProof.cxx:540
 TProof.cxx:541
 TProof.cxx:542
 TProof.cxx:543
 TProof.cxx:544
 TProof.cxx:545
 TProof.cxx:546
 TProof.cxx:547
 TProof.cxx:548
 TProof.cxx:549
 TProof.cxx:550
 TProof.cxx:551
 TProof.cxx:552
 TProof.cxx:553
 TProof.cxx:554
 TProof.cxx:555
 TProof.cxx:556
 TProof.cxx:557
 TProof.cxx:558
 TProof.cxx:559
 TProof.cxx:560
 TProof.cxx:561
 TProof.cxx:562
 TProof.cxx:563
 TProof.cxx:564
 TProof.cxx:565
 TProof.cxx:566
 TProof.cxx:567
 TProof.cxx:568
 TProof.cxx:569
 TProof.cxx:570
 TProof.cxx:571
 TProof.cxx:572
 TProof.cxx:573
 TProof.cxx:574
 TProof.cxx:575
 TProof.cxx:576
 TProof.cxx:577
 TProof.cxx:578
 TProof.cxx:579
 TProof.cxx:580
 TProof.cxx:581
 TProof.cxx:582
 TProof.cxx:583
 TProof.cxx:584
 TProof.cxx:585
 TProof.cxx:586
 TProof.cxx:587
 TProof.cxx:588
 TProof.cxx:589
 TProof.cxx:590
 TProof.cxx:591
 TProof.cxx:592
 TProof.cxx:593
 TProof.cxx:594
 TProof.cxx:595
 TProof.cxx:596
 TProof.cxx:597
 TProof.cxx:598
 TProof.cxx:599
 TProof.cxx:600
 TProof.cxx:601
 TProof.cxx:602
 TProof.cxx:603
 TProof.cxx:604
 TProof.cxx:605
 TProof.cxx:606
 TProof.cxx:607
 TProof.cxx:608
 TProof.cxx:609
 TProof.cxx:610
 TProof.cxx:611
 TProof.cxx:612
 TProof.cxx:613
 TProof.cxx:614
 TProof.cxx:615
 TProof.cxx:616
 TProof.cxx:617
 TProof.cxx:618
 TProof.cxx:619
 TProof.cxx:620
 TProof.cxx:621
 TProof.cxx:622
 TProof.cxx:623
 TProof.cxx:624
 TProof.cxx:625
 TProof.cxx:626
 TProof.cxx:627
 TProof.cxx:628
 TProof.cxx:629
 TProof.cxx:630
 TProof.cxx:631
 TProof.cxx:632
 TProof.cxx:633
 TProof.cxx:634
 TProof.cxx:635
 TProof.cxx:636
 TProof.cxx:637
 TProof.cxx:638
 TProof.cxx:639
 TProof.cxx:640
 TProof.cxx:641
 TProof.cxx:642
 TProof.cxx:643
 TProof.cxx:644
 TProof.cxx:645
 TProof.cxx:646
 TProof.cxx:647
 TProof.cxx:648
 TProof.cxx:649
 TProof.cxx:650
 TProof.cxx:651
 TProof.cxx:652
 TProof.cxx:653
 TProof.cxx:654
 TProof.cxx:655
 TProof.cxx:656
 TProof.cxx:657
 TProof.cxx:658
 TProof.cxx:659
 TProof.cxx:660
 TProof.cxx:661
 TProof.cxx:662
 TProof.cxx:663
 TProof.cxx:664
 TProof.cxx:665
 TProof.cxx:666
 TProof.cxx:667
 TProof.cxx:668
 TProof.cxx:669
 TProof.cxx:670
 TProof.cxx:671
 TProof.cxx:672
 TProof.cxx:673
 TProof.cxx:674
 TProof.cxx:675
 TProof.cxx:676
 TProof.cxx:677
 TProof.cxx:678
 TProof.cxx:679
 TProof.cxx:680
 TProof.cxx:681
 TProof.cxx:682
 TProof.cxx:683
 TProof.cxx:684
 TProof.cxx:685
 TProof.cxx:686
 TProof.cxx:687
 TProof.cxx:688
 TProof.cxx:689
 TProof.cxx:690
 TProof.cxx:691
 TProof.cxx:692
 TProof.cxx:693
 TProof.cxx:694
 TProof.cxx:695
 TProof.cxx:696
 TProof.cxx:697
 TProof.cxx:698
 TProof.cxx:699
 TProof.cxx:700
 TProof.cxx:701
 TProof.cxx:702
 TProof.cxx:703
 TProof.cxx:704
 TProof.cxx:705
 TProof.cxx:706
 TProof.cxx:707
 TProof.cxx:708
 TProof.cxx:709
 TProof.cxx:710
 TProof.cxx:711
 TProof.cxx:712
 TProof.cxx:713
 TProof.cxx:714
 TProof.cxx:715
 TProof.cxx:716
 TProof.cxx:717
 TProof.cxx:718
 TProof.cxx:719
 TProof.cxx:720
 TProof.cxx:721
 TProof.cxx:722
 TProof.cxx:723
 TProof.cxx:724
 TProof.cxx:725
 TProof.cxx:726
 TProof.cxx:727
 TProof.cxx:728
 TProof.cxx:729
 TProof.cxx:730
 TProof.cxx:731
 TProof.cxx:732
 TProof.cxx:733
 TProof.cxx:734
 TProof.cxx:735
 TProof.cxx:736
 TProof.cxx:737
 TProof.cxx:738
 TProof.cxx:739
 TProof.cxx:740
 TProof.cxx:741
 TProof.cxx:742
 TProof.cxx:743
 TProof.cxx:744
 TProof.cxx:745
 TProof.cxx:746
 TProof.cxx:747
 TProof.cxx:748
 TProof.cxx:749
 TProof.cxx:750
 TProof.cxx:751
 TProof.cxx:752
 TProof.cxx:753
 TProof.cxx:754
 TProof.cxx:755
 TProof.cxx:756
 TProof.cxx:757
 TProof.cxx:758
 TProof.cxx:759
 TProof.cxx:760
 TProof.cxx:761
 TProof.cxx:762
 TProof.cxx:763
 TProof.cxx:764
 TProof.cxx:765
 TProof.cxx:766
 TProof.cxx:767
 TProof.cxx:768
 TProof.cxx:769
 TProof.cxx:770
 TProof.cxx:771
 TProof.cxx:772
 TProof.cxx:773
 TProof.cxx:774
 TProof.cxx:775
 TProof.cxx:776
 TProof.cxx:777
 TProof.cxx:778
 TProof.cxx:779
 TProof.cxx:780
 TProof.cxx:781
 TProof.cxx:782
 TProof.cxx:783
 TProof.cxx:784
 TProof.cxx:785
 TProof.cxx:786
 TProof.cxx:787
 TProof.cxx:788
 TProof.cxx:789
 TProof.cxx:790
 TProof.cxx:791
 TProof.cxx:792
 TProof.cxx:793
 TProof.cxx:794
 TProof.cxx:795
 TProof.cxx:796
 TProof.cxx:797
 TProof.cxx:798
 TProof.cxx:799
 TProof.cxx:800
 TProof.cxx:801
 TProof.cxx:802
 TProof.cxx:803
 TProof.cxx:804
 TProof.cxx:805
 TProof.cxx:806
 TProof.cxx:807
 TProof.cxx:808
 TProof.cxx:809
 TProof.cxx:810
 TProof.cxx:811
 TProof.cxx:812
 TProof.cxx:813
 TProof.cxx:814
 TProof.cxx:815
 TProof.cxx:816
 TProof.cxx:817
 TProof.cxx:818
 TProof.cxx:819
 TProof.cxx:820
 TProof.cxx:821
 TProof.cxx:822
 TProof.cxx:823
 TProof.cxx:824
 TProof.cxx:825
 TProof.cxx:826
 TProof.cxx:827
 TProof.cxx:828
 TProof.cxx:829
 TProof.cxx:830
 TProof.cxx:831
 TProof.cxx:832
 TProof.cxx:833
 TProof.cxx:834
 TProof.cxx:835
 TProof.cxx:836
 TProof.cxx:837
 TProof.cxx:838
 TProof.cxx:839
 TProof.cxx:840
 TProof.cxx:841
 TProof.cxx:842
 TProof.cxx:843
 TProof.cxx:844
 TProof.cxx:845
 TProof.cxx:846
 TProof.cxx:847
 TProof.cxx:848
 TProof.cxx:849
 TProof.cxx:850
 TProof.cxx:851
 TProof.cxx:852
 TProof.cxx:853
 TProof.cxx:854
 TProof.cxx:855
 TProof.cxx:856
 TProof.cxx:857
 TProof.cxx:858
 TProof.cxx:859
 TProof.cxx:860
 TProof.cxx:861
 TProof.cxx:862
 TProof.cxx:863
 TProof.cxx:864
 TProof.cxx:865
 TProof.cxx:866
 TProof.cxx:867
 TProof.cxx:868
 TProof.cxx:869
 TProof.cxx:870
 TProof.cxx:871
 TProof.cxx:872
 TProof.cxx:873
 TProof.cxx:874
 TProof.cxx:875
 TProof.cxx:876
 TProof.cxx:877
 TProof.cxx:878
 TProof.cxx:879
 TProof.cxx:880
 TProof.cxx:881
 TProof.cxx:882
 TProof.cxx:883
 TProof.cxx:884
 TProof.cxx:885
 TProof.cxx:886
 TProof.cxx:887
 TProof.cxx:888
 TProof.cxx:889
 TProof.cxx:890
 TProof.cxx:891
 TProof.cxx:892
 TProof.cxx:893
 TProof.cxx:894
 TProof.cxx:895
 TProof.cxx:896
 TProof.cxx:897
 TProof.cxx:898
 TProof.cxx:899
 TProof.cxx:900
 TProof.cxx:901
 TProof.cxx:902
 TProof.cxx:903
 TProof.cxx:904
 TProof.cxx:905
 TProof.cxx:906
 TProof.cxx:907
 TProof.cxx:908
 TProof.cxx:909
 TProof.cxx:910
 TProof.cxx:911
 TProof.cxx:912
 TProof.cxx:913
 TProof.cxx:914
 TProof.cxx:915
 TProof.cxx:916
 TProof.cxx:917
 TProof.cxx:918
 TProof.cxx:919
 TProof.cxx:920
 TProof.cxx:921
 TProof.cxx:922
 TProof.cxx:923
 TProof.cxx:924
 TProof.cxx:925
 TProof.cxx:926
 TProof.cxx:927
 TProof.cxx:928
 TProof.cxx:929
 TProof.cxx:930
 TProof.cxx:931
 TProof.cxx:932
 TProof.cxx:933
 TProof.cxx:934
 TProof.cxx:935
 TProof.cxx:936
 TProof.cxx:937
 TProof.cxx:938
 TProof.cxx:939
 TProof.cxx:940
 TProof.cxx:941
 TProof.cxx:942
 TProof.cxx:943
 TProof.cxx:944
 TProof.cxx:945
 TProof.cxx:946
 TProof.cxx:947
 TProof.cxx:948
 TProof.cxx:949
 TProof.cxx:950
 TProof.cxx:951
 TProof.cxx:952
 TProof.cxx:953
 TProof.cxx:954
 TProof.cxx:955
 TProof.cxx:956
 TProof.cxx:957
 TProof.cxx:958
 TProof.cxx:959
 TProof.cxx:960
 TProof.cxx:961
 TProof.cxx:962
 TProof.cxx:963
 TProof.cxx:964
 TProof.cxx:965
 TProof.cxx:966
 TProof.cxx:967
 TProof.cxx:968
 TProof.cxx:969
 TProof.cxx:970
 TProof.cxx:971
 TProof.cxx:972
 TProof.cxx:973
 TProof.cxx:974
 TProof.cxx:975
 TProof.cxx:976
 TProof.cxx:977
 TProof.cxx:978
 TProof.cxx:979
 TProof.cxx:980
 TProof.cxx:981
 TProof.cxx:982
 TProof.cxx:983
 TProof.cxx:984
 TProof.cxx:985
 TProof.cxx:986
 TProof.cxx:987
 TProof.cxx:988
 TProof.cxx:989
 TProof.cxx:990
 TProof.cxx:991
 TProof.cxx:992
 TProof.cxx:993
 TProof.cxx:994
 TProof.cxx:995
 TProof.cxx:996
 TProof.cxx:997
 TProof.cxx:998
 TProof.cxx:999
 TProof.cxx:1000
 TProof.cxx:1001
 TProof.cxx:1002
 TProof.cxx:1003
 TProof.cxx:1004
 TProof.cxx:1005
 TProof.cxx:1006
 TProof.cxx:1007
 TProof.cxx:1008
 TProof.cxx:1009
 TProof.cxx:1010
 TProof.cxx:1011
 TProof.cxx:1012
 TProof.cxx:1013
 TProof.cxx:1014
 TProof.cxx:1015
 TProof.cxx:1016
 TProof.cxx:1017
 TProof.cxx:1018
 TProof.cxx:1019
 TProof.cxx:1020
 TProof.cxx:1021
 TProof.cxx:1022
 TProof.cxx:1023
 TProof.cxx:1024
 TProof.cxx:1025
 TProof.cxx:1026
 TProof.cxx:1027
 TProof.cxx:1028
 TProof.cxx:1029
 TProof.cxx:1030
 TProof.cxx:1031
 TProof.cxx:1032
 TProof.cxx:1033
 TProof.cxx:1034
 TProof.cxx:1035
 TProof.cxx:1036
 TProof.cxx:1037
 TProof.cxx:1038
 TProof.cxx:1039
 TProof.cxx:1040
 TProof.cxx:1041
 TProof.cxx:1042
 TProof.cxx:1043
 TProof.cxx:1044
 TProof.cxx:1045
 TProof.cxx:1046
 TProof.cxx:1047
 TProof.cxx:1048
 TProof.cxx:1049
 TProof.cxx:1050
 TProof.cxx:1051
 TProof.cxx:1052
 TProof.cxx:1053
 TProof.cxx:1054
 TProof.cxx:1055
 TProof.cxx:1056
 TProof.cxx:1057
 TProof.cxx:1058
 TProof.cxx:1059
 TProof.cxx:1060
 TProof.cxx:1061
 TProof.cxx:1062
 TProof.cxx:1063
 TProof.cxx:1064
 TProof.cxx:1065
 TProof.cxx:1066
 TProof.cxx:1067
 TProof.cxx:1068
 TProof.cxx:1069
 TProof.cxx:1070
 TProof.cxx:1071
 TProof.cxx:1072
 TProof.cxx:1073
 TProof.cxx:1074
 TProof.cxx:1075
 TProof.cxx:1076
 TProof.cxx:1077
 TProof.cxx:1078
 TProof.cxx:1079
 TProof.cxx:1080
 TProof.cxx:1081
 TProof.cxx:1082
 TProof.cxx:1083
 TProof.cxx:1084
 TProof.cxx:1085
 TProof.cxx:1086
 TProof.cxx:1087
 TProof.cxx:1088
 TProof.cxx:1089
 TProof.cxx:1090
 TProof.cxx:1091
 TProof.cxx:1092
 TProof.cxx:1093
 TProof.cxx:1094
 TProof.cxx:1095
 TProof.cxx:1096
 TProof.cxx:1097
 TProof.cxx:1098
 TProof.cxx:1099
 TProof.cxx:1100
 TProof.cxx:1101
 TProof.cxx:1102
 TProof.cxx:1103
 TProof.cxx:1104
 TProof.cxx:1105
 TProof.cxx:1106
 TProof.cxx:1107
 TProof.cxx:1108
 TProof.cxx:1109
 TProof.cxx:1110
 TProof.cxx:1111
 TProof.cxx:1112
 TProof.cxx:1113
 TProof.cxx:1114
 TProof.cxx:1115
 TProof.cxx:1116
 TProof.cxx:1117
 TProof.cxx:1118
 TProof.cxx:1119
 TProof.cxx:1120
 TProof.cxx:1121
 TProof.cxx:1122
 TProof.cxx:1123
 TProof.cxx:1124
 TProof.cxx:1125
 TProof.cxx:1126
 TProof.cxx:1127
 TProof.cxx:1128
 TProof.cxx:1129
 TProof.cxx:1130
 TProof.cxx:1131
 TProof.cxx:1132
 TProof.cxx:1133
 TProof.cxx:1134
 TProof.cxx:1135
 TProof.cxx:1136
 TProof.cxx:1137
 TProof.cxx:1138
 TProof.cxx:1139
 TProof.cxx:1140
 TProof.cxx:1141
 TProof.cxx:1142
 TProof.cxx:1143
 TProof.cxx:1144
 TProof.cxx:1145
 TProof.cxx:1146
 TProof.cxx:1147
 TProof.cxx:1148
 TProof.cxx:1149
 TProof.cxx:1150
 TProof.cxx:1151
 TProof.cxx:1152
 TProof.cxx:1153
 TProof.cxx:1154
 TProof.cxx:1155
 TProof.cxx:1156
 TProof.cxx:1157
 TProof.cxx:1158
 TProof.cxx:1159
 TProof.cxx:1160
 TProof.cxx:1161
 TProof.cxx:1162
 TProof.cxx:1163
 TProof.cxx:1164
 TProof.cxx:1165
 TProof.cxx:1166
 TProof.cxx:1167
 TProof.cxx:1168
 TProof.cxx:1169
 TProof.cxx:1170
 TProof.cxx:1171
 TProof.cxx:1172
 TProof.cxx:1173
 TProof.cxx:1174
 TProof.cxx:1175
 TProof.cxx:1176
 TProof.cxx:1177
 TProof.cxx:1178
 TProof.cxx:1179
 TProof.cxx:1180
 TProof.cxx:1181
 TProof.cxx:1182
 TProof.cxx:1183
 TProof.cxx:1184
 TProof.cxx:1185
 TProof.cxx:1186
 TProof.cxx:1187
 TProof.cxx:1188
 TProof.cxx:1189
 TProof.cxx:1190
 TProof.cxx:1191
 TProof.cxx:1192
 TProof.cxx:1193
 TProof.cxx:1194
 TProof.cxx:1195
 TProof.cxx:1196
 TProof.cxx:1197
 TProof.cxx:1198
 TProof.cxx:1199
 TProof.cxx:1200
 TProof.cxx:1201
 TProof.cxx:1202
 TProof.cxx:1203
 TProof.cxx:1204
 TProof.cxx:1205
 TProof.cxx:1206
 TProof.cxx:1207
 TProof.cxx:1208
 TProof.cxx:1209
 TProof.cxx:1210
 TProof.cxx:1211
 TProof.cxx:1212
 TProof.cxx:1213
 TProof.cxx:1214
 TProof.cxx:1215
 TProof.cxx:1216
 TProof.cxx:1217
 TProof.cxx:1218
 TProof.cxx:1219
 TProof.cxx:1220
 TProof.cxx:1221
 TProof.cxx:1222
 TProof.cxx:1223
 TProof.cxx:1224
 TProof.cxx:1225
 TProof.cxx:1226
 TProof.cxx:1227
 TProof.cxx:1228
 TProof.cxx:1229
 TProof.cxx:1230
 TProof.cxx:1231
 TProof.cxx:1232
 TProof.cxx:1233
 TProof.cxx:1234
 TProof.cxx:1235
 TProof.cxx:1236
 TProof.cxx:1237
 TProof.cxx:1238
 TProof.cxx:1239
 TProof.cxx:1240
 TProof.cxx:1241
 TProof.cxx:1242
 TProof.cxx:1243
 TProof.cxx:1244
 TProof.cxx:1245
 TProof.cxx:1246
 TProof.cxx:1247
 TProof.cxx:1248
 TProof.cxx:1249
 TProof.cxx:1250
 TProof.cxx:1251
 TProof.cxx:1252
 TProof.cxx:1253
 TProof.cxx:1254
 TProof.cxx:1255
 TProof.cxx:1256
 TProof.cxx:1257
 TProof.cxx:1258
 TProof.cxx:1259
 TProof.cxx:1260
 TProof.cxx:1261
 TProof.cxx:1262
 TProof.cxx:1263
 TProof.cxx:1264
 TProof.cxx:1265
 TProof.cxx:1266
 TProof.cxx:1267
 TProof.cxx:1268
 TProof.cxx:1269
 TProof.cxx:1270
 TProof.cxx:1271
 TProof.cxx:1272
 TProof.cxx:1273
 TProof.cxx:1274
 TProof.cxx:1275
 TProof.cxx:1276
 TProof.cxx:1277
 TProof.cxx:1278
 TProof.cxx:1279
 TProof.cxx:1280
 TProof.cxx:1281
 TProof.cxx:1282
 TProof.cxx:1283
 TProof.cxx:1284
 TProof.cxx:1285
 TProof.cxx:1286
 TProof.cxx:1287
 TProof.cxx:1288
 TProof.cxx:1289
 TProof.cxx:1290
 TProof.cxx:1291
 TProof.cxx:1292
 TProof.cxx:1293
 TProof.cxx:1294
 TProof.cxx:1295
 TProof.cxx:1296
 TProof.cxx:1297
 TProof.cxx:1298
 TProof.cxx:1299
 TProof.cxx:1300
 TProof.cxx:1301
 TProof.cxx:1302
 TProof.cxx:1303
 TProof.cxx:1304
 TProof.cxx:1305
 TProof.cxx:1306
 TProof.cxx:1307
 TProof.cxx:1308
 TProof.cxx:1309
 TProof.cxx:1310
 TProof.cxx:1311
 TProof.cxx:1312
 TProof.cxx:1313
 TProof.cxx:1314
 TProof.cxx:1315
 TProof.cxx:1316
 TProof.cxx:1317
 TProof.cxx:1318
 TProof.cxx:1319
 TProof.cxx:1320
 TProof.cxx:1321
 TProof.cxx:1322
 TProof.cxx:1323
 TProof.cxx:1324
 TProof.cxx:1325
 TProof.cxx:1326
 TProof.cxx:1327
 TProof.cxx:1328
 TProof.cxx:1329
 TProof.cxx:1330
 TProof.cxx:1331
 TProof.cxx:1332
 TProof.cxx:1333
 TProof.cxx:1334
 TProof.cxx:1335
 TProof.cxx:1336
 TProof.cxx:1337
 TProof.cxx:1338
 TProof.cxx:1339
 TProof.cxx:1340
 TProof.cxx:1341
 TProof.cxx:1342
 TProof.cxx:1343
 TProof.cxx:1344
 TProof.cxx:1345
 TProof.cxx:1346
 TProof.cxx:1347
 TProof.cxx:1348
 TProof.cxx:1349
 TProof.cxx:1350
 TProof.cxx:1351
 TProof.cxx:1352
 TProof.cxx:1353
 TProof.cxx:1354
 TProof.cxx:1355
 TProof.cxx:1356
 TProof.cxx:1357
 TProof.cxx:1358
 TProof.cxx:1359
 TProof.cxx:1360
 TProof.cxx:1361
 TProof.cxx:1362
 TProof.cxx:1363
 TProof.cxx:1364
 TProof.cxx:1365
 TProof.cxx:1366
 TProof.cxx:1367
 TProof.cxx:1368
 TProof.cxx:1369
 TProof.cxx:1370
 TProof.cxx:1371
 TProof.cxx:1372
 TProof.cxx:1373
 TProof.cxx:1374
 TProof.cxx:1375
 TProof.cxx:1376
 TProof.cxx:1377
 TProof.cxx:1378
 TProof.cxx:1379
 TProof.cxx:1380
 TProof.cxx:1381
 TProof.cxx:1382
 TProof.cxx:1383
 TProof.cxx:1384
 TProof.cxx:1385
 TProof.cxx:1386
 TProof.cxx:1387
 TProof.cxx:1388
 TProof.cxx:1389
 TProof.cxx:1390
 TProof.cxx:1391
 TProof.cxx:1392
 TProof.cxx:1393
 TProof.cxx:1394
 TProof.cxx:1395
 TProof.cxx:1396
 TProof.cxx:1397
 TProof.cxx:1398
 TProof.cxx:1399
 TProof.cxx:1400
 TProof.cxx:1401
 TProof.cxx:1402
 TProof.cxx:1403
 TProof.cxx:1404
 TProof.cxx:1405
 TProof.cxx:1406
 TProof.cxx:1407
 TProof.cxx:1408
 TProof.cxx:1409
 TProof.cxx:1410
 TProof.cxx:1411
 TProof.cxx:1412
 TProof.cxx:1413
 TProof.cxx:1414
 TProof.cxx:1415
 TProof.cxx:1416
 TProof.cxx:1417
 TProof.cxx:1418
 TProof.cxx:1419
 TProof.cxx:1420
 TProof.cxx:1421
 TProof.cxx:1422
 TProof.cxx:1423
 TProof.cxx:1424
 TProof.cxx:1425
 TProof.cxx:1426
 TProof.cxx:1427
 TProof.cxx:1428
 TProof.cxx:1429
 TProof.cxx:1430
 TProof.cxx:1431
 TProof.cxx:1432
 TProof.cxx:1433
 TProof.cxx:1434
 TProof.cxx:1435
 TProof.cxx:1436
 TProof.cxx:1437
 TProof.cxx:1438
 TProof.cxx:1439
 TProof.cxx:1440
 TProof.cxx:1441
 TProof.cxx:1442
 TProof.cxx:1443
 TProof.cxx:1444
 TProof.cxx:1445
 TProof.cxx:1446
 TProof.cxx:1447
 TProof.cxx:1448
 TProof.cxx:1449
 TProof.cxx:1450
 TProof.cxx:1451
 TProof.cxx:1452
 TProof.cxx:1453
 TProof.cxx:1454
 TProof.cxx:1455
 TProof.cxx:1456
 TProof.cxx:1457
 TProof.cxx:1458
 TProof.cxx:1459
 TProof.cxx:1460
 TProof.cxx:1461
 TProof.cxx:1462
 TProof.cxx:1463
 TProof.cxx:1464
 TProof.cxx:1465
 TProof.cxx:1466
 TProof.cxx:1467
 TProof.cxx:1468
 TProof.cxx:1469
 TProof.cxx:1470
 TProof.cxx:1471
 TProof.cxx:1472
 TProof.cxx:1473
 TProof.cxx:1474
 TProof.cxx:1475
 TProof.cxx:1476
 TProof.cxx:1477
 TProof.cxx:1478
 TProof.cxx:1479
 TProof.cxx:1480
 TProof.cxx:1481
 TProof.cxx:1482
 TProof.cxx:1483
 TProof.cxx:1484
 TProof.cxx:1485
 TProof.cxx:1486
 TProof.cxx:1487
 TProof.cxx:1488
 TProof.cxx:1489
 TProof.cxx:1490
 TProof.cxx:1491
 TProof.cxx:1492
 TProof.cxx:1493
 TProof.cxx:1494
 TProof.cxx:1495
 TProof.cxx:1496
 TProof.cxx:1497
 TProof.cxx:1498
 TProof.cxx:1499
 TProof.cxx:1500
 TProof.cxx:1501
 TProof.cxx:1502
 TProof.cxx:1503
 TProof.cxx:1504
 TProof.cxx:1505
 TProof.cxx:1506
 TProof.cxx:1507
 TProof.cxx:1508
 TProof.cxx:1509
 TProof.cxx:1510
 TProof.cxx:1511
 TProof.cxx:1512
 TProof.cxx:1513
 TProof.cxx:1514
 TProof.cxx:1515
 TProof.cxx:1516
 TProof.cxx:1517
 TProof.cxx:1518
 TProof.cxx:1519
 TProof.cxx:1520
 TProof.cxx:1521
 TProof.cxx:1522
 TProof.cxx:1523
 TProof.cxx:1524
 TProof.cxx:1525
 TProof.cxx:1526
 TProof.cxx:1527
 TProof.cxx:1528
 TProof.cxx:1529
 TProof.cxx:1530
 TProof.cxx:1531
 TProof.cxx:1532
 TProof.cxx:1533
 TProof.cxx:1534
 TProof.cxx:1535
 TProof.cxx:1536
 TProof.cxx:1537
 TProof.cxx:1538
 TProof.cxx:1539
 TProof.cxx:1540
 TProof.cxx:1541
 TProof.cxx:1542
 TProof.cxx:1543
 TProof.cxx:1544
 TProof.cxx:1545
 TProof.cxx:1546
 TProof.cxx:1547
 TProof.cxx:1548
 TProof.cxx:1549
 TProof.cxx:1550
 TProof.cxx:1551
 TProof.cxx:1552
 TProof.cxx:1553
 TProof.cxx:1554
 TProof.cxx:1555
 TProof.cxx:1556
 TProof.cxx:1557
 TProof.cxx:1558
 TProof.cxx:1559
 TProof.cxx:1560
 TProof.cxx:1561
 TProof.cxx:1562
 TProof.cxx:1563
 TProof.cxx:1564
 TProof.cxx:1565
 TProof.cxx:1566
 TProof.cxx:1567
 TProof.cxx:1568
 TProof.cxx:1569
 TProof.cxx:1570
 TProof.cxx:1571
 TProof.cxx:1572
 TProof.cxx:1573
 TProof.cxx:1574
 TProof.cxx:1575
 TProof.cxx:1576
 TProof.cxx:1577
 TProof.cxx:1578
 TProof.cxx:1579
 TProof.cxx:1580
 TProof.cxx:1581
 TProof.cxx:1582
 TProof.cxx:1583
 TProof.cxx:1584
 TProof.cxx:1585
 TProof.cxx:1586
 TProof.cxx:1587
 TProof.cxx:1588
 TProof.cxx:1589
 TProof.cxx:1590
 TProof.cxx:1591
 TProof.cxx:1592
 TProof.cxx:1593
 TProof.cxx:1594
 TProof.cxx:1595
 TProof.cxx:1596
 TProof.cxx:1597
 TProof.cxx:1598
 TProof.cxx:1599
 TProof.cxx:1600
 TProof.cxx:1601
 TProof.cxx:1602
 TProof.cxx:1603
 TProof.cxx:1604
 TProof.cxx:1605
 TProof.cxx:1606
 TProof.cxx:1607
 TProof.cxx:1608
 TProof.cxx:1609
 TProof.cxx:1610
 TProof.cxx:1611
 TProof.cxx:1612
 TProof.cxx:1613
 TProof.cxx:1614
 TProof.cxx:1615
 TProof.cxx:1616
 TProof.cxx:1617
 TProof.cxx:1618
 TProof.cxx:1619
 TProof.cxx:1620
 TProof.cxx:1621
 TProof.cxx:1622
 TProof.cxx:1623
 TProof.cxx:1624
 TProof.cxx:1625
 TProof.cxx:1626
 TProof.cxx:1627
 TProof.cxx:1628
 TProof.cxx:1629
 TProof.cxx:1630
 TProof.cxx:1631
 TProof.cxx:1632
 TProof.cxx:1633
 TProof.cxx:1634
 TProof.cxx:1635
 TProof.cxx:1636
 TProof.cxx:1637
 TProof.cxx:1638
 TProof.cxx:1639
 TProof.cxx:1640
 TProof.cxx:1641
 TProof.cxx:1642
 TProof.cxx:1643
 TProof.cxx:1644
 TProof.cxx:1645
 TProof.cxx:1646
 TProof.cxx:1647
 TProof.cxx:1648
 TProof.cxx:1649
 TProof.cxx:1650
 TProof.cxx:1651
 TProof.cxx:1652
 TProof.cxx:1653
 TProof.cxx:1654
 TProof.cxx:1655
 TProof.cxx:1656
 TProof.cxx:1657
 TProof.cxx:1658
 TProof.cxx:1659
 TProof.cxx:1660
 TProof.cxx:1661
 TProof.cxx:1662
 TProof.cxx:1663
 TProof.cxx:1664
 TProof.cxx:1665
 TProof.cxx:1666
 TProof.cxx:1667
 TProof.cxx:1668
 TProof.cxx:1669
 TProof.cxx:1670
 TProof.cxx:1671
 TProof.cxx:1672
 TProof.cxx:1673
 TProof.cxx:1674
 TProof.cxx:1675
 TProof.cxx:1676
 TProof.cxx:1677
 TProof.cxx:1678
 TProof.cxx:1679
 TProof.cxx:1680
 TProof.cxx:1681
 TProof.cxx:1682
 TProof.cxx:1683
 TProof.cxx:1684
 TProof.cxx:1685
 TProof.cxx:1686
 TProof.cxx:1687
 TProof.cxx:1688
 TProof.cxx:1689
 TProof.cxx:1690
 TProof.cxx:1691
 TProof.cxx:1692
 TProof.cxx:1693
 TProof.cxx:1694
 TProof.cxx:1695
 TProof.cxx:1696
 TProof.cxx:1697
 TProof.cxx:1698
 TProof.cxx:1699
 TProof.cxx:1700
 TProof.cxx:1701
 TProof.cxx:1702
 TProof.cxx:1703
 TProof.cxx:1704
 TProof.cxx:1705
 TProof.cxx:1706
 TProof.cxx:1707
 TProof.cxx:1708
 TProof.cxx:1709
 TProof.cxx:1710
 TProof.cxx:1711
 TProof.cxx:1712
 TProof.cxx:1713
 TProof.cxx:1714
 TProof.cxx:1715
 TProof.cxx:1716
 TProof.cxx:1717
 TProof.cxx:1718
 TProof.cxx:1719
 TProof.cxx:1720
 TProof.cxx:1721
 TProof.cxx:1722
 TProof.cxx:1723
 TProof.cxx:1724
 TProof.cxx:1725
 TProof.cxx:1726
 TProof.cxx:1727
 TProof.cxx:1728
 TProof.cxx:1729
 TProof.cxx:1730
 TProof.cxx:1731
 TProof.cxx:1732
 TProof.cxx:1733
 TProof.cxx:1734
 TProof.cxx:1735
 TProof.cxx:1736
 TProof.cxx:1737
 TProof.cxx:1738
 TProof.cxx:1739
 TProof.cxx:1740
 TProof.cxx:1741
 TProof.cxx:1742
 TProof.cxx:1743
 TProof.cxx:1744
 TProof.cxx:1745
 TProof.cxx:1746
 TProof.cxx:1747
 TProof.cxx:1748
 TProof.cxx:1749
 TProof.cxx:1750
 TProof.cxx:1751
 TProof.cxx:1752
 TProof.cxx:1753
 TProof.cxx:1754
 TProof.cxx:1755
 TProof.cxx:1756
 TProof.cxx:1757
 TProof.cxx:1758
 TProof.cxx:1759
 TProof.cxx:1760
 TProof.cxx:1761
 TProof.cxx:1762
 TProof.cxx:1763
 TProof.cxx:1764
 TProof.cxx:1765
 TProof.cxx:1766
 TProof.cxx:1767
 TProof.cxx:1768
 TProof.cxx:1769
 TProof.cxx:1770
 TProof.cxx:1771
 TProof.cxx:1772
 TProof.cxx:1773
 TProof.cxx:1774
 TProof.cxx:1775
 TProof.cxx:1776
 TProof.cxx:1777
 TProof.cxx:1778
 TProof.cxx:1779
 TProof.cxx:1780
 TProof.cxx:1781
 TProof.cxx:1782
 TProof.cxx:1783
 TProof.cxx:1784
 TProof.cxx:1785
 TProof.cxx:1786
 TProof.cxx:1787
 TProof.cxx:1788
 TProof.cxx:1789
 TProof.cxx:1790
 TProof.cxx:1791
 TProof.cxx:1792
 TProof.cxx:1793
 TProof.cxx:1794
 TProof.cxx:1795
 TProof.cxx:1796
 TProof.cxx:1797
 TProof.cxx:1798
 TProof.cxx:1799
 TProof.cxx:1800
 TProof.cxx:1801
 TProof.cxx:1802
 TProof.cxx:1803
 TProof.cxx:1804
 TProof.cxx:1805
 TProof.cxx:1806
 TProof.cxx:1807
 TProof.cxx:1808
 TProof.cxx:1809
 TProof.cxx:1810
 TProof.cxx:1811
 TProof.cxx:1812
 TProof.cxx:1813
 TProof.cxx:1814
 TProof.cxx:1815
 TProof.cxx:1816
 TProof.cxx:1817
 TProof.cxx:1818
 TProof.cxx:1819
 TProof.cxx:1820
 TProof.cxx:1821
 TProof.cxx:1822
 TProof.cxx:1823
 TProof.cxx:1824
 TProof.cxx:1825
 TProof.cxx:1826
 TProof.cxx:1827
 TProof.cxx:1828
 TProof.cxx:1829
 TProof.cxx:1830
 TProof.cxx:1831
 TProof.cxx:1832
 TProof.cxx:1833
 TProof.cxx:1834
 TProof.cxx:1835
 TProof.cxx:1836
 TProof.cxx:1837
 TProof.cxx:1838
 TProof.cxx:1839
 TProof.cxx:1840
 TProof.cxx:1841
 TProof.cxx:1842
 TProof.cxx:1843
 TProof.cxx:1844
 TProof.cxx:1845
 TProof.cxx:1846
 TProof.cxx:1847
 TProof.cxx:1848
 TProof.cxx:1849
 TProof.cxx:1850
 TProof.cxx:1851
 TProof.cxx:1852
 TProof.cxx:1853
 TProof.cxx:1854
 TProof.cxx:1855
 TProof.cxx:1856
 TProof.cxx:1857
 TProof.cxx:1858
 TProof.cxx:1859
 TProof.cxx:1860
 TProof.cxx:1861
 TProof.cxx:1862
 TProof.cxx:1863
 TProof.cxx:1864
 TProof.cxx:1865
 TProof.cxx:1866
 TProof.cxx:1867
 TProof.cxx:1868
 TProof.cxx:1869
 TProof.cxx:1870
 TProof.cxx:1871
 TProof.cxx:1872
 TProof.cxx:1873
 TProof.cxx:1874
 TProof.cxx:1875
 TProof.cxx:1876
 TProof.cxx:1877
 TProof.cxx:1878
 TProof.cxx:1879
 TProof.cxx:1880
 TProof.cxx:1881
 TProof.cxx:1882
 TProof.cxx:1883
 TProof.cxx:1884
 TProof.cxx:1885
 TProof.cxx:1886
 TProof.cxx:1887
 TProof.cxx:1888
 TProof.cxx:1889
 TProof.cxx:1890
 TProof.cxx:1891
 TProof.cxx:1892
 TProof.cxx:1893
 TProof.cxx:1894
 TProof.cxx:1895
 TProof.cxx:1896
 TProof.cxx:1897
 TProof.cxx:1898
 TProof.cxx:1899
 TProof.cxx:1900
 TProof.cxx:1901
 TProof.cxx:1902
 TProof.cxx:1903
 TProof.cxx:1904
 TProof.cxx:1905
 TProof.cxx:1906
 TProof.cxx:1907
 TProof.cxx:1908
 TProof.cxx:1909
 TProof.cxx:1910
 TProof.cxx:1911
 TProof.cxx:1912
 TProof.cxx:1913
 TProof.cxx:1914
 TProof.cxx:1915
 TProof.cxx:1916
 TProof.cxx:1917
 TProof.cxx:1918
 TProof.cxx:1919
 TProof.cxx:1920
 TProof.cxx:1921
 TProof.cxx:1922
 TProof.cxx:1923
 TProof.cxx:1924
 TProof.cxx:1925
 TProof.cxx:1926
 TProof.cxx:1927
 TProof.cxx:1928
 TProof.cxx:1929
 TProof.cxx:1930
 TProof.cxx:1931
 TProof.cxx:1932
 TProof.cxx:1933
 TProof.cxx:1934
 TProof.cxx:1935
 TProof.cxx:1936
 TProof.cxx:1937
 TProof.cxx:1938
 TProof.cxx:1939
 TProof.cxx:1940
 TProof.cxx:1941
 TProof.cxx:1942
 TProof.cxx:1943
 TProof.cxx:1944
 TProof.cxx:1945
 TProof.cxx:1946
 TProof.cxx:1947
 TProof.cxx:1948
 TProof.cxx:1949
 TProof.cxx:1950
 TProof.cxx:1951
 TProof.cxx:1952
 TProof.cxx:1953
 TProof.cxx:1954
 TProof.cxx:1955
 TProof.cxx:1956
 TProof.cxx:1957
 TProof.cxx:1958
 TProof.cxx:1959
 TProof.cxx:1960
 TProof.cxx:1961
 TProof.cxx:1962
 TProof.cxx:1963
 TProof.cxx:1964
 TProof.cxx:1965
 TProof.cxx:1966
 TProof.cxx:1967
 TProof.cxx:1968
 TProof.cxx:1969
 TProof.cxx:1970
 TProof.cxx:1971
 TProof.cxx:1972
 TProof.cxx:1973
 TProof.cxx:1974
 TProof.cxx:1975
 TProof.cxx:1976
 TProof.cxx:1977
 TProof.cxx:1978
 TProof.cxx:1979
 TProof.cxx:1980
 TProof.cxx:1981
 TProof.cxx:1982
 TProof.cxx:1983
 TProof.cxx:1984
 TProof.cxx:1985
 TProof.cxx:1986
 TProof.cxx:1987
 TProof.cxx:1988
 TProof.cxx:1989
 TProof.cxx:1990
 TProof.cxx:1991
 TProof.cxx:1992
 TProof.cxx:1993
 TProof.cxx:1994
 TProof.cxx:1995
 TProof.cxx:1996
 TProof.cxx:1997
 TProof.cxx:1998
 TProof.cxx:1999
 TProof.cxx:2000
 TProof.cxx:2001
 TProof.cxx:2002
 TProof.cxx:2003
 TProof.cxx:2004
 TProof.cxx:2005
 TProof.cxx:2006
 TProof.cxx:2007
 TProof.cxx:2008
 TProof.cxx:2009
 TProof.cxx:2010
 TProof.cxx:2011
 TProof.cxx:2012
 TProof.cxx:2013
 TProof.cxx:2014
 TProof.cxx:2015
 TProof.cxx:2016
 TProof.cxx:2017
 TProof.cxx:2018
 TProof.cxx:2019
 TProof.cxx:2020
 TProof.cxx:2021
 TProof.cxx:2022
 TProof.cxx:2023
 TProof.cxx:2024
 TProof.cxx:2025
 TProof.cxx:2026
 TProof.cxx:2027
 TProof.cxx:2028
 TProof.cxx:2029
 TProof.cxx:2030
 TProof.cxx:2031
 TProof.cxx:2032
 TProof.cxx:2033
 TProof.cxx:2034
 TProof.cxx:2035
 TProof.cxx:2036
 TProof.cxx:2037
 TProof.cxx:2038
 TProof.cxx:2039
 TProof.cxx:2040
 TProof.cxx:2041
 TProof.cxx:2042
 TProof.cxx:2043
 TProof.cxx:2044
 TProof.cxx:2045
 TProof.cxx:2046
 TProof.cxx:2047
 TProof.cxx:2048
 TProof.cxx:2049
 TProof.cxx:2050
 TProof.cxx:2051
 TProof.cxx:2052
 TProof.cxx:2053
 TProof.cxx:2054
 TProof.cxx:2055
 TProof.cxx:2056
 TProof.cxx:2057
 TProof.cxx:2058
 TProof.cxx:2059
 TProof.cxx:2060
 TProof.cxx:2061
 TProof.cxx:2062
 TProof.cxx:2063
 TProof.cxx:2064
 TProof.cxx:2065
 TProof.cxx:2066
 TProof.cxx:2067
 TProof.cxx:2068
 TProof.cxx:2069
 TProof.cxx:2070
 TProof.cxx:2071
 TProof.cxx:2072
 TProof.cxx:2073
 TProof.cxx:2074
 TProof.cxx:2075
 TProof.cxx:2076
 TProof.cxx:2077
 TProof.cxx:2078
 TProof.cxx:2079
 TProof.cxx:2080
 TProof.cxx:2081
 TProof.cxx:2082
 TProof.cxx:2083
 TProof.cxx:2084
 TProof.cxx:2085
 TProof.cxx:2086
 TProof.cxx:2087
 TProof.cxx:2088
 TProof.cxx:2089
 TProof.cxx:2090
 TProof.cxx:2091
 TProof.cxx:2092
 TProof.cxx:2093
 TProof.cxx:2094
 TProof.cxx:2095
 TProof.cxx:2096
 TProof.cxx:2097
 TProof.cxx:2098
 TProof.cxx:2099
 TProof.cxx:2100
 TProof.cxx:2101
 TProof.cxx:2102
 TProof.cxx:2103
 TProof.cxx:2104
 TProof.cxx:2105
 TProof.cxx:2106
 TProof.cxx:2107
 TProof.cxx:2108
 TProof.cxx:2109
 TProof.cxx:2110
 TProof.cxx:2111
 TProof.cxx:2112
 TProof.cxx:2113
 TProof.cxx:2114
 TProof.cxx:2115
 TProof.cxx:2116
 TProof.cxx:2117
 TProof.cxx:2118
 TProof.cxx:2119
 TProof.cxx:2120
 TProof.cxx:2121
 TProof.cxx:2122
 TProof.cxx:2123
 TProof.cxx:2124
 TProof.cxx:2125
 TProof.cxx:2126
 TProof.cxx:2127
 TProof.cxx:2128
 TProof.cxx:2129
 TProof.cxx:2130
 TProof.cxx:2131
 TProof.cxx:2132
 TProof.cxx:2133
 TProof.cxx:2134
 TProof.cxx:2135
 TProof.cxx:2136
 TProof.cxx:2137
 TProof.cxx:2138
 TProof.cxx:2139
 TProof.cxx:2140
 TProof.cxx:2141
 TProof.cxx:2142
 TProof.cxx:2143
 TProof.cxx:2144
 TProof.cxx:2145
 TProof.cxx:2146
 TProof.cxx:2147
 TProof.cxx:2148
 TProof.cxx:2149
 TProof.cxx:2150
 TProof.cxx:2151
 TProof.cxx:2152
 TProof.cxx:2153
 TProof.cxx:2154
 TProof.cxx:2155
 TProof.cxx:2156
 TProof.cxx:2157
 TProof.cxx:2158
 TProof.cxx:2159
 TProof.cxx:2160
 TProof.cxx:2161
 TProof.cxx:2162
 TProof.cxx:2163
 TProof.cxx:2164
 TProof.cxx:2165
 TProof.cxx:2166
 TProof.cxx:2167
 TProof.cxx:2168
 TProof.cxx:2169
 TProof.cxx:2170
 TProof.cxx:2171
 TProof.cxx:2172
 TProof.cxx:2173
 TProof.cxx:2174
 TProof.cxx:2175
 TProof.cxx:2176
 TProof.cxx:2177
 TProof.cxx:2178
 TProof.cxx:2179
 TProof.cxx:2180
 TProof.cxx:2181
 TProof.cxx:2182
 TProof.cxx:2183
 TProof.cxx:2184
 TProof.cxx:2185
 TProof.cxx:2186
 TProof.cxx:2187
 TProof.cxx:2188
 TProof.cxx:2189
 TProof.cxx:2190
 TProof.cxx:2191
 TProof.cxx:2192
 TProof.cxx:2193
 TProof.cxx:2194
 TProof.cxx:2195
 TProof.cxx:2196
 TProof.cxx:2197
 TProof.cxx:2198
 TProof.cxx:2199
 TProof.cxx:2200
 TProof.cxx:2201
 TProof.cxx:2202
 TProof.cxx:2203
 TProof.cxx:2204
 TProof.cxx:2205
 TProof.cxx:2206
 TProof.cxx:2207
 TProof.cxx:2208
 TProof.cxx:2209
 TProof.cxx:2210
 TProof.cxx:2211
 TProof.cxx:2212
 TProof.cxx:2213
 TProof.cxx:2214
 TProof.cxx:2215
 TProof.cxx:2216
 TProof.cxx:2217
 TProof.cxx:2218
 TProof.cxx:2219
 TProof.cxx:2220
 TProof.cxx:2221
 TProof.cxx:2222
 TProof.cxx:2223
 TProof.cxx:2224
 TProof.cxx:2225
 TProof.cxx:2226
 TProof.cxx:2227
 TProof.cxx:2228
 TProof.cxx:2229
 TProof.cxx:2230
 TProof.cxx:2231
 TProof.cxx:2232
 TProof.cxx:2233
 TProof.cxx:2234
 TProof.cxx:2235
 TProof.cxx:2236
 TProof.cxx:2237
 TProof.cxx:2238
 TProof.cxx:2239
 TProof.cxx:2240
 TProof.cxx:2241
 TProof.cxx:2242
 TProof.cxx:2243
 TProof.cxx:2244
 TProof.cxx:2245
 TProof.cxx:2246
 TProof.cxx:2247
 TProof.cxx:2248
 TProof.cxx:2249
 TProof.cxx:2250
 TProof.cxx:2251
 TProof.cxx:2252
 TProof.cxx:2253
 TProof.cxx:2254
 TProof.cxx:2255
 TProof.cxx:2256
 TProof.cxx:2257
 TProof.cxx:2258
 TProof.cxx:2259
 TProof.cxx:2260
 TProof.cxx:2261
 TProof.cxx:2262
 TProof.cxx:2263
 TProof.cxx:2264
 TProof.cxx:2265
 TProof.cxx:2266
 TProof.cxx:2267
 TProof.cxx:2268
 TProof.cxx:2269
 TProof.cxx:2270
 TProof.cxx:2271
 TProof.cxx:2272
 TProof.cxx:2273
 TProof.cxx:2274
 TProof.cxx:2275
 TProof.cxx:2276
 TProof.cxx:2277
 TProof.cxx:2278
 TProof.cxx:2279
 TProof.cxx:2280
 TProof.cxx:2281
 TProof.cxx:2282
 TProof.cxx:2283
 TProof.cxx:2284
 TProof.cxx:2285
 TProof.cxx:2286
 TProof.cxx:2287
 TProof.cxx:2288
 TProof.cxx:2289
 TProof.cxx:2290
 TProof.cxx:2291
 TProof.cxx:2292
 TProof.cxx:2293
 TProof.cxx:2294
 TProof.cxx:2295
 TProof.cxx:2296
 TProof.cxx:2297
 TProof.cxx:2298
 TProof.cxx:2299
 TProof.cxx:2300
 TProof.cxx:2301
 TProof.cxx:2302
 TProof.cxx:2303
 TProof.cxx:2304
 TProof.cxx:2305
 TProof.cxx:2306
 TProof.cxx:2307
 TProof.cxx:2308
 TProof.cxx:2309
 TProof.cxx:2310
 TProof.cxx:2311
 TProof.cxx:2312
 TProof.cxx:2313
 TProof.cxx:2314
 TProof.cxx:2315
 TProof.cxx:2316
 TProof.cxx:2317
 TProof.cxx:2318
 TProof.cxx:2319
 TProof.cxx:2320
 TProof.cxx:2321
 TProof.cxx:2322
 TProof.cxx:2323
 TProof.cxx:2324
 TProof.cxx:2325
 TProof.cxx:2326
 TProof.cxx:2327
 TProof.cxx:2328
 TProof.cxx:2329
 TProof.cxx:2330
 TProof.cxx:2331
 TProof.cxx:2332
 TProof.cxx:2333
 TProof.cxx:2334
 TProof.cxx:2335
 TProof.cxx:2336
 TProof.cxx:2337
 TProof.cxx:2338
 TProof.cxx:2339
 TProof.cxx:2340
 TProof.cxx:2341
 TProof.cxx:2342
 TProof.cxx:2343
 TProof.cxx:2344
 TProof.cxx:2345
 TProof.cxx:2346
 TProof.cxx:2347
 TProof.cxx:2348
 TProof.cxx:2349
 TProof.cxx:2350
 TProof.cxx:2351
 TProof.cxx:2352
 TProof.cxx:2353
 TProof.cxx:2354
 TProof.cxx:2355
 TProof.cxx:2356
 TProof.cxx:2357
 TProof.cxx:2358
 TProof.cxx:2359
 TProof.cxx:2360
 TProof.cxx:2361
 TProof.cxx:2362
 TProof.cxx:2363
 TProof.cxx:2364
 TProof.cxx:2365
 TProof.cxx:2366
 TProof.cxx:2367
 TProof.cxx:2368
 TProof.cxx:2369
 TProof.cxx:2370
 TProof.cxx:2371
 TProof.cxx:2372
 TProof.cxx:2373
 TProof.cxx:2374
 TProof.cxx:2375
 TProof.cxx:2376
 TProof.cxx:2377
 TProof.cxx:2378
 TProof.cxx:2379
 TProof.cxx:2380
 TProof.cxx:2381
 TProof.cxx:2382
 TProof.cxx:2383
 TProof.cxx:2384
 TProof.cxx:2385
 TProof.cxx:2386
 TProof.cxx:2387
 TProof.cxx:2388
 TProof.cxx:2389
 TProof.cxx:2390
 TProof.cxx:2391
 TProof.cxx:2392
 TProof.cxx:2393
 TProof.cxx:2394
 TProof.cxx:2395
 TProof.cxx:2396
 TProof.cxx:2397
 TProof.cxx:2398
 TProof.cxx:2399
 TProof.cxx:2400
 TProof.cxx:2401
 TProof.cxx:2402
 TProof.cxx:2403
 TProof.cxx:2404
 TProof.cxx:2405
 TProof.cxx:2406
 TProof.cxx:2407
 TProof.cxx:2408
 TProof.cxx:2409
 TProof.cxx:2410
 TProof.cxx:2411
 TProof.cxx:2412
 TProof.cxx:2413
 TProof.cxx:2414
 TProof.cxx:2415
 TProof.cxx:2416
 TProof.cxx:2417
 TProof.cxx:2418
 TProof.cxx:2419
 TProof.cxx:2420
 TProof.cxx:2421
 TProof.cxx:2422
 TProof.cxx:2423
 TProof.cxx:2424
 TProof.cxx:2425
 TProof.cxx:2426
 TProof.cxx:2427
 TProof.cxx:2428
 TProof.cxx:2429
 TProof.cxx:2430
 TProof.cxx:2431
 TProof.cxx:2432
 TProof.cxx:2433
 TProof.cxx:2434
 TProof.cxx:2435
 TProof.cxx:2436
 TProof.cxx:2437
 TProof.cxx:2438
 TProof.cxx:2439
 TProof.cxx:2440
 TProof.cxx:2441
 TProof.cxx:2442
 TProof.cxx:2443
 TProof.cxx:2444
 TProof.cxx:2445
 TProof.cxx:2446
 TProof.cxx:2447
 TProof.cxx:2448
 TProof.cxx:2449
 TProof.cxx:2450
 TProof.cxx:2451
 TProof.cxx:2452
 TProof.cxx:2453
 TProof.cxx:2454
 TProof.cxx:2455
 TProof.cxx:2456
 TProof.cxx:2457
 TProof.cxx:2458
 TProof.cxx:2459
 TProof.cxx:2460
 TProof.cxx:2461
 TProof.cxx:2462
 TProof.cxx:2463
 TProof.cxx:2464
 TProof.cxx:2465
 TProof.cxx:2466
 TProof.cxx:2467
 TProof.cxx:2468
 TProof.cxx:2469
 TProof.cxx:2470
 TProof.cxx:2471
 TProof.cxx:2472
 TProof.cxx:2473
 TProof.cxx:2474
 TProof.cxx:2475
 TProof.cxx:2476
 TProof.cxx:2477
 TProof.cxx:2478
 TProof.cxx:2479
 TProof.cxx:2480
 TProof.cxx:2481
 TProof.cxx:2482
 TProof.cxx:2483
 TProof.cxx:2484
 TProof.cxx:2485
 TProof.cxx:2486
 TProof.cxx:2487
 TProof.cxx:2488
 TProof.cxx:2489
 TProof.cxx:2490
 TProof.cxx:2491
 TProof.cxx:2492
 TProof.cxx:2493
 TProof.cxx:2494
 TProof.cxx:2495
 TProof.cxx:2496
 TProof.cxx:2497
 TProof.cxx:2498
 TProof.cxx:2499
 TProof.cxx:2500
 TProof.cxx:2501
 TProof.cxx:2502
 TProof.cxx:2503
 TProof.cxx:2504
 TProof.cxx:2505
 TProof.cxx:2506
 TProof.cxx:2507
 TProof.cxx:2508
 TProof.cxx:2509
 TProof.cxx:2510
 TProof.cxx:2511
 TProof.cxx:2512
 TProof.cxx:2513
 TProof.cxx:2514
 TProof.cxx:2515
 TProof.cxx:2516
 TProof.cxx:2517
 TProof.cxx:2518
 TProof.cxx:2519
 TProof.cxx:2520
 TProof.cxx:2521
 TProof.cxx:2522
 TProof.cxx:2523
 TProof.cxx:2524
 TProof.cxx:2525
 TProof.cxx:2526
 TProof.cxx:2527
 TProof.cxx:2528
 TProof.cxx:2529
 TProof.cxx:2530
 TProof.cxx:2531
 TProof.cxx:2532
 TProof.cxx:2533
 TProof.cxx:2534
 TProof.cxx:2535
 TProof.cxx:2536
 TProof.cxx:2537
 TProof.cxx:2538
 TProof.cxx:2539
 TProof.cxx:2540
 TProof.cxx:2541
 TProof.cxx:2542
 TProof.cxx:2543
 TProof.cxx:2544
 TProof.cxx:2545
 TProof.cxx:2546
 TProof.cxx:2547
 TProof.cxx:2548
 TProof.cxx:2549
 TProof.cxx:2550
 TProof.cxx:2551
 TProof.cxx:2552
 TProof.cxx:2553
 TProof.cxx:2554
 TProof.cxx:2555
 TProof.cxx:2556
 TProof.cxx:2557
 TProof.cxx:2558
 TProof.cxx:2559
 TProof.cxx:2560
 TProof.cxx:2561
 TProof.cxx:2562
 TProof.cxx:2563
 TProof.cxx:2564
 TProof.cxx:2565
 TProof.cxx:2566
 TProof.cxx:2567
 TProof.cxx:2568
 TProof.cxx:2569
 TProof.cxx:2570
 TProof.cxx:2571
 TProof.cxx:2572
 TProof.cxx:2573
 TProof.cxx:2574
 TProof.cxx:2575
 TProof.cxx:2576
 TProof.cxx:2577
 TProof.cxx:2578
 TProof.cxx:2579
 TProof.cxx:2580
 TProof.cxx:2581
 TProof.cxx:2582
 TProof.cxx:2583
 TProof.cxx:2584
 TProof.cxx:2585
 TProof.cxx:2586
 TProof.cxx:2587
 TProof.cxx:2588
 TProof.cxx:2589
 TProof.cxx:2590
 TProof.cxx:2591
 TProof.cxx:2592
 TProof.cxx:2593
 TProof.cxx:2594
 TProof.cxx:2595
 TProof.cxx:2596
 TProof.cxx:2597
 TProof.cxx:2598
 TProof.cxx:2599
 TProof.cxx:2600
 TProof.cxx:2601
 TProof.cxx:2602
 TProof.cxx:2603
 TProof.cxx:2604
 TProof.cxx:2605
 TProof.cxx:2606
 TProof.cxx:2607
 TProof.cxx:2608
 TProof.cxx:2609
 TProof.cxx:2610
 TProof.cxx:2611
 TProof.cxx:2612
 TProof.cxx:2613
 TProof.cxx:2614
 TProof.cxx:2615
 TProof.cxx:2616
 TProof.cxx:2617
 TProof.cxx:2618
 TProof.cxx:2619
 TProof.cxx:2620
 TProof.cxx:2621
 TProof.cxx:2622
 TProof.cxx:2623
 TProof.cxx:2624
 TProof.cxx:2625
 TProof.cxx:2626
 TProof.cxx:2627
 TProof.cxx:2628
 TProof.cxx:2629
 TProof.cxx:2630
 TProof.cxx:2631
 TProof.cxx:2632
 TProof.cxx:2633
 TProof.cxx:2634
 TProof.cxx:2635
 TProof.cxx:2636
 TProof.cxx:2637
 TProof.cxx:2638
 TProof.cxx:2639
 TProof.cxx:2640
 TProof.cxx:2641
 TProof.cxx:2642
 TProof.cxx:2643
 TProof.cxx:2644
 TProof.cxx:2645
 TProof.cxx:2646
 TProof.cxx:2647
 TProof.cxx:2648
 TProof.cxx:2649
 TProof.cxx:2650
 TProof.cxx:2651
 TProof.cxx:2652
 TProof.cxx:2653
 TProof.cxx:2654
 TProof.cxx:2655
 TProof.cxx:2656
 TProof.cxx:2657
 TProof.cxx:2658
 TProof.cxx:2659
 TProof.cxx:2660
 TProof.cxx:2661
 TProof.cxx:2662
 TProof.cxx:2663
 TProof.cxx:2664
 TProof.cxx:2665
 TProof.cxx:2666
 TProof.cxx:2667
 TProof.cxx:2668
 TProof.cxx:2669
 TProof.cxx:2670
 TProof.cxx:2671
 TProof.cxx:2672
 TProof.cxx:2673
 TProof.cxx:2674
 TProof.cxx:2675
 TProof.cxx:2676
 TProof.cxx:2677
 TProof.cxx:2678
 TProof.cxx:2679
 TProof.cxx:2680
 TProof.cxx:2681
 TProof.cxx:2682
 TProof.cxx:2683
 TProof.cxx:2684
 TProof.cxx:2685
 TProof.cxx:2686
 TProof.cxx:2687
 TProof.cxx:2688
 TProof.cxx:2689
 TProof.cxx:2690
 TProof.cxx:2691
 TProof.cxx:2692
 TProof.cxx:2693
 TProof.cxx:2694
 TProof.cxx:2695
 TProof.cxx:2696
 TProof.cxx:2697
 TProof.cxx:2698
 TProof.cxx:2699
 TProof.cxx:2700
 TProof.cxx:2701
 TProof.cxx:2702
 TProof.cxx:2703
 TProof.cxx:2704
 TProof.cxx:2705
 TProof.cxx:2706
 TProof.cxx:2707
 TProof.cxx:2708
 TProof.cxx:2709
 TProof.cxx:2710
 TProof.cxx:2711
 TProof.cxx:2712
 TProof.cxx:2713
 TProof.cxx:2714
 TProof.cxx:2715
 TProof.cxx:2716
 TProof.cxx:2717
 TProof.cxx:2718
 TProof.cxx:2719
 TProof.cxx:2720
 TProof.cxx:2721
 TProof.cxx:2722
 TProof.cxx:2723
 TProof.cxx:2724
 TProof.cxx:2725
 TProof.cxx:2726
 TProof.cxx:2727
 TProof.cxx:2728
 TProof.cxx:2729
 TProof.cxx:2730
 TProof.cxx:2731
 TProof.cxx:2732
 TProof.cxx:2733
 TProof.cxx:2734
 TProof.cxx:2735
 TProof.cxx:2736
 TProof.cxx:2737
 TProof.cxx:2738
 TProof.cxx:2739
 TProof.cxx:2740
 TProof.cxx:2741
 TProof.cxx:2742
 TProof.cxx:2743
 TProof.cxx:2744
 TProof.cxx:2745
 TProof.cxx:2746
 TProof.cxx:2747
 TProof.cxx:2748
 TProof.cxx:2749
 TProof.cxx:2750
 TProof.cxx:2751
 TProof.cxx:2752
 TProof.cxx:2753
 TProof.cxx:2754
 TProof.cxx:2755
 TProof.cxx:2756
 TProof.cxx:2757
 TProof.cxx:2758
 TProof.cxx:2759
 TProof.cxx:2760
 TProof.cxx:2761
 TProof.cxx:2762
 TProof.cxx:2763
 TProof.cxx:2764
 TProof.cxx:2765
 TProof.cxx:2766
 TProof.cxx:2767
 TProof.cxx:2768
 TProof.cxx:2769
 TProof.cxx:2770
 TProof.cxx:2771
 TProof.cxx:2772
 TProof.cxx:2773
 TProof.cxx:2774
 TProof.cxx:2775
 TProof.cxx:2776
 TProof.cxx:2777
 TProof.cxx:2778
 TProof.cxx:2779
 TProof.cxx:2780
 TProof.cxx:2781
 TProof.cxx:2782
 TProof.cxx:2783
 TProof.cxx:2784
 TProof.cxx:2785
 TProof.cxx:2786
 TProof.cxx:2787
 TProof.cxx:2788
 TProof.cxx:2789
 TProof.cxx:2790
 TProof.cxx:2791
 TProof.cxx:2792
 TProof.cxx:2793
 TProof.cxx:2794
 TProof.cxx:2795
 TProof.cxx:2796
 TProof.cxx:2797
 TProof.cxx:2798
 TProof.cxx:2799
 TProof.cxx:2800
 TProof.cxx:2801
 TProof.cxx:2802
 TProof.cxx:2803
 TProof.cxx:2804
 TProof.cxx:2805
 TProof.cxx:2806
 TProof.cxx:2807
 TProof.cxx:2808
 TProof.cxx:2809
 TProof.cxx:2810
 TProof.cxx:2811
 TProof.cxx:2812
 TProof.cxx:2813
 TProof.cxx:2814
 TProof.cxx:2815
 TProof.cxx:2816
 TProof.cxx:2817
 TProof.cxx:2818
 TProof.cxx:2819
 TProof.cxx:2820
 TProof.cxx:2821
 TProof.cxx:2822
 TProof.cxx:2823
 TProof.cxx:2824
 TProof.cxx:2825
 TProof.cxx:2826
 TProof.cxx:2827
 TProof.cxx:2828
 TProof.cxx:2829
 TProof.cxx:2830
 TProof.cxx:2831
 TProof.cxx:2832
 TProof.cxx:2833
 TProof.cxx:2834
 TProof.cxx:2835
 TProof.cxx:2836
 TProof.cxx:2837
 TProof.cxx:2838
 TProof.cxx:2839
 TProof.cxx:2840
 TProof.cxx:2841
 TProof.cxx:2842
 TProof.cxx:2843
 TProof.cxx:2844
 TProof.cxx:2845
 TProof.cxx:2846
 TProof.cxx:2847
 TProof.cxx:2848
 TProof.cxx:2849
 TProof.cxx:2850
 TProof.cxx:2851
 TProof.cxx:2852
 TProof.cxx:2853
 TProof.cxx:2854
 TProof.cxx:2855
 TProof.cxx:2856
 TProof.cxx:2857
 TProof.cxx:2858
 TProof.cxx:2859
 TProof.cxx:2860
 TProof.cxx:2861
 TProof.cxx:2862
 TProof.cxx:2863
 TProof.cxx:2864
 TProof.cxx:2865
 TProof.cxx:2866
 TProof.cxx:2867
 TProof.cxx:2868
 TProof.cxx:2869
 TProof.cxx:2870
 TProof.cxx:2871
 TProof.cxx:2872
 TProof.cxx:2873
 TProof.cxx:2874
 TProof.cxx:2875
 TProof.cxx:2876
 TProof.cxx:2877
 TProof.cxx:2878
 TProof.cxx:2879
 TProof.cxx:2880
 TProof.cxx:2881
 TProof.cxx:2882
 TProof.cxx:2883
 TProof.cxx:2884
 TProof.cxx:2885
 TProof.cxx:2886
 TProof.cxx:2887
 TProof.cxx:2888
 TProof.cxx:2889
 TProof.cxx:2890
 TProof.cxx:2891
 TProof.cxx:2892
 TProof.cxx:2893
 TProof.cxx:2894
 TProof.cxx:2895
 TProof.cxx:2896
 TProof.cxx:2897
 TProof.cxx:2898
 TProof.cxx:2899
 TProof.cxx:2900
 TProof.cxx:2901
 TProof.cxx:2902
 TProof.cxx:2903
 TProof.cxx:2904
 TProof.cxx:2905
 TProof.cxx:2906
 TProof.cxx:2907
 TProof.cxx:2908
 TProof.cxx:2909
 TProof.cxx:2910
 TProof.cxx:2911
 TProof.cxx:2912
 TProof.cxx:2913
 TProof.cxx:2914
 TProof.cxx:2915
 TProof.cxx:2916
 TProof.cxx:2917
 TProof.cxx:2918
 TProof.cxx:2919
 TProof.cxx:2920
 TProof.cxx:2921
 TProof.cxx:2922
 TProof.cxx:2923
 TProof.cxx:2924
 TProof.cxx:2925
 TProof.cxx:2926
 TProof.cxx:2927
 TProof.cxx:2928
 TProof.cxx:2929
 TProof.cxx:2930
 TProof.cxx:2931
 TProof.cxx:2932
 TProof.cxx:2933
 TProof.cxx:2934
 TProof.cxx:2935
 TProof.cxx:2936
 TProof.cxx:2937
 TProof.cxx:2938
 TProof.cxx:2939
 TProof.cxx:2940
 TProof.cxx:2941
 TProof.cxx:2942
 TProof.cxx:2943
 TProof.cxx:2944
 TProof.cxx:2945
 TProof.cxx:2946
 TProof.cxx:2947
 TProof.cxx:2948
 TProof.cxx:2949
 TProof.cxx:2950
 TProof.cxx:2951
 TProof.cxx:2952
 TProof.cxx:2953
 TProof.cxx:2954
 TProof.cxx:2955
 TProof.cxx:2956
 TProof.cxx:2957
 TProof.cxx:2958
 TProof.cxx:2959
 TProof.cxx:2960
 TProof.cxx:2961
 TProof.cxx:2962
 TProof.cxx:2963
 TProof.cxx:2964
 TProof.cxx:2965
 TProof.cxx:2966
 TProof.cxx:2967
 TProof.cxx:2968
 TProof.cxx:2969
 TProof.cxx:2970
 TProof.cxx:2971
 TProof.cxx:2972
 TProof.cxx:2973
 TProof.cxx:2974
 TProof.cxx:2975
 TProof.cxx:2976
 TProof.cxx:2977
 TProof.cxx:2978
 TProof.cxx:2979
 TProof.cxx:2980
 TProof.cxx:2981
 TProof.cxx:2982
 TProof.cxx:2983
 TProof.cxx:2984
 TProof.cxx:2985
 TProof.cxx:2986
 TProof.cxx:2987
 TProof.cxx:2988
 TProof.cxx:2989
 TProof.cxx:2990
 TProof.cxx:2991
 TProof.cxx:2992
 TProof.cxx:2993
 TProof.cxx:2994
 TProof.cxx:2995
 TProof.cxx:2996
 TProof.cxx:2997
 TProof.cxx:2998
 TProof.cxx:2999
 TProof.cxx:3000
 TProof.cxx:3001
 TProof.cxx:3002
 TProof.cxx:3003
 TProof.cxx:3004
 TProof.cxx:3005
 TProof.cxx:3006
 TProof.cxx:3007
 TProof.cxx:3008
 TProof.cxx:3009
 TProof.cxx:3010
 TProof.cxx:3011
 TProof.cxx:3012
 TProof.cxx:3013
 TProof.cxx:3014
 TProof.cxx:3015
 TProof.cxx:3016
 TProof.cxx:3017
 TProof.cxx:3018
 TProof.cxx:3019
 TProof.cxx:3020
 TProof.cxx:3021
 TProof.cxx:3022
 TProof.cxx:3023
 TProof.cxx:3024
 TProof.cxx:3025
 TProof.cxx:3026
 TProof.cxx:3027
 TProof.cxx:3028
 TProof.cxx:3029
 TProof.cxx:3030
 TProof.cxx:3031
 TProof.cxx:3032
 TProof.cxx:3033
 TProof.cxx:3034
 TProof.cxx:3035
 TProof.cxx:3036
 TProof.cxx:3037
 TProof.cxx:3038
 TProof.cxx:3039
 TProof.cxx:3040
 TProof.cxx:3041
 TProof.cxx:3042
 TProof.cxx:3043
 TProof.cxx:3044
 TProof.cxx:3045
 TProof.cxx:3046
 TProof.cxx:3047
 TProof.cxx:3048
 TProof.cxx:3049
 TProof.cxx:3050
 TProof.cxx:3051
 TProof.cxx:3052
 TProof.cxx:3053
 TProof.cxx:3054
 TProof.cxx:3055
 TProof.cxx:3056
 TProof.cxx:3057
 TProof.cxx:3058
 TProof.cxx:3059
 TProof.cxx:3060
 TProof.cxx:3061
 TProof.cxx:3062
 TProof.cxx:3063
 TProof.cxx:3064
 TProof.cxx:3065
 TProof.cxx:3066
 TProof.cxx:3067
 TProof.cxx:3068
 TProof.cxx:3069
 TProof.cxx:3070
 TProof.cxx:3071
 TProof.cxx:3072
 TProof.cxx:3073
 TProof.cxx:3074
 TProof.cxx:3075
 TProof.cxx:3076
 TProof.cxx:3077
 TProof.cxx:3078
 TProof.cxx:3079
 TProof.cxx:3080
 TProof.cxx:3081
 TProof.cxx:3082
 TProof.cxx:3083
 TProof.cxx:3084
 TProof.cxx:3085
 TProof.cxx:3086
 TProof.cxx:3087
 TProof.cxx:3088
 TProof.cxx:3089
 TProof.cxx:3090
 TProof.cxx:3091
 TProof.cxx:3092
 TProof.cxx:3093
 TProof.cxx:3094
 TProof.cxx:3095
 TProof.cxx:3096
 TProof.cxx:3097
 TProof.cxx:3098
 TProof.cxx:3099
 TProof.cxx:3100
 TProof.cxx:3101
 TProof.cxx:3102
 TProof.cxx:3103
 TProof.cxx:3104
 TProof.cxx:3105
 TProof.cxx:3106
 TProof.cxx:3107
 TProof.cxx:3108
 TProof.cxx:3109
 TProof.cxx:3110
 TProof.cxx:3111
 TProof.cxx:3112
 TProof.cxx:3113
 TProof.cxx:3114
 TProof.cxx:3115
 TProof.cxx:3116
 TProof.cxx:3117
 TProof.cxx:3118
 TProof.cxx:3119
 TProof.cxx:3120
 TProof.cxx:3121
 TProof.cxx:3122
 TProof.cxx:3123
 TProof.cxx:3124
 TProof.cxx:3125
 TProof.cxx:3126
 TProof.cxx:3127
 TProof.cxx:3128
 TProof.cxx:3129
 TProof.cxx:3130
 TProof.cxx:3131
 TProof.cxx:3132
 TProof.cxx:3133
 TProof.cxx:3134
 TProof.cxx:3135
 TProof.cxx:3136
 TProof.cxx:3137
 TProof.cxx:3138
 TProof.cxx:3139
 TProof.cxx:3140
 TProof.cxx:3141
 TProof.cxx:3142
 TProof.cxx:3143
 TProof.cxx:3144
 TProof.cxx:3145
 TProof.cxx:3146
 TProof.cxx:3147
 TProof.cxx:3148
 TProof.cxx:3149
 TProof.cxx:3150
 TProof.cxx:3151
 TProof.cxx:3152
 TProof.cxx:3153
 TProof.cxx:3154
 TProof.cxx:3155
 TProof.cxx:3156
 TProof.cxx:3157
 TProof.cxx:3158
 TProof.cxx:3159
 TProof.cxx:3160
 TProof.cxx:3161
 TProof.cxx:3162
 TProof.cxx:3163
 TProof.cxx:3164
 TProof.cxx:3165
 TProof.cxx:3166
 TProof.cxx:3167
 TProof.cxx:3168
 TProof.cxx:3169
 TProof.cxx:3170
 TProof.cxx:3171
 TProof.cxx:3172
 TProof.cxx:3173
 TProof.cxx:3174
 TProof.cxx:3175
 TProof.cxx:3176
 TProof.cxx:3177
 TProof.cxx:3178
 TProof.cxx:3179
 TProof.cxx:3180
 TProof.cxx:3181
 TProof.cxx:3182
 TProof.cxx:3183
 TProof.cxx:3184
 TProof.cxx:3185
 TProof.cxx:3186
 TProof.cxx:3187
 TProof.cxx:3188
 TProof.cxx:3189
 TProof.cxx:3190
 TProof.cxx:3191
 TProof.cxx:3192
 TProof.cxx:3193
 TProof.cxx:3194
 TProof.cxx:3195
 TProof.cxx:3196
 TProof.cxx:3197
 TProof.cxx:3198
 TProof.cxx:3199
 TProof.cxx:3200
 TProof.cxx:3201
 TProof.cxx:3202
 TProof.cxx:3203
 TProof.cxx:3204
 TProof.cxx:3205
 TProof.cxx:3206
 TProof.cxx:3207
 TProof.cxx:3208
 TProof.cxx:3209
 TProof.cxx:3210
 TProof.cxx:3211
 TProof.cxx:3212
 TProof.cxx:3213
 TProof.cxx:3214
 TProof.cxx:3215
 TProof.cxx:3216
 TProof.cxx:3217
 TProof.cxx:3218
 TProof.cxx:3219
 TProof.cxx:3220
 TProof.cxx:3221
 TProof.cxx:3222
 TProof.cxx:3223
 TProof.cxx:3224
 TProof.cxx:3225
 TProof.cxx:3226
 TProof.cxx:3227
 TProof.cxx:3228
 TProof.cxx:3229
 TProof.cxx:3230
 TProof.cxx:3231
 TProof.cxx:3232
 TProof.cxx:3233
 TProof.cxx:3234
 TProof.cxx:3235
 TProof.cxx:3236
 TProof.cxx:3237
 TProof.cxx:3238
 TProof.cxx:3239
 TProof.cxx:3240
 TProof.cxx:3241
 TProof.cxx:3242
 TProof.cxx:3243
 TProof.cxx:3244
 TProof.cxx:3245
 TProof.cxx:3246
 TProof.cxx:3247
 TProof.cxx:3248
 TProof.cxx:3249
 TProof.cxx:3250
 TProof.cxx:3251
 TProof.cxx:3252
 TProof.cxx:3253
 TProof.cxx:3254
 TProof.cxx:3255
 TProof.cxx:3256
 TProof.cxx:3257
 TProof.cxx:3258
 TProof.cxx:3259
 TProof.cxx:3260
 TProof.cxx:3261
 TProof.cxx:3262
 TProof.cxx:3263
 TProof.cxx:3264
 TProof.cxx:3265
 TProof.cxx:3266
 TProof.cxx:3267
 TProof.cxx:3268
 TProof.cxx:3269
 TProof.cxx:3270
 TProof.cxx:3271
 TProof.cxx:3272
 TProof.cxx:3273
 TProof.cxx:3274
 TProof.cxx:3275
 TProof.cxx:3276
 TProof.cxx:3277
 TProof.cxx:3278
 TProof.cxx:3279
 TProof.cxx:3280
 TProof.cxx:3281
 TProof.cxx:3282
 TProof.cxx:3283
 TProof.cxx:3284
 TProof.cxx:3285
 TProof.cxx:3286
 TProof.cxx:3287
 TProof.cxx:3288
 TProof.cxx:3289
 TProof.cxx:3290
 TProof.cxx:3291
 TProof.cxx:3292
 TProof.cxx:3293
 TProof.cxx:3294
 TProof.cxx:3295
 TProof.cxx:3296
 TProof.cxx:3297
 TProof.cxx:3298
 TProof.cxx:3299
 TProof.cxx:3300
 TProof.cxx:3301
 TProof.cxx:3302
 TProof.cxx:3303
 TProof.cxx:3304
 TProof.cxx:3305
 TProof.cxx:3306
 TProof.cxx:3307
 TProof.cxx:3308
 TProof.cxx:3309
 TProof.cxx:3310
 TProof.cxx:3311
 TProof.cxx:3312
 TProof.cxx:3313
 TProof.cxx:3314
 TProof.cxx:3315
 TProof.cxx:3316
 TProof.cxx:3317
 TProof.cxx:3318
 TProof.cxx:3319
 TProof.cxx:3320
 TProof.cxx:3321
 TProof.cxx:3322
 TProof.cxx:3323
 TProof.cxx:3324
 TProof.cxx:3325
 TProof.cxx:3326
 TProof.cxx:3327
 TProof.cxx:3328
 TProof.cxx:3329
 TProof.cxx:3330
 TProof.cxx:3331
 TProof.cxx:3332
 TProof.cxx:3333
 TProof.cxx:3334
 TProof.cxx:3335
 TProof.cxx:3336
 TProof.cxx:3337
 TProof.cxx:3338
 TProof.cxx:3339
 TProof.cxx:3340
 TProof.cxx:3341
 TProof.cxx:3342
 TProof.cxx:3343
 TProof.cxx:3344
 TProof.cxx:3345
 TProof.cxx:3346
 TProof.cxx:3347
 TProof.cxx:3348
 TProof.cxx:3349
 TProof.cxx:3350
 TProof.cxx:3351
 TProof.cxx:3352
 TProof.cxx:3353
 TProof.cxx:3354
 TProof.cxx:3355
 TProof.cxx:3356
 TProof.cxx:3357
 TProof.cxx:3358
 TProof.cxx:3359
 TProof.cxx:3360
 TProof.cxx:3361
 TProof.cxx:3362
 TProof.cxx:3363
 TProof.cxx:3364
 TProof.cxx:3365
 TProof.cxx:3366
 TProof.cxx:3367
 TProof.cxx:3368
 TProof.cxx:3369
 TProof.cxx:3370
 TProof.cxx:3371
 TProof.cxx:3372
 TProof.cxx:3373
 TProof.cxx:3374
 TProof.cxx:3375
 TProof.cxx:3376
 TProof.cxx:3377
 TProof.cxx:3378
 TProof.cxx:3379
 TProof.cxx:3380
 TProof.cxx:3381
 TProof.cxx:3382
 TProof.cxx:3383
 TProof.cxx:3384
 TProof.cxx:3385
 TProof.cxx:3386
 TProof.cxx:3387
 TProof.cxx:3388
 TProof.cxx:3389
 TProof.cxx:3390
 TProof.cxx:3391
 TProof.cxx:3392
 TProof.cxx:3393
 TProof.cxx:3394
 TProof.cxx:3395
 TProof.cxx:3396
 TProof.cxx:3397
 TProof.cxx:3398
 TProof.cxx:3399
 TProof.cxx:3400
 TProof.cxx:3401
 TProof.cxx:3402
 TProof.cxx:3403
 TProof.cxx:3404
 TProof.cxx:3405
 TProof.cxx:3406
 TProof.cxx:3407
 TProof.cxx:3408
 TProof.cxx:3409
 TProof.cxx:3410
 TProof.cxx:3411
 TProof.cxx:3412
 TProof.cxx:3413
 TProof.cxx:3414
 TProof.cxx:3415
 TProof.cxx:3416
 TProof.cxx:3417
 TProof.cxx:3418
 TProof.cxx:3419
 TProof.cxx:3420
 TProof.cxx:3421
 TProof.cxx:3422
 TProof.cxx:3423
 TProof.cxx:3424
 TProof.cxx:3425
 TProof.cxx:3426
 TProof.cxx:3427
 TProof.cxx:3428
 TProof.cxx:3429
 TProof.cxx:3430
 TProof.cxx:3431
 TProof.cxx:3432
 TProof.cxx:3433
 TProof.cxx:3434
 TProof.cxx:3435
 TProof.cxx:3436
 TProof.cxx:3437
 TProof.cxx:3438
 TProof.cxx:3439
 TProof.cxx:3440
 TProof.cxx:3441
 TProof.cxx:3442
 TProof.cxx:3443
 TProof.cxx:3444
 TProof.cxx:3445
 TProof.cxx:3446
 TProof.cxx:3447
 TProof.cxx:3448
 TProof.cxx:3449
 TProof.cxx:3450
 TProof.cxx:3451
 TProof.cxx:3452
 TProof.cxx:3453
 TProof.cxx:3454
 TProof.cxx:3455
 TProof.cxx:3456
 TProof.cxx:3457
 TProof.cxx:3458
 TProof.cxx:3459
 TProof.cxx:3460
 TProof.cxx:3461
 TProof.cxx:3462
 TProof.cxx:3463
 TProof.cxx:3464
 TProof.cxx:3465
 TProof.cxx:3466
 TProof.cxx:3467
 TProof.cxx:3468
 TProof.cxx:3469
 TProof.cxx:3470
 TProof.cxx:3471
 TProof.cxx:3472
 TProof.cxx:3473
 TProof.cxx:3474
 TProof.cxx:3475
 TProof.cxx:3476
 TProof.cxx:3477
 TProof.cxx:3478
 TProof.cxx:3479
 TProof.cxx:3480
 TProof.cxx:3481
 TProof.cxx:3482
 TProof.cxx:3483
 TProof.cxx:3484
 TProof.cxx:3485
 TProof.cxx:3486
 TProof.cxx:3487
 TProof.cxx:3488
 TProof.cxx:3489
 TProof.cxx:3490
 TProof.cxx:3491
 TProof.cxx:3492
 TProof.cxx:3493
 TProof.cxx:3494
 TProof.cxx:3495
 TProof.cxx:3496
 TProof.cxx:3497
 TProof.cxx:3498
 TProof.cxx:3499
 TProof.cxx:3500
 TProof.cxx:3501
 TProof.cxx:3502
 TProof.cxx:3503
 TProof.cxx:3504
 TProof.cxx:3505
 TProof.cxx:3506
 TProof.cxx:3507
 TProof.cxx:3508
 TProof.cxx:3509
 TProof.cxx:3510
 TProof.cxx:3511
 TProof.cxx:3512
 TProof.cxx:3513
 TProof.cxx:3514
 TProof.cxx:3515
 TProof.cxx:3516
 TProof.cxx:3517
 TProof.cxx:3518
 TProof.cxx:3519
 TProof.cxx:3520
 TProof.cxx:3521
 TProof.cxx:3522
 TProof.cxx:3523
 TProof.cxx:3524
 TProof.cxx:3525
 TProof.cxx:3526
 TProof.cxx:3527
 TProof.cxx:3528
 TProof.cxx:3529
 TProof.cxx:3530
 TProof.cxx:3531
 TProof.cxx:3532
 TProof.cxx:3533
 TProof.cxx:3534
 TProof.cxx:3535
 TProof.cxx:3536
 TProof.cxx:3537
 TProof.cxx:3538
 TProof.cxx:3539
 TProof.cxx:3540
 TProof.cxx:3541
 TProof.cxx:3542
 TProof.cxx:3543
 TProof.cxx:3544
 TProof.cxx:3545
 TProof.cxx:3546
 TProof.cxx:3547
 TProof.cxx:3548
 TProof.cxx:3549
 TProof.cxx:3550
 TProof.cxx:3551
 TProof.cxx:3552
 TProof.cxx:3553
 TProof.cxx:3554
 TProof.cxx:3555
 TProof.cxx:3556
 TProof.cxx:3557
 TProof.cxx:3558
 TProof.cxx:3559
 TProof.cxx:3560
 TProof.cxx:3561
 TProof.cxx:3562
 TProof.cxx:3563
 TProof.cxx:3564
 TProof.cxx:3565
 TProof.cxx:3566
 TProof.cxx:3567
 TProof.cxx:3568
 TProof.cxx:3569
 TProof.cxx:3570
 TProof.cxx:3571
 TProof.cxx:3572
 TProof.cxx:3573
 TProof.cxx:3574
 TProof.cxx:3575
 TProof.cxx:3576
 TProof.cxx:3577
 TProof.cxx:3578
 TProof.cxx:3579
 TProof.cxx:3580
 TProof.cxx:3581
 TProof.cxx:3582
 TProof.cxx:3583
 TProof.cxx:3584
 TProof.cxx:3585
 TProof.cxx:3586
 TProof.cxx:3587
 TProof.cxx:3588
 TProof.cxx:3589
 TProof.cxx:3590
 TProof.cxx:3591
 TProof.cxx:3592
 TProof.cxx:3593
 TProof.cxx:3594
 TProof.cxx:3595
 TProof.cxx:3596
 TProof.cxx:3597
 TProof.cxx:3598
 TProof.cxx:3599
 TProof.cxx:3600
 TProof.cxx:3601
 TProof.cxx:3602
 TProof.cxx:3603
 TProof.cxx:3604
 TProof.cxx:3605
 TProof.cxx:3606
 TProof.cxx:3607
 TProof.cxx:3608
 TProof.cxx:3609
 TProof.cxx:3610
 TProof.cxx:3611
 TProof.cxx:3612
 TProof.cxx:3613
 TProof.cxx:3614
 TProof.cxx:3615
 TProof.cxx:3616
 TProof.cxx:3617
 TProof.cxx:3618
 TProof.cxx:3619
 TProof.cxx:3620
 TProof.cxx:3621
 TProof.cxx:3622
 TProof.cxx:3623
 TProof.cxx:3624
 TProof.cxx:3625
 TProof.cxx:3626
 TProof.cxx:3627
 TProof.cxx:3628
 TProof.cxx:3629
 TProof.cxx:3630
 TProof.cxx:3631
 TProof.cxx:3632
 TProof.cxx:3633
 TProof.cxx:3634
 TProof.cxx:3635
 TProof.cxx:3636
 TProof.cxx:3637
 TProof.cxx:3638
 TProof.cxx:3639
 TProof.cxx:3640
 TProof.cxx:3641
 TProof.cxx:3642
 TProof.cxx:3643
 TProof.cxx:3644
 TProof.cxx:3645
 TProof.cxx:3646
 TProof.cxx:3647
 TProof.cxx:3648
 TProof.cxx:3649
 TProof.cxx:3650
 TProof.cxx:3651
 TProof.cxx:3652
 TProof.cxx:3653
 TProof.cxx:3654
 TProof.cxx:3655
 TProof.cxx:3656
 TProof.cxx:3657
 TProof.cxx:3658
 TProof.cxx:3659
 TProof.cxx:3660
 TProof.cxx:3661
 TProof.cxx:3662
 TProof.cxx:3663
 TProof.cxx:3664
 TProof.cxx:3665
 TProof.cxx:3666
 TProof.cxx:3667
 TProof.cxx:3668
 TProof.cxx:3669
 TProof.cxx:3670
 TProof.cxx:3671
 TProof.cxx:3672
 TProof.cxx:3673
 TProof.cxx:3674
 TProof.cxx:3675
 TProof.cxx:3676
 TProof.cxx:3677
 TProof.cxx:3678
 TProof.cxx:3679
 TProof.cxx:3680
 TProof.cxx:3681
 TProof.cxx:3682
 TProof.cxx:3683
 TProof.cxx:3684
 TProof.cxx:3685
 TProof.cxx:3686
 TProof.cxx:3687
 TProof.cxx:3688
 TProof.cxx:3689
 TProof.cxx:3690
 TProof.cxx:3691
 TProof.cxx:3692
 TProof.cxx:3693
 TProof.cxx:3694
 TProof.cxx:3695
 TProof.cxx:3696
 TProof.cxx:3697
 TProof.cxx:3698
 TProof.cxx:3699
 TProof.cxx:3700
 TProof.cxx:3701
 TProof.cxx:3702
 TProof.cxx:3703
 TProof.cxx:3704
 TProof.cxx:3705
 TProof.cxx:3706
 TProof.cxx:3707
 TProof.cxx:3708
 TProof.cxx:3709
 TProof.cxx:3710
 TProof.cxx:3711
 TProof.cxx:3712
 TProof.cxx:3713
 TProof.cxx:3714
 TProof.cxx:3715
 TProof.cxx:3716
 TProof.cxx:3717
 TProof.cxx:3718
 TProof.cxx:3719
 TProof.cxx:3720
 TProof.cxx:3721
 TProof.cxx:3722
 TProof.cxx:3723
 TProof.cxx:3724
 TProof.cxx:3725
 TProof.cxx:3726
 TProof.cxx:3727
 TProof.cxx:3728
 TProof.cxx:3729
 TProof.cxx:3730
 TProof.cxx:3731
 TProof.cxx:3732
 TProof.cxx:3733
 TProof.cxx:3734
 TProof.cxx:3735
 TProof.cxx:3736
 TProof.cxx:3737
 TProof.cxx:3738
 TProof.cxx:3739
 TProof.cxx:3740
 TProof.cxx:3741
 TProof.cxx:3742
 TProof.cxx:3743
 TProof.cxx:3744
 TProof.cxx:3745
 TProof.cxx:3746
 TProof.cxx:3747
 TProof.cxx:3748
 TProof.cxx:3749
 TProof.cxx:3750
 TProof.cxx:3751
 TProof.cxx:3752
 TProof.cxx:3753
 TProof.cxx:3754
 TProof.cxx:3755
 TProof.cxx:3756
 TProof.cxx:3757
 TProof.cxx:3758
 TProof.cxx:3759
 TProof.cxx:3760
 TProof.cxx:3761
 TProof.cxx:3762
 TProof.cxx:3763
 TProof.cxx:3764
 TProof.cxx:3765
 TProof.cxx:3766
 TProof.cxx:3767
 TProof.cxx:3768
 TProof.cxx:3769
 TProof.cxx:3770
 TProof.cxx:3771
 TProof.cxx:3772
 TProof.cxx:3773
 TProof.cxx:3774
 TProof.cxx:3775
 TProof.cxx:3776
 TProof.cxx:3777
 TProof.cxx:3778
 TProof.cxx:3779
 TProof.cxx:3780
 TProof.cxx:3781
 TProof.cxx:3782
 TProof.cxx:3783
 TProof.cxx:3784
 TProof.cxx:3785
 TProof.cxx:3786
 TProof.cxx:3787
 TProof.cxx:3788
 TProof.cxx:3789
 TProof.cxx:3790
 TProof.cxx:3791
 TProof.cxx:3792
 TProof.cxx:3793
 TProof.cxx:3794
 TProof.cxx:3795
 TProof.cxx:3796
 TProof.cxx:3797
 TProof.cxx:3798
 TProof.cxx:3799
 TProof.cxx:3800
 TProof.cxx:3801
 TProof.cxx:3802
 TProof.cxx:3803
 TProof.cxx:3804
 TProof.cxx:3805
 TProof.cxx:3806
 TProof.cxx:3807
 TProof.cxx:3808
 TProof.cxx:3809
 TProof.cxx:3810
 TProof.cxx:3811
 TProof.cxx:3812
 TProof.cxx:3813
 TProof.cxx:3814
 TProof.cxx:3815
 TProof.cxx:3816
 TProof.cxx:3817
 TProof.cxx:3818
 TProof.cxx:3819
 TProof.cxx:3820
 TProof.cxx:3821
 TProof.cxx:3822
 TProof.cxx:3823
 TProof.cxx:3824
 TProof.cxx:3825
 TProof.cxx:3826
 TProof.cxx:3827
 TProof.cxx:3828
 TProof.cxx:3829
 TProof.cxx:3830
 TProof.cxx:3831
 TProof.cxx:3832
 TProof.cxx:3833
 TProof.cxx:3834
 TProof.cxx:3835
 TProof.cxx:3836
 TProof.cxx:3837
 TProof.cxx:3838
 TProof.cxx:3839
 TProof.cxx:3840
 TProof.cxx:3841
 TProof.cxx:3842
 TProof.cxx:3843
 TProof.cxx:3844
 TProof.cxx:3845
 TProof.cxx:3846
 TProof.cxx:3847
 TProof.cxx:3848
 TProof.cxx:3849
 TProof.cxx:3850
 TProof.cxx:3851
 TProof.cxx:3852
 TProof.cxx:3853
 TProof.cxx:3854
 TProof.cxx:3855
 TProof.cxx:3856
 TProof.cxx:3857
 TProof.cxx:3858
 TProof.cxx:3859
 TProof.cxx:3860
 TProof.cxx:3861
 TProof.cxx:3862
 TProof.cxx:3863
 TProof.cxx:3864
 TProof.cxx:3865
 TProof.cxx:3866
 TProof.cxx:3867
 TProof.cxx:3868
 TProof.cxx:3869
 TProof.cxx:3870
 TProof.cxx:3871
 TProof.cxx:3872
 TProof.cxx:3873
 TProof.cxx:3874
 TProof.cxx:3875
 TProof.cxx:3876
 TProof.cxx:3877
 TProof.cxx:3878
 TProof.cxx:3879
 TProof.cxx:3880
 TProof.cxx:3881
 TProof.cxx:3882
 TProof.cxx:3883
 TProof.cxx:3884
 TProof.cxx:3885
 TProof.cxx:3886
 TProof.cxx:3887
 TProof.cxx:3888
 TProof.cxx:3889
 TProof.cxx:3890
 TProof.cxx:3891
 TProof.cxx:3892
 TProof.cxx:3893
 TProof.cxx:3894
 TProof.cxx:3895
 TProof.cxx:3896
 TProof.cxx:3897
 TProof.cxx:3898
 TProof.cxx:3899
 TProof.cxx:3900
 TProof.cxx:3901
 TProof.cxx:3902
 TProof.cxx:3903
 TProof.cxx:3904
 TProof.cxx:3905
 TProof.cxx:3906
 TProof.cxx:3907
 TProof.cxx:3908
 TProof.cxx:3909
 TProof.cxx:3910
 TProof.cxx:3911
 TProof.cxx:3912
 TProof.cxx:3913
 TProof.cxx:3914
 TProof.cxx:3915
 TProof.cxx:3916
 TProof.cxx:3917
 TProof.cxx:3918
 TProof.cxx:3919
 TProof.cxx:3920
 TProof.cxx:3921
 TProof.cxx:3922
 TProof.cxx:3923
 TProof.cxx:3924
 TProof.cxx:3925
 TProof.cxx:3926
 TProof.cxx:3927
 TProof.cxx:3928
 TProof.cxx:3929
 TProof.cxx:3930
 TProof.cxx:3931
 TProof.cxx:3932
 TProof.cxx:3933
 TProof.cxx:3934
 TProof.cxx:3935
 TProof.cxx:3936
 TProof.cxx:3937
 TProof.cxx:3938
 TProof.cxx:3939
 TProof.cxx:3940
 TProof.cxx:3941
 TProof.cxx:3942
 TProof.cxx:3943
 TProof.cxx:3944
 TProof.cxx:3945
 TProof.cxx:3946
 TProof.cxx:3947
 TProof.cxx:3948
 TProof.cxx:3949
 TProof.cxx:3950
 TProof.cxx:3951
 TProof.cxx:3952
 TProof.cxx:3953
 TProof.cxx:3954
 TProof.cxx:3955
 TProof.cxx:3956
 TProof.cxx:3957
 TProof.cxx:3958
 TProof.cxx:3959
 TProof.cxx:3960
 TProof.cxx:3961
 TProof.cxx:3962
 TProof.cxx:3963
 TProof.cxx:3964
 TProof.cxx:3965
 TProof.cxx:3966
 TProof.cxx:3967
 TProof.cxx:3968
 TProof.cxx:3969
 TProof.cxx:3970
 TProof.cxx:3971
 TProof.cxx:3972
 TProof.cxx:3973
 TProof.cxx:3974
 TProof.cxx:3975
 TProof.cxx:3976
 TProof.cxx:3977
 TProof.cxx:3978
 TProof.cxx:3979
 TProof.cxx:3980
 TProof.cxx:3981
 TProof.cxx:3982
 TProof.cxx:3983
 TProof.cxx:3984
 TProof.cxx:3985
 TProof.cxx:3986
 TProof.cxx:3987
 TProof.cxx:3988
 TProof.cxx:3989
 TProof.cxx:3990
 TProof.cxx:3991
 TProof.cxx:3992
 TProof.cxx:3993
 TProof.cxx:3994
 TProof.cxx:3995
 TProof.cxx:3996
 TProof.cxx:3997
 TProof.cxx:3998
 TProof.cxx:3999
 TProof.cxx:4000
 TProof.cxx:4001
 TProof.cxx:4002
 TProof.cxx:4003
 TProof.cxx:4004
 TProof.cxx:4005
 TProof.cxx:4006
 TProof.cxx:4007
 TProof.cxx:4008
 TProof.cxx:4009
 TProof.cxx:4010
 TProof.cxx:4011
 TProof.cxx:4012
 TProof.cxx:4013
 TProof.cxx:4014
 TProof.cxx:4015
 TProof.cxx:4016
 TProof.cxx:4017
 TProof.cxx:4018
 TProof.cxx:4019
 TProof.cxx:4020
 TProof.cxx:4021
 TProof.cxx:4022
 TProof.cxx:4023
 TProof.cxx:4024
 TProof.cxx:4025
 TProof.cxx:4026
 TProof.cxx:4027
 TProof.cxx:4028
 TProof.cxx:4029
 TProof.cxx:4030
 TProof.cxx:4031
 TProof.cxx:4032
 TProof.cxx:4033
 TProof.cxx:4034
 TProof.cxx:4035
 TProof.cxx:4036
 TProof.cxx:4037
 TProof.cxx:4038
 TProof.cxx:4039
 TProof.cxx:4040
 TProof.cxx:4041
 TProof.cxx:4042
 TProof.cxx:4043
 TProof.cxx:4044
 TProof.cxx:4045
 TProof.cxx:4046
 TProof.cxx:4047
 TProof.cxx:4048
 TProof.cxx:4049
 TProof.cxx:4050
 TProof.cxx:4051
 TProof.cxx:4052
 TProof.cxx:4053
 TProof.cxx:4054
 TProof.cxx:4055
 TProof.cxx:4056
 TProof.cxx:4057
 TProof.cxx:4058
 TProof.cxx:4059
 TProof.cxx:4060
 TProof.cxx:4061
 TProof.cxx:4062
 TProof.cxx:4063
 TProof.cxx:4064
 TProof.cxx:4065
 TProof.cxx:4066
 TProof.cxx:4067
 TProof.cxx:4068
 TProof.cxx:4069
 TProof.cxx:4070
 TProof.cxx:4071
 TProof.cxx:4072
 TProof.cxx:4073
 TProof.cxx:4074
 TProof.cxx:4075
 TProof.cxx:4076
 TProof.cxx:4077
 TProof.cxx:4078
 TProof.cxx:4079
 TProof.cxx:4080
 TProof.cxx:4081
 TProof.cxx:4082
 TProof.cxx:4083
 TProof.cxx:4084
 TProof.cxx:4085
 TProof.cxx:4086
 TProof.cxx:4087
 TProof.cxx:4088
 TProof.cxx:4089
 TProof.cxx:4090
 TProof.cxx:4091
 TProof.cxx:4092
 TProof.cxx:4093
 TProof.cxx:4094
 TProof.cxx:4095
 TProof.cxx:4096
 TProof.cxx:4097
 TProof.cxx:4098
 TProof.cxx:4099
 TProof.cxx:4100
 TProof.cxx:4101
 TProof.cxx:4102
 TProof.cxx:4103
 TProof.cxx:4104
 TProof.cxx:4105
 TProof.cxx:4106
 TProof.cxx:4107
 TProof.cxx:4108
 TProof.cxx:4109
 TProof.cxx:4110
 TProof.cxx:4111
 TProof.cxx:4112
 TProof.cxx:4113
 TProof.cxx:4114
 TProof.cxx:4115
 TProof.cxx:4116
 TProof.cxx:4117
 TProof.cxx:4118
 TProof.cxx:4119
 TProof.cxx:4120
 TProof.cxx:4121
 TProof.cxx:4122
 TProof.cxx:4123
 TProof.cxx:4124
 TProof.cxx:4125
 TProof.cxx:4126
 TProof.cxx:4127
 TProof.cxx:4128
 TProof.cxx:4129
 TProof.cxx:4130
 TProof.cxx:4131
 TProof.cxx:4132
 TProof.cxx:4133
 TProof.cxx:4134
 TProof.cxx:4135
 TProof.cxx:4136
 TProof.cxx:4137
 TProof.cxx:4138
 TProof.cxx:4139
 TProof.cxx:4140
 TProof.cxx:4141
 TProof.cxx:4142
 TProof.cxx:4143
 TProof.cxx:4144
 TProof.cxx:4145
 TProof.cxx:4146
 TProof.cxx:4147
 TProof.cxx:4148
 TProof.cxx:4149
 TProof.cxx:4150
 TProof.cxx:4151
 TProof.cxx:4152
 TProof.cxx:4153
 TProof.cxx:4154
 TProof.cxx:4155
 TProof.cxx:4156
 TProof.cxx:4157
 TProof.cxx:4158
 TProof.cxx:4159
 TProof.cxx:4160
 TProof.cxx:4161
 TProof.cxx:4162
 TProof.cxx:4163
 TProof.cxx:4164
 TProof.cxx:4165
 TProof.cxx:4166
 TProof.cxx:4167
 TProof.cxx:4168
 TProof.cxx:4169
 TProof.cxx:4170
 TProof.cxx:4171
 TProof.cxx:4172
 TProof.cxx:4173
 TProof.cxx:4174
 TProof.cxx:4175
 TProof.cxx:4176
 TProof.cxx:4177
 TProof.cxx:4178
 TProof.cxx:4179
 TProof.cxx:4180
 TProof.cxx:4181
 TProof.cxx:4182
 TProof.cxx:4183
 TProof.cxx:4184
 TProof.cxx:4185
 TProof.cxx:4186
 TProof.cxx:4187
 TProof.cxx:4188
 TProof.cxx:4189
 TProof.cxx:4190
 TProof.cxx:4191
 TProof.cxx:4192
 TProof.cxx:4193
 TProof.cxx:4194
 TProof.cxx:4195
 TProof.cxx:4196
 TProof.cxx:4197
 TProof.cxx:4198
 TProof.cxx:4199
 TProof.cxx:4200
 TProof.cxx:4201
 TProof.cxx:4202
 TProof.cxx:4203
 TProof.cxx:4204
 TProof.cxx:4205
 TProof.cxx:4206
 TProof.cxx:4207
 TProof.cxx:4208
 TProof.cxx:4209
 TProof.cxx:4210
 TProof.cxx:4211
 TProof.cxx:4212
 TProof.cxx:4213
 TProof.cxx:4214
 TProof.cxx:4215
 TProof.cxx:4216
 TProof.cxx:4217
 TProof.cxx:4218
 TProof.cxx:4219
 TProof.cxx:4220
 TProof.cxx:4221
 TProof.cxx:4222
 TProof.cxx:4223
 TProof.cxx:4224
 TProof.cxx:4225
 TProof.cxx:4226
 TProof.cxx:4227
 TProof.cxx:4228
 TProof.cxx:4229
 TProof.cxx:4230
 TProof.cxx:4231
 TProof.cxx:4232
 TProof.cxx:4233
 TProof.cxx:4234
 TProof.cxx:4235
 TProof.cxx:4236
 TProof.cxx:4237
 TProof.cxx:4238
 TProof.cxx:4239
 TProof.cxx:4240
 TProof.cxx:4241
 TProof.cxx:4242
 TProof.cxx:4243
 TProof.cxx:4244
 TProof.cxx:4245
 TProof.cxx:4246
 TProof.cxx:4247
 TProof.cxx:4248
 TProof.cxx:4249
 TProof.cxx:4250
 TProof.cxx:4251
 TProof.cxx:4252
 TProof.cxx:4253
 TProof.cxx:4254
 TProof.cxx:4255
 TProof.cxx:4256
 TProof.cxx:4257
 TProof.cxx:4258
 TProof.cxx:4259
 TProof.cxx:4260
 TProof.cxx:4261
 TProof.cxx:4262
 TProof.cxx:4263
 TProof.cxx:4264
 TProof.cxx:4265
 TProof.cxx:4266
 TProof.cxx:4267
 TProof.cxx:4268
 TProof.cxx:4269
 TProof.cxx:4270
 TProof.cxx:4271
 TProof.cxx:4272
 TProof.cxx:4273
 TProof.cxx:4274
 TProof.cxx:4275
 TProof.cxx:4276
 TProof.cxx:4277
 TProof.cxx:4278
 TProof.cxx:4279
 TProof.cxx:4280
 TProof.cxx:4281
 TProof.cxx:4282
 TProof.cxx:4283
 TProof.cxx:4284
 TProof.cxx:4285
 TProof.cxx:4286
 TProof.cxx:4287
 TProof.cxx:4288
 TProof.cxx:4289
 TProof.cxx:4290
 TProof.cxx:4291
 TProof.cxx:4292
 TProof.cxx:4293
 TProof.cxx:4294
 TProof.cxx:4295
 TProof.cxx:4296
 TProof.cxx:4297
 TProof.cxx:4298
 TProof.cxx:4299
 TProof.cxx:4300
 TProof.cxx:4301
 TProof.cxx:4302
 TProof.cxx:4303
 TProof.cxx:4304
 TProof.cxx:4305
 TProof.cxx:4306
 TProof.cxx:4307
 TProof.cxx:4308
 TProof.cxx:4309
 TProof.cxx:4310
 TProof.cxx:4311
 TProof.cxx:4312
 TProof.cxx:4313
 TProof.cxx:4314
 TProof.cxx:4315
 TProof.cxx:4316
 TProof.cxx:4317
 TProof.cxx:4318
 TProof.cxx:4319
 TProof.cxx:4320
 TProof.cxx:4321
 TProof.cxx:4322
 TProof.cxx:4323
 TProof.cxx:4324
 TProof.cxx:4325
 TProof.cxx:4326
 TProof.cxx:4327
 TProof.cxx:4328
 TProof.cxx:4329
 TProof.cxx:4330
 TProof.cxx:4331
 TProof.cxx:4332
 TProof.cxx:4333
 TProof.cxx:4334
 TProof.cxx:4335
 TProof.cxx:4336
 TProof.cxx:4337
 TProof.cxx:4338
 TProof.cxx:4339
 TProof.cxx:4340
 TProof.cxx:4341
 TProof.cxx:4342
 TProof.cxx:4343
 TProof.cxx:4344
 TProof.cxx:4345
 TProof.cxx:4346
 TProof.cxx:4347
 TProof.cxx:4348
 TProof.cxx:4349
 TProof.cxx:4350
 TProof.cxx:4351
 TProof.cxx:4352
 TProof.cxx:4353
 TProof.cxx:4354
 TProof.cxx:4355
 TProof.cxx:4356
 TProof.cxx:4357
 TProof.cxx:4358
 TProof.cxx:4359
 TProof.cxx:4360
 TProof.cxx:4361
 TProof.cxx:4362
 TProof.cxx:4363
 TProof.cxx:4364
 TProof.cxx:4365
 TProof.cxx:4366
 TProof.cxx:4367
 TProof.cxx:4368
 TProof.cxx:4369
 TProof.cxx:4370
 TProof.cxx:4371
 TProof.cxx:4372
 TProof.cxx:4373
 TProof.cxx:4374
 TProof.cxx:4375
 TProof.cxx:4376
 TProof.cxx:4377
 TProof.cxx:4378
 TProof.cxx:4379
 TProof.cxx:4380
 TProof.cxx:4381
 TProof.cxx:4382
 TProof.cxx:4383
 TProof.cxx:4384
 TProof.cxx:4385
 TProof.cxx:4386
 TProof.cxx:4387
 TProof.cxx:4388
 TProof.cxx:4389
 TProof.cxx:4390
 TProof.cxx:4391
 TProof.cxx:4392
 TProof.cxx:4393
 TProof.cxx:4394
 TProof.cxx:4395
 TProof.cxx:4396
 TProof.cxx:4397
 TProof.cxx:4398
 TProof.cxx:4399
 TProof.cxx:4400
 TProof.cxx:4401
 TProof.cxx:4402
 TProof.cxx:4403
 TProof.cxx:4404
 TProof.cxx:4405
 TProof.cxx:4406
 TProof.cxx:4407
 TProof.cxx:4408
 TProof.cxx:4409
 TProof.cxx:4410
 TProof.cxx:4411
 TProof.cxx:4412
 TProof.cxx:4413
 TProof.cxx:4414
 TProof.cxx:4415
 TProof.cxx:4416
 TProof.cxx:4417
 TProof.cxx:4418
 TProof.cxx:4419
 TProof.cxx:4420
 TProof.cxx:4421
 TProof.cxx:4422
 TProof.cxx:4423
 TProof.cxx:4424
 TProof.cxx:4425
 TProof.cxx:4426
 TProof.cxx:4427
 TProof.cxx:4428
 TProof.cxx:4429
 TProof.cxx:4430
 TProof.cxx:4431
 TProof.cxx:4432
 TProof.cxx:4433
 TProof.cxx:4434
 TProof.cxx:4435
 TProof.cxx:4436
 TProof.cxx:4437
 TProof.cxx:4438
 TProof.cxx:4439
 TProof.cxx:4440
 TProof.cxx:4441
 TProof.cxx:4442
 TProof.cxx:4443
 TProof.cxx:4444
 TProof.cxx:4445
 TProof.cxx:4446
 TProof.cxx:4447
 TProof.cxx:4448
 TProof.cxx:4449
 TProof.cxx:4450
 TProof.cxx:4451
 TProof.cxx:4452
 TProof.cxx:4453
 TProof.cxx:4454
 TProof.cxx:4455
 TProof.cxx:4456
 TProof.cxx:4457
 TProof.cxx:4458
 TProof.cxx:4459
 TProof.cxx:4460
 TProof.cxx:4461
 TProof.cxx:4462
 TProof.cxx:4463
 TProof.cxx:4464
 TProof.cxx:4465
 TProof.cxx:4466
 TProof.cxx:4467
 TProof.cxx:4468
 TProof.cxx:4469
 TProof.cxx:4470
 TProof.cxx:4471
 TProof.cxx:4472
 TProof.cxx:4473
 TProof.cxx:4474
 TProof.cxx:4475
 TProof.cxx:4476
 TProof.cxx:4477
 TProof.cxx:4478
 TProof.cxx:4479
 TProof.cxx:4480
 TProof.cxx:4481
 TProof.cxx:4482
 TProof.cxx:4483
 TProof.cxx:4484
 TProof.cxx:4485
 TProof.cxx:4486
 TProof.cxx:4487
 TProof.cxx:4488
 TProof.cxx:4489
 TProof.cxx:4490
 TProof.cxx:4491
 TProof.cxx:4492
 TProof.cxx:4493
 TProof.cxx:4494
 TProof.cxx:4495
 TProof.cxx:4496
 TProof.cxx:4497
 TProof.cxx:4498
 TProof.cxx:4499
 TProof.cxx:4500
 TProof.cxx:4501
 TProof.cxx:4502
 TProof.cxx:4503
 TProof.cxx:4504
 TProof.cxx:4505
 TProof.cxx:4506
 TProof.cxx:4507
 TProof.cxx:4508
 TProof.cxx:4509
 TProof.cxx:4510
 TProof.cxx:4511
 TProof.cxx:4512
 TProof.cxx:4513
 TProof.cxx:4514
 TProof.cxx:4515
 TProof.cxx:4516
 TProof.cxx:4517
 TProof.cxx:4518
 TProof.cxx:4519
 TProof.cxx:4520
 TProof.cxx:4521
 TProof.cxx:4522
 TProof.cxx:4523
 TProof.cxx:4524
 TProof.cxx:4525
 TProof.cxx:4526
 TProof.cxx:4527
 TProof.cxx:4528
 TProof.cxx:4529
 TProof.cxx:4530
 TProof.cxx:4531
 TProof.cxx:4532
 TProof.cxx:4533
 TProof.cxx:4534
 TProof.cxx:4535
 TProof.cxx:4536
 TProof.cxx:4537
 TProof.cxx:4538
 TProof.cxx:4539
 TProof.cxx:4540
 TProof.cxx:4541
 TProof.cxx:4542
 TProof.cxx:4543
 TProof.cxx:4544
 TProof.cxx:4545
 TProof.cxx:4546
 TProof.cxx:4547
 TProof.cxx:4548
 TProof.cxx:4549
 TProof.cxx:4550
 TProof.cxx:4551
 TProof.cxx:4552
 TProof.cxx:4553
 TProof.cxx:4554
 TProof.cxx:4555
 TProof.cxx:4556
 TProof.cxx:4557
 TProof.cxx:4558
 TProof.cxx:4559
 TProof.cxx:4560
 TProof.cxx:4561
 TProof.cxx:4562
 TProof.cxx:4563
 TProof.cxx:4564
 TProof.cxx:4565
 TProof.cxx:4566
 TProof.cxx:4567
 TProof.cxx:4568
 TProof.cxx:4569
 TProof.cxx:4570
 TProof.cxx:4571
 TProof.cxx:4572
 TProof.cxx:4573
 TProof.cxx:4574
 TProof.cxx:4575
 TProof.cxx:4576
 TProof.cxx:4577
 TProof.cxx:4578
 TProof.cxx:4579
 TProof.cxx:4580
 TProof.cxx:4581
 TProof.cxx:4582
 TProof.cxx:4583
 TProof.cxx:4584
 TProof.cxx:4585
 TProof.cxx:4586
 TProof.cxx:4587
 TProof.cxx:4588
 TProof.cxx:4589
 TProof.cxx:4590
 TProof.cxx:4591
 TProof.cxx:4592
 TProof.cxx:4593
 TProof.cxx:4594
 TProof.cxx:4595
 TProof.cxx:4596
 TProof.cxx:4597
 TProof.cxx:4598
 TProof.cxx:4599
 TProof.cxx:4600
 TProof.cxx:4601
 TProof.cxx:4602
 TProof.cxx:4603
 TProof.cxx:4604
 TProof.cxx:4605
 TProof.cxx:4606
 TProof.cxx:4607
 TProof.cxx:4608
 TProof.cxx:4609
 TProof.cxx:4610
 TProof.cxx:4611
 TProof.cxx:4612
 TProof.cxx:4613
 TProof.cxx:4614
 TProof.cxx:4615
 TProof.cxx:4616
 TProof.cxx:4617
 TProof.cxx:4618
 TProof.cxx:4619
 TProof.cxx:4620
 TProof.cxx:4621
 TProof.cxx:4622
 TProof.cxx:4623
 TProof.cxx:4624
 TProof.cxx:4625
 TProof.cxx:4626
 TProof.cxx:4627
 TProof.cxx:4628
 TProof.cxx:4629
 TProof.cxx:4630
 TProof.cxx:4631
 TProof.cxx:4632
 TProof.cxx:4633
 TProof.cxx:4634
 TProof.cxx:4635
 TProof.cxx:4636
 TProof.cxx:4637
 TProof.cxx:4638
 TProof.cxx:4639
 TProof.cxx:4640
 TProof.cxx:4641
 TProof.cxx:4642
 TProof.cxx:4643
 TProof.cxx:4644
 TProof.cxx:4645
 TProof.cxx:4646
 TProof.cxx:4647
 TProof.cxx:4648
 TProof.cxx:4649
 TProof.cxx:4650
 TProof.cxx:4651
 TProof.cxx:4652
 TProof.cxx:4653
 TProof.cxx:4654
 TProof.cxx:4655
 TProof.cxx:4656
 TProof.cxx:4657
 TProof.cxx:4658
 TProof.cxx:4659
 TProof.cxx:4660
 TProof.cxx:4661
 TProof.cxx:4662
 TProof.cxx:4663
 TProof.cxx:4664
 TProof.cxx:4665
 TProof.cxx:4666
 TProof.cxx:4667
 TProof.cxx:4668
 TProof.cxx:4669
 TProof.cxx:4670
 TProof.cxx:4671
 TProof.cxx:4672
 TProof.cxx:4673
 TProof.cxx:4674
 TProof.cxx:4675
 TProof.cxx:4676
 TProof.cxx:4677
 TProof.cxx:4678
 TProof.cxx:4679
 TProof.cxx:4680
 TProof.cxx:4681
 TProof.cxx:4682
 TProof.cxx:4683
 TProof.cxx:4684
 TProof.cxx:4685
 TProof.cxx:4686
 TProof.cxx:4687
 TProof.cxx:4688
 TProof.cxx:4689
 TProof.cxx:4690
 TProof.cxx:4691
 TProof.cxx:4692
 TProof.cxx:4693
 TProof.cxx:4694
 TProof.cxx:4695
 TProof.cxx:4696
 TProof.cxx:4697
 TProof.cxx:4698
 TProof.cxx:4699
 TProof.cxx:4700
 TProof.cxx:4701
 TProof.cxx:4702
 TProof.cxx:4703
 TProof.cxx:4704
 TProof.cxx:4705
 TProof.cxx:4706
 TProof.cxx:4707
 TProof.cxx:4708
 TProof.cxx:4709
 TProof.cxx:4710
 TProof.cxx:4711
 TProof.cxx:4712
 TProof.cxx:4713
 TProof.cxx:4714
 TProof.cxx:4715
 TProof.cxx:4716
 TProof.cxx:4717
 TProof.cxx:4718
 TProof.cxx:4719
 TProof.cxx:4720
 TProof.cxx:4721
 TProof.cxx:4722
 TProof.cxx:4723
 TProof.cxx:4724
 TProof.cxx:4725
 TProof.cxx:4726
 TProof.cxx:4727
 TProof.cxx:4728
 TProof.cxx:4729
 TProof.cxx:4730
 TProof.cxx:4731
 TProof.cxx:4732
 TProof.cxx:4733
 TProof.cxx:4734
 TProof.cxx:4735
 TProof.cxx:4736
 TProof.cxx:4737
 TProof.cxx:4738
 TProof.cxx:4739
 TProof.cxx:4740
 TProof.cxx:4741
 TProof.cxx:4742
 TProof.cxx:4743
 TProof.cxx:4744
 TProof.cxx:4745
 TProof.cxx:4746
 TProof.cxx:4747
 TProof.cxx:4748
 TProof.cxx:4749
 TProof.cxx:4750
 TProof.cxx:4751
 TProof.cxx:4752
 TProof.cxx:4753
 TProof.cxx:4754
 TProof.cxx:4755
 TProof.cxx:4756
 TProof.cxx:4757
 TProof.cxx:4758
 TProof.cxx:4759
 TProof.cxx:4760
 TProof.cxx:4761
 TProof.cxx:4762
 TProof.cxx:4763
 TProof.cxx:4764
 TProof.cxx:4765
 TProof.cxx:4766
 TProof.cxx:4767
 TProof.cxx:4768
 TProof.cxx:4769
 TProof.cxx:4770
 TProof.cxx:4771
 TProof.cxx:4772
 TProof.cxx:4773
 TProof.cxx:4774
 TProof.cxx:4775
 TProof.cxx:4776
 TProof.cxx:4777
 TProof.cxx:4778
 TProof.cxx:4779
 TProof.cxx:4780
 TProof.cxx:4781
 TProof.cxx:4782
 TProof.cxx:4783
 TProof.cxx:4784
 TProof.cxx:4785
 TProof.cxx:4786
 TProof.cxx:4787
 TProof.cxx:4788
 TProof.cxx:4789
 TProof.cxx:4790
 TProof.cxx:4791
 TProof.cxx:4792
 TProof.cxx:4793
 TProof.cxx:4794
 TProof.cxx:4795
 TProof.cxx:4796
 TProof.cxx:4797
 TProof.cxx:4798
 TProof.cxx:4799
 TProof.cxx:4800
 TProof.cxx:4801
 TProof.cxx:4802
 TProof.cxx:4803
 TProof.cxx:4804
 TProof.cxx:4805
 TProof.cxx:4806
 TProof.cxx:4807
 TProof.cxx:4808
 TProof.cxx:4809
 TProof.cxx:4810
 TProof.cxx:4811
 TProof.cxx:4812
 TProof.cxx:4813
 TProof.cxx:4814
 TProof.cxx:4815
 TProof.cxx:4816
 TProof.cxx:4817
 TProof.cxx:4818
 TProof.cxx:4819
 TProof.cxx:4820
 TProof.cxx:4821
 TProof.cxx:4822
 TProof.cxx:4823
 TProof.cxx:4824
 TProof.cxx:4825
 TProof.cxx:4826
 TProof.cxx:4827
 TProof.cxx:4828
 TProof.cxx:4829
 TProof.cxx:4830
 TProof.cxx:4831
 TProof.cxx:4832
 TProof.cxx:4833
 TProof.cxx:4834
 TProof.cxx:4835
 TProof.cxx:4836
 TProof.cxx:4837
 TProof.cxx:4838
 TProof.cxx:4839
 TProof.cxx:4840
 TProof.cxx:4841
 TProof.cxx:4842
 TProof.cxx:4843
 TProof.cxx:4844
 TProof.cxx:4845
 TProof.cxx:4846
 TProof.cxx:4847
 TProof.cxx:4848
 TProof.cxx:4849
 TProof.cxx:4850
 TProof.cxx:4851
 TProof.cxx:4852
 TProof.cxx:4853
 TProof.cxx:4854
 TProof.cxx:4855
 TProof.cxx:4856
 TProof.cxx:4857
 TProof.cxx:4858
 TProof.cxx:4859
 TProof.cxx:4860
 TProof.cxx:4861
 TProof.cxx:4862
 TProof.cxx:4863
 TProof.cxx:4864
 TProof.cxx:4865
 TProof.cxx:4866
 TProof.cxx:4867
 TProof.cxx:4868
 TProof.cxx:4869
 TProof.cxx:4870
 TProof.cxx:4871
 TProof.cxx:4872
 TProof.cxx:4873
 TProof.cxx:4874
 TProof.cxx:4875
 TProof.cxx:4876
 TProof.cxx:4877
 TProof.cxx:4878
 TProof.cxx:4879
 TProof.cxx:4880
 TProof.cxx:4881
 TProof.cxx:4882
 TProof.cxx:4883
 TProof.cxx:4884
 TProof.cxx:4885
 TProof.cxx:4886
 TProof.cxx:4887
 TProof.cxx:4888
 TProof.cxx:4889
 TProof.cxx:4890
 TProof.cxx:4891
 TProof.cxx:4892
 TProof.cxx:4893
 TProof.cxx:4894
 TProof.cxx:4895
 TProof.cxx:4896
 TProof.cxx:4897
 TProof.cxx:4898
 TProof.cxx:4899
 TProof.cxx:4900
 TProof.cxx:4901
 TProof.cxx:4902
 TProof.cxx:4903
 TProof.cxx:4904
 TProof.cxx:4905
 TProof.cxx:4906
 TProof.cxx:4907
 TProof.cxx:4908
 TProof.cxx:4909
 TProof.cxx:4910
 TProof.cxx:4911
 TProof.cxx:4912
 TProof.cxx:4913
 TProof.cxx:4914
 TProof.cxx:4915
 TProof.cxx:4916
 TProof.cxx:4917
 TProof.cxx:4918
 TProof.cxx:4919
 TProof.cxx:4920
 TProof.cxx:4921
 TProof.cxx:4922
 TProof.cxx:4923
 TProof.cxx:4924
 TProof.cxx:4925
 TProof.cxx:4926
 TProof.cxx:4927
 TProof.cxx:4928
 TProof.cxx:4929
 TProof.cxx:4930
 TProof.cxx:4931
 TProof.cxx:4932
 TProof.cxx:4933
 TProof.cxx:4934
 TProof.cxx:4935
 TProof.cxx:4936
 TProof.cxx:4937
 TProof.cxx:4938
 TProof.cxx:4939
 TProof.cxx:4940
 TProof.cxx:4941
 TProof.cxx:4942
 TProof.cxx:4943
 TProof.cxx:4944
 TProof.cxx:4945
 TProof.cxx:4946
 TProof.cxx:4947
 TProof.cxx:4948
 TProof.cxx:4949
 TProof.cxx:4950
 TProof.cxx:4951
 TProof.cxx:4952
 TProof.cxx:4953
 TProof.cxx:4954
 TProof.cxx:4955
 TProof.cxx:4956
 TProof.cxx:4957
 TProof.cxx:4958
 TProof.cxx:4959
 TProof.cxx:4960
 TProof.cxx:4961
 TProof.cxx:4962
 TProof.cxx:4963
 TProof.cxx:4964
 TProof.cxx:4965
 TProof.cxx:4966
 TProof.cxx:4967
 TProof.cxx:4968
 TProof.cxx:4969
 TProof.cxx:4970
 TProof.cxx:4971
 TProof.cxx:4972
 TProof.cxx:4973
 TProof.cxx:4974
 TProof.cxx:4975
 TProof.cxx:4976
 TProof.cxx:4977
 TProof.cxx:4978
 TProof.cxx:4979
 TProof.cxx:4980
 TProof.cxx:4981
 TProof.cxx:4982
 TProof.cxx:4983
 TProof.cxx:4984
 TProof.cxx:4985
 TProof.cxx:4986
 TProof.cxx:4987
 TProof.cxx:4988
 TProof.cxx:4989
 TProof.cxx:4990
 TProof.cxx:4991
 TProof.cxx:4992
 TProof.cxx:4993
 TProof.cxx:4994
 TProof.cxx:4995
 TProof.cxx:4996
 TProof.cxx:4997
 TProof.cxx:4998
 TProof.cxx:4999
 TProof.cxx:5000
 TProof.cxx:5001
 TProof.cxx:5002
 TProof.cxx:5003
 TProof.cxx:5004
 TProof.cxx:5005
 TProof.cxx:5006
 TProof.cxx:5007
 TProof.cxx:5008
 TProof.cxx:5009
 TProof.cxx:5010
 TProof.cxx:5011
 TProof.cxx:5012
 TProof.cxx:5013
 TProof.cxx:5014
 TProof.cxx:5015
 TProof.cxx:5016
 TProof.cxx:5017
 TProof.cxx:5018
 TProof.cxx:5019
 TProof.cxx:5020
 TProof.cxx:5021
 TProof.cxx:5022
 TProof.cxx:5023
 TProof.cxx:5024
 TProof.cxx:5025
 TProof.cxx:5026
 TProof.cxx:5027
 TProof.cxx:5028
 TProof.cxx:5029
 TProof.cxx:5030
 TProof.cxx:5031
 TProof.cxx:5032
 TProof.cxx:5033
 TProof.cxx:5034
 TProof.cxx:5035
 TProof.cxx:5036
 TProof.cxx:5037
 TProof.cxx:5038
 TProof.cxx:5039
 TProof.cxx:5040
 TProof.cxx:5041
 TProof.cxx:5042
 TProof.cxx:5043
 TProof.cxx:5044
 TProof.cxx:5045
 TProof.cxx:5046
 TProof.cxx:5047
 TProof.cxx:5048
 TProof.cxx:5049
 TProof.cxx:5050
 TProof.cxx:5051
 TProof.cxx:5052
 TProof.cxx:5053
 TProof.cxx:5054
 TProof.cxx:5055
 TProof.cxx:5056
 TProof.cxx:5057
 TProof.cxx:5058
 TProof.cxx:5059
 TProof.cxx:5060
 TProof.cxx:5061
 TProof.cxx:5062
 TProof.cxx:5063
 TProof.cxx:5064
 TProof.cxx:5065
 TProof.cxx:5066
 TProof.cxx:5067
 TProof.cxx:5068
 TProof.cxx:5069
 TProof.cxx:5070
 TProof.cxx:5071
 TProof.cxx:5072
 TProof.cxx:5073
 TProof.cxx:5074
 TProof.cxx:5075
 TProof.cxx:5076
 TProof.cxx:5077
 TProof.cxx:5078
 TProof.cxx:5079
 TProof.cxx:5080
 TProof.cxx:5081
 TProof.cxx:5082
 TProof.cxx:5083
 TProof.cxx:5084
 TProof.cxx:5085
 TProof.cxx:5086
 TProof.cxx:5087
 TProof.cxx:5088
 TProof.cxx:5089
 TProof.cxx:5090
 TProof.cxx:5091
 TProof.cxx:5092
 TProof.cxx:5093
 TProof.cxx:5094
 TProof.cxx:5095
 TProof.cxx:5096
 TProof.cxx:5097
 TProof.cxx:5098
 TProof.cxx:5099
 TProof.cxx:5100
 TProof.cxx:5101
 TProof.cxx:5102
 TProof.cxx:5103
 TProof.cxx:5104
 TProof.cxx:5105
 TProof.cxx:5106
 TProof.cxx:5107
 TProof.cxx:5108
 TProof.cxx:5109
 TProof.cxx:5110
 TProof.cxx:5111
 TProof.cxx:5112
 TProof.cxx:5113
 TProof.cxx:5114
 TProof.cxx:5115
 TProof.cxx:5116
 TProof.cxx:5117
 TProof.cxx:5118
 TProof.cxx:5119
 TProof.cxx:5120
 TProof.cxx:5121
 TProof.cxx:5122
 TProof.cxx:5123
 TProof.cxx:5124
 TProof.cxx:5125
 TProof.cxx:5126
 TProof.cxx:5127
 TProof.cxx:5128
 TProof.cxx:5129
 TProof.cxx:5130
 TProof.cxx:5131
 TProof.cxx:5132
 TProof.cxx:5133
 TProof.cxx:5134
 TProof.cxx:5135
 TProof.cxx:5136
 TProof.cxx:5137
 TProof.cxx:5138
 TProof.cxx:5139
 TProof.cxx:5140
 TProof.cxx:5141
 TProof.cxx:5142
 TProof.cxx:5143
 TProof.cxx:5144
 TProof.cxx:5145
 TProof.cxx:5146
 TProof.cxx:5147
 TProof.cxx:5148
 TProof.cxx:5149
 TProof.cxx:5150
 TProof.cxx:5151
 TProof.cxx:5152
 TProof.cxx:5153
 TProof.cxx:5154
 TProof.cxx:5155
 TProof.cxx:5156
 TProof.cxx:5157
 TProof.cxx:5158
 TProof.cxx:5159
 TProof.cxx:5160
 TProof.cxx:5161
 TProof.cxx:5162
 TProof.cxx:5163
 TProof.cxx:5164
 TProof.cxx:5165
 TProof.cxx:5166
 TProof.cxx:5167
 TProof.cxx:5168
 TProof.cxx:5169
 TProof.cxx:5170
 TProof.cxx:5171
 TProof.cxx:5172
 TProof.cxx:5173
 TProof.cxx:5174
 TProof.cxx:5175
 TProof.cxx:5176
 TProof.cxx:5177
 TProof.cxx:5178
 TProof.cxx:5179
 TProof.cxx:5180
 TProof.cxx:5181
 TProof.cxx:5182
 TProof.cxx:5183
 TProof.cxx:5184
 TProof.cxx:5185
 TProof.cxx:5186
 TProof.cxx:5187
 TProof.cxx:5188
 TProof.cxx:5189
 TProof.cxx:5190
 TProof.cxx:5191
 TProof.cxx:5192
 TProof.cxx:5193
 TProof.cxx:5194
 TProof.cxx:5195
 TProof.cxx:5196
 TProof.cxx:5197
 TProof.cxx:5198
 TProof.cxx:5199
 TProof.cxx:5200
 TProof.cxx:5201
 TProof.cxx:5202
 TProof.cxx:5203
 TProof.cxx:5204
 TProof.cxx:5205
 TProof.cxx:5206
 TProof.cxx:5207
 TProof.cxx:5208
 TProof.cxx:5209
 TProof.cxx:5210
 TProof.cxx:5211
 TProof.cxx:5212
 TProof.cxx:5213
 TProof.cxx:5214
 TProof.cxx:5215
 TProof.cxx:5216
 TProof.cxx:5217
 TProof.cxx:5218
 TProof.cxx:5219
 TProof.cxx:5220
 TProof.cxx:5221
 TProof.cxx:5222
 TProof.cxx:5223
 TProof.cxx:5224
 TProof.cxx:5225
 TProof.cxx:5226
 TProof.cxx:5227
 TProof.cxx:5228
 TProof.cxx:5229
 TProof.cxx:5230
 TProof.cxx:5231
 TProof.cxx:5232
 TProof.cxx:5233
 TProof.cxx:5234
 TProof.cxx:5235
 TProof.cxx:5236
 TProof.cxx:5237
 TProof.cxx:5238
 TProof.cxx:5239
 TProof.cxx:5240
 TProof.cxx:5241
 TProof.cxx:5242
 TProof.cxx:5243
 TProof.cxx:5244
 TProof.cxx:5245
 TProof.cxx:5246
 TProof.cxx:5247
 TProof.cxx:5248
 TProof.cxx:5249
 TProof.cxx:5250
 TProof.cxx:5251
 TProof.cxx:5252
 TProof.cxx:5253
 TProof.cxx:5254
 TProof.cxx:5255
 TProof.cxx:5256
 TProof.cxx:5257
 TProof.cxx:5258
 TProof.cxx:5259
 TProof.cxx:5260
 TProof.cxx:5261
 TProof.cxx:5262
 TProof.cxx:5263
 TProof.cxx:5264
 TProof.cxx:5265
 TProof.cxx:5266
 TProof.cxx:5267
 TProof.cxx:5268
 TProof.cxx:5269
 TProof.cxx:5270
 TProof.cxx:5271
 TProof.cxx:5272
 TProof.cxx:5273
 TProof.cxx:5274
 TProof.cxx:5275
 TProof.cxx:5276
 TProof.cxx:5277
 TProof.cxx:5278
 TProof.cxx:5279
 TProof.cxx:5280
 TProof.cxx:5281
 TProof.cxx:5282
 TProof.cxx:5283
 TProof.cxx:5284
 TProof.cxx:5285
 TProof.cxx:5286
 TProof.cxx:5287
 TProof.cxx:5288
 TProof.cxx:5289
 TProof.cxx:5290
 TProof.cxx:5291
 TProof.cxx:5292
 TProof.cxx:5293
 TProof.cxx:5294
 TProof.cxx:5295
 TProof.cxx:5296
 TProof.cxx:5297
 TProof.cxx:5298
 TProof.cxx:5299
 TProof.cxx:5300
 TProof.cxx:5301
 TProof.cxx:5302
 TProof.cxx:5303
 TProof.cxx:5304
 TProof.cxx:5305
 TProof.cxx:5306
 TProof.cxx:5307
 TProof.cxx:5308
 TProof.cxx:5309
 TProof.cxx:5310
 TProof.cxx:5311
 TProof.cxx:5312
 TProof.cxx:5313
 TProof.cxx:5314
 TProof.cxx:5315
 TProof.cxx:5316
 TProof.cxx:5317
 TProof.cxx:5318
 TProof.cxx:5319
 TProof.cxx:5320
 TProof.cxx:5321
 TProof.cxx:5322
 TProof.cxx:5323
 TProof.cxx:5324
 TProof.cxx:5325
 TProof.cxx:5326
 TProof.cxx:5327
 TProof.cxx:5328
 TProof.cxx:5329
 TProof.cxx:5330
 TProof.cxx:5331
 TProof.cxx:5332
 TProof.cxx:5333
 TProof.cxx:5334
 TProof.cxx:5335
 TProof.cxx:5336
 TProof.cxx:5337
 TProof.cxx:5338
 TProof.cxx:5339
 TProof.cxx:5340
 TProof.cxx:5341
 TProof.cxx:5342
 TProof.cxx:5343
 TProof.cxx:5344
 TProof.cxx:5345
 TProof.cxx:5346
 TProof.cxx:5347
 TProof.cxx:5348
 TProof.cxx:5349
 TProof.cxx:5350
 TProof.cxx:5351
 TProof.cxx:5352
 TProof.cxx:5353
 TProof.cxx:5354
 TProof.cxx:5355
 TProof.cxx:5356
 TProof.cxx:5357
 TProof.cxx:5358
 TProof.cxx:5359
 TProof.cxx:5360
 TProof.cxx:5361
 TProof.cxx:5362
 TProof.cxx:5363
 TProof.cxx:5364
 TProof.cxx:5365
 TProof.cxx:5366
 TProof.cxx:5367
 TProof.cxx:5368
 TProof.cxx:5369
 TProof.cxx:5370
 TProof.cxx:5371
 TProof.cxx:5372
 TProof.cxx:5373
 TProof.cxx:5374
 TProof.cxx:5375
 TProof.cxx:5376
 TProof.cxx:5377
 TProof.cxx:5378
 TProof.cxx:5379
 TProof.cxx:5380
 TProof.cxx:5381
 TProof.cxx:5382
 TProof.cxx:5383
 TProof.cxx:5384
 TProof.cxx:5385
 TProof.cxx:5386
 TProof.cxx:5387
 TProof.cxx:5388
 TProof.cxx:5389
 TProof.cxx:5390
 TProof.cxx:5391
 TProof.cxx:5392
 TProof.cxx:5393
 TProof.cxx:5394
 TProof.cxx:5395
 TProof.cxx:5396
 TProof.cxx:5397
 TProof.cxx:5398
 TProof.cxx:5399
 TProof.cxx:5400
 TProof.cxx:5401
 TProof.cxx:5402
 TProof.cxx:5403
 TProof.cxx:5404
 TProof.cxx:5405
 TProof.cxx:5406
 TProof.cxx:5407
 TProof.cxx:5408
 TProof.cxx:5409
 TProof.cxx:5410
 TProof.cxx:5411
 TProof.cxx:5412
 TProof.cxx:5413
 TProof.cxx:5414
 TProof.cxx:5415
 TProof.cxx:5416
 TProof.cxx:5417
 TProof.cxx:5418
 TProof.cxx:5419
 TProof.cxx:5420
 TProof.cxx:5421
 TProof.cxx:5422
 TProof.cxx:5423
 TProof.cxx:5424
 TProof.cxx:5425
 TProof.cxx:5426
 TProof.cxx:5427
 TProof.cxx:5428
 TProof.cxx:5429
 TProof.cxx:5430
 TProof.cxx:5431
 TProof.cxx:5432
 TProof.cxx:5433
 TProof.cxx:5434
 TProof.cxx:5435
 TProof.cxx:5436
 TProof.cxx:5437
 TProof.cxx:5438
 TProof.cxx:5439
 TProof.cxx:5440
 TProof.cxx:5441
 TProof.cxx:5442
 TProof.cxx:5443
 TProof.cxx:5444
 TProof.cxx:5445
 TProof.cxx:5446
 TProof.cxx:5447
 TProof.cxx:5448
 TProof.cxx:5449
 TProof.cxx:5450
 TProof.cxx:5451
 TProof.cxx:5452
 TProof.cxx:5453
 TProof.cxx:5454
 TProof.cxx:5455
 TProof.cxx:5456
 TProof.cxx:5457
 TProof.cxx:5458
 TProof.cxx:5459
 TProof.cxx:5460
 TProof.cxx:5461
 TProof.cxx:5462
 TProof.cxx:5463
 TProof.cxx:5464
 TProof.cxx:5465
 TProof.cxx:5466
 TProof.cxx:5467
 TProof.cxx:5468
 TProof.cxx:5469
 TProof.cxx:5470
 TProof.cxx:5471
 TProof.cxx:5472
 TProof.cxx:5473
 TProof.cxx:5474
 TProof.cxx:5475
 TProof.cxx:5476
 TProof.cxx:5477
 TProof.cxx:5478
 TProof.cxx:5479
 TProof.cxx:5480
 TProof.cxx:5481
 TProof.cxx:5482
 TProof.cxx:5483
 TProof.cxx:5484
 TProof.cxx:5485
 TProof.cxx:5486
 TProof.cxx:5487
 TProof.cxx:5488
 TProof.cxx:5489
 TProof.cxx:5490
 TProof.cxx:5491
 TProof.cxx:5492
 TProof.cxx:5493
 TProof.cxx:5494
 TProof.cxx:5495
 TProof.cxx:5496
 TProof.cxx:5497
 TProof.cxx:5498
 TProof.cxx:5499
 TProof.cxx:5500
 TProof.cxx:5501
 TProof.cxx:5502
 TProof.cxx:5503
 TProof.cxx:5504
 TProof.cxx:5505
 TProof.cxx:5506
 TProof.cxx:5507
 TProof.cxx:5508
 TProof.cxx:5509
 TProof.cxx:5510
 TProof.cxx:5511
 TProof.cxx:5512
 TProof.cxx:5513
 TProof.cxx:5514
 TProof.cxx:5515
 TProof.cxx:5516
 TProof.cxx:5517
 TProof.cxx:5518
 TProof.cxx:5519
 TProof.cxx:5520
 TProof.cxx:5521
 TProof.cxx:5522
 TProof.cxx:5523
 TProof.cxx:5524
 TProof.cxx:5525
 TProof.cxx:5526
 TProof.cxx:5527
 TProof.cxx:5528
 TProof.cxx:5529
 TProof.cxx:5530
 TProof.cxx:5531
 TProof.cxx:5532
 TProof.cxx:5533
 TProof.cxx:5534
 TProof.cxx:5535
 TProof.cxx:5536
 TProof.cxx:5537
 TProof.cxx:5538
 TProof.cxx:5539
 TProof.cxx:5540
 TProof.cxx:5541
 TProof.cxx:5542
 TProof.cxx:5543
 TProof.cxx:5544
 TProof.cxx:5545
 TProof.cxx:5546
 TProof.cxx:5547
 TProof.cxx:5548
 TProof.cxx:5549
 TProof.cxx:5550
 TProof.cxx:5551
 TProof.cxx:5552
 TProof.cxx:5553
 TProof.cxx:5554
 TProof.cxx:5555
 TProof.cxx:5556
 TProof.cxx:5557
 TProof.cxx:5558
 TProof.cxx:5559
 TProof.cxx:5560
 TProof.cxx:5561
 TProof.cxx:5562
 TProof.cxx:5563
 TProof.cxx:5564
 TProof.cxx:5565
 TProof.cxx:5566
 TProof.cxx:5567
 TProof.cxx:5568
 TProof.cxx:5569
 TProof.cxx:5570
 TProof.cxx:5571
 TProof.cxx:5572
 TProof.cxx:5573
 TProof.cxx:5574
 TProof.cxx:5575
 TProof.cxx:5576
 TProof.cxx:5577
 TProof.cxx:5578
 TProof.cxx:5579
 TProof.cxx:5580
 TProof.cxx:5581
 TProof.cxx:5582
 TProof.cxx:5583
 TProof.cxx:5584
 TProof.cxx:5585
 TProof.cxx:5586
 TProof.cxx:5587
 TProof.cxx:5588
 TProof.cxx:5589
 TProof.cxx:5590
 TProof.cxx:5591
 TProof.cxx:5592
 TProof.cxx:5593
 TProof.cxx:5594
 TProof.cxx:5595
 TProof.cxx:5596
 TProof.cxx:5597
 TProof.cxx:5598
 TProof.cxx:5599
 TProof.cxx:5600
 TProof.cxx:5601
 TProof.cxx:5602
 TProof.cxx:5603
 TProof.cxx:5604
 TProof.cxx:5605
 TProof.cxx:5606
 TProof.cxx:5607
 TProof.cxx:5608
 TProof.cxx:5609
 TProof.cxx:5610
 TProof.cxx:5611
 TProof.cxx:5612
 TProof.cxx:5613
 TProof.cxx:5614
 TProof.cxx:5615
 TProof.cxx:5616
 TProof.cxx:5617
 TProof.cxx:5618
 TProof.cxx:5619
 TProof.cxx:5620
 TProof.cxx:5621
 TProof.cxx:5622
 TProof.cxx:5623
 TProof.cxx:5624
 TProof.cxx:5625
 TProof.cxx:5626
 TProof.cxx:5627
 TProof.cxx:5628
 TProof.cxx:5629
 TProof.cxx:5630
 TProof.cxx:5631
 TProof.cxx:5632
 TProof.cxx:5633
 TProof.cxx:5634
 TProof.cxx:5635
 TProof.cxx:5636
 TProof.cxx:5637
 TProof.cxx:5638
 TProof.cxx:5639
 TProof.cxx:5640
 TProof.cxx:5641
 TProof.cxx:5642
 TProof.cxx:5643
 TProof.cxx:5644
 TProof.cxx:5645
 TProof.cxx:5646
 TProof.cxx:5647
 TProof.cxx:5648
 TProof.cxx:5649
 TProof.cxx:5650
 TProof.cxx:5651
 TProof.cxx:5652
 TProof.cxx:5653
 TProof.cxx:5654
 TProof.cxx:5655
 TProof.cxx:5656
 TProof.cxx:5657
 TProof.cxx:5658
 TProof.cxx:5659
 TProof.cxx:5660
 TProof.cxx:5661
 TProof.cxx:5662
 TProof.cxx:5663
 TProof.cxx:5664
 TProof.cxx:5665
 TProof.cxx:5666
 TProof.cxx:5667
 TProof.cxx:5668
 TProof.cxx:5669
 TProof.cxx:5670
 TProof.cxx:5671
 TProof.cxx:5672
 TProof.cxx:5673
 TProof.cxx:5674
 TProof.cxx:5675
 TProof.cxx:5676
 TProof.cxx:5677
 TProof.cxx:5678
 TProof.cxx:5679
 TProof.cxx:5680
 TProof.cxx:5681
 TProof.cxx:5682
 TProof.cxx:5683
 TProof.cxx:5684
 TProof.cxx:5685
 TProof.cxx:5686
 TProof.cxx:5687
 TProof.cxx:5688
 TProof.cxx:5689
 TProof.cxx:5690
 TProof.cxx:5691
 TProof.cxx:5692
 TProof.cxx:5693
 TProof.cxx:5694
 TProof.cxx:5695
 TProof.cxx:5696
 TProof.cxx:5697
 TProof.cxx:5698
 TProof.cxx:5699
 TProof.cxx:5700
 TProof.cxx:5701
 TProof.cxx:5702
 TProof.cxx:5703
 TProof.cxx:5704
 TProof.cxx:5705
 TProof.cxx:5706
 TProof.cxx:5707
 TProof.cxx:5708
 TProof.cxx:5709
 TProof.cxx:5710
 TProof.cxx:5711
 TProof.cxx:5712
 TProof.cxx:5713
 TProof.cxx:5714
 TProof.cxx:5715
 TProof.cxx:5716
 TProof.cxx:5717
 TProof.cxx:5718
 TProof.cxx:5719
 TProof.cxx:5720
 TProof.cxx:5721
 TProof.cxx:5722
 TProof.cxx:5723
 TProof.cxx:5724
 TProof.cxx:5725
 TProof.cxx:5726
 TProof.cxx:5727
 TProof.cxx:5728
 TProof.cxx:5729
 TProof.cxx:5730
 TProof.cxx:5731
 TProof.cxx:5732
 TProof.cxx:5733
 TProof.cxx:5734
 TProof.cxx:5735
 TProof.cxx:5736
 TProof.cxx:5737
 TProof.cxx:5738
 TProof.cxx:5739
 TProof.cxx:5740
 TProof.cxx:5741
 TProof.cxx:5742
 TProof.cxx:5743
 TProof.cxx:5744
 TProof.cxx:5745
 TProof.cxx:5746
 TProof.cxx:5747
 TProof.cxx:5748
 TProof.cxx:5749
 TProof.cxx:5750
 TProof.cxx:5751
 TProof.cxx:5752
 TProof.cxx:5753
 TProof.cxx:5754
 TProof.cxx:5755
 TProof.cxx:5756
 TProof.cxx:5757
 TProof.cxx:5758
 TProof.cxx:5759
 TProof.cxx:5760
 TProof.cxx:5761
 TProof.cxx:5762
 TProof.cxx:5763
 TProof.cxx:5764
 TProof.cxx:5765
 TProof.cxx:5766
 TProof.cxx:5767
 TProof.cxx:5768
 TProof.cxx:5769
 TProof.cxx:5770
 TProof.cxx:5771
 TProof.cxx:5772
 TProof.cxx:5773
 TProof.cxx:5774
 TProof.cxx:5775
 TProof.cxx:5776
 TProof.cxx:5777
 TProof.cxx:5778
 TProof.cxx:5779
 TProof.cxx:5780
 TProof.cxx:5781
 TProof.cxx:5782
 TProof.cxx:5783
 TProof.cxx:5784
 TProof.cxx:5785
 TProof.cxx:5786
 TProof.cxx:5787
 TProof.cxx:5788
 TProof.cxx:5789
 TProof.cxx:5790
 TProof.cxx:5791
 TProof.cxx:5792
 TProof.cxx:5793
 TProof.cxx:5794
 TProof.cxx:5795
 TProof.cxx:5796
 TProof.cxx:5797
 TProof.cxx:5798
 TProof.cxx:5799
 TProof.cxx:5800
 TProof.cxx:5801
 TProof.cxx:5802
 TProof.cxx:5803
 TProof.cxx:5804
 TProof.cxx:5805
 TProof.cxx:5806
 TProof.cxx:5807
 TProof.cxx:5808
 TProof.cxx:5809
 TProof.cxx:5810
 TProof.cxx:5811
 TProof.cxx:5812
 TProof.cxx:5813
 TProof.cxx:5814
 TProof.cxx:5815
 TProof.cxx:5816
 TProof.cxx:5817
 TProof.cxx:5818
 TProof.cxx:5819
 TProof.cxx:5820
 TProof.cxx:5821
 TProof.cxx:5822
 TProof.cxx:5823
 TProof.cxx:5824
 TProof.cxx:5825
 TProof.cxx:5826
 TProof.cxx:5827
 TProof.cxx:5828
 TProof.cxx:5829
 TProof.cxx:5830
 TProof.cxx:5831
 TProof.cxx:5832
 TProof.cxx:5833
 TProof.cxx:5834
 TProof.cxx:5835
 TProof.cxx:5836
 TProof.cxx:5837
 TProof.cxx:5838
 TProof.cxx:5839
 TProof.cxx:5840
 TProof.cxx:5841
 TProof.cxx:5842
 TProof.cxx:5843
 TProof.cxx:5844
 TProof.cxx:5845
 TProof.cxx:5846
 TProof.cxx:5847
 TProof.cxx:5848
 TProof.cxx:5849
 TProof.cxx:5850
 TProof.cxx:5851
 TProof.cxx:5852
 TProof.cxx:5853
 TProof.cxx:5854
 TProof.cxx:5855
 TProof.cxx:5856
 TProof.cxx:5857
 TProof.cxx:5858
 TProof.cxx:5859
 TProof.cxx:5860
 TProof.cxx:5861
 TProof.cxx:5862
 TProof.cxx:5863
 TProof.cxx:5864
 TProof.cxx:5865
 TProof.cxx:5866
 TProof.cxx:5867
 TProof.cxx:5868
 TProof.cxx:5869
 TProof.cxx:5870
 TProof.cxx:5871
 TProof.cxx:5872
 TProof.cxx:5873
 TProof.cxx:5874
 TProof.cxx:5875
 TProof.cxx:5876
 TProof.cxx:5877
 TProof.cxx:5878
 TProof.cxx:5879
 TProof.cxx:5880
 TProof.cxx:5881
 TProof.cxx:5882
 TProof.cxx:5883
 TProof.cxx:5884
 TProof.cxx:5885
 TProof.cxx:5886
 TProof.cxx:5887
 TProof.cxx:5888
 TProof.cxx:5889
 TProof.cxx:5890
 TProof.cxx:5891
 TProof.cxx:5892
 TProof.cxx:5893
 TProof.cxx:5894
 TProof.cxx:5895
 TProof.cxx:5896
 TProof.cxx:5897
 TProof.cxx:5898
 TProof.cxx:5899
 TProof.cxx:5900
 TProof.cxx:5901
 TProof.cxx:5902
 TProof.cxx:5903
 TProof.cxx:5904
 TProof.cxx:5905
 TProof.cxx:5906
 TProof.cxx:5907
 TProof.cxx:5908
 TProof.cxx:5909
 TProof.cxx:5910
 TProof.cxx:5911
 TProof.cxx:5912
 TProof.cxx:5913
 TProof.cxx:5914
 TProof.cxx:5915
 TProof.cxx:5916
 TProof.cxx:5917
 TProof.cxx:5918
 TProof.cxx:5919
 TProof.cxx:5920
 TProof.cxx:5921
 TProof.cxx:5922
 TProof.cxx:5923
 TProof.cxx:5924
 TProof.cxx:5925
 TProof.cxx:5926
 TProof.cxx:5927
 TProof.cxx:5928
 TProof.cxx:5929
 TProof.cxx:5930
 TProof.cxx:5931
 TProof.cxx:5932
 TProof.cxx:5933
 TProof.cxx:5934
 TProof.cxx:5935
 TProof.cxx:5936
 TProof.cxx:5937
 TProof.cxx:5938
 TProof.cxx:5939
 TProof.cxx:5940
 TProof.cxx:5941
 TProof.cxx:5942
 TProof.cxx:5943
 TProof.cxx:5944
 TProof.cxx:5945
 TProof.cxx:5946
 TProof.cxx:5947
 TProof.cxx:5948
 TProof.cxx:5949
 TProof.cxx:5950
 TProof.cxx:5951
 TProof.cxx:5952
 TProof.cxx:5953
 TProof.cxx:5954
 TProof.cxx:5955
 TProof.cxx:5956
 TProof.cxx:5957
 TProof.cxx:5958
 TProof.cxx:5959
 TProof.cxx:5960
 TProof.cxx:5961
 TProof.cxx:5962
 TProof.cxx:5963
 TProof.cxx:5964
 TProof.cxx:5965
 TProof.cxx:5966
 TProof.cxx:5967
 TProof.cxx:5968
 TProof.cxx:5969
 TProof.cxx:5970
 TProof.cxx:5971
 TProof.cxx:5972
 TProof.cxx:5973
 TProof.cxx:5974
 TProof.cxx:5975
 TProof.cxx:5976
 TProof.cxx:5977
 TProof.cxx:5978
 TProof.cxx:5979
 TProof.cxx:5980
 TProof.cxx:5981
 TProof.cxx:5982
 TProof.cxx:5983
 TProof.cxx:5984
 TProof.cxx:5985
 TProof.cxx:5986
 TProof.cxx:5987
 TProof.cxx:5988
 TProof.cxx:5989
 TProof.cxx:5990
 TProof.cxx:5991
 TProof.cxx:5992
 TProof.cxx:5993
 TProof.cxx:5994
 TProof.cxx:5995
 TProof.cxx:5996
 TProof.cxx:5997
 TProof.cxx:5998
 TProof.cxx:5999
 TProof.cxx:6000
 TProof.cxx:6001
 TProof.cxx:6002
 TProof.cxx:6003
 TProof.cxx:6004
 TProof.cxx:6005
 TProof.cxx:6006
 TProof.cxx:6007
 TProof.cxx:6008
 TProof.cxx:6009
 TProof.cxx:6010
 TProof.cxx:6011
 TProof.cxx:6012
 TProof.cxx:6013
 TProof.cxx:6014
 TProof.cxx:6015
 TProof.cxx:6016
 TProof.cxx:6017
 TProof.cxx:6018
 TProof.cxx:6019
 TProof.cxx:6020
 TProof.cxx:6021
 TProof.cxx:6022
 TProof.cxx:6023
 TProof.cxx:6024
 TProof.cxx:6025
 TProof.cxx:6026
 TProof.cxx:6027
 TProof.cxx:6028
 TProof.cxx:6029
 TProof.cxx:6030
 TProof.cxx:6031
 TProof.cxx:6032
 TProof.cxx:6033
 TProof.cxx:6034
 TProof.cxx:6035
 TProof.cxx:6036
 TProof.cxx:6037
 TProof.cxx:6038
 TProof.cxx:6039
 TProof.cxx:6040
 TProof.cxx:6041
 TProof.cxx:6042
 TProof.cxx:6043
 TProof.cxx:6044
 TProof.cxx:6045
 TProof.cxx:6046
 TProof.cxx:6047
 TProof.cxx:6048
 TProof.cxx:6049
 TProof.cxx:6050
 TProof.cxx:6051
 TProof.cxx:6052
 TProof.cxx:6053
 TProof.cxx:6054
 TProof.cxx:6055
 TProof.cxx:6056
 TProof.cxx:6057
 TProof.cxx:6058
 TProof.cxx:6059
 TProof.cxx:6060
 TProof.cxx:6061
 TProof.cxx:6062
 TProof.cxx:6063
 TProof.cxx:6064
 TProof.cxx:6065
 TProof.cxx:6066
 TProof.cxx:6067
 TProof.cxx:6068
 TProof.cxx:6069
 TProof.cxx:6070
 TProof.cxx:6071
 TProof.cxx:6072
 TProof.cxx:6073
 TProof.cxx:6074
 TProof.cxx:6075
 TProof.cxx:6076
 TProof.cxx:6077
 TProof.cxx:6078
 TProof.cxx:6079
 TProof.cxx:6080
 TProof.cxx:6081
 TProof.cxx:6082
 TProof.cxx:6083
 TProof.cxx:6084
 TProof.cxx:6085
 TProof.cxx:6086
 TProof.cxx:6087
 TProof.cxx:6088
 TProof.cxx:6089
 TProof.cxx:6090
 TProof.cxx:6091
 TProof.cxx:6092
 TProof.cxx:6093
 TProof.cxx:6094
 TProof.cxx:6095
 TProof.cxx:6096
 TProof.cxx:6097
 TProof.cxx:6098
 TProof.cxx:6099
 TProof.cxx:6100
 TProof.cxx:6101
 TProof.cxx:6102
 TProof.cxx:6103
 TProof.cxx:6104
 TProof.cxx:6105
 TProof.cxx:6106
 TProof.cxx:6107
 TProof.cxx:6108
 TProof.cxx:6109
 TProof.cxx:6110
 TProof.cxx:6111
 TProof.cxx:6112
 TProof.cxx:6113
 TProof.cxx:6114
 TProof.cxx:6115
 TProof.cxx:6116
 TProof.cxx:6117
 TProof.cxx:6118
 TProof.cxx:6119
 TProof.cxx:6120
 TProof.cxx:6121
 TProof.cxx:6122
 TProof.cxx:6123
 TProof.cxx:6124
 TProof.cxx:6125
 TProof.cxx:6126
 TProof.cxx:6127
 TProof.cxx:6128
 TProof.cxx:6129
 TProof.cxx:6130
 TProof.cxx:6131
 TProof.cxx:6132
 TProof.cxx:6133
 TProof.cxx:6134
 TProof.cxx:6135
 TProof.cxx:6136
 TProof.cxx:6137
 TProof.cxx:6138
 TProof.cxx:6139
 TProof.cxx:6140
 TProof.cxx:6141
 TProof.cxx:6142
 TProof.cxx:6143
 TProof.cxx:6144
 TProof.cxx:6145
 TProof.cxx:6146
 TProof.cxx:6147
 TProof.cxx:6148
 TProof.cxx:6149
 TProof.cxx:6150
 TProof.cxx:6151
 TProof.cxx:6152
 TProof.cxx:6153
 TProof.cxx:6154
 TProof.cxx:6155
 TProof.cxx:6156
 TProof.cxx:6157
 TProof.cxx:6158
 TProof.cxx:6159
 TProof.cxx:6160
 TProof.cxx:6161
 TProof.cxx:6162
 TProof.cxx:6163
 TProof.cxx:6164
 TProof.cxx:6165
 TProof.cxx:6166
 TProof.cxx:6167
 TProof.cxx:6168
 TProof.cxx:6169
 TProof.cxx:6170
 TProof.cxx:6171
 TProof.cxx:6172
 TProof.cxx:6173
 TProof.cxx:6174
 TProof.cxx:6175
 TProof.cxx:6176
 TProof.cxx:6177
 TProof.cxx:6178
 TProof.cxx:6179
 TProof.cxx:6180
 TProof.cxx:6181
 TProof.cxx:6182
 TProof.cxx:6183
 TProof.cxx:6184
 TProof.cxx:6185
 TProof.cxx:6186
 TProof.cxx:6187
 TProof.cxx:6188
 TProof.cxx:6189
 TProof.cxx:6190
 TProof.cxx:6191
 TProof.cxx:6192
 TProof.cxx:6193
 TProof.cxx:6194
 TProof.cxx:6195
 TProof.cxx:6196
 TProof.cxx:6197
 TProof.cxx:6198
 TProof.cxx:6199
 TProof.cxx:6200
 TProof.cxx:6201
 TProof.cxx:6202
 TProof.cxx:6203
 TProof.cxx:6204
 TProof.cxx:6205
 TProof.cxx:6206
 TProof.cxx:6207
 TProof.cxx:6208
 TProof.cxx:6209
 TProof.cxx:6210
 TProof.cxx:6211
 TProof.cxx:6212
 TProof.cxx:6213
 TProof.cxx:6214
 TProof.cxx:6215
 TProof.cxx:6216
 TProof.cxx:6217
 TProof.cxx:6218
 TProof.cxx:6219
 TProof.cxx:6220
 TProof.cxx:6221
 TProof.cxx:6222
 TProof.cxx:6223
 TProof.cxx:6224
 TProof.cxx:6225
 TProof.cxx:6226
 TProof.cxx:6227
 TProof.cxx:6228
 TProof.cxx:6229
 TProof.cxx:6230
 TProof.cxx:6231
 TProof.cxx:6232
 TProof.cxx:6233
 TProof.cxx:6234
 TProof.cxx:6235
 TProof.cxx:6236
 TProof.cxx:6237
 TProof.cxx:6238
 TProof.cxx:6239
 TProof.cxx:6240
 TProof.cxx:6241
 TProof.cxx:6242
 TProof.cxx:6243
 TProof.cxx:6244
 TProof.cxx:6245
 TProof.cxx:6246
 TProof.cxx:6247
 TProof.cxx:6248
 TProof.cxx:6249
 TProof.cxx:6250
 TProof.cxx:6251
 TProof.cxx:6252
 TProof.cxx:6253
 TProof.cxx:6254
 TProof.cxx:6255
 TProof.cxx:6256
 TProof.cxx:6257
 TProof.cxx:6258
 TProof.cxx:6259
 TProof.cxx:6260
 TProof.cxx:6261
 TProof.cxx:6262
 TProof.cxx:6263
 TProof.cxx:6264
 TProof.cxx:6265
 TProof.cxx:6266
 TProof.cxx:6267
 TProof.cxx:6268
 TProof.cxx:6269
 TProof.cxx:6270
 TProof.cxx:6271
 TProof.cxx:6272
 TProof.cxx:6273
 TProof.cxx:6274
 TProof.cxx:6275
 TProof.cxx:6276
 TProof.cxx:6277
 TProof.cxx:6278
 TProof.cxx:6279
 TProof.cxx:6280
 TProof.cxx:6281
 TProof.cxx:6282
 TProof.cxx:6283
 TProof.cxx:6284
 TProof.cxx:6285
 TProof.cxx:6286
 TProof.cxx:6287
 TProof.cxx:6288
 TProof.cxx:6289
 TProof.cxx:6290
 TProof.cxx:6291
 TProof.cxx:6292
 TProof.cxx:6293
 TProof.cxx:6294
 TProof.cxx:6295
 TProof.cxx:6296
 TProof.cxx:6297
 TProof.cxx:6298
 TProof.cxx:6299
 TProof.cxx:6300
 TProof.cxx:6301
 TProof.cxx:6302
 TProof.cxx:6303
 TProof.cxx:6304
 TProof.cxx:6305
 TProof.cxx:6306
 TProof.cxx:6307
 TProof.cxx:6308
 TProof.cxx:6309
 TProof.cxx:6310
 TProof.cxx:6311
 TProof.cxx:6312
 TProof.cxx:6313
 TProof.cxx:6314
 TProof.cxx:6315
 TProof.cxx:6316
 TProof.cxx:6317
 TProof.cxx:6318
 TProof.cxx:6319
 TProof.cxx:6320
 TProof.cxx:6321
 TProof.cxx:6322
 TProof.cxx:6323
 TProof.cxx:6324
 TProof.cxx:6325
 TProof.cxx:6326
 TProof.cxx:6327
 TProof.cxx:6328
 TProof.cxx:6329
 TProof.cxx:6330
 TProof.cxx:6331
 TProof.cxx:6332
 TProof.cxx:6333
 TProof.cxx:6334
 TProof.cxx:6335
 TProof.cxx:6336
 TProof.cxx:6337
 TProof.cxx:6338
 TProof.cxx:6339
 TProof.cxx:6340
 TProof.cxx:6341
 TProof.cxx:6342
 TProof.cxx:6343
 TProof.cxx:6344
 TProof.cxx:6345
 TProof.cxx:6346
 TProof.cxx:6347
 TProof.cxx:6348
 TProof.cxx:6349
 TProof.cxx:6350
 TProof.cxx:6351
 TProof.cxx:6352
 TProof.cxx:6353
 TProof.cxx:6354
 TProof.cxx:6355
 TProof.cxx:6356
 TProof.cxx:6357
 TProof.cxx:6358
 TProof.cxx:6359
 TProof.cxx:6360
 TProof.cxx:6361
 TProof.cxx:6362
 TProof.cxx:6363
 TProof.cxx:6364
 TProof.cxx:6365
 TProof.cxx:6366
 TProof.cxx:6367
 TProof.cxx:6368
 TProof.cxx:6369
 TProof.cxx:6370
 TProof.cxx:6371
 TProof.cxx:6372
 TProof.cxx:6373
 TProof.cxx:6374
 TProof.cxx:6375
 TProof.cxx:6376
 TProof.cxx:6377
 TProof.cxx:6378
 TProof.cxx:6379
 TProof.cxx:6380
 TProof.cxx:6381
 TProof.cxx:6382
 TProof.cxx:6383
 TProof.cxx:6384
 TProof.cxx:6385
 TProof.cxx:6386
 TProof.cxx:6387
 TProof.cxx:6388
 TProof.cxx:6389
 TProof.cxx:6390
 TProof.cxx:6391
 TProof.cxx:6392
 TProof.cxx:6393
 TProof.cxx:6394
 TProof.cxx:6395
 TProof.cxx:6396
 TProof.cxx:6397
 TProof.cxx:6398
 TProof.cxx:6399
 TProof.cxx:6400
 TProof.cxx:6401
 TProof.cxx:6402
 TProof.cxx:6403
 TProof.cxx:6404
 TProof.cxx:6405
 TProof.cxx:6406
 TProof.cxx:6407
 TProof.cxx:6408
 TProof.cxx:6409
 TProof.cxx:6410
 TProof.cxx:6411
 TProof.cxx:6412
 TProof.cxx:6413
 TProof.cxx:6414
 TProof.cxx:6415
 TProof.cxx:6416
 TProof.cxx:6417
 TProof.cxx:6418
 TProof.cxx:6419
 TProof.cxx:6420
 TProof.cxx:6421
 TProof.cxx:6422
 TProof.cxx:6423
 TProof.cxx:6424
 TProof.cxx:6425
 TProof.cxx:6426
 TProof.cxx:6427
 TProof.cxx:6428
 TProof.cxx:6429
 TProof.cxx:6430
 TProof.cxx:6431
 TProof.cxx:6432
 TProof.cxx:6433
 TProof.cxx:6434
 TProof.cxx:6435
 TProof.cxx:6436
 TProof.cxx:6437
 TProof.cxx:6438
 TProof.cxx:6439
 TProof.cxx:6440
 TProof.cxx:6441
 TProof.cxx:6442
 TProof.cxx:6443
 TProof.cxx:6444
 TProof.cxx:6445
 TProof.cxx:6446
 TProof.cxx:6447
 TProof.cxx:6448
 TProof.cxx:6449
 TProof.cxx:6450
 TProof.cxx:6451
 TProof.cxx:6452
 TProof.cxx:6453
 TProof.cxx:6454
 TProof.cxx:6455
 TProof.cxx:6456
 TProof.cxx:6457
 TProof.cxx:6458
 TProof.cxx:6459
 TProof.cxx:6460
 TProof.cxx:6461
 TProof.cxx:6462
 TProof.cxx:6463
 TProof.cxx:6464
 TProof.cxx:6465
 TProof.cxx:6466
 TProof.cxx:6467
 TProof.cxx:6468
 TProof.cxx:6469
 TProof.cxx:6470
 TProof.cxx:6471
 TProof.cxx:6472
 TProof.cxx:6473
 TProof.cxx:6474
 TProof.cxx:6475
 TProof.cxx:6476
 TProof.cxx:6477
 TProof.cxx:6478
 TProof.cxx:6479
 TProof.cxx:6480
 TProof.cxx:6481
 TProof.cxx:6482
 TProof.cxx:6483
 TProof.cxx:6484
 TProof.cxx:6485
 TProof.cxx:6486
 TProof.cxx:6487
 TProof.cxx:6488
 TProof.cxx:6489
 TProof.cxx:6490
 TProof.cxx:6491
 TProof.cxx:6492
 TProof.cxx:6493
 TProof.cxx:6494
 TProof.cxx:6495
 TProof.cxx:6496
 TProof.cxx:6497
 TProof.cxx:6498
 TProof.cxx:6499
 TProof.cxx:6500
 TProof.cxx:6501
 TProof.cxx:6502
 TProof.cxx:6503
 TProof.cxx:6504
 TProof.cxx:6505
 TProof.cxx:6506
 TProof.cxx:6507
 TProof.cxx:6508
 TProof.cxx:6509
 TProof.cxx:6510
 TProof.cxx:6511
 TProof.cxx:6512
 TProof.cxx:6513
 TProof.cxx:6514
 TProof.cxx:6515
 TProof.cxx:6516
 TProof.cxx:6517
 TProof.cxx:6518
 TProof.cxx:6519
 TProof.cxx:6520
 TProof.cxx:6521
 TProof.cxx:6522
 TProof.cxx:6523
 TProof.cxx:6524
 TProof.cxx:6525
 TProof.cxx:6526
 TProof.cxx:6527
 TProof.cxx:6528
 TProof.cxx:6529
 TProof.cxx:6530
 TProof.cxx:6531
 TProof.cxx:6532
 TProof.cxx:6533
 TProof.cxx:6534
 TProof.cxx:6535
 TProof.cxx:6536
 TProof.cxx:6537
 TProof.cxx:6538
 TProof.cxx:6539
 TProof.cxx:6540
 TProof.cxx:6541
 TProof.cxx:6542
 TProof.cxx:6543
 TProof.cxx:6544
 TProof.cxx:6545
 TProof.cxx:6546
 TProof.cxx:6547
 TProof.cxx:6548
 TProof.cxx:6549
 TProof.cxx:6550
 TProof.cxx:6551
 TProof.cxx:6552
 TProof.cxx:6553
 TProof.cxx:6554
 TProof.cxx:6555
 TProof.cxx:6556
 TProof.cxx:6557
 TProof.cxx:6558
 TProof.cxx:6559
 TProof.cxx:6560
 TProof.cxx:6561
 TProof.cxx:6562
 TProof.cxx:6563
 TProof.cxx:6564
 TProof.cxx:6565
 TProof.cxx:6566
 TProof.cxx:6567
 TProof.cxx:6568
 TProof.cxx:6569
 TProof.cxx:6570
 TProof.cxx:6571
 TProof.cxx:6572
 TProof.cxx:6573
 TProof.cxx:6574
 TProof.cxx:6575
 TProof.cxx:6576
 TProof.cxx:6577
 TProof.cxx:6578
 TProof.cxx:6579
 TProof.cxx:6580
 TProof.cxx:6581
 TProof.cxx:6582
 TProof.cxx:6583
 TProof.cxx:6584
 TProof.cxx:6585
 TProof.cxx:6586
 TProof.cxx:6587
 TProof.cxx:6588
 TProof.cxx:6589
 TProof.cxx:6590
 TProof.cxx:6591
 TProof.cxx:6592
 TProof.cxx:6593
 TProof.cxx:6594
 TProof.cxx:6595
 TProof.cxx:6596
 TProof.cxx:6597
 TProof.cxx:6598
 TProof.cxx:6599
 TProof.cxx:6600
 TProof.cxx:6601
 TProof.cxx:6602
 TProof.cxx:6603
 TProof.cxx:6604
 TProof.cxx:6605
 TProof.cxx:6606
 TProof.cxx:6607
 TProof.cxx:6608
 TProof.cxx:6609
 TProof.cxx:6610
 TProof.cxx:6611
 TProof.cxx:6612
 TProof.cxx:6613
 TProof.cxx:6614
 TProof.cxx:6615
 TProof.cxx:6616
 TProof.cxx:6617
 TProof.cxx:6618
 TProof.cxx:6619
 TProof.cxx:6620
 TProof.cxx:6621
 TProof.cxx:6622
 TProof.cxx:6623
 TProof.cxx:6624
 TProof.cxx:6625
 TProof.cxx:6626
 TProof.cxx:6627
 TProof.cxx:6628
 TProof.cxx:6629
 TProof.cxx:6630
 TProof.cxx:6631
 TProof.cxx:6632
 TProof.cxx:6633
 TProof.cxx:6634
 TProof.cxx:6635
 TProof.cxx:6636
 TProof.cxx:6637
 TProof.cxx:6638
 TProof.cxx:6639
 TProof.cxx:6640
 TProof.cxx:6641
 TProof.cxx:6642
 TProof.cxx:6643
 TProof.cxx:6644
 TProof.cxx:6645
 TProof.cxx:6646
 TProof.cxx:6647
 TProof.cxx:6648
 TProof.cxx:6649
 TProof.cxx:6650
 TProof.cxx:6651
 TProof.cxx:6652
 TProof.cxx:6653
 TProof.cxx:6654
 TProof.cxx:6655
 TProof.cxx:6656
 TProof.cxx:6657
 TProof.cxx:6658
 TProof.cxx:6659
 TProof.cxx:6660
 TProof.cxx:6661
 TProof.cxx:6662
 TProof.cxx:6663
 TProof.cxx:6664
 TProof.cxx:6665
 TProof.cxx:6666
 TProof.cxx:6667
 TProof.cxx:6668
 TProof.cxx:6669
 TProof.cxx:6670
 TProof.cxx:6671
 TProof.cxx:6672
 TProof.cxx:6673
 TProof.cxx:6674
 TProof.cxx:6675
 TProof.cxx:6676
 TProof.cxx:6677
 TProof.cxx:6678
 TProof.cxx:6679
 TProof.cxx:6680
 TProof.cxx:6681
 TProof.cxx:6682
 TProof.cxx:6683
 TProof.cxx:6684
 TProof.cxx:6685
 TProof.cxx:6686
 TProof.cxx:6687
 TProof.cxx:6688
 TProof.cxx:6689
 TProof.cxx:6690
 TProof.cxx:6691
 TProof.cxx:6692
 TProof.cxx:6693
 TProof.cxx:6694
 TProof.cxx:6695
 TProof.cxx:6696
 TProof.cxx:6697
 TProof.cxx:6698
 TProof.cxx:6699
 TProof.cxx:6700
 TProof.cxx:6701
 TProof.cxx:6702
 TProof.cxx:6703
 TProof.cxx:6704
 TProof.cxx:6705
 TProof.cxx:6706
 TProof.cxx:6707
 TProof.cxx:6708
 TProof.cxx:6709
 TProof.cxx:6710
 TProof.cxx:6711
 TProof.cxx:6712
 TProof.cxx:6713
 TProof.cxx:6714
 TProof.cxx:6715
 TProof.cxx:6716
 TProof.cxx:6717
 TProof.cxx:6718
 TProof.cxx:6719
 TProof.cxx:6720
 TProof.cxx:6721
 TProof.cxx:6722
 TProof.cxx:6723
 TProof.cxx:6724
 TProof.cxx:6725
 TProof.cxx:6726
 TProof.cxx:6727
 TProof.cxx:6728
 TProof.cxx:6729
 TProof.cxx:6730
 TProof.cxx:6731
 TProof.cxx:6732
 TProof.cxx:6733
 TProof.cxx:6734
 TProof.cxx:6735
 TProof.cxx:6736
 TProof.cxx:6737
 TProof.cxx:6738
 TProof.cxx:6739
 TProof.cxx:6740
 TProof.cxx:6741
 TProof.cxx:6742
 TProof.cxx:6743
 TProof.cxx:6744
 TProof.cxx:6745
 TProof.cxx:6746
 TProof.cxx:6747
 TProof.cxx:6748
 TProof.cxx:6749
 TProof.cxx:6750
 TProof.cxx:6751
 TProof.cxx:6752
 TProof.cxx:6753
 TProof.cxx:6754
 TProof.cxx:6755
 TProof.cxx:6756
 TProof.cxx:6757
 TProof.cxx:6758
 TProof.cxx:6759
 TProof.cxx:6760
 TProof.cxx:6761
 TProof.cxx:6762
 TProof.cxx:6763
 TProof.cxx:6764
 TProof.cxx:6765
 TProof.cxx:6766
 TProof.cxx:6767
 TProof.cxx:6768
 TProof.cxx:6769
 TProof.cxx:6770
 TProof.cxx:6771
 TProof.cxx:6772
 TProof.cxx:6773
 TProof.cxx:6774
 TProof.cxx:6775
 TProof.cxx:6776
 TProof.cxx:6777
 TProof.cxx:6778
 TProof.cxx:6779
 TProof.cxx:6780
 TProof.cxx:6781
 TProof.cxx:6782
 TProof.cxx:6783
 TProof.cxx:6784
 TProof.cxx:6785
 TProof.cxx:6786
 TProof.cxx:6787
 TProof.cxx:6788
 TProof.cxx:6789
 TProof.cxx:6790
 TProof.cxx:6791
 TProof.cxx:6792
 TProof.cxx:6793
 TProof.cxx:6794
 TProof.cxx:6795
 TProof.cxx:6796
 TProof.cxx:6797
 TProof.cxx:6798
 TProof.cxx:6799
 TProof.cxx:6800
 TProof.cxx:6801
 TProof.cxx:6802
 TProof.cxx:6803
 TProof.cxx:6804
 TProof.cxx:6805
 TProof.cxx:6806
 TProof.cxx:6807
 TProof.cxx:6808
 TProof.cxx:6809
 TProof.cxx:6810
 TProof.cxx:6811
 TProof.cxx:6812
 TProof.cxx:6813
 TProof.cxx:6814
 TProof.cxx:6815
 TProof.cxx:6816
 TProof.cxx:6817
 TProof.cxx:6818
 TProof.cxx:6819
 TProof.cxx:6820
 TProof.cxx:6821
 TProof.cxx:6822
 TProof.cxx:6823
 TProof.cxx:6824
 TProof.cxx:6825
 TProof.cxx:6826
 TProof.cxx:6827
 TProof.cxx:6828
 TProof.cxx:6829
 TProof.cxx:6830
 TProof.cxx:6831
 TProof.cxx:6832
 TProof.cxx:6833
 TProof.cxx:6834
 TProof.cxx:6835
 TProof.cxx:6836
 TProof.cxx:6837
 TProof.cxx:6838
 TProof.cxx:6839
 TProof.cxx:6840
 TProof.cxx:6841
 TProof.cxx:6842
 TProof.cxx:6843
 TProof.cxx:6844
 TProof.cxx:6845
 TProof.cxx:6846
 TProof.cxx:6847
 TProof.cxx:6848
 TProof.cxx:6849
 TProof.cxx:6850
 TProof.cxx:6851
 TProof.cxx:6852
 TProof.cxx:6853
 TProof.cxx:6854
 TProof.cxx:6855
 TProof.cxx:6856
 TProof.cxx:6857
 TProof.cxx:6858
 TProof.cxx:6859
 TProof.cxx:6860
 TProof.cxx:6861
 TProof.cxx:6862
 TProof.cxx:6863
 TProof.cxx:6864
 TProof.cxx:6865
 TProof.cxx:6866
 TProof.cxx:6867
 TProof.cxx:6868
 TProof.cxx:6869
 TProof.cxx:6870
 TProof.cxx:6871
 TProof.cxx:6872
 TProof.cxx:6873
 TProof.cxx:6874
 TProof.cxx:6875
 TProof.cxx:6876
 TProof.cxx:6877
 TProof.cxx:6878
 TProof.cxx:6879
 TProof.cxx:6880
 TProof.cxx:6881
 TProof.cxx:6882
 TProof.cxx:6883
 TProof.cxx:6884
 TProof.cxx:6885
 TProof.cxx:6886
 TProof.cxx:6887
 TProof.cxx:6888
 TProof.cxx:6889
 TProof.cxx:6890
 TProof.cxx:6891
 TProof.cxx:6892
 TProof.cxx:6893
 TProof.cxx:6894
 TProof.cxx:6895
 TProof.cxx:6896
 TProof.cxx:6897
 TProof.cxx:6898
 TProof.cxx:6899
 TProof.cxx:6900
 TProof.cxx:6901
 TProof.cxx:6902
 TProof.cxx:6903
 TProof.cxx:6904
 TProof.cxx:6905
 TProof.cxx:6906
 TProof.cxx:6907
 TProof.cxx:6908
 TProof.cxx:6909
 TProof.cxx:6910
 TProof.cxx:6911
 TProof.cxx:6912
 TProof.cxx:6913
 TProof.cxx:6914
 TProof.cxx:6915
 TProof.cxx:6916
 TProof.cxx:6917
 TProof.cxx:6918
 TProof.cxx:6919
 TProof.cxx:6920
 TProof.cxx:6921
 TProof.cxx:6922
 TProof.cxx:6923
 TProof.cxx:6924
 TProof.cxx:6925
 TProof.cxx:6926
 TProof.cxx:6927
 TProof.cxx:6928
 TProof.cxx:6929
 TProof.cxx:6930
 TProof.cxx:6931
 TProof.cxx:6932
 TProof.cxx:6933
 TProof.cxx:6934
 TProof.cxx:6935
 TProof.cxx:6936
 TProof.cxx:6937
 TProof.cxx:6938
 TProof.cxx:6939
 TProof.cxx:6940
 TProof.cxx:6941
 TProof.cxx:6942
 TProof.cxx:6943
 TProof.cxx:6944
 TProof.cxx:6945
 TProof.cxx:6946
 TProof.cxx:6947
 TProof.cxx:6948
 TProof.cxx:6949
 TProof.cxx:6950
 TProof.cxx:6951
 TProof.cxx:6952
 TProof.cxx:6953
 TProof.cxx:6954
 TProof.cxx:6955
 TProof.cxx:6956
 TProof.cxx:6957
 TProof.cxx:6958
 TProof.cxx:6959
 TProof.cxx:6960
 TProof.cxx:6961
 TProof.cxx:6962
 TProof.cxx:6963
 TProof.cxx:6964
 TProof.cxx:6965
 TProof.cxx:6966
 TProof.cxx:6967
 TProof.cxx:6968
 TProof.cxx:6969
 TProof.cxx:6970
 TProof.cxx:6971
 TProof.cxx:6972
 TProof.cxx:6973
 TProof.cxx:6974
 TProof.cxx:6975
 TProof.cxx:6976
 TProof.cxx:6977
 TProof.cxx:6978
 TProof.cxx:6979
 TProof.cxx:6980
 TProof.cxx:6981
 TProof.cxx:6982
 TProof.cxx:6983
 TProof.cxx:6984
 TProof.cxx:6985
 TProof.cxx:6986
 TProof.cxx:6987
 TProof.cxx:6988
 TProof.cxx:6989
 TProof.cxx:6990
 TProof.cxx:6991
 TProof.cxx:6992
 TProof.cxx:6993
 TProof.cxx:6994
 TProof.cxx:6995
 TProof.cxx:6996
 TProof.cxx:6997
 TProof.cxx:6998
 TProof.cxx:6999
 TProof.cxx:7000
 TProof.cxx:7001
 TProof.cxx:7002
 TProof.cxx:7003
 TProof.cxx:7004
 TProof.cxx:7005
 TProof.cxx:7006
 TProof.cxx:7007
 TProof.cxx:7008
 TProof.cxx:7009
 TProof.cxx:7010
 TProof.cxx:7011
 TProof.cxx:7012
 TProof.cxx:7013
 TProof.cxx:7014
 TProof.cxx:7015
 TProof.cxx:7016
 TProof.cxx:7017
 TProof.cxx:7018
 TProof.cxx:7019
 TProof.cxx:7020
 TProof.cxx:7021
 TProof.cxx:7022
 TProof.cxx:7023
 TProof.cxx:7024
 TProof.cxx:7025
 TProof.cxx:7026
 TProof.cxx:7027
 TProof.cxx:7028
 TProof.cxx:7029
 TProof.cxx:7030
 TProof.cxx:7031
 TProof.cxx:7032
 TProof.cxx:7033
 TProof.cxx:7034
 TProof.cxx:7035
 TProof.cxx:7036
 TProof.cxx:7037
 TProof.cxx:7038
 TProof.cxx:7039
 TProof.cxx:7040
 TProof.cxx:7041
 TProof.cxx:7042
 TProof.cxx:7043
 TProof.cxx:7044
 TProof.cxx:7045
 TProof.cxx:7046
 TProof.cxx:7047
 TProof.cxx:7048
 TProof.cxx:7049
 TProof.cxx:7050
 TProof.cxx:7051
 TProof.cxx:7052
 TProof.cxx:7053
 TProof.cxx:7054
 TProof.cxx:7055
 TProof.cxx:7056
 TProof.cxx:7057
 TProof.cxx:7058
 TProof.cxx:7059
 TProof.cxx:7060
 TProof.cxx:7061
 TProof.cxx:7062
 TProof.cxx:7063
 TProof.cxx:7064
 TProof.cxx:7065
 TProof.cxx:7066
 TProof.cxx:7067
 TProof.cxx:7068
 TProof.cxx:7069
 TProof.cxx:7070
 TProof.cxx:7071
 TProof.cxx:7072
 TProof.cxx:7073
 TProof.cxx:7074
 TProof.cxx:7075
 TProof.cxx:7076
 TProof.cxx:7077
 TProof.cxx:7078
 TProof.cxx:7079
 TProof.cxx:7080
 TProof.cxx:7081
 TProof.cxx:7082
 TProof.cxx:7083
 TProof.cxx:7084
 TProof.cxx:7085
 TProof.cxx:7086
 TProof.cxx:7087
 TProof.cxx:7088
 TProof.cxx:7089
 TProof.cxx:7090
 TProof.cxx:7091
 TProof.cxx:7092
 TProof.cxx:7093
 TProof.cxx:7094
 TProof.cxx:7095
 TProof.cxx:7096
 TProof.cxx:7097
 TProof.cxx:7098
 TProof.cxx:7099
 TProof.cxx:7100
 TProof.cxx:7101
 TProof.cxx:7102
 TProof.cxx:7103
 TProof.cxx:7104
 TProof.cxx:7105
 TProof.cxx:7106
 TProof.cxx:7107
 TProof.cxx:7108
 TProof.cxx:7109
 TProof.cxx:7110
 TProof.cxx:7111
 TProof.cxx:7112
 TProof.cxx:7113
 TProof.cxx:7114
 TProof.cxx:7115
 TProof.cxx:7116
 TProof.cxx:7117
 TProof.cxx:7118
 TProof.cxx:7119
 TProof.cxx:7120
 TProof.cxx:7121
 TProof.cxx:7122
 TProof.cxx:7123
 TProof.cxx:7124
 TProof.cxx:7125
 TProof.cxx:7126
 TProof.cxx:7127
 TProof.cxx:7128
 TProof.cxx:7129
 TProof.cxx:7130
 TProof.cxx:7131
 TProof.cxx:7132
 TProof.cxx:7133
 TProof.cxx:7134
 TProof.cxx:7135
 TProof.cxx:7136
 TProof.cxx:7137
 TProof.cxx:7138
 TProof.cxx:7139
 TProof.cxx:7140
 TProof.cxx:7141
 TProof.cxx:7142
 TProof.cxx:7143
 TProof.cxx:7144
 TProof.cxx:7145
 TProof.cxx:7146
 TProof.cxx:7147
 TProof.cxx:7148
 TProof.cxx:7149
 TProof.cxx:7150
 TProof.cxx:7151
 TProof.cxx:7152
 TProof.cxx:7153
 TProof.cxx:7154
 TProof.cxx:7155
 TProof.cxx:7156
 TProof.cxx:7157
 TProof.cxx:7158
 TProof.cxx:7159
 TProof.cxx:7160
 TProof.cxx:7161
 TProof.cxx:7162
 TProof.cxx:7163
 TProof.cxx:7164
 TProof.cxx:7165
 TProof.cxx:7166
 TProof.cxx:7167
 TProof.cxx:7168
 TProof.cxx:7169
 TProof.cxx:7170
 TProof.cxx:7171
 TProof.cxx:7172
 TProof.cxx:7173
 TProof.cxx:7174
 TProof.cxx:7175
 TProof.cxx:7176
 TProof.cxx:7177
 TProof.cxx:7178
 TProof.cxx:7179
 TProof.cxx:7180
 TProof.cxx:7181
 TProof.cxx:7182
 TProof.cxx:7183
 TProof.cxx:7184
 TProof.cxx:7185
 TProof.cxx:7186
 TProof.cxx:7187
 TProof.cxx:7188
 TProof.cxx:7189
 TProof.cxx:7190
 TProof.cxx:7191
 TProof.cxx:7192
 TProof.cxx:7193
 TProof.cxx:7194
 TProof.cxx:7195
 TProof.cxx:7196
 TProof.cxx:7197
 TProof.cxx:7198
 TProof.cxx:7199
 TProof.cxx:7200
 TProof.cxx:7201
 TProof.cxx:7202
 TProof.cxx:7203
 TProof.cxx:7204
 TProof.cxx:7205
 TProof.cxx:7206
 TProof.cxx:7207
 TProof.cxx:7208
 TProof.cxx:7209
 TProof.cxx:7210
 TProof.cxx:7211
 TProof.cxx:7212
 TProof.cxx:7213
 TProof.cxx:7214
 TProof.cxx:7215
 TProof.cxx:7216
 TProof.cxx:7217
 TProof.cxx:7218
 TProof.cxx:7219
 TProof.cxx:7220
 TProof.cxx:7221
 TProof.cxx:7222
 TProof.cxx:7223
 TProof.cxx:7224
 TProof.cxx:7225
 TProof.cxx:7226
 TProof.cxx:7227
 TProof.cxx:7228
 TProof.cxx:7229
 TProof.cxx:7230
 TProof.cxx:7231
 TProof.cxx:7232
 TProof.cxx:7233
 TProof.cxx:7234
 TProof.cxx:7235
 TProof.cxx:7236
 TProof.cxx:7237
 TProof.cxx:7238
 TProof.cxx:7239
 TProof.cxx:7240
 TProof.cxx:7241
 TProof.cxx:7242
 TProof.cxx:7243
 TProof.cxx:7244
 TProof.cxx:7245
 TProof.cxx:7246
 TProof.cxx:7247
 TProof.cxx:7248
 TProof.cxx:7249
 TProof.cxx:7250
 TProof.cxx:7251
 TProof.cxx:7252
 TProof.cxx:7253
 TProof.cxx:7254
 TProof.cxx:7255
 TProof.cxx:7256
 TProof.cxx:7257
 TProof.cxx:7258
 TProof.cxx:7259
 TProof.cxx:7260
 TProof.cxx:7261
 TProof.cxx:7262
 TProof.cxx:7263
 TProof.cxx:7264
 TProof.cxx:7265
 TProof.cxx:7266
 TProof.cxx:7267
 TProof.cxx:7268
 TProof.cxx:7269
 TProof.cxx:7270
 TProof.cxx:7271
 TProof.cxx:7272
 TProof.cxx:7273
 TProof.cxx:7274
 TProof.cxx:7275
 TProof.cxx:7276
 TProof.cxx:7277
 TProof.cxx:7278
 TProof.cxx:7279
 TProof.cxx:7280
 TProof.cxx:7281
 TProof.cxx:7282
 TProof.cxx:7283
 TProof.cxx:7284
 TProof.cxx:7285
 TProof.cxx:7286
 TProof.cxx:7287
 TProof.cxx:7288
 TProof.cxx:7289
 TProof.cxx:7290
 TProof.cxx:7291
 TProof.cxx:7292
 TProof.cxx:7293
 TProof.cxx:7294
 TProof.cxx:7295
 TProof.cxx:7296
 TProof.cxx:7297
 TProof.cxx:7298
 TProof.cxx:7299
 TProof.cxx:7300
 TProof.cxx:7301
 TProof.cxx:7302
 TProof.cxx:7303
 TProof.cxx:7304
 TProof.cxx:7305
 TProof.cxx:7306
 TProof.cxx:7307
 TProof.cxx:7308
 TProof.cxx:7309
 TProof.cxx:7310
 TProof.cxx:7311
 TProof.cxx:7312
 TProof.cxx:7313
 TProof.cxx:7314
 TProof.cxx:7315
 TProof.cxx:7316
 TProof.cxx:7317
 TProof.cxx:7318
 TProof.cxx:7319
 TProof.cxx:7320
 TProof.cxx:7321
 TProof.cxx:7322
 TProof.cxx:7323
 TProof.cxx:7324
 TProof.cxx:7325
 TProof.cxx:7326
 TProof.cxx:7327
 TProof.cxx:7328
 TProof.cxx:7329
 TProof.cxx:7330
 TProof.cxx:7331
 TProof.cxx:7332
 TProof.cxx:7333
 TProof.cxx:7334
 TProof.cxx:7335
 TProof.cxx:7336
 TProof.cxx:7337
 TProof.cxx:7338
 TProof.cxx:7339
 TProof.cxx:7340
 TProof.cxx:7341
 TProof.cxx:7342
 TProof.cxx:7343
 TProof.cxx:7344
 TProof.cxx:7345
 TProof.cxx:7346
 TProof.cxx:7347
 TProof.cxx:7348
 TProof.cxx:7349
 TProof.cxx:7350
 TProof.cxx:7351
 TProof.cxx:7352
 TProof.cxx:7353
 TProof.cxx:7354
 TProof.cxx:7355
 TProof.cxx:7356
 TProof.cxx:7357
 TProof.cxx:7358
 TProof.cxx:7359
 TProof.cxx:7360
 TProof.cxx:7361
 TProof.cxx:7362
 TProof.cxx:7363
 TProof.cxx:7364
 TProof.cxx:7365
 TProof.cxx:7366
 TProof.cxx:7367
 TProof.cxx:7368
 TProof.cxx:7369
 TProof.cxx:7370
 TProof.cxx:7371
 TProof.cxx:7372
 TProof.cxx:7373
 TProof.cxx:7374
 TProof.cxx:7375
 TProof.cxx:7376
 TProof.cxx:7377
 TProof.cxx:7378
 TProof.cxx:7379
 TProof.cxx:7380
 TProof.cxx:7381
 TProof.cxx:7382
 TProof.cxx:7383
 TProof.cxx:7384
 TProof.cxx:7385
 TProof.cxx:7386
 TProof.cxx:7387
 TProof.cxx:7388
 TProof.cxx:7389
 TProof.cxx:7390
 TProof.cxx:7391
 TProof.cxx:7392
 TProof.cxx:7393
 TProof.cxx:7394
 TProof.cxx:7395
 TProof.cxx:7396
 TProof.cxx:7397
 TProof.cxx:7398
 TProof.cxx:7399
 TProof.cxx:7400
 TProof.cxx:7401
 TProof.cxx:7402
 TProof.cxx:7403
 TProof.cxx:7404
 TProof.cxx:7405
 TProof.cxx:7406
 TProof.cxx:7407
 TProof.cxx:7408
 TProof.cxx:7409
 TProof.cxx:7410
 TProof.cxx:7411
 TProof.cxx:7412
 TProof.cxx:7413
 TProof.cxx:7414
 TProof.cxx:7415
 TProof.cxx:7416
 TProof.cxx:7417
 TProof.cxx:7418
 TProof.cxx:7419
 TProof.cxx:7420
 TProof.cxx:7421
 TProof.cxx:7422
 TProof.cxx:7423
 TProof.cxx:7424
 TProof.cxx:7425
 TProof.cxx:7426
 TProof.cxx:7427
 TProof.cxx:7428
 TProof.cxx:7429
 TProof.cxx:7430
 TProof.cxx:7431
 TProof.cxx:7432
 TProof.cxx:7433
 TProof.cxx:7434
 TProof.cxx:7435
 TProof.cxx:7436
 TProof.cxx:7437
 TProof.cxx:7438
 TProof.cxx:7439
 TProof.cxx:7440
 TProof.cxx:7441
 TProof.cxx:7442
 TProof.cxx:7443
 TProof.cxx:7444
 TProof.cxx:7445
 TProof.cxx:7446
 TProof.cxx:7447
 TProof.cxx:7448
 TProof.cxx:7449
 TProof.cxx:7450
 TProof.cxx:7451
 TProof.cxx:7452
 TProof.cxx:7453
 TProof.cxx:7454
 TProof.cxx:7455
 TProof.cxx:7456
 TProof.cxx:7457
 TProof.cxx:7458
 TProof.cxx:7459
 TProof.cxx:7460
 TProof.cxx:7461
 TProof.cxx:7462
 TProof.cxx:7463
 TProof.cxx:7464
 TProof.cxx:7465
 TProof.cxx:7466
 TProof.cxx:7467
 TProof.cxx:7468
 TProof.cxx:7469
 TProof.cxx:7470
 TProof.cxx:7471
 TProof.cxx:7472
 TProof.cxx:7473
 TProof.cxx:7474
 TProof.cxx:7475
 TProof.cxx:7476
 TProof.cxx:7477
 TProof.cxx:7478
 TProof.cxx:7479
 TProof.cxx:7480
 TProof.cxx:7481
 TProof.cxx:7482
 TProof.cxx:7483
 TProof.cxx:7484
 TProof.cxx:7485
 TProof.cxx:7486
 TProof.cxx:7487
 TProof.cxx:7488
 TProof.cxx:7489
 TProof.cxx:7490
 TProof.cxx:7491
 TProof.cxx:7492
 TProof.cxx:7493
 TProof.cxx:7494
 TProof.cxx:7495
 TProof.cxx:7496
 TProof.cxx:7497
 TProof.cxx:7498
 TProof.cxx:7499
 TProof.cxx:7500
 TProof.cxx:7501
 TProof.cxx:7502
 TProof.cxx:7503
 TProof.cxx:7504
 TProof.cxx:7505
 TProof.cxx:7506
 TProof.cxx:7507
 TProof.cxx:7508
 TProof.cxx:7509
 TProof.cxx:7510
 TProof.cxx:7511
 TProof.cxx:7512
 TProof.cxx:7513
 TProof.cxx:7514
 TProof.cxx:7515
 TProof.cxx:7516
 TProof.cxx:7517
 TProof.cxx:7518
 TProof.cxx:7519
 TProof.cxx:7520
 TProof.cxx:7521
 TProof.cxx:7522
 TProof.cxx:7523
 TProof.cxx:7524
 TProof.cxx:7525
 TProof.cxx:7526
 TProof.cxx:7527
 TProof.cxx:7528
 TProof.cxx:7529
 TProof.cxx:7530
 TProof.cxx:7531
 TProof.cxx:7532
 TProof.cxx:7533
 TProof.cxx:7534
 TProof.cxx:7535
 TProof.cxx:7536
 TProof.cxx:7537
 TProof.cxx:7538
 TProof.cxx:7539
 TProof.cxx:7540
 TProof.cxx:7541
 TProof.cxx:7542
 TProof.cxx:7543
 TProof.cxx:7544
 TProof.cxx:7545
 TProof.cxx:7546
 TProof.cxx:7547
 TProof.cxx:7548
 TProof.cxx:7549
 TProof.cxx:7550
 TProof.cxx:7551
 TProof.cxx:7552
 TProof.cxx:7553
 TProof.cxx:7554
 TProof.cxx:7555
 TProof.cxx:7556
 TProof.cxx:7557
 TProof.cxx:7558
 TProof.cxx:7559
 TProof.cxx:7560
 TProof.cxx:7561
 TProof.cxx:7562
 TProof.cxx:7563
 TProof.cxx:7564
 TProof.cxx:7565
 TProof.cxx:7566
 TProof.cxx:7567
 TProof.cxx:7568
 TProof.cxx:7569
 TProof.cxx:7570
 TProof.cxx:7571
 TProof.cxx:7572
 TProof.cxx:7573
 TProof.cxx:7574
 TProof.cxx:7575
 TProof.cxx:7576
 TProof.cxx:7577
 TProof.cxx:7578
 TProof.cxx:7579
 TProof.cxx:7580
 TProof.cxx:7581
 TProof.cxx:7582
 TProof.cxx:7583
 TProof.cxx:7584
 TProof.cxx:7585
 TProof.cxx:7586
 TProof.cxx:7587
 TProof.cxx:7588
 TProof.cxx:7589
 TProof.cxx:7590
 TProof.cxx:7591
 TProof.cxx:7592
 TProof.cxx:7593
 TProof.cxx:7594
 TProof.cxx:7595
 TProof.cxx:7596
 TProof.cxx:7597
 TProof.cxx:7598
 TProof.cxx:7599
 TProof.cxx:7600
 TProof.cxx:7601
 TProof.cxx:7602
 TProof.cxx:7603
 TProof.cxx:7604
 TProof.cxx:7605
 TProof.cxx:7606
 TProof.cxx:7607
 TProof.cxx:7608
 TProof.cxx:7609
 TProof.cxx:7610
 TProof.cxx:7611
 TProof.cxx:7612
 TProof.cxx:7613
 TProof.cxx:7614
 TProof.cxx:7615
 TProof.cxx:7616
 TProof.cxx:7617
 TProof.cxx:7618
 TProof.cxx:7619
 TProof.cxx:7620
 TProof.cxx:7621
 TProof.cxx:7622
 TProof.cxx:7623
 TProof.cxx:7624
 TProof.cxx:7625
 TProof.cxx:7626
 TProof.cxx:7627
 TProof.cxx:7628
 TProof.cxx:7629
 TProof.cxx:7630
 TProof.cxx:7631
 TProof.cxx:7632
 TProof.cxx:7633
 TProof.cxx:7634
 TProof.cxx:7635
 TProof.cxx:7636
 TProof.cxx:7637
 TProof.cxx:7638
 TProof.cxx:7639
 TProof.cxx:7640
 TProof.cxx:7641
 TProof.cxx:7642
 TProof.cxx:7643
 TProof.cxx:7644
 TProof.cxx:7645
 TProof.cxx:7646
 TProof.cxx:7647
 TProof.cxx:7648
 TProof.cxx:7649
 TProof.cxx:7650
 TProof.cxx:7651
 TProof.cxx:7652
 TProof.cxx:7653
 TProof.cxx:7654
 TProof.cxx:7655
 TProof.cxx:7656
 TProof.cxx:7657
 TProof.cxx:7658
 TProof.cxx:7659
 TProof.cxx:7660
 TProof.cxx:7661
 TProof.cxx:7662
 TProof.cxx:7663
 TProof.cxx:7664
 TProof.cxx:7665
 TProof.cxx:7666
 TProof.cxx:7667
 TProof.cxx:7668
 TProof.cxx:7669
 TProof.cxx:7670
 TProof.cxx:7671
 TProof.cxx:7672
 TProof.cxx:7673
 TProof.cxx:7674
 TProof.cxx:7675
 TProof.cxx:7676
 TProof.cxx:7677
 TProof.cxx:7678
 TProof.cxx:7679
 TProof.cxx:7680
 TProof.cxx:7681
 TProof.cxx:7682
 TProof.cxx:7683
 TProof.cxx:7684
 TProof.cxx:7685
 TProof.cxx:7686
 TProof.cxx:7687
 TProof.cxx:7688
 TProof.cxx:7689
 TProof.cxx:7690
 TProof.cxx:7691
 TProof.cxx:7692
 TProof.cxx:7693
 TProof.cxx:7694
 TProof.cxx:7695
 TProof.cxx:7696
 TProof.cxx:7697
 TProof.cxx:7698
 TProof.cxx:7699
 TProof.cxx:7700
 TProof.cxx:7701
 TProof.cxx:7702
 TProof.cxx:7703
 TProof.cxx:7704
 TProof.cxx:7705
 TProof.cxx:7706
 TProof.cxx:7707
 TProof.cxx:7708
 TProof.cxx:7709
 TProof.cxx:7710
 TProof.cxx:7711
 TProof.cxx:7712
 TProof.cxx:7713
 TProof.cxx:7714
 TProof.cxx:7715
 TProof.cxx:7716
 TProof.cxx:7717
 TProof.cxx:7718
 TProof.cxx:7719
 TProof.cxx:7720
 TProof.cxx:7721
 TProof.cxx:7722
 TProof.cxx:7723
 TProof.cxx:7724
 TProof.cxx:7725
 TProof.cxx:7726
 TProof.cxx:7727
 TProof.cxx:7728
 TProof.cxx:7729
 TProof.cxx:7730
 TProof.cxx:7731
 TProof.cxx:7732
 TProof.cxx:7733
 TProof.cxx:7734
 TProof.cxx:7735
 TProof.cxx:7736
 TProof.cxx:7737
 TProof.cxx:7738
 TProof.cxx:7739
 TProof.cxx:7740
 TProof.cxx:7741
 TProof.cxx:7742
 TProof.cxx:7743
 TProof.cxx:7744
 TProof.cxx:7745
 TProof.cxx:7746
 TProof.cxx:7747
 TProof.cxx:7748
 TProof.cxx:7749
 TProof.cxx:7750
 TProof.cxx:7751
 TProof.cxx:7752
 TProof.cxx:7753
 TProof.cxx:7754
 TProof.cxx:7755
 TProof.cxx:7756
 TProof.cxx:7757
 TProof.cxx:7758
 TProof.cxx:7759
 TProof.cxx:7760
 TProof.cxx:7761
 TProof.cxx:7762
 TProof.cxx:7763
 TProof.cxx:7764
 TProof.cxx:7765
 TProof.cxx:7766
 TProof.cxx:7767
 TProof.cxx:7768
 TProof.cxx:7769
 TProof.cxx:7770
 TProof.cxx:7771
 TProof.cxx:7772
 TProof.cxx:7773
 TProof.cxx:7774
 TProof.cxx:7775
 TProof.cxx:7776
 TProof.cxx:7777
 TProof.cxx:7778
 TProof.cxx:7779
 TProof.cxx:7780
 TProof.cxx:7781
 TProof.cxx:7782
 TProof.cxx:7783
 TProof.cxx:7784
 TProof.cxx:7785
 TProof.cxx:7786
 TProof.cxx:7787
 TProof.cxx:7788
 TProof.cxx:7789
 TProof.cxx:7790
 TProof.cxx:7791
 TProof.cxx:7792
 TProof.cxx:7793
 TProof.cxx:7794
 TProof.cxx:7795
 TProof.cxx:7796
 TProof.cxx:7797
 TProof.cxx:7798
 TProof.cxx:7799
 TProof.cxx:7800
 TProof.cxx:7801
 TProof.cxx:7802
 TProof.cxx:7803
 TProof.cxx:7804
 TProof.cxx:7805
 TProof.cxx:7806
 TProof.cxx:7807
 TProof.cxx:7808
 TProof.cxx:7809
 TProof.cxx:7810
 TProof.cxx:7811
 TProof.cxx:7812
 TProof.cxx:7813
 TProof.cxx:7814
 TProof.cxx:7815
 TProof.cxx:7816
 TProof.cxx:7817
 TProof.cxx:7818
 TProof.cxx:7819
 TProof.cxx:7820
 TProof.cxx:7821
 TProof.cxx:7822
 TProof.cxx:7823
 TProof.cxx:7824
 TProof.cxx:7825
 TProof.cxx:7826
 TProof.cxx:7827
 TProof.cxx:7828
 TProof.cxx:7829
 TProof.cxx:7830
 TProof.cxx:7831
 TProof.cxx:7832
 TProof.cxx:7833
 TProof.cxx:7834
 TProof.cxx:7835
 TProof.cxx:7836
 TProof.cxx:7837
 TProof.cxx:7838
 TProof.cxx:7839
 TProof.cxx:7840
 TProof.cxx:7841
 TProof.cxx:7842
 TProof.cxx:7843
 TProof.cxx:7844
 TProof.cxx:7845
 TProof.cxx:7846
 TProof.cxx:7847
 TProof.cxx:7848
 TProof.cxx:7849
 TProof.cxx:7850
 TProof.cxx:7851
 TProof.cxx:7852
 TProof.cxx:7853
 TProof.cxx:7854
 TProof.cxx:7855
 TProof.cxx:7856
 TProof.cxx:7857
 TProof.cxx:7858
 TProof.cxx:7859
 TProof.cxx:7860
 TProof.cxx:7861
 TProof.cxx:7862
 TProof.cxx:7863
 TProof.cxx:7864
 TProof.cxx:7865
 TProof.cxx:7866
 TProof.cxx:7867
 TProof.cxx:7868
 TProof.cxx:7869
 TProof.cxx:7870
 TProof.cxx:7871
 TProof.cxx:7872
 TProof.cxx:7873
 TProof.cxx:7874
 TProof.cxx:7875
 TProof.cxx:7876
 TProof.cxx:7877
 TProof.cxx:7878
 TProof.cxx:7879
 TProof.cxx:7880
 TProof.cxx:7881
 TProof.cxx:7882
 TProof.cxx:7883
 TProof.cxx:7884
 TProof.cxx:7885
 TProof.cxx:7886
 TProof.cxx:7887
 TProof.cxx:7888
 TProof.cxx:7889
 TProof.cxx:7890
 TProof.cxx:7891
 TProof.cxx:7892
 TProof.cxx:7893
 TProof.cxx:7894
 TProof.cxx:7895
 TProof.cxx:7896
 TProof.cxx:7897
 TProof.cxx:7898
 TProof.cxx:7899
 TProof.cxx:7900
 TProof.cxx:7901
 TProof.cxx:7902
 TProof.cxx:7903
 TProof.cxx:7904
 TProof.cxx:7905
 TProof.cxx:7906
 TProof.cxx:7907
 TProof.cxx:7908
 TProof.cxx:7909
 TProof.cxx:7910
 TProof.cxx:7911
 TProof.cxx:7912
 TProof.cxx:7913
 TProof.cxx:7914
 TProof.cxx:7915
 TProof.cxx:7916
 TProof.cxx:7917
 TProof.cxx:7918
 TProof.cxx:7919
 TProof.cxx:7920
 TProof.cxx:7921
 TProof.cxx:7922
 TProof.cxx:7923
 TProof.cxx:7924
 TProof.cxx:7925
 TProof.cxx:7926
 TProof.cxx:7927
 TProof.cxx:7928
 TProof.cxx:7929
 TProof.cxx:7930
 TProof.cxx:7931
 TProof.cxx:7932
 TProof.cxx:7933
 TProof.cxx:7934
 TProof.cxx:7935
 TProof.cxx:7936
 TProof.cxx:7937
 TProof.cxx:7938
 TProof.cxx:7939
 TProof.cxx:7940
 TProof.cxx:7941
 TProof.cxx:7942
 TProof.cxx:7943
 TProof.cxx:7944
 TProof.cxx:7945
 TProof.cxx:7946
 TProof.cxx:7947
 TProof.cxx:7948
 TProof.cxx:7949
 TProof.cxx:7950
 TProof.cxx:7951
 TProof.cxx:7952
 TProof.cxx:7953
 TProof.cxx:7954
 TProof.cxx:7955
 TProof.cxx:7956
 TProof.cxx:7957
 TProof.cxx:7958
 TProof.cxx:7959
 TProof.cxx:7960
 TProof.cxx:7961
 TProof.cxx:7962
 TProof.cxx:7963
 TProof.cxx:7964
 TProof.cxx:7965
 TProof.cxx:7966
 TProof.cxx:7967
 TProof.cxx:7968
 TProof.cxx:7969
 TProof.cxx:7970
 TProof.cxx:7971
 TProof.cxx:7972
 TProof.cxx:7973
 TProof.cxx:7974
 TProof.cxx:7975
 TProof.cxx:7976
 TProof.cxx:7977
 TProof.cxx:7978
 TProof.cxx:7979
 TProof.cxx:7980
 TProof.cxx:7981
 TProof.cxx:7982
 TProof.cxx:7983
 TProof.cxx:7984
 TProof.cxx:7985
 TProof.cxx:7986
 TProof.cxx:7987
 TProof.cxx:7988
 TProof.cxx:7989
 TProof.cxx:7990
 TProof.cxx:7991
 TProof.cxx:7992
 TProof.cxx:7993
 TProof.cxx:7994
 TProof.cxx:7995
 TProof.cxx:7996
 TProof.cxx:7997
 TProof.cxx:7998
 TProof.cxx:7999
 TProof.cxx:8000
 TProof.cxx:8001
 TProof.cxx:8002
 TProof.cxx:8003
 TProof.cxx:8004
 TProof.cxx:8005
 TProof.cxx:8006
 TProof.cxx:8007
 TProof.cxx:8008
 TProof.cxx:8009
 TProof.cxx:8010
 TProof.cxx:8011
 TProof.cxx:8012
 TProof.cxx:8013
 TProof.cxx:8014
 TProof.cxx:8015
 TProof.cxx:8016
 TProof.cxx:8017
 TProof.cxx:8018
 TProof.cxx:8019
 TProof.cxx:8020
 TProof.cxx:8021
 TProof.cxx:8022
 TProof.cxx:8023
 TProof.cxx:8024
 TProof.cxx:8025
 TProof.cxx:8026
 TProof.cxx:8027
 TProof.cxx:8028
 TProof.cxx:8029
 TProof.cxx:8030
 TProof.cxx:8031
 TProof.cxx:8032
 TProof.cxx:8033
 TProof.cxx:8034
 TProof.cxx:8035
 TProof.cxx:8036
 TProof.cxx:8037
 TProof.cxx:8038
 TProof.cxx:8039
 TProof.cxx:8040
 TProof.cxx:8041
 TProof.cxx:8042
 TProof.cxx:8043
 TProof.cxx:8044
 TProof.cxx:8045
 TProof.cxx:8046
 TProof.cxx:8047
 TProof.cxx:8048
 TProof.cxx:8049
 TProof.cxx:8050
 TProof.cxx:8051
 TProof.cxx:8052
 TProof.cxx:8053
 TProof.cxx:8054
 TProof.cxx:8055
 TProof.cxx:8056
 TProof.cxx:8057
 TProof.cxx:8058
 TProof.cxx:8059
 TProof.cxx:8060
 TProof.cxx:8061
 TProof.cxx:8062
 TProof.cxx:8063
 TProof.cxx:8064
 TProof.cxx:8065
 TProof.cxx:8066
 TProof.cxx:8067
 TProof.cxx:8068
 TProof.cxx:8069
 TProof.cxx:8070
 TProof.cxx:8071
 TProof.cxx:8072
 TProof.cxx:8073
 TProof.cxx:8074
 TProof.cxx:8075
 TProof.cxx:8076
 TProof.cxx:8077
 TProof.cxx:8078
 TProof.cxx:8079
 TProof.cxx:8080
 TProof.cxx:8081
 TProof.cxx:8082
 TProof.cxx:8083
 TProof.cxx:8084
 TProof.cxx:8085
 TProof.cxx:8086
 TProof.cxx:8087
 TProof.cxx:8088
 TProof.cxx:8089
 TProof.cxx:8090
 TProof.cxx:8091
 TProof.cxx:8092
 TProof.cxx:8093
 TProof.cxx:8094
 TProof.cxx:8095
 TProof.cxx:8096
 TProof.cxx:8097
 TProof.cxx:8098
 TProof.cxx:8099
 TProof.cxx:8100
 TProof.cxx:8101
 TProof.cxx:8102
 TProof.cxx:8103
 TProof.cxx:8104
 TProof.cxx:8105
 TProof.cxx:8106
 TProof.cxx:8107
 TProof.cxx:8108
 TProof.cxx:8109
 TProof.cxx:8110
 TProof.cxx:8111
 TProof.cxx:8112
 TProof.cxx:8113
 TProof.cxx:8114
 TProof.cxx:8115
 TProof.cxx:8116
 TProof.cxx:8117
 TProof.cxx:8118
 TProof.cxx:8119
 TProof.cxx:8120
 TProof.cxx:8121
 TProof.cxx:8122
 TProof.cxx:8123
 TProof.cxx:8124
 TProof.cxx:8125
 TProof.cxx:8126
 TProof.cxx:8127
 TProof.cxx:8128
 TProof.cxx:8129
 TProof.cxx:8130
 TProof.cxx:8131
 TProof.cxx:8132
 TProof.cxx:8133
 TProof.cxx:8134
 TProof.cxx:8135
 TProof.cxx:8136
 TProof.cxx:8137
 TProof.cxx:8138
 TProof.cxx:8139
 TProof.cxx:8140
 TProof.cxx:8141
 TProof.cxx:8142
 TProof.cxx:8143
 TProof.cxx:8144
 TProof.cxx:8145
 TProof.cxx:8146
 TProof.cxx:8147
 TProof.cxx:8148
 TProof.cxx:8149
 TProof.cxx:8150
 TProof.cxx:8151
 TProof.cxx:8152
 TProof.cxx:8153
 TProof.cxx:8154
 TProof.cxx:8155
 TProof.cxx:8156
 TProof.cxx:8157
 TProof.cxx:8158
 TProof.cxx:8159
 TProof.cxx:8160
 TProof.cxx:8161
 TProof.cxx:8162
 TProof.cxx:8163
 TProof.cxx:8164
 TProof.cxx:8165
 TProof.cxx:8166
 TProof.cxx:8167
 TProof.cxx:8168
 TProof.cxx:8169
 TProof.cxx:8170
 TProof.cxx:8171
 TProof.cxx:8172
 TProof.cxx:8173
 TProof.cxx:8174
 TProof.cxx:8175
 TProof.cxx:8176
 TProof.cxx:8177
 TProof.cxx:8178
 TProof.cxx:8179
 TProof.cxx:8180
 TProof.cxx:8181
 TProof.cxx:8182
 TProof.cxx:8183
 TProof.cxx:8184
 TProof.cxx:8185
 TProof.cxx:8186
 TProof.cxx:8187
 TProof.cxx:8188
 TProof.cxx:8189
 TProof.cxx:8190
 TProof.cxx:8191
 TProof.cxx:8192
 TProof.cxx:8193
 TProof.cxx:8194
 TProof.cxx:8195
 TProof.cxx:8196
 TProof.cxx:8197
 TProof.cxx:8198
 TProof.cxx:8199
 TProof.cxx:8200
 TProof.cxx:8201
 TProof.cxx:8202
 TProof.cxx:8203
 TProof.cxx:8204
 TProof.cxx:8205
 TProof.cxx:8206
 TProof.cxx:8207
 TProof.cxx:8208
 TProof.cxx:8209
 TProof.cxx:8210
 TProof.cxx:8211
 TProof.cxx:8212
 TProof.cxx:8213
 TProof.cxx:8214
 TProof.cxx:8215
 TProof.cxx:8216
 TProof.cxx:8217
 TProof.cxx:8218
 TProof.cxx:8219
 TProof.cxx:8220
 TProof.cxx:8221
 TProof.cxx:8222
 TProof.cxx:8223
 TProof.cxx:8224
 TProof.cxx:8225
 TProof.cxx:8226
 TProof.cxx:8227
 TProof.cxx:8228
 TProof.cxx:8229
 TProof.cxx:8230
 TProof.cxx:8231
 TProof.cxx:8232
 TProof.cxx:8233
 TProof.cxx:8234
 TProof.cxx:8235
 TProof.cxx:8236
 TProof.cxx:8237
 TProof.cxx:8238
 TProof.cxx:8239
 TProof.cxx:8240
 TProof.cxx:8241
 TProof.cxx:8242
 TProof.cxx:8243
 TProof.cxx:8244
 TProof.cxx:8245
 TProof.cxx:8246
 TProof.cxx:8247
 TProof.cxx:8248
 TProof.cxx:8249
 TProof.cxx:8250
 TProof.cxx:8251
 TProof.cxx:8252
 TProof.cxx:8253
 TProof.cxx:8254
 TProof.cxx:8255
 TProof.cxx:8256
 TProof.cxx:8257
 TProof.cxx:8258
 TProof.cxx:8259
 TProof.cxx:8260
 TProof.cxx:8261
 TProof.cxx:8262
 TProof.cxx:8263
 TProof.cxx:8264
 TProof.cxx:8265
 TProof.cxx:8266
 TProof.cxx:8267
 TProof.cxx:8268
 TProof.cxx:8269
 TProof.cxx:8270
 TProof.cxx:8271
 TProof.cxx:8272
 TProof.cxx:8273
 TProof.cxx:8274
 TProof.cxx:8275
 TProof.cxx:8276
 TProof.cxx:8277
 TProof.cxx:8278
 TProof.cxx:8279
 TProof.cxx:8280
 TProof.cxx:8281
 TProof.cxx:8282
 TProof.cxx:8283
 TProof.cxx:8284
 TProof.cxx:8285
 TProof.cxx:8286
 TProof.cxx:8287
 TProof.cxx:8288
 TProof.cxx:8289
 TProof.cxx:8290
 TProof.cxx:8291
 TProof.cxx:8292
 TProof.cxx:8293
 TProof.cxx:8294
 TProof.cxx:8295
 TProof.cxx:8296
 TProof.cxx:8297
 TProof.cxx:8298
 TProof.cxx:8299
 TProof.cxx:8300
 TProof.cxx:8301
 TProof.cxx:8302
 TProof.cxx:8303
 TProof.cxx:8304
 TProof.cxx:8305
 TProof.cxx:8306
 TProof.cxx:8307
 TProof.cxx:8308
 TProof.cxx:8309
 TProof.cxx:8310
 TProof.cxx:8311
 TProof.cxx:8312
 TProof.cxx:8313
 TProof.cxx:8314
 TProof.cxx:8315
 TProof.cxx:8316
 TProof.cxx:8317
 TProof.cxx:8318
 TProof.cxx:8319
 TProof.cxx:8320
 TProof.cxx:8321
 TProof.cxx:8322
 TProof.cxx:8323
 TProof.cxx:8324
 TProof.cxx:8325
 TProof.cxx:8326
 TProof.cxx:8327
 TProof.cxx:8328
 TProof.cxx:8329
 TProof.cxx:8330
 TProof.cxx:8331
 TProof.cxx:8332
 TProof.cxx:8333
 TProof.cxx:8334
 TProof.cxx:8335
 TProof.cxx:8336
 TProof.cxx:8337
 TProof.cxx:8338
 TProof.cxx:8339
 TProof.cxx:8340
 TProof.cxx:8341
 TProof.cxx:8342
 TProof.cxx:8343
 TProof.cxx:8344
 TProof.cxx:8345
 TProof.cxx:8346
 TProof.cxx:8347
 TProof.cxx:8348
 TProof.cxx:8349
 TProof.cxx:8350
 TProof.cxx:8351
 TProof.cxx:8352
 TProof.cxx:8353
 TProof.cxx:8354
 TProof.cxx:8355
 TProof.cxx:8356
 TProof.cxx:8357
 TProof.cxx:8358
 TProof.cxx:8359
 TProof.cxx:8360
 TProof.cxx:8361
 TProof.cxx:8362
 TProof.cxx:8363
 TProof.cxx:8364
 TProof.cxx:8365
 TProof.cxx:8366
 TProof.cxx:8367
 TProof.cxx:8368
 TProof.cxx:8369
 TProof.cxx:8370
 TProof.cxx:8371
 TProof.cxx:8372
 TProof.cxx:8373
 TProof.cxx:8374
 TProof.cxx:8375
 TProof.cxx:8376
 TProof.cxx:8377
 TProof.cxx:8378
 TProof.cxx:8379
 TProof.cxx:8380
 TProof.cxx:8381
 TProof.cxx:8382
 TProof.cxx:8383
 TProof.cxx:8384
 TProof.cxx:8385
 TProof.cxx:8386
 TProof.cxx:8387
 TProof.cxx:8388
 TProof.cxx:8389
 TProof.cxx:8390
 TProof.cxx:8391
 TProof.cxx:8392
 TProof.cxx:8393
 TProof.cxx:8394
 TProof.cxx:8395
 TProof.cxx:8396
 TProof.cxx:8397
 TProof.cxx:8398
 TProof.cxx:8399
 TProof.cxx:8400
 TProof.cxx:8401
 TProof.cxx:8402
 TProof.cxx:8403
 TProof.cxx:8404
 TProof.cxx:8405
 TProof.cxx:8406
 TProof.cxx:8407
 TProof.cxx:8408
 TProof.cxx:8409
 TProof.cxx:8410
 TProof.cxx:8411
 TProof.cxx:8412
 TProof.cxx:8413
 TProof.cxx:8414
 TProof.cxx:8415
 TProof.cxx:8416
 TProof.cxx:8417
 TProof.cxx:8418
 TProof.cxx:8419
 TProof.cxx:8420
 TProof.cxx:8421
 TProof.cxx:8422
 TProof.cxx:8423
 TProof.cxx:8424
 TProof.cxx:8425
 TProof.cxx:8426
 TProof.cxx:8427
 TProof.cxx:8428
 TProof.cxx:8429
 TProof.cxx:8430
 TProof.cxx:8431
 TProof.cxx:8432
 TProof.cxx:8433
 TProof.cxx:8434
 TProof.cxx:8435
 TProof.cxx:8436
 TProof.cxx:8437
 TProof.cxx:8438
 TProof.cxx:8439
 TProof.cxx:8440
 TProof.cxx:8441
 TProof.cxx:8442
 TProof.cxx:8443
 TProof.cxx:8444
 TProof.cxx:8445
 TProof.cxx:8446
 TProof.cxx:8447
 TProof.cxx:8448
 TProof.cxx:8449
 TProof.cxx:8450
 TProof.cxx:8451
 TProof.cxx:8452
 TProof.cxx:8453
 TProof.cxx:8454
 TProof.cxx:8455
 TProof.cxx:8456
 TProof.cxx:8457
 TProof.cxx:8458
 TProof.cxx:8459
 TProof.cxx:8460
 TProof.cxx:8461
 TProof.cxx:8462
 TProof.cxx:8463
 TProof.cxx:8464
 TProof.cxx:8465
 TProof.cxx:8466
 TProof.cxx:8467
 TProof.cxx:8468
 TProof.cxx:8469
 TProof.cxx:8470
 TProof.cxx:8471
 TProof.cxx:8472
 TProof.cxx:8473
 TProof.cxx:8474
 TProof.cxx:8475
 TProof.cxx:8476
 TProof.cxx:8477
 TProof.cxx:8478
 TProof.cxx:8479
 TProof.cxx:8480
 TProof.cxx:8481
 TProof.cxx:8482
 TProof.cxx:8483
 TProof.cxx:8484
 TProof.cxx:8485
 TProof.cxx:8486
 TProof.cxx:8487
 TProof.cxx:8488
 TProof.cxx:8489
 TProof.cxx:8490
 TProof.cxx:8491
 TProof.cxx:8492
 TProof.cxx:8493
 TProof.cxx:8494
 TProof.cxx:8495
 TProof.cxx:8496
 TProof.cxx:8497
 TProof.cxx:8498
 TProof.cxx:8499
 TProof.cxx:8500
 TProof.cxx:8501
 TProof.cxx:8502
 TProof.cxx:8503
 TProof.cxx:8504
 TProof.cxx:8505
 TProof.cxx:8506
 TProof.cxx:8507
 TProof.cxx:8508
 TProof.cxx:8509
 TProof.cxx:8510
 TProof.cxx:8511
 TProof.cxx:8512
 TProof.cxx:8513
 TProof.cxx:8514
 TProof.cxx:8515
 TProof.cxx:8516
 TProof.cxx:8517
 TProof.cxx:8518
 TProof.cxx:8519
 TProof.cxx:8520
 TProof.cxx:8521
 TProof.cxx:8522
 TProof.cxx:8523
 TProof.cxx:8524
 TProof.cxx:8525
 TProof.cxx:8526
 TProof.cxx:8527
 TProof.cxx:8528
 TProof.cxx:8529
 TProof.cxx:8530
 TProof.cxx:8531
 TProof.cxx:8532
 TProof.cxx:8533
 TProof.cxx:8534
 TProof.cxx:8535
 TProof.cxx:8536
 TProof.cxx:8537
 TProof.cxx:8538
 TProof.cxx:8539
 TProof.cxx:8540
 TProof.cxx:8541
 TProof.cxx:8542
 TProof.cxx:8543
 TProof.cxx:8544
 TProof.cxx:8545
 TProof.cxx:8546
 TProof.cxx:8547
 TProof.cxx:8548
 TProof.cxx:8549
 TProof.cxx:8550
 TProof.cxx:8551
 TProof.cxx:8552
 TProof.cxx:8553
 TProof.cxx:8554
 TProof.cxx:8555
 TProof.cxx:8556
 TProof.cxx:8557
 TProof.cxx:8558
 TProof.cxx:8559
 TProof.cxx:8560
 TProof.cxx:8561
 TProof.cxx:8562
 TProof.cxx:8563
 TProof.cxx:8564
 TProof.cxx:8565
 TProof.cxx:8566
 TProof.cxx:8567
 TProof.cxx:8568
 TProof.cxx:8569
 TProof.cxx:8570
 TProof.cxx:8571
 TProof.cxx:8572
 TProof.cxx:8573
 TProof.cxx:8574
 TProof.cxx:8575
 TProof.cxx:8576
 TProof.cxx:8577
 TProof.cxx:8578
 TProof.cxx:8579
 TProof.cxx:8580
 TProof.cxx:8581
 TProof.cxx:8582
 TProof.cxx:8583
 TProof.cxx:8584
 TProof.cxx:8585
 TProof.cxx:8586
 TProof.cxx:8587
 TProof.cxx:8588
 TProof.cxx:8589
 TProof.cxx:8590
 TProof.cxx:8591
 TProof.cxx:8592
 TProof.cxx:8593
 TProof.cxx:8594
 TProof.cxx:8595
 TProof.cxx:8596
 TProof.cxx:8597
 TProof.cxx:8598
 TProof.cxx:8599
 TProof.cxx:8600
 TProof.cxx:8601
 TProof.cxx:8602
 TProof.cxx:8603
 TProof.cxx:8604
 TProof.cxx:8605
 TProof.cxx:8606
 TProof.cxx:8607
 TProof.cxx:8608
 TProof.cxx:8609
 TProof.cxx:8610
 TProof.cxx:8611
 TProof.cxx:8612
 TProof.cxx:8613
 TProof.cxx:8614
 TProof.cxx:8615
 TProof.cxx:8616
 TProof.cxx:8617
 TProof.cxx:8618
 TProof.cxx:8619
 TProof.cxx:8620
 TProof.cxx:8621
 TProof.cxx:8622
 TProof.cxx:8623
 TProof.cxx:8624
 TProof.cxx:8625
 TProof.cxx:8626
 TProof.cxx:8627
 TProof.cxx:8628
 TProof.cxx:8629
 TProof.cxx:8630
 TProof.cxx:8631
 TProof.cxx:8632
 TProof.cxx:8633
 TProof.cxx:8634
 TProof.cxx:8635
 TProof.cxx:8636
 TProof.cxx:8637
 TProof.cxx:8638
 TProof.cxx:8639
 TProof.cxx:8640
 TProof.cxx:8641
 TProof.cxx:8642
 TProof.cxx:8643
 TProof.cxx:8644
 TProof.cxx:8645
 TProof.cxx:8646
 TProof.cxx:8647
 TProof.cxx:8648
 TProof.cxx:8649
 TProof.cxx:8650
 TProof.cxx:8651
 TProof.cxx:8652
 TProof.cxx:8653
 TProof.cxx:8654
 TProof.cxx:8655
 TProof.cxx:8656
 TProof.cxx:8657
 TProof.cxx:8658
 TProof.cxx:8659
 TProof.cxx:8660
 TProof.cxx:8661
 TProof.cxx:8662
 TProof.cxx:8663
 TProof.cxx:8664
 TProof.cxx:8665
 TProof.cxx:8666
 TProof.cxx:8667
 TProof.cxx:8668
 TProof.cxx:8669
 TProof.cxx:8670
 TProof.cxx:8671
 TProof.cxx:8672
 TProof.cxx:8673
 TProof.cxx:8674
 TProof.cxx:8675
 TProof.cxx:8676
 TProof.cxx:8677
 TProof.cxx:8678
 TProof.cxx:8679
 TProof.cxx:8680
 TProof.cxx:8681
 TProof.cxx:8682
 TProof.cxx:8683
 TProof.cxx:8684
 TProof.cxx:8685
 TProof.cxx:8686
 TProof.cxx:8687
 TProof.cxx:8688
 TProof.cxx:8689
 TProof.cxx:8690
 TProof.cxx:8691
 TProof.cxx:8692
 TProof.cxx:8693
 TProof.cxx:8694
 TProof.cxx:8695
 TProof.cxx:8696
 TProof.cxx:8697
 TProof.cxx:8698
 TProof.cxx:8699
 TProof.cxx:8700
 TProof.cxx:8701
 TProof.cxx:8702
 TProof.cxx:8703
 TProof.cxx:8704
 TProof.cxx:8705
 TProof.cxx:8706
 TProof.cxx:8707
 TProof.cxx:8708
 TProof.cxx:8709
 TProof.cxx:8710
 TProof.cxx:8711
 TProof.cxx:8712
 TProof.cxx:8713
 TProof.cxx:8714
 TProof.cxx:8715
 TProof.cxx:8716
 TProof.cxx:8717
 TProof.cxx:8718
 TProof.cxx:8719
 TProof.cxx:8720
 TProof.cxx:8721
 TProof.cxx:8722
 TProof.cxx:8723
 TProof.cxx:8724
 TProof.cxx:8725
 TProof.cxx:8726
 TProof.cxx:8727
 TProof.cxx:8728
 TProof.cxx:8729
 TProof.cxx:8730
 TProof.cxx:8731
 TProof.cxx:8732
 TProof.cxx:8733
 TProof.cxx:8734
 TProof.cxx:8735
 TProof.cxx:8736
 TProof.cxx:8737
 TProof.cxx:8738
 TProof.cxx:8739
 TProof.cxx:8740
 TProof.cxx:8741
 TProof.cxx:8742
 TProof.cxx:8743
 TProof.cxx:8744
 TProof.cxx:8745
 TProof.cxx:8746
 TProof.cxx:8747
 TProof.cxx:8748
 TProof.cxx:8749
 TProof.cxx:8750
 TProof.cxx:8751
 TProof.cxx:8752
 TProof.cxx:8753
 TProof.cxx:8754
 TProof.cxx:8755
 TProof.cxx:8756
 TProof.cxx:8757
 TProof.cxx:8758
 TProof.cxx:8759
 TProof.cxx:8760
 TProof.cxx:8761
 TProof.cxx:8762
 TProof.cxx:8763
 TProof.cxx:8764
 TProof.cxx:8765
 TProof.cxx:8766
 TProof.cxx:8767
 TProof.cxx:8768
 TProof.cxx:8769
 TProof.cxx:8770
 TProof.cxx:8771
 TProof.cxx:8772
 TProof.cxx:8773
 TProof.cxx:8774
 TProof.cxx:8775
 TProof.cxx:8776
 TProof.cxx:8777
 TProof.cxx:8778
 TProof.cxx:8779
 TProof.cxx:8780
 TProof.cxx:8781
 TProof.cxx:8782
 TProof.cxx:8783
 TProof.cxx:8784
 TProof.cxx:8785
 TProof.cxx:8786
 TProof.cxx:8787
 TProof.cxx:8788
 TProof.cxx:8789
 TProof.cxx:8790
 TProof.cxx:8791
 TProof.cxx:8792
 TProof.cxx:8793
 TProof.cxx:8794
 TProof.cxx:8795
 TProof.cxx:8796
 TProof.cxx:8797
 TProof.cxx:8798
 TProof.cxx:8799
 TProof.cxx:8800
 TProof.cxx:8801
 TProof.cxx:8802
 TProof.cxx:8803
 TProof.cxx:8804
 TProof.cxx:8805
 TProof.cxx:8806
 TProof.cxx:8807
 TProof.cxx:8808
 TProof.cxx:8809
 TProof.cxx:8810
 TProof.cxx:8811
 TProof.cxx:8812
 TProof.cxx:8813
 TProof.cxx:8814
 TProof.cxx:8815
 TProof.cxx:8816
 TProof.cxx:8817
 TProof.cxx:8818
 TProof.cxx:8819
 TProof.cxx:8820
 TProof.cxx:8821
 TProof.cxx:8822
 TProof.cxx:8823
 TProof.cxx:8824
 TProof.cxx:8825
 TProof.cxx:8826
 TProof.cxx:8827
 TProof.cxx:8828
 TProof.cxx:8829
 TProof.cxx:8830
 TProof.cxx:8831
 TProof.cxx:8832
 TProof.cxx:8833
 TProof.cxx:8834
 TProof.cxx:8835
 TProof.cxx:8836
 TProof.cxx:8837
 TProof.cxx:8838
 TProof.cxx:8839
 TProof.cxx:8840
 TProof.cxx:8841
 TProof.cxx:8842
 TProof.cxx:8843
 TProof.cxx:8844
 TProof.cxx:8845
 TProof.cxx:8846
 TProof.cxx:8847
 TProof.cxx:8848
 TProof.cxx:8849
 TProof.cxx:8850
 TProof.cxx:8851
 TProof.cxx:8852
 TProof.cxx:8853
 TProof.cxx:8854
 TProof.cxx:8855
 TProof.cxx:8856
 TProof.cxx:8857
 TProof.cxx:8858
 TProof.cxx:8859
 TProof.cxx:8860
 TProof.cxx:8861
 TProof.cxx:8862
 TProof.cxx:8863
 TProof.cxx:8864
 TProof.cxx:8865
 TProof.cxx:8866
 TProof.cxx:8867
 TProof.cxx:8868
 TProof.cxx:8869
 TProof.cxx:8870
 TProof.cxx:8871
 TProof.cxx:8872
 TProof.cxx:8873
 TProof.cxx:8874
 TProof.cxx:8875
 TProof.cxx:8876
 TProof.cxx:8877
 TProof.cxx:8878
 TProof.cxx:8879
 TProof.cxx:8880
 TProof.cxx:8881
 TProof.cxx:8882
 TProof.cxx:8883
 TProof.cxx:8884
 TProof.cxx:8885
 TProof.cxx:8886
 TProof.cxx:8887
 TProof.cxx:8888
 TProof.cxx:8889
 TProof.cxx:8890
 TProof.cxx:8891
 TProof.cxx:8892
 TProof.cxx:8893
 TProof.cxx:8894
 TProof.cxx:8895
 TProof.cxx:8896
 TProof.cxx:8897
 TProof.cxx:8898
 TProof.cxx:8899
 TProof.cxx:8900
 TProof.cxx:8901
 TProof.cxx:8902
 TProof.cxx:8903
 TProof.cxx:8904
 TProof.cxx:8905
 TProof.cxx:8906
 TProof.cxx:8907
 TProof.cxx:8908
 TProof.cxx:8909
 TProof.cxx:8910
 TProof.cxx:8911
 TProof.cxx:8912
 TProof.cxx:8913
 TProof.cxx:8914
 TProof.cxx:8915
 TProof.cxx:8916
 TProof.cxx:8917
 TProof.cxx:8918
 TProof.cxx:8919
 TProof.cxx:8920
 TProof.cxx:8921
 TProof.cxx:8922
 TProof.cxx:8923
 TProof.cxx:8924
 TProof.cxx:8925
 TProof.cxx:8926
 TProof.cxx:8927
 TProof.cxx:8928
 TProof.cxx:8929
 TProof.cxx:8930
 TProof.cxx:8931
 TProof.cxx:8932
 TProof.cxx:8933
 TProof.cxx:8934
 TProof.cxx:8935
 TProof.cxx:8936
 TProof.cxx:8937
 TProof.cxx:8938
 TProof.cxx:8939
 TProof.cxx:8940
 TProof.cxx:8941
 TProof.cxx:8942
 TProof.cxx:8943
 TProof.cxx:8944
 TProof.cxx:8945
 TProof.cxx:8946
 TProof.cxx:8947
 TProof.cxx:8948
 TProof.cxx:8949
 TProof.cxx:8950
 TProof.cxx:8951
 TProof.cxx:8952
 TProof.cxx:8953
 TProof.cxx:8954
 TProof.cxx:8955
 TProof.cxx:8956
 TProof.cxx:8957
 TProof.cxx:8958
 TProof.cxx:8959
 TProof.cxx:8960
 TProof.cxx:8961
 TProof.cxx:8962
 TProof.cxx:8963
 TProof.cxx:8964
 TProof.cxx:8965
 TProof.cxx:8966
 TProof.cxx:8967
 TProof.cxx:8968
 TProof.cxx:8969
 TProof.cxx:8970
 TProof.cxx:8971
 TProof.cxx:8972
 TProof.cxx:8973
 TProof.cxx:8974
 TProof.cxx:8975
 TProof.cxx:8976
 TProof.cxx:8977
 TProof.cxx:8978
 TProof.cxx:8979
 TProof.cxx:8980
 TProof.cxx:8981
 TProof.cxx:8982
 TProof.cxx:8983
 TProof.cxx:8984
 TProof.cxx:8985
 TProof.cxx:8986
 TProof.cxx:8987
 TProof.cxx:8988
 TProof.cxx:8989
 TProof.cxx:8990
 TProof.cxx:8991
 TProof.cxx:8992
 TProof.cxx:8993
 TProof.cxx:8994
 TProof.cxx:8995
 TProof.cxx:8996
 TProof.cxx:8997
 TProof.cxx:8998
 TProof.cxx:8999
 TProof.cxx:9000
 TProof.cxx:9001
 TProof.cxx:9002
 TProof.cxx:9003
 TProof.cxx:9004
 TProof.cxx:9005
 TProof.cxx:9006
 TProof.cxx:9007
 TProof.cxx:9008
 TProof.cxx:9009
 TProof.cxx:9010
 TProof.cxx:9011
 TProof.cxx:9012
 TProof.cxx:9013
 TProof.cxx:9014
 TProof.cxx:9015
 TProof.cxx:9016
 TProof.cxx:9017
 TProof.cxx:9018
 TProof.cxx:9019
 TProof.cxx:9020
 TProof.cxx:9021
 TProof.cxx:9022
 TProof.cxx:9023
 TProof.cxx:9024
 TProof.cxx:9025
 TProof.cxx:9026
 TProof.cxx:9027
 TProof.cxx:9028
 TProof.cxx:9029
 TProof.cxx:9030
 TProof.cxx:9031
 TProof.cxx:9032
 TProof.cxx:9033
 TProof.cxx:9034
 TProof.cxx:9035
 TProof.cxx:9036
 TProof.cxx:9037
 TProof.cxx:9038
 TProof.cxx:9039
 TProof.cxx:9040
 TProof.cxx:9041
 TProof.cxx:9042
 TProof.cxx:9043
 TProof.cxx:9044
 TProof.cxx:9045
 TProof.cxx:9046
 TProof.cxx:9047
 TProof.cxx:9048
 TProof.cxx:9049
 TProof.cxx:9050
 TProof.cxx:9051
 TProof.cxx:9052
 TProof.cxx:9053
 TProof.cxx:9054
 TProof.cxx:9055
 TProof.cxx:9056
 TProof.cxx:9057
 TProof.cxx:9058
 TProof.cxx:9059
 TProof.cxx:9060
 TProof.cxx:9061
 TProof.cxx:9062
 TProof.cxx:9063
 TProof.cxx:9064
 TProof.cxx:9065
 TProof.cxx:9066
 TProof.cxx:9067
 TProof.cxx:9068
 TProof.cxx:9069
 TProof.cxx:9070
 TProof.cxx:9071
 TProof.cxx:9072
 TProof.cxx:9073
 TProof.cxx:9074
 TProof.cxx:9075
 TProof.cxx:9076
 TProof.cxx:9077
 TProof.cxx:9078
 TProof.cxx:9079
 TProof.cxx:9080
 TProof.cxx:9081
 TProof.cxx:9082
 TProof.cxx:9083
 TProof.cxx:9084
 TProof.cxx:9085
 TProof.cxx:9086
 TProof.cxx:9087
 TProof.cxx:9088
 TProof.cxx:9089
 TProof.cxx:9090
 TProof.cxx:9091
 TProof.cxx:9092
 TProof.cxx:9093
 TProof.cxx:9094
 TProof.cxx:9095
 TProof.cxx:9096
 TProof.cxx:9097
 TProof.cxx:9098
 TProof.cxx:9099
 TProof.cxx:9100
 TProof.cxx:9101
 TProof.cxx:9102
 TProof.cxx:9103
 TProof.cxx:9104
 TProof.cxx:9105
 TProof.cxx:9106
 TProof.cxx:9107
 TProof.cxx:9108
 TProof.cxx:9109
 TProof.cxx:9110
 TProof.cxx:9111
 TProof.cxx:9112
 TProof.cxx:9113
 TProof.cxx:9114
 TProof.cxx:9115
 TProof.cxx:9116
 TProof.cxx:9117
 TProof.cxx:9118
 TProof.cxx:9119
 TProof.cxx:9120
 TProof.cxx:9121
 TProof.cxx:9122
 TProof.cxx:9123
 TProof.cxx:9124
 TProof.cxx:9125
 TProof.cxx:9126
 TProof.cxx:9127
 TProof.cxx:9128
 TProof.cxx:9129
 TProof.cxx:9130
 TProof.cxx:9131
 TProof.cxx:9132
 TProof.cxx:9133
 TProof.cxx:9134
 TProof.cxx:9135
 TProof.cxx:9136
 TProof.cxx:9137
 TProof.cxx:9138
 TProof.cxx:9139
 TProof.cxx:9140
 TProof.cxx:9141
 TProof.cxx:9142
 TProof.cxx:9143
 TProof.cxx:9144
 TProof.cxx:9145
 TProof.cxx:9146
 TProof.cxx:9147
 TProof.cxx:9148
 TProof.cxx:9149
 TProof.cxx:9150
 TProof.cxx:9151
 TProof.cxx:9152
 TProof.cxx:9153
 TProof.cxx:9154
 TProof.cxx:9155
 TProof.cxx:9156
 TProof.cxx:9157
 TProof.cxx:9158
 TProof.cxx:9159
 TProof.cxx:9160
 TProof.cxx:9161
 TProof.cxx:9162
 TProof.cxx:9163
 TProof.cxx:9164
 TProof.cxx:9165
 TProof.cxx:9166
 TProof.cxx:9167
 TProof.cxx:9168
 TProof.cxx:9169
 TProof.cxx:9170
 TProof.cxx:9171
 TProof.cxx:9172
 TProof.cxx:9173
 TProof.cxx:9174
 TProof.cxx:9175
 TProof.cxx:9176
 TProof.cxx:9177
 TProof.cxx:9178
 TProof.cxx:9179
 TProof.cxx:9180
 TProof.cxx:9181
 TProof.cxx:9182
 TProof.cxx:9183
 TProof.cxx:9184
 TProof.cxx:9185
 TProof.cxx:9186
 TProof.cxx:9187
 TProof.cxx:9188
 TProof.cxx:9189
 TProof.cxx:9190
 TProof.cxx:9191
 TProof.cxx:9192
 TProof.cxx:9193
 TProof.cxx:9194
 TProof.cxx:9195
 TProof.cxx:9196
 TProof.cxx:9197
 TProof.cxx:9198
 TProof.cxx:9199
 TProof.cxx:9200
 TProof.cxx:9201
 TProof.cxx:9202
 TProof.cxx:9203
 TProof.cxx:9204
 TProof.cxx:9205
 TProof.cxx:9206
 TProof.cxx:9207
 TProof.cxx:9208
 TProof.cxx:9209
 TProof.cxx:9210
 TProof.cxx:9211
 TProof.cxx:9212
 TProof.cxx:9213
 TProof.cxx:9214
 TProof.cxx:9215
 TProof.cxx:9216
 TProof.cxx:9217
 TProof.cxx:9218
 TProof.cxx:9219
 TProof.cxx:9220
 TProof.cxx:9221
 TProof.cxx:9222
 TProof.cxx:9223
 TProof.cxx:9224
 TProof.cxx:9225
 TProof.cxx:9226
 TProof.cxx:9227
 TProof.cxx:9228
 TProof.cxx:9229
 TProof.cxx:9230
 TProof.cxx:9231
 TProof.cxx:9232
 TProof.cxx:9233
 TProof.cxx:9234
 TProof.cxx:9235
 TProof.cxx:9236
 TProof.cxx:9237
 TProof.cxx:9238
 TProof.cxx:9239
 TProof.cxx:9240
 TProof.cxx:9241
 TProof.cxx:9242
 TProof.cxx:9243
 TProof.cxx:9244
 TProof.cxx:9245
 TProof.cxx:9246
 TProof.cxx:9247
 TProof.cxx:9248
 TProof.cxx:9249
 TProof.cxx:9250
 TProof.cxx:9251
 TProof.cxx:9252
 TProof.cxx:9253
 TProof.cxx:9254
 TProof.cxx:9255
 TProof.cxx:9256
 TProof.cxx:9257
 TProof.cxx:9258
 TProof.cxx:9259
 TProof.cxx:9260
 TProof.cxx:9261
 TProof.cxx:9262
 TProof.cxx:9263
 TProof.cxx:9264
 TProof.cxx:9265
 TProof.cxx:9266
 TProof.cxx:9267
 TProof.cxx:9268
 TProof.cxx:9269
 TProof.cxx:9270
 TProof.cxx:9271
 TProof.cxx:9272
 TProof.cxx:9273
 TProof.cxx:9274
 TProof.cxx:9275
 TProof.cxx:9276
 TProof.cxx:9277
 TProof.cxx:9278
 TProof.cxx:9279
 TProof.cxx:9280
 TProof.cxx:9281
 TProof.cxx:9282
 TProof.cxx:9283
 TProof.cxx:9284
 TProof.cxx:9285
 TProof.cxx:9286
 TProof.cxx:9287
 TProof.cxx:9288
 TProof.cxx:9289
 TProof.cxx:9290
 TProof.cxx:9291
 TProof.cxx:9292
 TProof.cxx:9293
 TProof.cxx:9294
 TProof.cxx:9295
 TProof.cxx:9296
 TProof.cxx:9297
 TProof.cxx:9298
 TProof.cxx:9299
 TProof.cxx:9300
 TProof.cxx:9301
 TProof.cxx:9302
 TProof.cxx:9303
 TProof.cxx:9304
 TProof.cxx:9305
 TProof.cxx:9306
 TProof.cxx:9307
 TProof.cxx:9308
 TProof.cxx:9309
 TProof.cxx:9310
 TProof.cxx:9311
 TProof.cxx:9312
 TProof.cxx:9313
 TProof.cxx:9314
 TProof.cxx:9315
 TProof.cxx:9316
 TProof.cxx:9317
 TProof.cxx:9318
 TProof.cxx:9319
 TProof.cxx:9320
 TProof.cxx:9321
 TProof.cxx:9322
 TProof.cxx:9323
 TProof.cxx:9324
 TProof.cxx:9325
 TProof.cxx:9326
 TProof.cxx:9327
 TProof.cxx:9328
 TProof.cxx:9329
 TProof.cxx:9330
 TProof.cxx:9331
 TProof.cxx:9332
 TProof.cxx:9333
 TProof.cxx:9334
 TProof.cxx:9335
 TProof.cxx:9336
 TProof.cxx:9337
 TProof.cxx:9338
 TProof.cxx:9339
 TProof.cxx:9340
 TProof.cxx:9341
 TProof.cxx:9342
 TProof.cxx:9343
 TProof.cxx:9344
 TProof.cxx:9345
 TProof.cxx:9346
 TProof.cxx:9347
 TProof.cxx:9348
 TProof.cxx:9349
 TProof.cxx:9350
 TProof.cxx:9351
 TProof.cxx:9352
 TProof.cxx:9353
 TProof.cxx:9354
 TProof.cxx:9355
 TProof.cxx:9356
 TProof.cxx:9357
 TProof.cxx:9358
 TProof.cxx:9359
 TProof.cxx:9360
 TProof.cxx:9361
 TProof.cxx:9362
 TProof.cxx:9363
 TProof.cxx:9364
 TProof.cxx:9365
 TProof.cxx:9366
 TProof.cxx:9367
 TProof.cxx:9368
 TProof.cxx:9369
 TProof.cxx:9370
 TProof.cxx:9371
 TProof.cxx:9372
 TProof.cxx:9373
 TProof.cxx:9374
 TProof.cxx:9375
 TProof.cxx:9376
 TProof.cxx:9377
 TProof.cxx:9378
 TProof.cxx:9379
 TProof.cxx:9380
 TProof.cxx:9381
 TProof.cxx:9382
 TProof.cxx:9383
 TProof.cxx:9384
 TProof.cxx:9385
 TProof.cxx:9386
 TProof.cxx:9387
 TProof.cxx:9388
 TProof.cxx:9389
 TProof.cxx:9390
 TProof.cxx:9391
 TProof.cxx:9392
 TProof.cxx:9393
 TProof.cxx:9394
 TProof.cxx:9395
 TProof.cxx:9396
 TProof.cxx:9397
 TProof.cxx:9398
 TProof.cxx:9399
 TProof.cxx:9400
 TProof.cxx:9401
 TProof.cxx:9402
 TProof.cxx:9403
 TProof.cxx:9404
 TProof.cxx:9405
 TProof.cxx:9406
 TProof.cxx:9407
 TProof.cxx:9408
 TProof.cxx:9409
 TProof.cxx:9410
 TProof.cxx:9411
 TProof.cxx:9412
 TProof.cxx:9413
 TProof.cxx:9414
 TProof.cxx:9415
 TProof.cxx:9416
 TProof.cxx:9417
 TProof.cxx:9418
 TProof.cxx:9419
 TProof.cxx:9420
 TProof.cxx:9421
 TProof.cxx:9422
 TProof.cxx:9423
 TProof.cxx:9424
 TProof.cxx:9425
 TProof.cxx:9426
 TProof.cxx:9427
 TProof.cxx:9428
 TProof.cxx:9429
 TProof.cxx:9430
 TProof.cxx:9431
 TProof.cxx:9432
 TProof.cxx:9433
 TProof.cxx:9434
 TProof.cxx:9435
 TProof.cxx:9436
 TProof.cxx:9437
 TProof.cxx:9438
 TProof.cxx:9439
 TProof.cxx:9440
 TProof.cxx:9441
 TProof.cxx:9442
 TProof.cxx:9443
 TProof.cxx:9444
 TProof.cxx:9445
 TProof.cxx:9446
 TProof.cxx:9447
 TProof.cxx:9448
 TProof.cxx:9449
 TProof.cxx:9450
 TProof.cxx:9451
 TProof.cxx:9452
 TProof.cxx:9453
 TProof.cxx:9454
 TProof.cxx:9455
 TProof.cxx:9456
 TProof.cxx:9457
 TProof.cxx:9458
 TProof.cxx:9459
 TProof.cxx:9460
 TProof.cxx:9461
 TProof.cxx:9462
 TProof.cxx:9463
 TProof.cxx:9464
 TProof.cxx:9465
 TProof.cxx:9466
 TProof.cxx:9467
 TProof.cxx:9468
 TProof.cxx:9469
 TProof.cxx:9470
 TProof.cxx:9471
 TProof.cxx:9472
 TProof.cxx:9473
 TProof.cxx:9474
 TProof.cxx:9475
 TProof.cxx:9476
 TProof.cxx:9477
 TProof.cxx:9478
 TProof.cxx:9479
 TProof.cxx:9480
 TProof.cxx:9481
 TProof.cxx:9482
 TProof.cxx:9483
 TProof.cxx:9484
 TProof.cxx:9485
 TProof.cxx:9486
 TProof.cxx:9487
 TProof.cxx:9488
 TProof.cxx:9489
 TProof.cxx:9490
 TProof.cxx:9491
 TProof.cxx:9492
 TProof.cxx:9493
 TProof.cxx:9494
 TProof.cxx:9495
 TProof.cxx:9496
 TProof.cxx:9497
 TProof.cxx:9498
 TProof.cxx:9499
 TProof.cxx:9500
 TProof.cxx:9501
 TProof.cxx:9502
 TProof.cxx:9503
 TProof.cxx:9504
 TProof.cxx:9505
 TProof.cxx:9506
 TProof.cxx:9507
 TProof.cxx:9508
 TProof.cxx:9509
 TProof.cxx:9510
 TProof.cxx:9511
 TProof.cxx:9512
 TProof.cxx:9513
 TProof.cxx:9514
 TProof.cxx:9515
 TProof.cxx:9516
 TProof.cxx:9517
 TProof.cxx:9518
 TProof.cxx:9519
 TProof.cxx:9520
 TProof.cxx:9521
 TProof.cxx:9522
 TProof.cxx:9523
 TProof.cxx:9524
 TProof.cxx:9525
 TProof.cxx:9526
 TProof.cxx:9527
 TProof.cxx:9528
 TProof.cxx:9529
 TProof.cxx:9530
 TProof.cxx:9531
 TProof.cxx:9532
 TProof.cxx:9533
 TProof.cxx:9534
 TProof.cxx:9535
 TProof.cxx:9536
 TProof.cxx:9537
 TProof.cxx:9538
 TProof.cxx:9539
 TProof.cxx:9540
 TProof.cxx:9541
 TProof.cxx:9542
 TProof.cxx:9543
 TProof.cxx:9544
 TProof.cxx:9545
 TProof.cxx:9546
 TProof.cxx:9547
 TProof.cxx:9548
 TProof.cxx:9549
 TProof.cxx:9550
 TProof.cxx:9551
 TProof.cxx:9552
 TProof.cxx:9553
 TProof.cxx:9554
 TProof.cxx:9555
 TProof.cxx:9556
 TProof.cxx:9557
 TProof.cxx:9558
 TProof.cxx:9559
 TProof.cxx:9560
 TProof.cxx:9561
 TProof.cxx:9562
 TProof.cxx:9563
 TProof.cxx:9564
 TProof.cxx:9565
 TProof.cxx:9566
 TProof.cxx:9567
 TProof.cxx:9568
 TProof.cxx:9569
 TProof.cxx:9570
 TProof.cxx:9571
 TProof.cxx:9572
 TProof.cxx:9573
 TProof.cxx:9574
 TProof.cxx:9575
 TProof.cxx:9576
 TProof.cxx:9577
 TProof.cxx:9578
 TProof.cxx:9579
 TProof.cxx:9580
 TProof.cxx:9581
 TProof.cxx:9582
 TProof.cxx:9583
 TProof.cxx:9584
 TProof.cxx:9585
 TProof.cxx:9586
 TProof.cxx:9587
 TProof.cxx:9588
 TProof.cxx:9589
 TProof.cxx:9590
 TProof.cxx:9591
 TProof.cxx:9592
 TProof.cxx:9593
 TProof.cxx:9594
 TProof.cxx:9595
 TProof.cxx:9596
 TProof.cxx:9597
 TProof.cxx:9598
 TProof.cxx:9599
 TProof.cxx:9600
 TProof.cxx:9601
 TProof.cxx:9602
 TProof.cxx:9603
 TProof.cxx:9604
 TProof.cxx:9605
 TProof.cxx:9606
 TProof.cxx:9607
 TProof.cxx:9608
 TProof.cxx:9609
 TProof.cxx:9610
 TProof.cxx:9611
 TProof.cxx:9612
 TProof.cxx:9613
 TProof.cxx:9614
 TProof.cxx:9615
 TProof.cxx:9616
 TProof.cxx:9617
 TProof.cxx:9618
 TProof.cxx:9619
 TProof.cxx:9620
 TProof.cxx:9621
 TProof.cxx:9622
 TProof.cxx:9623
 TProof.cxx:9624
 TProof.cxx:9625
 TProof.cxx:9626
 TProof.cxx:9627
 TProof.cxx:9628
 TProof.cxx:9629
 TProof.cxx:9630
 TProof.cxx:9631
 TProof.cxx:9632
 TProof.cxx:9633
 TProof.cxx:9634
 TProof.cxx:9635
 TProof.cxx:9636
 TProof.cxx:9637
 TProof.cxx:9638
 TProof.cxx:9639
 TProof.cxx:9640
 TProof.cxx:9641
 TProof.cxx:9642
 TProof.cxx:9643
 TProof.cxx:9644
 TProof.cxx:9645
 TProof.cxx:9646
 TProof.cxx:9647
 TProof.cxx:9648
 TProof.cxx:9649
 TProof.cxx:9650
 TProof.cxx:9651
 TProof.cxx:9652
 TProof.cxx:9653
 TProof.cxx:9654
 TProof.cxx:9655
 TProof.cxx:9656
 TProof.cxx:9657
 TProof.cxx:9658
 TProof.cxx:9659
 TProof.cxx:9660
 TProof.cxx:9661
 TProof.cxx:9662
 TProof.cxx:9663
 TProof.cxx:9664
 TProof.cxx:9665
 TProof.cxx:9666
 TProof.cxx:9667
 TProof.cxx:9668
 TProof.cxx:9669
 TProof.cxx:9670
 TProof.cxx:9671
 TProof.cxx:9672
 TProof.cxx:9673
 TProof.cxx:9674
 TProof.cxx:9675
 TProof.cxx:9676
 TProof.cxx:9677
 TProof.cxx:9678
 TProof.cxx:9679
 TProof.cxx:9680
 TProof.cxx:9681
 TProof.cxx:9682
 TProof.cxx:9683
 TProof.cxx:9684
 TProof.cxx:9685
 TProof.cxx:9686
 TProof.cxx:9687
 TProof.cxx:9688
 TProof.cxx:9689
 TProof.cxx:9690
 TProof.cxx:9691
 TProof.cxx:9692
 TProof.cxx:9693
 TProof.cxx:9694
 TProof.cxx:9695
 TProof.cxx:9696
 TProof.cxx:9697
 TProof.cxx:9698
 TProof.cxx:9699
 TProof.cxx:9700
 TProof.cxx:9701
 TProof.cxx:9702
 TProof.cxx:9703
 TProof.cxx:9704
 TProof.cxx:9705
 TProof.cxx:9706
 TProof.cxx:9707
 TProof.cxx:9708
 TProof.cxx:9709
 TProof.cxx:9710
 TProof.cxx:9711
 TProof.cxx:9712
 TProof.cxx:9713
 TProof.cxx:9714
 TProof.cxx:9715
 TProof.cxx:9716
 TProof.cxx:9717
 TProof.cxx:9718
 TProof.cxx:9719
 TProof.cxx:9720
 TProof.cxx:9721
 TProof.cxx:9722
 TProof.cxx:9723
 TProof.cxx:9724
 TProof.cxx:9725
 TProof.cxx:9726
 TProof.cxx:9727
 TProof.cxx:9728
 TProof.cxx:9729
 TProof.cxx:9730
 TProof.cxx:9731
 TProof.cxx:9732
 TProof.cxx:9733
 TProof.cxx:9734
 TProof.cxx:9735
 TProof.cxx:9736
 TProof.cxx:9737
 TProof.cxx:9738
 TProof.cxx:9739
 TProof.cxx:9740
 TProof.cxx:9741
 TProof.cxx:9742
 TProof.cxx:9743
 TProof.cxx:9744
 TProof.cxx:9745
 TProof.cxx:9746
 TProof.cxx:9747
 TProof.cxx:9748
 TProof.cxx:9749
 TProof.cxx:9750
 TProof.cxx:9751
 TProof.cxx:9752
 TProof.cxx:9753
 TProof.cxx:9754
 TProof.cxx:9755
 TProof.cxx:9756
 TProof.cxx:9757
 TProof.cxx:9758
 TProof.cxx:9759
 TProof.cxx:9760
 TProof.cxx:9761
 TProof.cxx:9762
 TProof.cxx:9763
 TProof.cxx:9764
 TProof.cxx:9765
 TProof.cxx:9766
 TProof.cxx:9767
 TProof.cxx:9768
 TProof.cxx:9769
 TProof.cxx:9770
 TProof.cxx:9771
 TProof.cxx:9772
 TProof.cxx:9773
 TProof.cxx:9774
 TProof.cxx:9775
 TProof.cxx:9776
 TProof.cxx:9777
 TProof.cxx:9778
 TProof.cxx:9779
 TProof.cxx:9780
 TProof.cxx:9781
 TProof.cxx:9782
 TProof.cxx:9783
 TProof.cxx:9784
 TProof.cxx:9785
 TProof.cxx:9786
 TProof.cxx:9787
 TProof.cxx:9788
 TProof.cxx:9789
 TProof.cxx:9790
 TProof.cxx:9791
 TProof.cxx:9792
 TProof.cxx:9793
 TProof.cxx:9794
 TProof.cxx:9795
 TProof.cxx:9796
 TProof.cxx:9797
 TProof.cxx:9798
 TProof.cxx:9799
 TProof.cxx:9800
 TProof.cxx:9801
 TProof.cxx:9802
 TProof.cxx:9803
 TProof.cxx:9804
 TProof.cxx:9805
 TProof.cxx:9806
 TProof.cxx:9807
 TProof.cxx:9808
 TProof.cxx:9809
 TProof.cxx:9810
 TProof.cxx:9811
 TProof.cxx:9812
 TProof.cxx:9813
 TProof.cxx:9814
 TProof.cxx:9815
 TProof.cxx:9816
 TProof.cxx:9817
 TProof.cxx:9818
 TProof.cxx:9819
 TProof.cxx:9820
 TProof.cxx:9821
 TProof.cxx:9822
 TProof.cxx:9823
 TProof.cxx:9824
 TProof.cxx:9825
 TProof.cxx:9826
 TProof.cxx:9827
 TProof.cxx:9828
 TProof.cxx:9829
 TProof.cxx:9830
 TProof.cxx:9831
 TProof.cxx:9832
 TProof.cxx:9833
 TProof.cxx:9834
 TProof.cxx:9835
 TProof.cxx:9836
 TProof.cxx:9837
 TProof.cxx:9838
 TProof.cxx:9839
 TProof.cxx:9840
 TProof.cxx:9841
 TProof.cxx:9842
 TProof.cxx:9843
 TProof.cxx:9844
 TProof.cxx:9845
 TProof.cxx:9846
 TProof.cxx:9847
 TProof.cxx:9848
 TProof.cxx:9849
 TProof.cxx:9850
 TProof.cxx:9851
 TProof.cxx:9852
 TProof.cxx:9853
 TProof.cxx:9854
 TProof.cxx:9855
 TProof.cxx:9856
 TProof.cxx:9857
 TProof.cxx:9858
 TProof.cxx:9859
 TProof.cxx:9860
 TProof.cxx:9861
 TProof.cxx:9862
 TProof.cxx:9863
 TProof.cxx:9864
 TProof.cxx:9865
 TProof.cxx:9866
 TProof.cxx:9867
 TProof.cxx:9868
 TProof.cxx:9869
 TProof.cxx:9870
 TProof.cxx:9871
 TProof.cxx:9872
 TProof.cxx:9873
 TProof.cxx:9874
 TProof.cxx:9875
 TProof.cxx:9876
 TProof.cxx:9877
 TProof.cxx:9878
 TProof.cxx:9879
 TProof.cxx:9880
 TProof.cxx:9881
 TProof.cxx:9882
 TProof.cxx:9883
 TProof.cxx:9884
 TProof.cxx:9885
 TProof.cxx:9886
 TProof.cxx:9887
 TProof.cxx:9888
 TProof.cxx:9889
 TProof.cxx:9890
 TProof.cxx:9891
 TProof.cxx:9892
 TProof.cxx:9893
 TProof.cxx:9894
 TProof.cxx:9895
 TProof.cxx:9896
 TProof.cxx:9897
 TProof.cxx:9898
 TProof.cxx:9899
 TProof.cxx:9900
 TProof.cxx:9901
 TProof.cxx:9902
 TProof.cxx:9903
 TProof.cxx:9904
 TProof.cxx:9905
 TProof.cxx:9906
 TProof.cxx:9907
 TProof.cxx:9908
 TProof.cxx:9909
 TProof.cxx:9910
 TProof.cxx:9911
 TProof.cxx:9912
 TProof.cxx:9913
 TProof.cxx:9914
 TProof.cxx:9915
 TProof.cxx:9916
 TProof.cxx:9917
 TProof.cxx:9918
 TProof.cxx:9919
 TProof.cxx:9920
 TProof.cxx:9921
 TProof.cxx:9922
 TProof.cxx:9923
 TProof.cxx:9924
 TProof.cxx:9925
 TProof.cxx:9926
 TProof.cxx:9927
 TProof.cxx:9928
 TProof.cxx:9929
 TProof.cxx:9930
 TProof.cxx:9931
 TProof.cxx:9932
 TProof.cxx:9933
 TProof.cxx:9934
 TProof.cxx:9935
 TProof.cxx:9936
 TProof.cxx:9937
 TProof.cxx:9938
 TProof.cxx:9939
 TProof.cxx:9940
 TProof.cxx:9941
 TProof.cxx:9942
 TProof.cxx:9943
 TProof.cxx:9944
 TProof.cxx:9945
 TProof.cxx:9946
 TProof.cxx:9947
 TProof.cxx:9948
 TProof.cxx:9949
 TProof.cxx:9950
 TProof.cxx:9951
 TProof.cxx:9952
 TProof.cxx:9953
 TProof.cxx:9954
 TProof.cxx:9955
 TProof.cxx:9956
 TProof.cxx:9957
 TProof.cxx:9958
 TProof.cxx:9959
 TProof.cxx:9960
 TProof.cxx:9961
 TProof.cxx:9962
 TProof.cxx:9963
 TProof.cxx:9964
 TProof.cxx:9965
 TProof.cxx:9966
 TProof.cxx:9967
 TProof.cxx:9968
 TProof.cxx:9969
 TProof.cxx:9970
 TProof.cxx:9971
 TProof.cxx:9972
 TProof.cxx:9973
 TProof.cxx:9974
 TProof.cxx:9975
 TProof.cxx:9976
 TProof.cxx:9977
 TProof.cxx:9978
 TProof.cxx:9979
 TProof.cxx:9980
 TProof.cxx:9981
 TProof.cxx:9982
 TProof.cxx:9983
 TProof.cxx:9984
 TProof.cxx:9985
 TProof.cxx:9986
 TProof.cxx:9987
 TProof.cxx:9988
 TProof.cxx:9989
 TProof.cxx:9990
 TProof.cxx:9991
 TProof.cxx:9992
 TProof.cxx:9993
 TProof.cxx:9994
 TProof.cxx:9995
 TProof.cxx:9996
 TProof.cxx:9997
 TProof.cxx:9998
 TProof.cxx:9999
 TProof.cxx:10000
 TProof.cxx:10001
 TProof.cxx:10002
 TProof.cxx:10003
 TProof.cxx:10004
 TProof.cxx:10005
 TProof.cxx:10006
 TProof.cxx:10007
 TProof.cxx:10008
 TProof.cxx:10009
 TProof.cxx:10010
 TProof.cxx:10011
 TProof.cxx:10012
 TProof.cxx:10013
 TProof.cxx:10014
 TProof.cxx:10015
 TProof.cxx:10016
 TProof.cxx:10017
 TProof.cxx:10018
 TProof.cxx:10019
 TProof.cxx:10020
 TProof.cxx:10021
 TProof.cxx:10022
 TProof.cxx:10023
 TProof.cxx:10024
 TProof.cxx:10025
 TProof.cxx:10026
 TProof.cxx:10027
 TProof.cxx:10028
 TProof.cxx:10029
 TProof.cxx:10030
 TProof.cxx:10031
 TProof.cxx:10032
 TProof.cxx:10033
 TProof.cxx:10034
 TProof.cxx:10035
 TProof.cxx:10036
 TProof.cxx:10037
 TProof.cxx:10038
 TProof.cxx:10039
 TProof.cxx:10040
 TProof.cxx:10041
 TProof.cxx:10042
 TProof.cxx:10043
 TProof.cxx:10044
 TProof.cxx:10045
 TProof.cxx:10046
 TProof.cxx:10047
 TProof.cxx:10048
 TProof.cxx:10049
 TProof.cxx:10050
 TProof.cxx:10051
 TProof.cxx:10052
 TProof.cxx:10053
 TProof.cxx:10054
 TProof.cxx:10055
 TProof.cxx:10056
 TProof.cxx:10057
 TProof.cxx:10058
 TProof.cxx:10059