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

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

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

#include "TProofDraw.h"
#include "TProofPlayer.h"
#include "THashList.h"
#include "TEnv.h"
#include "TEventIter.h"
#include "TVirtualPacketizer.h"
#include "TSelector.h"
#include "TSocket.h"
#include "TProofServ.h"
#include "TProof.h"
#include "TProofOutputFile.h"
#include "TProofSuperMaster.h"
#include "TSlave.h"
#include "TClass.h"
#include "TROOT.h"
#include "TError.h"
#include "TException.h"
#include "MessageTypes.h"
#include "TMessage.h"
#include "TDSetProxy.h"
#include "TString.h"
#include "TSystem.h"
#include "TFile.h"
#include "TFileCollection.h"
#include "TFileInfo.h"
#include "TFileMerger.h"
#include "TProofDebug.h"
#include "TTimer.h"
#include "TMap.h"
#include "TPerfStats.h"
#include "TStatus.h"
#include "TEventList.h"
#include "TProofLimitsFinder.h"
#include "THashList.h"
#include "TSortedList.h"
#include "TTree.h"
#include "TEntryList.h"
#include "TDSet.h"
#include "TDrawFeedback.h"
#include "TNamed.h"
#include "TObjString.h"
#include "TQueryResult.h"
#include "TMD5.h"
#include "TMethodCall.h"
#include "TObjArray.h"
#include "TMutex.h"
#include "TH1.h"
#include "TVirtualMonitoring.h"
#include "TParameter.h"
#include "TOutputListSelectorDataMap.h"
#include "TStopwatch.h"

// Timeout exception
#define kPEX_STOPPED  1001
#define kPEX_ABORTED  1002

// To flag an abort condition: use a local static variable to avoid
// warnings about problems with longjumps
static Bool_t gAbort = kFALSE;

class TAutoBinVal : public TNamed {
private:
   Double_t fXmin, fXmax, fYmin, fYmax, fZmin, fZmax;

public:
   TAutoBinVal(const char *name, Double_t xmin, Double_t xmax, Double_t ymin,
               Double_t ymax, Double_t zmin, Double_t zmax) : TNamed(name,"")
   {
      fXmin = xmin; fXmax = xmax;
      fYmin = ymin; fYmax = ymax;
      fZmin = zmin; fZmax = zmax;
   }
   void GetAll(Double_t& xmin, Double_t& xmax, Double_t& ymin,
               Double_t& ymax, Double_t& zmin, Double_t& zmax)
   {
      xmin = fXmin; xmax = fXmax;
      ymin = fYmin; ymax = fYmax;
      zmin = fZmin; zmax = fZmax;
   }

};

//
// Special timer to dispatch pending events while processing
//______________________________________________________________________________
class TDispatchTimer : public TTimer {
private:
   TProofPlayer    *fPlayer;

public:
   TDispatchTimer(TProofPlayer *p) : TTimer(1000, kFALSE), fPlayer(p) { }

   Bool_t Notify();
};
//______________________________________________________________________________
Bool_t TDispatchTimer::Notify()
{
   // Handle expiration of the timer associated with dispatching pending
   // events while processing. We must act as fast as possible here, so
   // we just set a flag submitting a request for dispatching pending events

   if (gDebug > 0) printf("TDispatchTimer::Notify: called!\n");

   fPlayer->SetBit(TProofPlayer::kDispatchOneEvent);

   // Needed for the next shot
   Reset();
   return kTRUE;
}

//
// Special timer to notify reach of max packet proc time
//______________________________________________________________________________
class TProctimeTimer : public TTimer {
private:
   TProofPlayer    *fPlayer;

public:
   TProctimeTimer(TProofPlayer *p, Long_t to) : TTimer(to, kFALSE), fPlayer(p) { }

   Bool_t Notify();
};
//______________________________________________________________________________
Bool_t TProctimeTimer::Notify()
{
   // Handle expiration of the timer associated with dispatching pending
   // events while processing. We must act as fast as possible here, so
   // we just set a flag submitting a request for dispatching pending events

   if (gDebug > 0) printf("TProctimeTimer::Notify: called!\n");

   fPlayer->SetBit(TProofPlayer::kMaxProcTimeReached);

   // One shot only
   return kTRUE;
}

//
// Special timer to handle stop/abort request via exception raising
//______________________________________________________________________________
class TStopTimer : public TTimer {
private:
   Bool_t           fAbort;
   TProofPlayer    *fPlayer;

public:
   TStopTimer(TProofPlayer *p, Bool_t abort, Int_t to);

   Bool_t Notify();
};

//______________________________________________________________________________
TStopTimer::TStopTimer(TProofPlayer *p, Bool_t abort, Int_t to)
           : TTimer(((to <= 0 || to > 864000) ? 10 : to * 1000), kFALSE)
{
   // Constructor for the timer to stop/abort processing.
   // The 'timeout' is in seconds.
   // Make sure that 'to' make sense, i.e. not larger than 10 days;
   // the minimum value is 10 ms (0 does not seem to start the timer ...).

   if (gDebug > 0)
      Info ("TStopTimer","enter: %d, timeout: %d", abort, to);

   fPlayer = p;
   fAbort = abort;

   if (gDebug > 1)
      Info ("TStopTimer","timeout set to %s ms", fTime.AsString());
}

//______________________________________________________________________________
Bool_t TStopTimer::Notify()
{
   // Handle the signal coming from the expiration of the timer
   // associated with an abort or stop request.
   // We raise an exception which will be processed in the
   // event loop.

   if (gDebug > 0) printf("TStopTimer::Notify: called!\n");

   if (fAbort)
      Throw(kPEX_ABORTED);
   else
      Throw(kPEX_STOPPED);

   return kTRUE;
}

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

ClassImp(TProofPlayer)

THashList *TProofPlayer::fgDrawInputPars = 0;

//______________________________________________________________________________
TProofPlayer::TProofPlayer(TProof *)
   : fAutoBins(0), fOutput(0), fSelector(0), fCreateSelObj(kTRUE), fSelectorClass(0),
     fFeedbackTimer(0), fFeedbackPeriod(2000),
     fEvIter(0), fSelStatus(0),
     fTotalEvents(0), fReadBytesRun(0), fReadCallsRun(0), fProcessedRun(0),
     fQueryResults(0), fQuery(0), fPreviousQuery(0), fDrawQueries(0),
     fMaxDrawQueries(1), fStopTimer(0), fStopTimerMtx(0), fDispatchTimer(0),
     fProcTimeTimer(0), fProcTime(0),
     fOutputFile(0),
     fSaveMemThreshold(-1), fSavePartialResults(kFALSE), fSaveResultsPerPacket(kFALSE)
{
   // Default ctor.

   fInput         = new TList;
   fExitStatus    = kFinished;
   fProgressStatus = new TProofProgressStatus();
   ResetBit(TProofPlayer::kDispatchOneEvent);
   ResetBit(TProofPlayer::kIsProcessing);
   ResetBit(TProofPlayer::kMaxProcTimeReached);
   ResetBit(TProofPlayer::kMaxProcTimeExtended);

   static Bool_t initLimitsFinder = kFALSE;
   if (!initLimitsFinder && gProofServ && !gProofServ->IsMaster()) {
      THLimitsFinder::SetLimitsFinder(new TProofLimitsFinder);
      initLimitsFinder = kTRUE;
   }

}

//______________________________________________________________________________
TProofPlayer::~TProofPlayer()
{
   // Destructor.

   fInput->Clear("nodelete");
   SafeDelete(fInput);
   // The output list is owned by fSelector and destroyed in there
   SafeDelete(fSelector);
   SafeDelete(fFeedbackTimer);
   SafeDelete(fEvIter);
   SafeDelete(fQueryResults);
   SafeDelete(fDispatchTimer);
   SafeDelete(fProcTimeTimer);
   SafeDelete(fProcTime);
   SafeDelete(fStopTimer);
}

//______________________________________________________________________________
void TProofPlayer::SetProcessing(Bool_t on)
{
   // Set processing bit according to 'on'

   if (on)
      SetBit(TProofPlayer::kIsProcessing);
   else
      ResetBit(TProofPlayer::kIsProcessing);
}

//______________________________________________________________________________
void TProofPlayer::StopProcess(Bool_t abort, Int_t timeout)
{
   // Stop the process after this event. If timeout is positive, start
   // a timer firing after timeout seconds to hard-stop time-expensive
   // events.

   if (gDebug > 0)
      Info ("StopProcess","abort: %d, timeout: %d", abort, timeout);

   if (fEvIter != 0)
      fEvIter->StopProcess(abort);
   Long_t to = 1;
   if (abort == kTRUE) {
      fExitStatus = kAborted;
   } else {
      fExitStatus = kStopped;
      to = timeout;
   }
   // Start countdown, if needed
   if (to > 0)
      SetStopTimer(kTRUE, abort, to);
}

//______________________________________________________________________________
void TProofPlayer::SetDispatchTimer(Bool_t on)
{
   // Enable/disable the timer to dispatch pening events while processing.

   SafeDelete(fDispatchTimer);
   ResetBit(TProofPlayer::kDispatchOneEvent);
   if (on) {
      fDispatchTimer = new TDispatchTimer(this);
      fDispatchTimer->Start();
   }
}

//______________________________________________________________________________
void TProofPlayer::SetStopTimer(Bool_t on, Bool_t abort, Int_t timeout)
{
   // Enable/disable the timer to stop/abort processing.
   // The 'timeout' is in seconds.

   fStopTimerMtx = (fStopTimerMtx) ? fStopTimerMtx : new TMutex(kTRUE);
   R__LOCKGUARD(fStopTimerMtx);

   // Clean-up the timer
   SafeDelete(fStopTimer);
   if (on) {
      // create timer
      fStopTimer = new TStopTimer(this, abort, timeout);
      // Start the countdown
      fStopTimer->Start();
      if (gDebug > 0)
         Info ("SetStopTimer", "%s timer STARTED (timeout: %d)",
                               (abort ? "ABORT" : "STOP"), timeout);
   } else {
      if (gDebug > 0)
         Info ("SetStopTimer", "timer STOPPED");
   }
}

//______________________________________________________________________________
void TProofPlayer::AddQueryResult(TQueryResult *q)
{
   // Add query result to the list, making sure that there are no
   // duplicates.

   if (!q) {
      Warning("AddQueryResult","query undefined - do nothing");
      return;
   }

   // Treat differently normal and draw queries
   if (!(q->IsDraw())) {
      if (!fQueryResults) {
         fQueryResults = new TList;
         fQueryResults->Add(q);
      } else {
         TIter nxr(fQueryResults);
         TQueryResult *qr = 0;
         TQueryResult *qp = 0;
         while ((qr = (TQueryResult *) nxr())) {
            // If same query, remove old version and break
            if (*qr == *q) {
               fQueryResults->Remove(qr);
               delete qr;
               break;
            }
            // Record position according to start time
            if (qr->GetStartTime().Convert() <= q->GetStartTime().Convert())
               qp = qr;
         }

         if (!qp) {
            fQueryResults->AddFirst(q);
         } else {
            fQueryResults->AddAfter(qp, q);
         }
      }
   } else if (IsClient()) {
      // If max reached, eliminate first the oldest one
      if (fDrawQueries == fMaxDrawQueries && fMaxDrawQueries > 0) {
         TIter nxr(fQueryResults);
         TQueryResult *qr = 0;
         while ((qr = (TQueryResult *) nxr())) {
            // If same query, remove old version and break
            if (qr->IsDraw()) {
               fDrawQueries--;
               fQueryResults->Remove(qr);
               delete qr;
               break;
            }
         }
      }
      // Add new draw query
      if (fDrawQueries >= 0 && fDrawQueries < fMaxDrawQueries) {
         fDrawQueries++;
         if (!fQueryResults)
            fQueryResults = new TList;
         fQueryResults->Add(q);
      }
   }
}

//______________________________________________________________________________
void TProofPlayer::RemoveQueryResult(const char *ref)
{
   // Remove all query result instances referenced 'ref' from
   // the list of results.

   if (fQueryResults) {
      TIter nxq(fQueryResults);
      TQueryResult *qr = 0;
      while ((qr = (TQueryResult *) nxq())) {
         if (qr->Matches(ref)) {
            fQueryResults->Remove(qr);
            delete qr;
         }
      }
   }
}

//______________________________________________________________________________
TQueryResult *TProofPlayer::GetQueryResult(const char *ref)
{
   // Get query result instances referenced 'ref' from
   // the list of results.

   if (fQueryResults) {
      if (ref && strlen(ref) > 0) {
         TIter nxq(fQueryResults);
         TQueryResult *qr = 0;
         while ((qr = (TQueryResult *) nxq())) {
            if (qr->Matches(ref))
               return qr;
         }
      } else {
         // Get last
         return (TQueryResult *) fQueryResults->Last();
      }
   }

   // Nothing found
   return (TQueryResult *)0;
}

//______________________________________________________________________________
void TProofPlayer::SetCurrentQuery(TQueryResult *q)
{
   // Set current query and save previous value.

   fPreviousQuery = fQuery;
   fQuery = q;
}

//______________________________________________________________________________
void TProofPlayer::AddInput(TObject *inp)
{
   // Add object to input list.

   fInput->Add(inp);
}

//______________________________________________________________________________
void TProofPlayer::ClearInput()
{
   // Clear input list.

   fInput->Clear();
}

//______________________________________________________________________________
TObject *TProofPlayer::GetOutput(const char *name) const
{
   // Get output object by name.

   if (fOutput)
      return fOutput->FindObject(name);
   return 0;
}

//______________________________________________________________________________
TList *TProofPlayer::GetOutputList() const
{
   // Get output list.

   TList *ol = fOutput;
   if (!ol && fQuery)
      ol = fQuery->GetOutputList();
   return ol;
}

//______________________________________________________________________________
Int_t TProofPlayer::ReinitSelector(TQueryResult *qr)
{
   // Reinitialize fSelector using the selector files in the query result.
   // Needed when Finalize is called after a Process execution for the same
   // selector name.

   Int_t rc = 0;

   // Make sure we have a query
   if (!qr) {
      Info("ReinitSelector", "query undefined - do nothing");
      return -1;
   }

   // Selector name
   TString selec = qr->GetSelecImp()->GetName();
   if (selec.Length() <= 0) {
      Info("ReinitSelector", "selector name undefined - do nothing");
      return -1;
   }

   // Find out if this is a standard selection used for Draw actions
   Bool_t stdselec = TSelector::IsStandardDraw(selec);

   // Find out if this is a precompiled selector: in such a case we do not
   // have the code in TMacros, so we must rely on local libraries
   Bool_t compselec = (selec.Contains(".") || stdselec) ? kFALSE : kTRUE;

   // If not, find out if it needs to be expanded
   TString ipathold;
   if (!stdselec && !compselec) {
      // Check checksums for the versions of the selector files
      Bool_t expandselec = kTRUE;
      TString dir, ipath;
      char *selc = gSystem->Which(TROOT::GetMacroPath(), selec, kReadPermission);
      if (selc) {
         // Check checksums
         TMD5 *md5icur = 0, *md5iold = 0, *md5hcur = 0, *md5hold = 0;
         // Implementation files
         md5icur = TMD5::FileChecksum(selc);
         md5iold = qr->GetSelecImp()->Checksum();
         // Header files
         TString selh(selc);
         Int_t dot = selh.Last('.');
         if (dot != kNPOS) selh.Remove(dot);
         selh += ".h";
         if (!gSystem->AccessPathName(selh, kReadPermission))
            md5hcur = TMD5::FileChecksum(selh);
         md5hold = qr->GetSelecHdr()->Checksum();

         // If nothing has changed nothing to do
         if (md5hcur && md5hold && md5icur && md5iold)
            if (*md5hcur == *md5hold && *md5icur == *md5iold)
               expandselec = kFALSE;

         SafeDelete(md5icur);
         SafeDelete(md5hcur);
         SafeDelete(md5iold);
         SafeDelete(md5hold);
         if (selc) delete [] selc;
      }

      Bool_t ok = kTRUE;
      // Expand selector files, if needed
      if (expandselec) {

         ok = kFALSE;
         // Expand files in a temporary directory
         TUUID u;
         dir = Form("%s/%s",gSystem->TempDirectory(),u.AsString());
         if (!(gSystem->MakeDirectory(dir))) {

            // Export implementation file
            selec = Form("%s/%s",dir.Data(),selec.Data());
            qr->GetSelecImp()->SaveSource(selec);

            // Export header file
            TString seleh = Form("%s/%s",dir.Data(),qr->GetSelecHdr()->GetName());
            qr->GetSelecHdr()->SaveSource(seleh);

            // Adjust include path
            ipathold = gSystem->GetIncludePath();
            ipath = Form("-I%s %s", dir.Data(), gSystem->GetIncludePath());
            gSystem->SetIncludePath(ipath.Data());

            ok = kTRUE;
         }
      }
      TString opt(qr->GetOptions());
      Ssiz_t id = opt.Last('#');
      if (id != kNPOS && id < opt.Length() - 1)
         selec += opt(id + 1, opt.Length());

      if (!ok) {
         Info("ReinitSelector", "problems locating or exporting selector files");
         return -1;
      }
   }

   // Cleanup previous stuff
   SafeDelete(fSelector);
   fSelectorClass = 0;

   // Init the selector now
   Int_t iglevelsave = gErrorIgnoreLevel;
   if (compselec)
      // Silent error printout on first attempt
      gErrorIgnoreLevel = kBreak;

   if ((fSelector = TSelector::GetSelector(selec))) {
      if (compselec)
         gErrorIgnoreLevel = iglevelsave; // restore ignore level
      fSelectorClass = fSelector->IsA();
      fSelector->SetOption(qr->GetOptions());

   } else {
      if (compselec) {
         gErrorIgnoreLevel = iglevelsave; // restore ignore level
         // Retry by loading first the libraries listed in TQueryResult, if any
         if (strlen(qr->GetLibList()) > 0) {
            TString sl(qr->GetLibList());
            TObjArray *oa = sl.Tokenize(" ");
            if (oa) {
               Bool_t retry = kFALSE;
               TIter nxl(oa);
               TObjString *os = 0;
               while ((os = (TObjString *) nxl())) {
                  TString lib = gSystem->BaseName(os->GetName());
                  if (lib != "lib") {
                     lib.ReplaceAll("-l", "lib");
                     if (gSystem->Load(lib) == 0)
                        retry = kTRUE;
                  }
               }
               // Retry now, if the case
               if (retry)
                  fSelector = TSelector::GetSelector(selec);
            }
         }
      }
      if (!fSelector) {
         if (compselec)
            Info("ReinitSelector", "compiled selector re-init failed:"
                                   " automatic reload unsuccessful:"
                                   " please load manually the correct library");
         rc = -1;
      }
   }
   if (fSelector) {
      // Draw needs to reinit temp histos
      fSelector->SetInputList(qr->GetInputList());
      if (stdselec) {
         ((TProofDraw *)fSelector)->DefVar();
      } else {
         // variables may have been initialized in Begin()
         fSelector->Begin(0);
      }
   }

   // Restore original include path, if needed
   if (ipathold.Length() > 0)
      gSystem->SetIncludePath(ipathold.Data());

   return rc;
}

//______________________________________________________________________________
Int_t TProofPlayer::AddOutputObject(TObject *)
{
   // Incorporate output object (may not be used in this class).

   MayNotUse("AddOutputObject");
   return -1;
}

//______________________________________________________________________________
void TProofPlayer::AddOutput(TList *)
{
   // Incorporate output list (may not be used in this class).

   MayNotUse("AddOutput");
}

//______________________________________________________________________________
void TProofPlayer::StoreOutput(TList *)
{
   // Store output list (may not be used in this class).

   MayNotUse("StoreOutput");
}

//______________________________________________________________________________
void TProofPlayer::StoreFeedback(TObject *, TList *)
{
   // Store feedback list (may not be used in this class).

   MayNotUse("StoreFeedback");
}

//______________________________________________________________________________
void TProofPlayer::Progress(Long64_t /*total*/, Long64_t /*processed*/)
{
   // Report progress (may not be used in this class).

   MayNotUse("Progress");
}

//______________________________________________________________________________
void TProofPlayer::Progress(Long64_t /*total*/, Long64_t /*processed*/,
                            Long64_t /*bytesread*/,
                            Float_t /*evtRate*/, Float_t /*mbRate*/,
                            Float_t /*evtrti*/, Float_t /*mbrti*/)
{
   // Report progress (may not be used in this class).

   MayNotUse("Progress");
}

//______________________________________________________________________________
void TProofPlayer::Progress(TProofProgressInfo * /*pi*/)
{
   // Report progress (may not be used in this class).

   MayNotUse("Progress");
}

//______________________________________________________________________________
void TProofPlayer::Feedback(TList *)
{
   // Set feedback list (may not be used in this class).

   MayNotUse("Feedback");
}

//______________________________________________________________________________
TDrawFeedback *TProofPlayer::CreateDrawFeedback(TProof *p)
{
   // Draw feedback creation proxy. When accessed via TProof avoids
   // link dependency on libProofPlayer.

   return new TDrawFeedback(p);
}

//______________________________________________________________________________
void TProofPlayer::SetDrawFeedbackOption(TDrawFeedback *f, Option_t *opt)
{
   // Set draw feedback option.

   if (f)
      f->SetOption(opt);
}

//______________________________________________________________________________
void TProofPlayer::DeleteDrawFeedback(TDrawFeedback *f)
{
   // Delete draw feedback object.

   delete f;
}

//______________________________________________________________________________
Int_t TProofPlayer::SavePartialResults(Bool_t queryend, Bool_t force)
{
   // Save the partial results of this query to a dedicated file under the user
   // data directory. The file name has the form
   //         <session_tag>.q<query_seq_num>.root
   // The file pat and the file are created if not existing already.
   // Only objects in the outputlist not being TProofOutputFile are saved.
   // The packets list 'packets' is saved if given.
   // Trees not attached to any file are attached to the open file.
   // If 'queryend' is kTRUE evrything is written out (TTrees included).
   // The actual saving action is controlled by 'force' and by fSavePartialResults /
   // fSaveResultsPerPacket:
   //
   //    fSavePartialResults = kFALSE/kTRUE  no-saving/saving
   //    fSaveResultsPerPacket = kFALSE/kTRUE  save-per-query/save-per-packet
   //
   // The function CheckMemUsage sets fSavePartialResults = 1 if fSaveMemThreshold > 0 and
   // ProcInfo_t::fMemResident >= fSaveMemThreshold: from that point on partial results
   // are always saved and expensive calls to TSystem::GetProcInfo saved.
   // The switch fSaveResultsPerPacket is instead controlled by the user or admin
   // who can also force saving in all cases; parameter PROOF_SavePartialResults or
   // RC env ProofPlayer.SavePartialResults .
   // However, if 'force' is kTRUE, fSavePartialResults and fSaveResultsPerPacket
   // are ignored.
   // Return -1 in case of problems, 0 otherwise.

   Bool_t save = (force || (fSavePartialResults &&
                 (queryend || fSaveResultsPerPacket))) ? kTRUE : kFALSE;
   if (!save) {
      PDB(kOutput, 2)
         Info("SavePartialResults", "partial result saving disabled");
      return 0;
   }

   // Sanity check
   if (!gProofServ) {
      Error("SavePartialResults", "gProofServ undefined: something really wrong going on!!!");
      return -1;
   }
   if (!fOutput) {
      Error("SavePartialResults", "fOutput undefined: something really wrong going on!!!");
      return -1;
   }

   PDB(kOutput, 1)
      Info("SavePartialResults", "start saving partial results {%d,%d,%d,%d}",
                                 queryend, force, fSavePartialResults, fSaveResultsPerPacket);

   // Get list of processed packets from the iterator
   PDB(kOutput, 2) Info("SavePartialResults", "fEvIter: %p", fEvIter);

   TList *packets = (fEvIter) ? fEvIter->GetPackets() : 0;
   PDB(kOutput, 2) Info("SavePartialResults", "list of packets: %p, sz: %d",
                                              packets, (packets ? packets->GetSize(): -1));

   // Open the file
   const char *oopt = "UPDATE";
   // Check if the file has already been defined
   TString baseName(fOutputFilePath);
   if (fOutputFilePath.IsNull()) {
      baseName.Form("output-%s.q%d.root", gProofServ->GetTopSessionTag(), gProofServ->GetQuerySeqNum());
      if (gProofServ->GetDataDirOpts() && strlen(gProofServ->GetDataDirOpts()) > 0) {
         fOutputFilePath.Form("%s/%s?%s", gProofServ->GetDataDir(), baseName.Data(),
                                          gProofServ->GetDataDirOpts());
      } else {
         fOutputFilePath.Form("%s/%s", gProofServ->GetDataDir(), baseName.Data());
      }
      Info("SavePartialResults", "file with (partial) output: '%s'", fOutputFilePath.Data());
      oopt = "RECREATE";
   }
   // Open the file in write mode
   if (!(fOutputFile = TFile::Open(fOutputFilePath, oopt)) ||
         (fOutputFile && fOutputFile->IsZombie())) {
      Error("SavePartialResults", "cannot open '%s' for writing", fOutputFilePath.Data());
      SafeDelete(fOutputFile);
      return -1;
   }

   // Save current directory
   TDirectory *curdir = gDirectory;
   fOutputFile->cd();

   // Write first the packets list, if required
   if (packets) {
      TDirectory *packetsDir = fOutputFile->mkdir("packets");
      if (packetsDir) packetsDir->cd();
      packets->Write(0, TObject::kSingleKey | TObject::kOverwrite);
      fOutputFile->cd();
   }

   Bool_t notempty = kFALSE;
   // Write out the output list
   TList torm;
   TIter nxo(fOutput);
   TObject *o = 0;
   while ((o = nxo())) {
      // Skip output file drivers
      if (o->InheritsFrom(TProofOutputFile::Class())) continue;
      // Skip control objets
      if (!strncmp(o->GetName(), "PROOF_", 6)) continue;
      // Skip data members mapping
      if (o->InheritsFrom(TOutputListSelectorDataMap::Class())) continue;
      // Skip missing file info
      if (!strcmp(o->GetName(), "MissingFiles")) continue;
      // Trees need a special treatment
      if (o->InheritsFrom("TTree")) {
         TTree *t = (TTree *) o;
         TDirectory *d = t->GetDirectory();
         // If the tree is not attached to any file ...
         if (!d || (d  && !d->InheritsFrom("TFile"))) {
            // ... we attach it
            t->SetDirectory(fOutputFile);
         }
         if (t->GetDirectory() == fOutputFile) {
            if (queryend) {
               // ... we write it out
               o->Write(0, TObject::kOverwrite);
               // At least something in the file
               notempty = kTRUE;
               // Flag for removal from the outputlist
               torm.Add(o);
               // Prevent double-deletion attempts
               t->SetDirectory(0);
            } else {
               // ... or we set in automatic flush mode
               t->SetAutoFlush();
            }
         }
      } else if (queryend || fSaveResultsPerPacket) {
         // Save overwriting what's already there
         o->Write(0, TObject::kOverwrite);
         // At least something in the file
         notempty = kTRUE;
         // Flag for removal from the outputlist
         if (queryend) torm.Add(o);
      }
   }

   // Restore previous directory
   gDirectory = curdir;

   // Close the file if required
   if (notempty) {
      if (!fOutput->FindObject(baseName)) {
         TProofOutputFile *po = 0;
         // Get directions
         TNamed *nm = (TNamed *) fInput->FindObject("PROOF_DefaultOutputOption");
         TString oname = (nm) ? nm->GetTitle() : fOutputFilePath.Data();
         if (nm && oname.BeginsWith("ds:")) {
            oname.Replace(0, 3, "");
            TString qtag =
               TString::Format("%s_q%d", gProofServ->GetTopSessionTag(), gProofServ->GetQuerySeqNum());
            oname.ReplaceAll("<qtag>", qtag);
            // Create the TProofOutputFile for dataset creation
            po = new TProofOutputFile(baseName, "DRO", oname.Data());
         } else {
            Bool_t hasddir = kFALSE;
            // Create the TProofOutputFile for automatic merging
            po = new TProofOutputFile(baseName, "M");
            if (oname.BeginsWith("of:")) oname.Replace(0, 3, "");
            if (gProofServ->IsTopMaster()) {
               if (!strcmp(TUrl(oname, kTRUE).GetProtocol(), "file")) {
                  TString dsrv;
                  TProofServ::GetLocalServer(dsrv);
                  TProofServ::FilterLocalroot(oname, dsrv);
                  oname.Insert(0, dsrv);
               }
            } else {
               if (nm) {
                  // The name has been sent by the client: resolve local place holders
                  oname.ReplaceAll("<file>", baseName);
               } else {
                  // We did not get any indication; the final file will be in the datadir on
                  // the top master and it will be resolved there
                  oname.Form("<datadir>/%s", baseName.Data());
                  hasddir = kTRUE;
               }
            }
            po->SetOutputFileName(oname.Data());
            if (hasddir)
               // Reset the bit, so that <datadir> has a chance to be resolved in AddOutputObject
               po->ResetBit(TProofOutputFile::kOutputFileNameSet);
            po->SetName(gSystem->BaseName(oname.Data()));
         }
         po->AdoptFile(fOutputFile);
         fOutput->Add(po);
         // Flag the nature of this file
         po->SetBit(TProofOutputFile::kSwapFile);
      }
   }
   fOutputFile->Close();
   SafeDelete(fOutputFile);

   // If last call, cleanup the output list from objects saved to file
   if (queryend && torm.GetSize() > 0) {
      TIter nxrm(&torm);
      while ((o = nxrm())) { fOutput->Remove(o); }
   }
   torm.SetOwner(kFALSE);

   PDB(kOutput, 1)
      Info("SavePartialResults", "partial results saved to file");
   // We are done
   return 0;
}

//______________________________________________________________________________
Int_t TProofPlayer::AssertSelector(const char *selector_file)
{
   // Make sure that a valid selector object
   // Return -1 in case of problems, 0 otherwise

   if (selector_file && strlen(selector_file)) {
      if (fCreateSelObj) SafeDelete(fSelector);
      // Get selector files from cache
      if (gProofServ) {
         gProofServ->GetCacheLock()->Lock();
         gProofServ->CopyFromCache(selector_file, 1);
      }

      if (!(fSelector = TSelector::GetSelector(selector_file))) {
         Error("AssertSelector", "cannot load: %s", selector_file );
         gProofServ->GetCacheLock()->Unlock();
         return -1;
      }

      // Save binaries to cache, if any
      if (gProofServ) {
         gProofServ->CopyToCache(selector_file, 1);
         gProofServ->GetCacheLock()->Unlock();
      }
      fCreateSelObj = kTRUE;
      Info("AssertSelector", "Processing via filename");
   } else if (!fSelector) {
      Error("AssertSelector", "no TSelector object define : cannot continue!");
      return -1;
   } else {
      Info("AssertSelector", "Processing via TSelector object");
   }
   // Done
   return 0;
}
//_____________________________________________________________________________
void TProofPlayer::UpdateProgressInfo()
{
   // Update fProgressStatus

   if (fProgressStatus) {
      fProgressStatus->IncEntries(fProcessedRun);
      fProgressStatus->SetBytesRead(TFile::GetFileBytesRead()-fReadBytesRun);
      fProgressStatus->SetReadCalls(TFile::GetFileReadCalls()-fReadCallsRun);
      fProgressStatus->SetLastUpdate();
      if (gMonitoringWriter)
         gMonitoringWriter->SendProcessingProgress(fProgressStatus->GetEntries(),
                                                   fReadBytesRun, kFALSE);
      fProcessedRun = 0;
   }
}

//______________________________________________________________________________
Long64_t TProofPlayer::Process(TDSet *dset, const char *selector_file,
                               Option_t *option, Long64_t nentries,
                               Long64_t first)
{
   // Process specified TDSet on PROOF worker.
   // The return value is -1 in case of error and TSelector::GetStatus()
   // in case of success.

   PDB(kGlobal,1) Info("Process","Enter");

   fExitStatus = kFinished;
   fOutput = 0;

   TCleanup clean(this);

   fSelectorClass = 0;
   TString wmsg;
   TRY {
      if (AssertSelector(selector_file) != 0 || !fSelector) {
         Error("Process", "cannot assert the selector object");
         return -1;
      }

      fSelectorClass = fSelector->IsA();
      Int_t version = fSelector->Version();
      if (version == 0 && IsClient()) fSelector->GetOutputList()->Clear();

      fOutput = (THashList *) fSelector->GetOutputList();

      if (gProofServ)
         TPerfStats::Start(fInput, fOutput);

      fSelStatus = new TStatus;
      fOutput->Add(fSelStatus);

      fSelector->SetOption(option);
      fSelector->SetInputList(fInput);

      // If in sequential (0-PROOF) mode validate the data set to get
      // the number of entries
      fTotalEvents = nentries;
      if (fTotalEvents < 0 && gProofServ &&
         gProofServ->IsMaster() && !gProofServ->IsParallel()) {
         dset->Validate();
         dset->Reset();
         TDSetElement *e = 0;
         while ((e = dset->Next())) {
            fTotalEvents += e->GetNum();
         }
      }

      dset->Reset();

      // Set parameters controlling the iterator behaviour
      Int_t useTreeCache = 1;
      if (TProof::GetParameter(fInput, "PROOF_UseTreeCache", useTreeCache) == 0) {
         if (useTreeCache > -1 && useTreeCache < 2)
            gEnv->SetValue("ProofPlayer.UseTreeCache", useTreeCache);
      }
      Long64_t cacheSize = -1;
      if (TProof::GetParameter(fInput, "PROOF_CacheSize", cacheSize) == 0) {
         TString sz = TString::Format("%lld", cacheSize);
         gEnv->SetValue("ProofPlayer.CacheSize", sz.Data());
      }
      // Parallel unzipping
      Int_t useParallelUnzip = 0;
      if (TProof::GetParameter(fInput, "PROOF_UseParallelUnzip", useParallelUnzip) == 0) {
         if (useParallelUnzip > -1 && useParallelUnzip < 2)
            gEnv->SetValue("ProofPlayer.UseParallelUnzip", useParallelUnzip);
      }
      // OS file caching (Mac Os X only)
      Int_t dontCacheFiles = 0;
      if (TProof::GetParameter(fInput, "PROOF_DontCacheFiles", dontCacheFiles) == 0) {
         if (dontCacheFiles == 1)
            gEnv->SetValue("ProofPlayer.DontCacheFiles", 1);
      }
      fEvIter = TEventIter::Create(dset, fSelector, first, nentries);

      // Control file object swap
      //     <how>*10 + <force>
      //     <how> =  0       end of run
      //              1       after each packet
      //     <force> = 0      no, swap only if memory threshold is reached
      //               1      swap in all cases, accordingly to <how>
      Int_t opt = 0;
      if (TProof::GetParameter(fInput, "PROOF_SavePartialResults", opt) != 0) {
         opt = gEnv->GetValue("ProofPlayer.SavePartialResults", 0);
      }
      fSaveResultsPerPacket = (opt >= 10) ? kTRUE : kFALSE;
      fSavePartialResults = (opt%10 > 0) ? kTRUE : kFALSE;
      Info("Process", "save partial results? %d  per-packet? %d", fSavePartialResults, fSaveResultsPerPacket);

      // Memory threshold for file object swap
      Float_t memfrac = gEnv->GetValue("ProofPlayer.SaveMemThreshold", -1.);
      if (memfrac > 0.) {
         // The threshold is per core
         SysInfo_t si;
         if (gSystem->GetSysInfo(&si) == 0) {
            fSaveMemThreshold = (Long_t) ((memfrac * si.fPhysRam * 1024.) / si.fCpus);
            Info("Process", "memory threshold for saving objects to file set to %ld kB",
                                 fSaveMemThreshold);
         } else {
            Error("Process", "cannot get SysInfo_t (!)");
         }
      }

      if (version == 0) {
         PDB(kLoop,1) Info("Process","Call Begin(0)");
         fSelector->Begin(0);
      } else {
         if (IsClient()) {
            // on client (for local run)
            PDB(kLoop,1) Info("Process","Call Begin(0)");
            fSelector->Begin(0);
         }
         if (!fSelStatus->TestBit(TStatus::kNotOk)) {
            PDB(kLoop,1) Info("Process","Call SlaveBegin(0)");
            fSelector->SlaveBegin(0);  // Init is called explicitly
                                       // from GetNextEvent()
         }
      }

   } CATCH(excode) {
      ResetBit(TProofPlayer::kIsProcessing);
      Error("Process","exception %d caught", excode);
      gProofServ->GetCacheLock()->Unlock();
      return -1;
   } ENDTRY;

   // Save the results, if needed, closing the file
   if (SavePartialResults(kFALSE) < 0)
      Warning("Process", "problems seetting up file-object swapping");

   // Create feedback lists, if required
   SetupFeedback();

   if (gMonitoringWriter)
      gMonitoringWriter->SendProcessingStatus("STARTED",kTRUE);

   PDB(kLoop,1)
      Info("Process","Looping over Process()");

   // get the byte read counter at the beginning of processing
   fReadBytesRun = TFile::GetFileBytesRead();
   fReadCallsRun = TFile::GetFileReadCalls();
   fProcessedRun = 0;
   // force the first monitoring info
   if (gMonitoringWriter)
      gMonitoringWriter->SendProcessingProgress(0,0,kTRUE);

   // Start asynchronous timer to dispatch pending events
   SetDispatchTimer(kTRUE);

   // Loop over range
   gAbort = kFALSE;
   Long64_t entry;
   fProgressStatus->Reset();
   if (gProofServ) gProofServ->ResetBit(TProofServ::kHighMemory);

   TRY {

      Int_t mrc = -1;
      // Get the frequency for checking memory consumption and logging information
      Long64_t memlogfreq = -1;
      if (((mrc = TProof::GetParameter(fInput, "PROOF_MemLogFreq", memlogfreq))) != 0) memlogfreq = -1;
      Long64_t singleshot = 1;
      Bool_t warnHWMres = kTRUE, warnHWMvir = kTRUE;
      TString lastMsg("(unfortunately no detailed info is available about current packet)");

      // Initial memory footprint
      if (!CheckMemUsage(singleshot, warnHWMres, warnHWMvir, wmsg)) {
         Error("Process", "%s", wmsg.Data());
         wmsg.Insert(0, TString::Format("ERROR:%s, after SlaveBegin(), ", gProofServ->GetOrdinal()));
         fSelStatus->Add(wmsg.Data());
         if (gProofServ) {
            gProofServ->SendAsynMessage(wmsg.Data());
            gProofServ->SetBit(TProofServ::kHighMemory);
         }
         fExitStatus = kStopped;
         ResetBit(TProofPlayer::kIsProcessing);
      } else if (!wmsg.IsNull()) {
         Warning("Process", "%s", wmsg.Data());
      }

      TPair *currentElem = 0;
      // The event loop on the worker
      Long64_t fst = -1, num;
      TEntryList *enl = 0;
      TEventList *evl = 0;
      Long_t maxproctime = -1;
      Bool_t newrun = kFALSE;
      while ((fEvIter->GetNextPacket(fst, num, &enl, &evl) != -1) &&
              !fSelStatus->TestBit(TStatus::kNotOk) &&
              fSelector->GetAbort() == TSelector::kContinue) {

         // This is needed by the inflate infrastructure to calculate
         // sleeping times
         SetBit(TProofPlayer::kIsProcessing);

         // Give the possibility to the selector to access additional info in the
         // incoming packet
         if (dset->Current()) {
            if (!currentElem) {
               currentElem = new TPair(new TObjString("PROOF_CurrentElement"), dset->Current());
               fInput->Add(currentElem);
            } else {
               if (currentElem->Value() != dset->Current()) {
                  currentElem->SetValue(dset->Current());
               } else if (dset->Current()->TestBit(TDSetElement::kNewRun)) {
                  dset->Current()->ResetBit(TDSetElement::kNewRun);
               }
            }
            if (dset->Current()->TestBit(TDSetElement::kNewPacket)) {
               if (dset->TestBit(TDSet::kEmpty)) {
                  lastMsg = "check logs for possible stacktrace - last cycle:";
               } else {
                  TDSetElement *elem = dynamic_cast<TDSetElement *>(currentElem->Value());
                  TString fn = (elem) ? elem->GetFileName() : "<undef>";
                  lastMsg.Form("while processing dset:'%s', file:'%s'"
                              " - check logs for possible stacktrace - last event:", dset->GetName(), fn.Data());
               }
               TProofServ::SetLastMsg(lastMsg);
            }
            // Set the max proc time, if any
            if (dset->Current()->GetMaxProcTime() >= 0.)
               maxproctime = (Long_t) (1000 * dset->Current()->GetMaxProcTime());
            newrun = (dset->Current()->TestBit(TDSetElement::kNewPacket)) ? kTRUE : kFALSE;
         }

         ResetBit(TProofPlayer::kMaxProcTimeReached);
         ResetBit(TProofPlayer::kMaxProcTimeExtended);
         // Setup packet proc time measurement
         if (maxproctime > 0) {
            if (!fProcTimeTimer) fProcTimeTimer = new TProctimeTimer(this, maxproctime);
            fProcTimeTimer->Start(maxproctime, kTRUE); // One shot
            if (!fProcTime) fProcTime = new TStopwatch();
            fProcTime->Reset();                        // Reset counters
         }
         Long64_t refnum = num;
         if (refnum < 0 && maxproctime <= 0) {
            wmsg.Form("neither entries nor max proc time specified:"
                      " risk of infinite loop: processing aborted");
            Error("Process", "%s", wmsg.Data());
            if (gProofServ) {
               wmsg.Insert(0, TString::Format("ERROR:%s, entry:%lld, ",
                                             gProofServ->GetOrdinal(), fProcessedRun));
               gProofServ->SendAsynMessage(wmsg.Data());
            }
            fExitStatus = kAborted;
            ResetBit(TProofPlayer::kIsProcessing);
            break;
         }
         while (refnum < 0 || num--) {

            // Did we use all our time?
            if (TestBit(TProofPlayer::kMaxProcTimeReached)) {
               fProcTime->Stop();
               if (!newrun && !TestBit(TProofPlayer::kMaxProcTimeExtended) && refnum > 0) {
                  // How much are we left with?
                  Float_t xleft = (refnum > num) ? (Float_t) num / (Float_t) (refnum) : 1.;
                  if (xleft < 0.2) {
                     // Give another try, 1.5 times the remaining measured expected time
                     Long_t mpt = (Long_t) (1500 * num / ((Double_t)(refnum - num) / fProcTime->RealTime()));
                     SetBit(TProofPlayer::kMaxProcTimeExtended);
                     fProcTimeTimer->Start(mpt, kTRUE); // One shot
                     ResetBit(TProofPlayer::kMaxProcTimeReached);
                  }
               }
               if (TestBit(TProofPlayer::kMaxProcTimeReached)) {
                  Info("Process", "max proc time reached (%ld msecs): packet processing stopped:\n%s",
                                  maxproctime, lastMsg.Data());

                  break;
               }
            }

            if (!(!fSelStatus->TestBit(TStatus::kNotOk) &&
                   fSelector->GetAbort() == TSelector::kContinue)) break;

            // Set entry number; if data iteration we may need to test the entry or event lists
            if (fEvIter->TestBit(TEventIter::kData)) {
               if (enl){
                  entry = enl->GetEntry(fst);
               } else if (evl) {
                  entry = evl->GetEntry(fst);
               } else {
                  entry = fst;
               }
               fst++;
            } else {
               entry = fst++;
            }
            // Pre-event processing
            fEvIter->PreProcessEvent(entry);

            // Set the last entry
            TProofServ::SetLastEntry(entry);

            if (fSelector->Version() == 0) {
               PDB(kLoop,3)
                  Info("Process","Call ProcessCut(%lld)", entry);
               if (fSelector->ProcessCut(entry)) {
                  PDB(kLoop,3)
                     Info("Process","Call ProcessFill(%lld)", entry);
                  fSelector->ProcessFill(entry);
               }
            } else {
               PDB(kLoop,3)
                  Info("Process","Call Process(%lld)", entry);
               fSelector->Process(entry);
               if (fSelector->GetAbort() == TSelector::kAbortProcess) {
                  ResetBit(TProofPlayer::kIsProcessing);
                  break;
               } else if (fSelector->GetAbort() == TSelector::kAbortFile) {
                  Info("Process", "packet processing aborted following the"
                                  " selector settings:\n%s", lastMsg.Data());
                  fEvIter->InvalidatePacket();
                  fProgressStatus->SetBit(TProofProgressStatus::kFileCorrupted);
               }
            }
            if (!fSelStatus->TestBit(TStatus::kNotOk)) fProcessedRun++;

            // Check the memory footprint, if required
            if (memlogfreq > 0 && (GetEventsProcessed() + fProcessedRun)%memlogfreq == 0) {
               if (!CheckMemUsage(memlogfreq, warnHWMres, warnHWMvir, wmsg)) {
                  Error("Process", "%s", wmsg.Data());
                  if (gProofServ) {
                     wmsg.Insert(0, TString::Format("ERROR:%s, entry:%lld, ",
                                                   gProofServ->GetOrdinal(), entry));
                     gProofServ->SendAsynMessage(wmsg.Data());
                  }
                  fExitStatus = kStopped;
                  ResetBit(TProofPlayer::kIsProcessing);
                  if (gProofServ) gProofServ->SetBit(TProofServ::kHighMemory);
                  break;
               } else {
                  if (!wmsg.IsNull()) {
                     Warning("Process", "%s", wmsg.Data());
                     if (gProofServ) {
                        wmsg.Insert(0, TString::Format("WARNING:%s, entry:%lld, ",
                                                      gProofServ->GetOrdinal(), entry));
                        gProofServ->SendAsynMessage(wmsg.Data());
                     }
                  }
               }
            }
            if (TestBit(TProofPlayer::kDispatchOneEvent)) {
               gSystem->DispatchOneEvent(kTRUE);
               ResetBit(TProofPlayer::kDispatchOneEvent);
            }
            ResetBit(TProofPlayer::kIsProcessing);
            if (fSelStatus->TestBit(TStatus::kNotOk) || gROOT->IsInterrupted()) break;

            // Make sure that the selector abort status is reset
            if (fSelector->GetAbort() == TSelector::kAbortFile)
               fSelector->Abort("status reset", TSelector::kContinue);
         }
      }

   } CATCH(excode) {
      if (excode == kPEX_STOPPED) {
         Info("Process","received stop-process signal");
         fExitStatus = kStopped;
      } else if (excode == kPEX_ABORTED) {
         gAbort = kTRUE;
         Info("Process","received abort-process signal");
         fExitStatus = kAborted;
      } else {
         Error("Process","exception %d caught", excode);
         // Perhaps we need a dedicated status code here ...
         gAbort = kTRUE;
         fExitStatus = kAborted;
      }
      ResetBit(TProofPlayer::kIsProcessing);
   } ENDTRY;

   // Clean-up the envelop for the current element
   TPair *currentElem = 0;
   if ((currentElem = (TPair *) fInput->FindObject("PROOF_CurrentElement"))) {
      if ((currentElem = (TPair *) fInput->Remove(currentElem))) {
         delete currentElem->Key();
         delete currentElem;
      }
   }

   // Final memory footprint
   Long64_t singleshot = 1;
   Bool_t warnHWMres = kTRUE, warnHWMvir = kTRUE;
   Bool_t shrc = CheckMemUsage(singleshot, warnHWMres, warnHWMvir, wmsg);
   if (!wmsg.IsNull()) Warning("Process", "%s (%s)", wmsg.Data(), shrc ? "warn" : "hwm");

   PDB(kGlobal,2)
      Info("Process","%lld events processed", fProgressStatus->GetEntries());

   if (gMonitoringWriter) {
      gMonitoringWriter->SendProcessingProgress(fProgressStatus->GetEntries(),
                                                TFile::GetFileBytesRead()-fReadBytesRun, kFALSE);
      gMonitoringWriter->SendProcessingStatus("DONE");
   }

   // Stop active timers
   SetDispatchTimer(kFALSE);
   if (fStopTimer != 0)
      SetStopTimer(kFALSE, gAbort);
   if (fFeedbackTimer != 0)
      HandleTimer(0);

   StopFeedback();

   // Save the results, if needed, closing the file
   if (SavePartialResults(kTRUE) < 0)
      Warning("Process", "problems saving the results to file");

   SafeDelete(fEvIter);

   // Finalize

   if (fExitStatus != kAborted) {

      TIter nxo(GetOutputList());
      TObject *o = 0;
      while ((o = nxo())) {
         // Special treatment for files
         if (o->IsA() == TProofOutputFile::Class()) {
            TProofOutputFile *of = (TProofOutputFile *)o;
            of->Print();
            of->SetWorkerOrdinal(gProofServ->GetOrdinal());
            const char *dir = of->GetDir();
            if (!dir || (dir && strlen(dir) <= 0)) {
               of->SetDir(gProofServ->GetSessionDir());
            } else if (dir && strlen(dir) > 0) {
               TUrl u(dir);
               if (!strcmp(u.GetHost(), "localhost") || !strcmp(u.GetHost(), "127.0.0.1") ||
                   !strcmp(u.GetHost(), "localhost.localdomain")) {
                  u.SetHost(TUrl(gSystem->HostName()).GetHostFQDN());
                  of->SetDir(u.GetUrl(kTRUE));
               }
               of->Print();
            }
         }
      }

      MapOutputListToDataMembers();

      if (!fSelStatus->TestBit(TStatus::kNotOk)) {
         if (fSelector->Version() == 0) {
            PDB(kLoop,1) Info("Process","Call Terminate()");
            fSelector->Terminate();
         } else {
            PDB(kLoop,1) Info("Process","Call SlaveTerminate()");
            fSelector->SlaveTerminate();
            if (IsClient() && !fSelStatus->TestBit(TStatus::kNotOk)) {
               PDB(kLoop,1) Info("Process","Call Terminate()");
               fSelector->Terminate();
            }
         }
      }

      // Add Selector status in the output list so it can be returned to the client as done
      // by Tree::Process (see ROOT-748). The status from the various workers will be added.
      fOutput->Add(new TParameter<Long64_t>("PROOF_SelectorStatus", (Long64_t) fSelector->GetStatus()));

      if (gProofServ && !gProofServ->IsParallel()) {  // put all the canvases onto the output list
         TIter nxc(gROOT->GetListOfCanvases());
         while (TObject *c = nxc())
            fOutput->Add(c);
      }
   }

   if (gProofServ)
      TPerfStats::Stop();

   return 0;
}

//______________________________________________________________________________
Long64_t TProofPlayer::Process(TDSet *dset, TSelector *selector,
                               Option_t *option, Long64_t nentries,
                               Long64_t first)
{
   // Process specified TDSet on PROOF worker with TSelector object
   // The return value is -1 in case of error and TSelector::GetStatus()
   // in case of success.

   if (!selector) {
      Error("Process", "selector object undefiend!");
      return -1;
   }

   if (fCreateSelObj) SafeDelete(fSelector);
   fSelector = selector;
   fCreateSelObj = kFALSE;
   return Process(dset, (const char *)0, option, nentries, first);
}

//______________________________________________________________________________
Bool_t TProofPlayer::JoinProcess(TList *)
{
   // Not implemented: meaningful only in the remote player. Returns kFALSE.

   return kFALSE;
}

//______________________________________________________________________________
Bool_t TProofPlayer::CheckMemUsage(Long64_t &mfreq, Bool_t &w80r,
                                   Bool_t &w80v, TString &wmsg)
{
   // Check the memory usage, if requested.
   // Return kTRUE if OK, kFALSE if above 95% of at least one between virtual or
   // resident limits are depassed.

   Long64_t processed = GetEventsProcessed() + fProcessedRun;
   if (mfreq > 0 && processed%mfreq == 0) {
      // Record the memory information
      ProcInfo_t pi;
      if (!gSystem->GetProcInfo(&pi)){
         wmsg = "";
         if (gProofServ)
            Info("CheckMemUsage|Svc", "Memory %ld virtual %ld resident event %lld",
                                      pi.fMemVirtual, pi.fMemResident, processed);
         // Save info in TStatus
         fSelStatus->SetMemValues(pi.fMemVirtual, pi.fMemResident);
         // Apply limit on virtual memory, if any: warn if above 80%, stop if above 95% of max
         if (TProofServ::GetVirtMemMax() > 0) {
            if (pi.fMemVirtual > TProofServ::GetMemStop() * TProofServ::GetVirtMemMax()) {
               wmsg.Form("using more than %d%% of allowed virtual memory (%ld kB)"
                         " - STOP processing", (Int_t) (TProofServ::GetMemStop() * 100), pi.fMemVirtual);
               return kFALSE;
            } else if (pi.fMemVirtual > TProofServ::GetMemHWM() * TProofServ::GetVirtMemMax() && w80v) {
               // Refine monitoring
               mfreq = 1;
               wmsg.Form("using more than %d%% of allowed virtual memory (%ld kB)",
                         (Int_t) (TProofServ::GetMemHWM() * 100), pi.fMemVirtual);
               w80v = kFALSE;
            }
         }
         // Apply limit on resident memory, if any: warn if above 80%, stop if above 95% of max
         if (TProofServ::GetResMemMax() > 0) {
            if (pi.fMemResident > TProofServ::GetMemStop() * TProofServ::GetResMemMax()) {
               wmsg.Form("using more than %d%% of allowed resident memory (%ld kB)"
                         " - STOP processing", (Int_t) (TProofServ::GetMemStop() * 100), pi.fMemResident);
               return kFALSE;
            } else if (pi.fMemResident > TProofServ::GetMemHWM() * TProofServ::GetResMemMax() && w80r) {
               // Refine monitoring
               mfreq = 1;
               if (wmsg.Length() > 0) {
                  wmsg.Form("using more than %d%% of allowed both virtual and resident memory ({%ld,%ld} kB)",
                            (Int_t) (TProofServ::GetMemHWM() * 100), pi.fMemVirtual, pi.fMemResident);
               } else {
                  wmsg.Form("using more than %d%% of allowed resident memory (%ld kB)",
                            (Int_t) (TProofServ::GetMemHWM() * 100), pi.fMemResident);
               }
               w80r = kFALSE;
            }
         }
         // In saving-partial-results mode flag the saving regime when reached to save expensive calls
         // to TSystem::GetProcInfo in SavePartialResults
         if (fSaveMemThreshold > 0 && pi.fMemResident >= fSaveMemThreshold) fSavePartialResults = kTRUE;
      }
   }
   // Done
   return kTRUE;
}

//______________________________________________________________________________
Long64_t TProofPlayer::Finalize(Bool_t, Bool_t)
{
   // Finalize query (may not be used in this class).

   MayNotUse("Finalize");
   return -1;
}

//______________________________________________________________________________
Long64_t TProofPlayer::Finalize(TQueryResult *)
{
   // Finalize query (may not be used in this class).

   MayNotUse("Finalize");
   return -1;
}
//______________________________________________________________________________
void TProofPlayer::MergeOutput(Bool_t)
{
   // Merge output (may not be used in this class).

   MayNotUse("MergeOutput");
   return;
}

//______________________________________________________________________________
void TProofPlayer::MapOutputListToDataMembers() const
{
   TOutputListSelectorDataMap* olsdm = new TOutputListSelectorDataMap(fSelector);
   fOutput->Add(olsdm);
}

//______________________________________________________________________________
void TProofPlayer::UpdateAutoBin(const char *name,
                                 Double_t& xmin, Double_t& xmax,
                                 Double_t& ymin, Double_t& ymax,
                                 Double_t& zmin, Double_t& zmax)
{
   // Update automatic binning parameters for given object "name".

   if ( fAutoBins == 0 ) {
      fAutoBins = new THashList;
   }

   TAutoBinVal *val = (TAutoBinVal*) fAutoBins->FindObject(name);

   if ( val == 0 ) {
      //look for info in higher master
      if (gProofServ && !gProofServ->IsTopMaster()) {
         TString key = name;
         TProofLimitsFinder::AutoBinFunc(key,xmin,xmax,ymin,ymax,zmin,zmax);
      }

      val = new TAutoBinVal(name,xmin,xmax,ymin,ymax,zmin,zmax);
      fAutoBins->Add(val);
   } else {
      val->GetAll(xmin,xmax,ymin,ymax,zmin,zmax);
   }
}

//______________________________________________________________________________
TDSetElement *TProofPlayer::GetNextPacket(TSlave *, TMessage *)
{
   // Get next packet (may not be used in this class).

   MayNotUse("GetNextPacket");
   return 0;
}

//______________________________________________________________________________
void TProofPlayer::SetupFeedback()
{
   // Set up feedback (may not be used in this class).

   MayNotUse("SetupFeedback");
}

//______________________________________________________________________________
void TProofPlayer::StopFeedback()
{
   // Stop feedback (may not be used in this class).

   MayNotUse("StopFeedback");
}

//______________________________________________________________________________
Long64_t TProofPlayer::DrawSelect(TDSet * /*set*/, const char * /*varexp*/,
                                  const char * /*selection*/, Option_t * /*option*/,
                                  Long64_t /*nentries*/, Long64_t /*firstentry*/)
{
   // Draw (may not be used in this class).

   MayNotUse("DrawSelect");
   return -1;
}

//______________________________________________________________________________
void TProofPlayer::HandleGetTreeHeader(TMessage *)
{
   // Handle tree header request.

   MayNotUse("HandleGetTreeHeader|");
}

//______________________________________________________________________________
void TProofPlayer::HandleRecvHisto(TMessage *mess)
{
   // Receive histo from slave.

   TObject *obj = mess->ReadObject(mess->GetClass());
   if (obj->InheritsFrom(TH1::Class())) {
      TH1 *h = (TH1*)obj;
      h->SetDirectory(0);
      TH1 *horg = (TH1*)gDirectory->GetList()->FindObject(h->GetName());
      if (horg)
         horg->Add(h);
      else
         h->SetDirectory(gDirectory);
   }
}

//______________________________________________________________________________
Int_t TProofPlayer::DrawCanvas(TObject *obj)
{
   // Draw the object if it is a canvas.
   // Return 0 in case of success, 1 if it is not a canvas or libProofDraw
   // is not available.

   static Int_t (*gDrawCanvasHook)(TObject *) = 0;

   // Load the library the first time
   if (!gDrawCanvasHook) {
      // Load library needed for graphics ...
      TString drawlib = "libProofDraw";
      char *p = 0;
      if ((p = gSystem->DynamicPathName(drawlib, kTRUE))) {
         delete[] p;
         if (gSystem->Load(drawlib) != -1) {
            // Locate DrawCanvas
            Func_t f = 0;
            if ((f = gSystem->DynFindSymbol(drawlib,"DrawCanvas")))
               gDrawCanvasHook = (Int_t (*)(TObject *))(f);
            else
               Warning("DrawCanvas", "can't find DrawCanvas");
         } else
            Warning("DrawCanvas", "can't load %s", drawlib.Data());
      } else
         Warning("DrawCanvas", "can't locate %s", drawlib.Data());
   }
   if (gDrawCanvasHook && obj)
      return (*gDrawCanvasHook)(obj);
   // No drawing hook or object undefined
   return 1;
}

//______________________________________________________________________________
Int_t TProofPlayer::GetDrawArgs(const char *var, const char *sel, Option_t *opt,
                                TString &selector, TString &objname)
{
   // Parse the arguments from var, sel and opt and fill the selector and
   // object name accordingly.
   // Return 0 in case of success, 1 if libProofDraw is not available.

   static Int_t (*gGetDrawArgsHook)(const char *, const char *, Option_t *,
                                    TString &, TString &) = 0;

   // Load the library the first time
   if (!gGetDrawArgsHook) {
      // Load library needed for graphics ...
      TString drawlib = "libProofDraw";
      char *p = 0;
      if ((p = gSystem->DynamicPathName(drawlib, kTRUE))) {
         delete[] p;
         if (gSystem->Load(drawlib) != -1) {
            // Locate GetDrawArgs
            Func_t f = 0;
            if ((f = gSystem->DynFindSymbol(drawlib,"GetDrawArgs")))
               gGetDrawArgsHook = (Int_t (*)(const char *, const char *, Option_t *,
                                             TString &, TString &))(f);
            else
               Warning("GetDrawArgs", "can't find GetDrawArgs");
         } else
            Warning("GetDrawArgs", "can't load %s", drawlib.Data());
      } else
         Warning("GetDrawArgs", "can't locate %s", drawlib.Data());
   }
   if (gGetDrawArgsHook)
      return (*gGetDrawArgsHook)(var, sel, opt, selector, objname);
   // No parser hook or object undefined
   return 1;
}

//______________________________________________________________________________
void TProofPlayer::FeedBackCanvas(const char *name, Bool_t create)
{
   // Create/destroy a named canvas for feedback

   static void (*gFeedBackCanvasHook)(const char *, Bool_t) = 0;

   // Load the library the first time
   if (!gFeedBackCanvasHook) {
      // Load library needed for graphics ...
      TString drawlib = "libProofDraw";
      char *p = 0;
      if ((p = gSystem->DynamicPathName(drawlib, kTRUE))) {
         delete[] p;
         if (gSystem->Load(drawlib) != -1) {
            // Locate FeedBackCanvas
            Func_t f = 0;
            if ((f = gSystem->DynFindSymbol(drawlib,"FeedBackCanvas")))
               gFeedBackCanvasHook = (void (*)(const char *, Bool_t))(f);
            else
               Warning("FeedBackCanvas", "can't find FeedBackCanvas");
         } else
            Warning("FeedBackCanvas", "can't load %s", drawlib.Data());
      } else
         Warning("FeedBackCanvas", "can't locate %s", drawlib.Data());
   }
   if (gFeedBackCanvasHook) (*gFeedBackCanvasHook)(name, create);
   // No parser hook or object undefined
   return;
}

//______________________________________________________________________________
Long64_t TProofPlayer::GetCacheSize()
{
   // Return the size in bytes of the cache

   if (fEvIter) return fEvIter->GetCacheSize();
   return -1;
}

//______________________________________________________________________________
Int_t TProofPlayer::GetLearnEntries()
{
   // Return the number of entries in the learning phase

   if (fEvIter) return fEvIter->GetLearnEntries();
   return -1;
}

//______________________________________________________________________________
void TProofPlayerRemote::SetMerging(Bool_t on)
{
   // Switch on/off merge timer

   if (on) {
      if (!fMergeSTW) fMergeSTW = new TStopwatch();
      PDB(kGlobal,1)
         Info("SetMerging", "ON: mergers: %d", fProof->fMergersCount);
      if (fNumMergers <= 0 && fProof->fMergersCount > 0)
         fNumMergers = fProof->fMergersCount;
   } else if (fMergeSTW) {
      fMergeSTW->Stop();
      Float_t rt = fMergeSTW->RealTime();
      PDB(kGlobal,1)
         Info("SetMerging", "OFF: rt: %f, mergers: %d", rt, fNumMergers);
      if (fQuery) {
         if (!fProof->TestBit(TProof::kIsClient) || fProof->IsLite()) {
            // On the master (or in Lite()) we set the merging time and the numebr of mergers
            fQuery->SetMergeTime(rt);
            fQuery->SetNumMergers(fNumMergers);
         } else {
            // In a standard client we save the transfer-to-client time 
            fQuery->SetRecvTime(rt);
         }
         PDB(kGlobal,2) fQuery->Print("F");
      }
   }
}

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

ClassImp(TProofPlayerLocal)

//______________________________________________________________________________
Long64_t TProofPlayerLocal::Process(TSelector *selector,
                                    Long64_t nentries, Option_t *option)
{
   // Process the specified TSelector object 'nentries' times.
   // Used to test the PROOF interator mechanism for cycle-driven selectors in a
   // local session.
   // The return value is -1 in case of error and TSelector::GetStatus()
   // in case of success.

   if (!selector) {
      Error("Process", "selector object undefiend!");
      return -1;
   }

   TDSetProxy *set = new TDSetProxy("", "", "");
   set->SetBit(TDSet::kEmpty);
   set->SetBit(TDSet::kIsLocal);
   Long64_t rc = Process(set, selector, option, nentries);
   SafeDelete(set);

   // Done
   return rc;
}

//______________________________________________________________________________
Long64_t TProofPlayerLocal::Process(const char *selector,
                                    Long64_t nentries, Option_t *option)
{
   // Process the specified TSelector file 'nentries' times.
   // Used to test the PROOF interator mechanism for cycle-driven selectors in a
   // local session.
   // Process specified TDSet on PROOF worker with TSelector object
   // The return value is -1 in case of error and TSelector::GetStatus()
   // in case of success.

   TDSetProxy *set = new TDSetProxy("", "", "");
   set->SetBit(TDSet::kEmpty);
   set->SetBit(TDSet::kIsLocal);
   Long64_t rc = Process(set, selector, option, nentries);
   SafeDelete(set);

   // Done
   return rc;
}


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

ClassImp(TProofPlayerRemote)

//______________________________________________________________________________
TProofPlayerRemote::~TProofPlayerRemote()
{
   // Destructor.

   SafeDelete(fOutput);      // owns the output list
   SafeDelete(fOutputLists);

   // Objects stored in maps are already deleted when merging the feedback
   SafeDelete(fFeedbackLists);
   SafeDelete(fPacketizer);

   if (fProcessMessage)
      SafeDelete(fProcessMessage);
}

//______________________________________________________________________________
Int_t TProofPlayerRemote::InitPacketizer(TDSet *dset, Long64_t nentries,
                                         Long64_t first, const char *defpackunit,
                                         const char *defpackdata)
{
   // Init the packetizer
   // Return 0 on success (fPacketizer is correctly initialized), -1 on failure.

   SafeDelete(fPacketizer);
   PDB(kGlobal,1) Info("Process","Enter");
   fDSet = dset;
   fExitStatus = kFinished;

   // This is done here to pickup on the fly changes
   Int_t honebyone = 1;
   if (TProof::GetParameter(fInput, "PROOF_MergeTH1OneByOne", honebyone) != 0)
      honebyone = gEnv->GetValue("ProofPlayer.MergeTH1OneByOne", 1);
   fMergeTH1OneByOne = (honebyone == 1) ? kTRUE : kFALSE;

   Bool_t noData = dset->TestBit(TDSet::kEmpty) ? kTRUE : kFALSE;

   TString packetizer;
   TList *listOfMissingFiles = 0;

   TMethodCall callEnv;
   TClass *cl;
   noData = dset->TestBit(TDSet::kEmpty) ? kTRUE : kFALSE;

   if (noData) {

      if (TProof::GetParameter(fInput, "PROOF_Packetizer", packetizer) != 0)
         packetizer = defpackunit;
      else
         Info("InitPacketizer", "using alternate packetizer: %s", packetizer.Data());

      // Get linked to the related class
      cl = TClass::GetClass(packetizer);
      if (cl == 0) {
         Error("InitPacketizer", "class '%s' not found", packetizer.Data());
         fExitStatus = kAborted;
         return -1;
      }

      // Init the constructor
      callEnv.InitWithPrototype(cl, cl->GetName(),"TList*,Long64_t,TList*,TProofProgressStatus*");
      if (!callEnv.IsValid()) {
         Error("InitPacketizer",
               "cannot find correct constructor for '%s'", cl->GetName());
         fExitStatus = kAborted;
         return -1;
      }
      callEnv.ResetParam();
      callEnv.SetParam((Long_t) fProof->GetListOfActiveSlaves());
      callEnv.SetParam((Long64_t) nentries);
      callEnv.SetParam((Long_t) fInput);
      callEnv.SetParam((Long_t) fProgressStatus);

   } else if (dset->TestBit(TDSet::kMultiDSet)) {

      // We have to process many datasets in one go, keeping them separate
      if (fProof->GetRunStatus() != TProof::kRunning) {
         // We have been asked to stop
         Error("InitPacketizer", "received stop/abort request");
         fExitStatus = kAborted;
         return -1;
      }

      // The multi packetizer
      packetizer = "TPacketizerMulti";

      // Get linked to the related class
      cl = TClass::GetClass(packetizer);
      if (cl == 0) {
         Error("InitPacketizer", "class '%s' not found", packetizer.Data());
         fExitStatus = kAborted;
         return -1;
      }

      // Init the constructor
      callEnv.InitWithPrototype(cl, cl->GetName(),"TDSet*,TList*,Long64_t,Long64_t,TList*,TProofProgressStatus*");
      if (!callEnv.IsValid()) {
         Error("InitPacketizer", "cannot find correct constructor for '%s'", cl->GetName());
         fExitStatus = kAborted;
         return -1;
      }
      callEnv.ResetParam();
      callEnv.SetParam((Long_t) dset);
      callEnv.SetParam((Long_t) fProof->GetListOfActiveSlaves());
      callEnv.SetParam((Long64_t) first);
      callEnv.SetParam((Long64_t) nentries);
      callEnv.SetParam((Long_t) fInput);
      callEnv.SetParam((Long_t) fProgressStatus);

      // We are going to test validity during the packetizer initialization
      dset->SetBit(TDSet::kValidityChecked);
      dset->ResetBit(TDSet::kSomeInvalid);

   } else {

      // Lookup - resolve the end-point urls to optmize the distribution.
      // The lookup was previously called in the packetizer's constructor.
      // A list for the missing files may already have been added to the
      // output list; otherwise, if needed it will be created inside
      if ((listOfMissingFiles = (TList *)fInput->FindObject("MissingFiles"))) {
         // Move it to the output list
         fInput->Remove(listOfMissingFiles);
      } else {
         listOfMissingFiles = new TList;
      }
      // Do the lookup; we only skip it if explicitly requested so.
      TString lkopt;
      if (TProof::GetParameter(fInput, "PROOF_LookupOpt", lkopt) != 0 || lkopt != "none")
         dset->Lookup(kTRUE, &listOfMissingFiles);

      if (fProof->GetRunStatus() != TProof::kRunning) {
         // We have been asked to stop
         Error("InitPacketizer", "received stop/abort request");
         fExitStatus = kAborted;
         return -1;
      }

      if (!(dset->GetListOfElements()) ||
          !(dset->GetListOfElements()->GetSize())) {
         if (gProofServ)
            gProofServ->SendAsynMessage("InitPacketizer: No files from the data set were found - Aborting");
         Error("InitPacketizer", "No files from the data set were found - Aborting");
         fExitStatus = kAborted;
         if (listOfMissingFiles) {
            listOfMissingFiles->SetOwner();
            fOutput->Remove(listOfMissingFiles);
            SafeDelete(listOfMissingFiles);
         }
         return -1;
      }

      if (TProof::GetParameter(fInput, "PROOF_Packetizer", packetizer) != 0)
         // Using standard packetizer TAdaptivePacketizer
         packetizer = defpackdata;
      else
         Info("InitPacketizer", "using alternate packetizer: %s", packetizer.Data());

      // Get linked to the related class
      cl = TClass::GetClass(packetizer);
      if (cl == 0) {
         Error("InitPacketizer", "class '%s' not found", packetizer.Data());
         fExitStatus = kAborted;
         return -1;
      }

      // Init the constructor
      callEnv.InitWithPrototype(cl, cl->GetName(),"TDSet*,TList*,Long64_t,Long64_t,TList*,TProofProgressStatus*");
      if (!callEnv.IsValid()) {
         Error("InitPacketizer", "cannot find correct constructor for '%s'", cl->GetName());
         fExitStatus = kAborted;
         return -1;
      }
      callEnv.ResetParam();
      callEnv.SetParam((Long_t) dset);
      callEnv.SetParam((Long_t) fProof->GetListOfActiveSlaves());
      callEnv.SetParam((Long64_t) first);
      callEnv.SetParam((Long64_t) nentries);
      callEnv.SetParam((Long_t) fInput);
      callEnv.SetParam((Long_t) fProgressStatus);

      // We are going to test validity during the packetizer initialization
      dset->SetBit(TDSet::kValidityChecked);
      dset->ResetBit(TDSet::kSomeInvalid);
   }

   // Get an instance of the packetizer
   Long_t ret = 0;
   callEnv.Execute(ret);
   if ((fPacketizer = (TVirtualPacketizer *)ret) == 0) {
      Error("InitPacketizer", "cannot construct '%s'", cl->GetName());
      fExitStatus = kAborted;
      return -1;
   }

   if (!fPacketizer->IsValid()) {
      Error("InitPacketizer",
            "instantiated packetizer object '%s' is invalid", cl->GetName());
      fExitStatus = kAborted;
      SafeDelete(fPacketizer);
      return -1;
   }

   // In multi mode retrieve the list of missing files
   if (!noData && dset->TestBit(TDSet::kMultiDSet)) {
      if ((listOfMissingFiles = (TList *) fInput->FindObject("MissingFiles"))) {
         // Remove it; it will be added to the output list
         fInput->Remove(listOfMissingFiles);
      }
   }

   if (!noData) {
      // Add invalid elements to the list of missing elements
      TDSetElement *elem = 0;
      if (dset->TestBit(TDSet::kSomeInvalid)) {
         TIter nxe(dset->GetListOfElements());
         while ((elem = (TDSetElement *)nxe())) {
            if (!elem->GetValid()) {
               if (!listOfMissingFiles)
                  listOfMissingFiles = new TList;
               listOfMissingFiles->Add(elem->GetFileInfo(dset->GetType()));
               dset->Remove(elem, kFALSE);
            }
         }
         // The invalid elements have been removed
         dset->ResetBit(TDSet::kSomeInvalid);
      }

      // Record the list of missing or invalid elements in the output list
      if (listOfMissingFiles && listOfMissingFiles->GetSize() > 0) {
         TIter missingFiles(listOfMissingFiles);
         TString msg;
         if (gDebug > 0) {
            TFileInfo *fi = 0;
            while ((fi = (TFileInfo *) missingFiles.Next())) {
               if (fi->GetCurrentUrl()) {
                  msg = Form("File not found: %s - skipping!",
                                                fi->GetCurrentUrl()->GetUrl());
               } else {
                  msg = Form("File not found: %s - skipping!", fi->GetName());
               }
               if (gProofServ) gProofServ->SendAsynMessage(msg.Data());
            }
         }
         // Make sure it will be sent back
         if (!GetOutput("MissingFiles")) {
            listOfMissingFiles->SetName("MissingFiles");
            AddOutputObject(listOfMissingFiles);
         }
         TStatus *tmpStatus = (TStatus *)GetOutput("PROOF_Status");
         if (!tmpStatus) AddOutputObject((tmpStatus = new TStatus()));

         // Estimate how much data are missing
         Int_t ngood = dset->GetListOfElements()->GetSize();
         Int_t nbad = listOfMissingFiles->GetSize();
         Double_t xb = Double_t(nbad) / Double_t(ngood + nbad);
         msg = Form(" About %.2f %c of the requested files (%d out of %d) were missing or unusable; details in"
                    " the 'missingFiles' list", xb * 100., '%', nbad, nbad + ngood);
         tmpStatus->Add(msg.Data());
         msg = Form(" +++\n"
                    " +++ About %.2f %c of the requested files (%d out of %d) are missing or unusable; details in"
                    " the 'MissingFiles' list\n"
                    " +++", xb * 100., '%', nbad, nbad + ngood);
         if (gProofServ) gProofServ->SendAsynMessage(msg.Data());
      } else {
         // Cleanup
         SafeDelete(listOfMissingFiles);
      }
   }

   // Done
   return 0;
}

//______________________________________________________________________________
Long64_t TProofPlayerRemote::Process(TDSet *dset, const char *selector_file,
                                     Option_t *option, Long64_t nentries,
                                     Long64_t first)
{
   // Process specified TDSet on PROOF.
   // This method is called on client and on the PROOF master.
   // The return value is -1 in case of an error and TSelector::GetStatus() in
   // in case of success.

   PDB(kGlobal,1) Info("Process", "Enter");

   fDSet = dset;
   fExitStatus = kFinished;

   if (!fProgressStatus) {
      Error("Process", "No progress status");
      return -1;
   }
   fProgressStatus->Reset();

   //   delete fOutput;
   if (!fOutput)
      fOutput = new THashList;
   else
      fOutput->Clear();

   SafeDelete(fFeedbackLists);

   if (fProof->IsMaster()){
      TPerfStats::Start(fInput, fOutput);
   } else {
      TPerfStats::Setup(fInput);
   }

   TStopwatch elapsed;

   // Define filename
   TString fn;
   fSelectorFileName = selector_file;

   if (fCreateSelObj) {
      if(!SendSelector(selector_file)) return -1;
      fn = gSystem->BaseName(selector_file);
   } else {
      fn = selector_file;
   }

   TMessage mesg(kPROOF_PROCESS);

   // Parse option
   Bool_t sync = (fProof->GetQueryMode(option) == TProof::kSync);

   TList *inputtmp = 0;  // List of temporary input objects
   TDSet *set = dset;
   if (fProof->IsMaster()) {

      PDB(kPacketizer,1) Info("Process","Create Proxy TDSet");
      set = new TDSetProxy( dset->GetType(), dset->GetObjName(),
                            dset->GetDirectory() );
      if (dset->TestBit(TDSet::kEmpty))
         set->SetBit(TDSet::kEmpty);

      if (InitPacketizer(dset, nentries, first, "TPacketizerUnit", "TPacketizer") != 0) {
         Error("Process", "cannot init the packetizer");
         fExitStatus = kAborted;
         return -1;
      }

      // Reset start, this is now managed by the packetizer
      first = 0;

      // Negative memlogfreq disable checks.
      // If 0 is passed we try to have 100 messages about memory
      // Otherwise we use the frequency passed.
      Int_t mrc = -1;
      Long64_t memlogfreq = -1, mlf;
      if (gSystem->Getenv("PROOF_MEMLOGFREQ")) {
         TString clf(gSystem->Getenv("PROOF_MEMLOGFREQ"));
         if (clf.IsDigit()) { memlogfreq = clf.Atoi(); mrc = 0; }
      }
      if ((mrc = TProof::GetParameter(fProof->GetInputList(), "PROOF_MemLogFreq", mlf)) == 0) memlogfreq = mlf;
      if (memlogfreq == 0) {
         memlogfreq = fPacketizer->GetTotalEntries()/(fProof->GetParallel()*100);
         if (memlogfreq <= 0) memlogfreq = 1;
      }
      if (mrc == 0) fProof->SetParameter("PROOF_MemLogFreq", memlogfreq);


      // Send input data, if any
      TString emsg;
      if (TProof::SendInputData(fQuery, fProof, emsg) != 0)
         Warning("Process", "could not forward input data: %s", emsg.Data());

      // Attach to the transient histogram with the assigned packets, if required
      if (fInput->FindObject("PROOF_StatsHist") != 0) {
         if (!(fProcPackets = (TH1I *) fOutput->FindObject("PROOF_ProcPcktHist"))) {
            Warning("Process", "could not attach to histogram 'PROOF_ProcPcktHist'");
         } else {
            PDB(kLoop,1)
               Info("Process", "attached to histogram 'PROOF_ProcPcktHist' to record"
                               " packets being processed");
         }
      }

   } else {

      // Check whether we have to enforce the use of submergers
      if (gEnv->Lookup("Proof.UseMergers") && !fInput->FindObject("PROOF_UseMergers")) {
         Int_t smg = gEnv->GetValue("Proof.UseMergers",-1);
         if (smg >= 0) {
            fInput->Add(new TParameter<Int_t>("PROOF_UseMergers", smg));
            if (gEnv->Lookup("Proof.MergersByHost")) {
               Int_t mbh = gEnv->GetValue("Proof.MergersByHost",0);
               if (mbh != 0) {
                  // Administrator settings have the priority
                  TObject *o = 0;
                  if ((o = fInput->FindObject("PROOF_MergersByHost"))) { fInput->Remove(o); delete o; }
                  fInput->Add(new TParameter<Int_t>("PROOF_MergersByHost", mbh));
               }
            }
         }
      }

      // For a new query clients should make sure that the temporary
      // output list is empty
      if (fOutputLists) {
         fOutputLists->Delete();
         delete fOutputLists;
         fOutputLists = 0;
      }

      if (!sync) {
         gSystem->RedirectOutput(fProof->fLogFileName);
         Printf(" ");
         Info("Process","starting new query");
      }

      // Define fSelector in Client if processing with filename
      if (fCreateSelObj) {
         SafeDelete(fSelector);
         if (!(fSelector = TSelector::GetSelector(selector_file))) {
            if (!sync)
               gSystem->RedirectOutput(0);
            return -1;
         }
      }

      fSelectorClass = 0;
      fSelectorClass = fSelector->IsA();

      // Add fSelector to inputlist if processing with object
      if (!fCreateSelObj) {
         // In any input list was set into the selector move it to the PROOF
         // input list, because we do not want to stream the selector one
         if (fSelector->GetInputList() && fSelector->GetInputList()->GetSize() > 0) {
            TIter nxi(fSelector->GetInputList());
            TObject *o = 0;
            while ((o = nxi())) {
               if (!fInput->FindObject(o)) {
                  fInput->Add(o);
                  if (!inputtmp) {
                     inputtmp = new TList;
                     inputtmp->SetOwner(kFALSE);
                  }
                  inputtmp->Add(o);
               }
            }
         }
         fInput->Add(fSelector);
      }
      // Set the input list for initialization
      fSelector->SetInputList(fInput);
      fSelector->SetOption(option);
      if (fSelector->GetOutputList()) fSelector->GetOutputList()->Clear();

      PDB(kLoop,1) Info("Process","Call Begin(0)");
      fSelector->Begin(0);

      // Reset the input list to avoid double streaming and related problems (saving
      // the TQueryResult)
      if (!fCreateSelObj) fSelector->SetInputList(0);

      // Send large input data objects, if any
      fProof->SendInputDataFile();

      if (!sync)
         gSystem->RedirectOutput(0);
   }

   TCleanup clean(this);
   SetupFeedback();

   TString opt = option;

   // Old servers need a dedicated streamer
   if (fProof->fProtocol < 13)
      dset->SetWriteV3(kTRUE);

   // Workers will get the entry ranges from the packetizer
   Long64_t num = (gProofServ && gProofServ->IsMaster() && gProofServ->IsParallel()) ? -1 : nentries;
   Long64_t fst = (gProofServ && gProofServ->IsMaster() && gProofServ->IsParallel()) ? -1 : first;

   // Entry- or Event- list ?
   TEntryList *enl = (!fProof->IsMaster()) ? dynamic_cast<TEntryList *>(set->GetEntryList())
                                           : (TEntryList *)0;
   TEventList *evl = (!fProof->IsMaster() && !enl) ? dynamic_cast<TEventList *>(set->GetEntryList())
                                           : (TEventList *)0;
   if (fProof->fProtocol > 14) {
      if (fProcessMessage) delete fProcessMessage;
      fProcessMessage = new TMessage(kPROOF_PROCESS);
      mesg << set << fn << fInput << opt << num << fst << evl << sync << enl;
      (*fProcessMessage) << set << fn << fInput << opt << num << fst << evl << sync << enl;
   } else {
      mesg << set << fn << fInput << opt << num << fst << evl << sync;
      if (enl)
         // Not supported remotely
         Warning("Process","entry lists not supported by the server");
   }

   // Reset the merging progress information
   fProof->ResetMergePrg();

   Int_t nb = fProof->Broadcast(mesg);
   PDB(kGlobal,1) Info("Process", "Broadcast called: %d workers notified", nb);
   if (fProof->IsLite()) fProof->fNotIdle += nb;

   // Reset streamer choice
   if (fProof->fProtocol < 13)
      dset->SetWriteV3(kFALSE);

   // Redirect logs from master to special log frame
   if (IsClient())
      fProof->fRedirLog = kTRUE;

   if (!IsClient()){
      // Signal the start of finalize for the memory log grepping
      Info("Process|Svc", "Start merging Memory information");
   }

   if (!sync) {
      if (IsClient()) {
         // Asynchronous query: just make sure that asynchronous input
         // is enabled and return the prompt
         PDB(kGlobal,1) Info("Process","Asynchronous processing:"
                                       " activating CollectInputFrom");
         fProof->Activate();

         // Receive the acknowledgement and query sequential number
         fProof->Collect();

         return fProof->fSeqNum;

      } else {
         PDB(kGlobal,1) Info("Process","Calling Collect");
         fProof->Collect();

         HandleTimer(0); // force an update of final result
         // This forces a last call to TPacketizer::HandleTimer via the second argument
         // (the first is ignored). This is needed when some events were skipped so that
         // the total number of entries is not the one requested. The packetizer has no
         // way in such a case to understand that processing is finished: it must be told.
         if (fPacketizer) {
            fPacketizer->StopProcess(kFALSE, kTRUE);
            // The progress timer will now stop itself at the next call
            fPacketizer->SetBit(TVirtualPacketizer::kIsDone);
            // Store process info
            elapsed.Stop();
            if (fQuery)
               fQuery->SetProcessInfo(0, 0., fPacketizer->GetBytesRead(),
                                             fPacketizer->GetInitTime(),
                                             elapsed.RealTime());
         }
         StopFeedback();

         return Finalize(kFALSE,sync);
      }
   } else {

      PDB(kGlobal,1) Info("Process","Synchronous processing: calling Collect");
      fProof->Collect();
      if (!(fProof->IsSync())) {
         // The server required to switch to asynchronous mode
         Info("Process", "switching to the asynchronous mode ...");
         return fProof->fSeqNum;
      }

      // Restore prompt logging, for clients (Collect leaves things as they were
      // at the time it was called)
      if (IsClient())
         fProof->fRedirLog = kFALSE;

      if (!IsClient()) {
         // Force an update of final result
         HandleTimer(0);
         // This forces a last call to TPacketizer::HandleTimer via the second argument
         // (the first is ignored). This is needed when some events were skipped so that
         // the total number of entries is not the one requested. The packetizer has no
         // way in such a case to understand that processing is finished: it must be told.
         if (fPacketizer) {
            fPacketizer->StopProcess(kFALSE, kTRUE);
            // The progress timer will now stop itself at the next call
            fPacketizer->SetBit(TVirtualPacketizer::kIsDone);
            // Store process info
            if (fQuery)
               fQuery->SetProcessInfo(0, 0., fPacketizer->GetBytesRead(),
                                             fPacketizer->GetInitTime(),
                                             fPacketizer->GetProcTime());
         }
      } else {
         // Set the input list: maybe required at termination
         if (!fCreateSelObj) fSelector->SetInputList(fInput);
      }
      StopFeedback();

      Long64_t rc = -1;
      if (!IsClient() || GetExitStatus() != TProofPlayer::kAborted)
         rc = Finalize(kFALSE,sync);

      // Remove temporary input objects, if any
      if (inputtmp) {
         TIter nxi(inputtmp);
         TObject *o = 0;
         while ((o = nxi())) fInput->Remove(o);
         SafeDelete(inputtmp);
      }

      // Done
      return rc;
   }
}

//______________________________________________________________________________
Long64_t TProofPlayerRemote::Process(TDSet *dset, TSelector *selector,
                                     Option_t *option, Long64_t nentries,
                                     Long64_t first)
{
   // Process specified TDSet on PROOF.
   // This method is called on client and on the PROOF master.
   // The return value is -1 in case of an error and TSelector::GetStatus() in
   // in case of success.

   if (!selector) {
      Error("Process", "selector object undefined");
      return -1;
   }

   // Define fSelector in Client
   if (IsClient() && (selector != fSelector)) {
      if (fCreateSelObj) SafeDelete(fSelector);
      fSelector = selector;
   }

   fCreateSelObj = kFALSE;
   Long64_t rc = Process(dset, selector->ClassName(), option, nentries, first);
   fCreateSelObj = kTRUE;

   // Done
   return rc;
}

//______________________________________________________________________________
Bool_t TProofPlayerRemote::JoinProcess(TList *workers)
{
   // Prepares the given list of new workers to join a progressing process.
   // Returns kTRUE on success, kFALSE otherwise.

   if (!fProcessMessage || !fProof || !fPacketizer) {
      Error("Process", "Should not happen: fProcessMessage=%p fProof=%p fPacketizer=%p",
         fProcessMessage, fProof, fPacketizer);
      return kFALSE;
   }

   if (!workers || !fProof->IsMaster()) {
      Error("Process", "Invalid call");
      return kFALSE;
   }

   PDB(kGlobal, 1)
      Info("Process", "Preparing %d new worker(s) to process", workers->GetEntries());

   // Sends the file associated to the TSelector, if necessary
   if (fCreateSelObj) {
      PDB(kGlobal, 2)
         Info("Process", "Sending selector file %s", fSelectorFileName.Data());
      if(!SendSelector(fSelectorFileName.Data())) {
         Error("Process", "Problems in sending selector file %s", fSelectorFileName.Data());
         return kFALSE;
      }
   }

   if (fProof->IsLite()) fProof->fNotIdle += workers->GetSize();

   PDB(kGlobal, 2)
      Info("Process", "Adding new workers to the packetizer");
   if (fPacketizer->AddWorkers(workers) == -1) {
      Error("Process", "Cannot add new workers to the packetizer!");
      return kFALSE;  // TODO: make new wrks inactive
   }

   PDB(kGlobal, 2)
      Info("Process", "Broadcasting process message to new workers");
   fProof->Broadcast(*fProcessMessage, workers);

   // Don't call Collect(): we came here from a global Collect() already which
   // will take care of new workers as well

   return kTRUE;

}

//______________________________________________________________________________
Bool_t TProofPlayerRemote::MergeOutputFiles()
{
   // Merge output in files

   PDB(kOutput,1) Info("MergeOutputFiles", "enter: fOutput size: %d", fOutput->GetSize());
   PDB(kOutput,2) fOutput->ls();

   TList *rmList = 0;
   if (fMergeFiles) {
      TIter nxo(fOutput);
      TObject *o = 0;
      TProofOutputFile *pf = 0;
      while ((o = nxo())) {
         if ((pf = dynamic_cast<TProofOutputFile*>(o))) {

            PDB(kOutput,2) pf->Print();

            if (pf->IsMerge()) {

               // Point to the merger
               Bool_t localMerge = (pf->GetTypeOpt() == TProofOutputFile::kLocal) ? kTRUE : kFALSE;
               TFileMerger *filemerger = pf->GetFileMerger(localMerge);
               if (!filemerger) {
                  Error("MergeOutputFiles", "file merger is null in TProofOutputFile! Protocol error?");
                  pf->Print();
                  continue;
               }
               // If only one instance the list in the merger is not yet created: do it now
               if (!pf->IsMerged()) {
                  PDB(kOutput,2) pf->Print();
                  TString fileLoc = TString::Format("%s/%s", pf->GetDir(), pf->GetFileName());
                  filemerger->AddFile(fileLoc);
               }
               // Datadir
               TString ddir, ddopts;
               if (gProofServ) {
                  ddir.Form("%s/", gProofServ->GetDataDir());
                  if (gProofServ->GetDataDirOpts()) ddopts= gProofServ->GetDataDirOpts();
               }
               // Set the output file
               TString outfile(pf->GetOutputFileName());
               if (outfile.Contains("<datadir>/")) {
                  outfile.ReplaceAll("<datadir>/", ddir.Data());
                  if (!ddopts.IsNull())
                     outfile += TString::Format("?%s", ddopts.Data());
                  pf->SetOutputFileName(outfile);
               }
               if ((gProofServ && gProofServ->IsTopMaster()) || (fProof && fProof->IsLite())) {
                  TFile::EFileType ftyp = TFile::kLocal;
                  TString srv;
                  TProofServ::GetLocalServer(srv);
                  TUrl usrv(srv);
                  Bool_t localFile = kFALSE;
                  if (pf->IsRetrieve()) {
                     // This file will be retrieved by the client: we created it in the data dir
                     // and save the file URL on the client in the title
                     if (outfile.BeginsWith("client:")) outfile.Replace(0, 7, "");
                     TString bn = gSystem->BaseName(TUrl(outfile.Data(), kTRUE).GetFile());
                     // The output file path on the master
                     outfile.Form("%s%s", ddir.Data(), bn.Data());
                     // Save the client path in the title if not defined yet
                     if (strlen(pf->GetTitle()) <= 0) pf->SetTitle(bn);
                     // The file is local
                     localFile = kTRUE;
                  } else {
                     // Check if the file is on the master or elsewhere
                     if (outfile.BeginsWith("master:")) outfile.Replace(0, 7, "");
                     // Check locality
                     TUrl uof(outfile.Data(), kTRUE);
                     TString lfn;
                     ftyp = TFile::GetType(uof.GetUrl(), "RECREATE", &lfn);
                     if (ftyp == TFile::kLocal && !srv.IsNull()) {
                        // Check if is a different server
                        if (uof.GetPort() > 0 && usrv.GetPort() > 0 &&
                            usrv.GetPort() != uof.GetPort()) ftyp = TFile::kNet;
                     }
                     // If it is really local set the file name
                     if (ftyp == TFile::kLocal) outfile = lfn;
                     // The file maybe local
                     if (ftyp == TFile::kLocal || ftyp == TFile::kFile) localFile = kTRUE;
                  }
                  // The remote output file name (the one to be used by the client)
                  TString outfilerem(outfile);
                  // For local files we add the local server
                  if (localFile) {
                     // Remove prefix, if any, if included and if Xrootd
                     TProofServ::FilterLocalroot(outfilerem, srv);
                     outfilerem.Insert(0, srv);
                  }
                  // Save the new remote output filename
                  pf->SetOutputFileName(outfilerem);
                  // Align the filename
                  pf->SetFileName(gSystem->BaseName(outfilerem));
               }
               if (!filemerger->OutputFile(outfile)) {
                  Error("MergeOutputFiles", "cannot open the output file");
                  continue;
               }
               // Merge
               PDB(kSubmerger,2) filemerger->PrintFiles("");
               if (!filemerger->Merge()) {
                  Error("MergeOutputFiles", "cannot merge the output files");
                  continue;
               }
               // Remove the files
               TList *fileList = filemerger->GetMergeList();
               if (fileList) {
                  TIter next(fileList);
                  TObjString *url = 0;
                  while((url = (TObjString*)next())) {
                     TUrl u(url->GetName());
                     if (!strcmp(u.GetProtocol(), "file")) {
                        gSystem->Unlink(u.GetFile());
                     } else {
                        gSystem->Unlink(url->GetName());
                     }
                  }
               }
               // Reset the merger
               filemerger->Reset();

            } else {

               // If not yet merged (for example when having only 1 active worker,
               // we need to create the dataset by calling Merge on an effectively empty list
               if (!pf->IsMerged()) {
                  TList dumlist;
                  dumlist.Add(new TNamed("dum", "dum"));
                  dumlist.SetOwner(kTRUE);
                  pf->Merge(&dumlist);
               }
               // Point to the dataset
               TFileCollection *fc = pf->GetFileCollection();
               if (!fc) {
                  Error("MergeOutputFiles", "file collection is null in TProofOutputFile! Protocol error?");
                  pf->Print();
                  continue;
               }
               // Add the collection to the output list for registration and/or to be returned
               // to the client
               fOutput->Add(fc);
               // Do not cleanup at destruction
               pf->ResetFileCollection();
               // Tell the main thread to register this dataset, if needed
               if (pf->IsRegister()) {
                  TString opt;
                  if ((pf->GetTypeOpt() & TProofOutputFile::kOverwrite)) opt += "O";
                  if ((pf->GetTypeOpt() & TProofOutputFile::kVerify)) opt += "V";
                  if (!fOutput->FindObject("PROOFSERV_RegisterDataSet"))
                     fOutput->Add(new TNamed("PROOFSERV_RegisterDataSet", ""));
                  TString tag = TString::Format("DATASET_%s", pf->GetTitle());
                  fOutput->Add(new TNamed(tag, opt));
               }
               // Remove this object from the output list and schedule it for distruction
               fOutput->Remove(pf);
               if (!rmList) rmList = new TList;
               rmList->Add(pf);
               PDB(kOutput,2) fOutput->Print();
            }
         }
      }
   }

   // Remove objects scheduled for removal
   if (rmList && rmList->GetSize() > 0) {
      TIter nxo(rmList);
      TObject *o = 0;
      while((o = nxo())) {
         fOutput->Remove(o);
      }
      rmList->SetOwner(kTRUE);
      delete rmList;
   }

   PDB(kOutput,1) Info("MergeOutputFiles", "done!");

   // Done
   return kTRUE;
}


//______________________________________________________________________________
void TProofPlayerRemote::SetSelectorDataMembersFromOutputList()
{
   // Set the selector's data members:
   // find the mapping of data members to otuput list entries in the output list
   // and apply it.
   TOutputListSelectorDataMap* olsdm
      = TOutputListSelectorDataMap::FindInList(fOutput);
   if (!olsdm) {
      PDB(kOutput,1) Warning("SetSelectorDataMembersFromOutputList",
                             "failed to find map object in output list!");
      return;
   }

   olsdm->SetDataMembers(fSelector);
}

//______________________________________________________________________________
Long64_t TProofPlayerRemote::Finalize(Bool_t force, Bool_t sync)
{

   // Finalize a query.
   // Returns -1 in case of an error, 0 otherwise.

   if (IsClient()) {
      if (fOutputLists == 0) {
         if (force)
            if (fQuery)
               return fProof->Finalize(Form("%s:%s", fQuery->GetTitle(),
                                                     fQuery->GetName()), force);
      } else {
         // Make sure the all objects are in the output list
         PDB(kGlobal,1) Info("Finalize","Calling Merge Output to finalize the output list");
         MergeOutput();
      }
   }

   Long64_t rv = 0;
   if (fProof->IsMaster()) {

      // Fill information for monitoring and stop it
      TStatus *status = (TStatus *) fOutput->FindObject("PROOF_Status");
      if (!status) {
         // The query was aborted: let's add some info in the output list
         status = new TStatus();
         fOutput->Add(status);
         TString emsg = TString::Format("Query aborted after %lld entries", GetEventsProcessed());
         status->Add(emsg);
      }
      status->SetExitStatus((Int_t) GetExitStatus());

      PDB(kOutput,1) Info("Finalize","Calling Merge Output");
      // Some objects (e.g. histos in autobin) may not have been merged yet
      // do it now
      MergeOutput();

      fOutput->SetOwner();

      // Add the active-wrks-vs-proctime info from the packetizer
      if (fPacketizer) {
         TObject *pperf = (TObject *) fPacketizer->GetProgressPerf(kTRUE);
         if (pperf) fOutput->Add(pperf);
         TList *parms = fPacketizer->GetConfigParams(kTRUE);
         if (parms) {
            TIter nxo(parms);
            TObject *o = 0;
            while ((o = nxo())) fOutput->Add(o);
         }

         // If other invalid elements were found during processing, add them to the
         // list of missing elements
         TDSetElement *elem = 0;
         if (fPacketizer->GetFailedPackets()) {
            TString type = (fPacketizer->TestBit(TVirtualPacketizer::kIsTree)) ? "TTree" : "";
            TList *listOfMissingFiles = (TList *) fOutput->FindObject("MissingFiles");
            if (!listOfMissingFiles) {
               listOfMissingFiles = new TList;
               listOfMissingFiles->SetName("MissingFiles");
            }
            TIter nxe(fPacketizer->GetFailedPackets());
            while ((elem = (TDSetElement *)nxe()))
               listOfMissingFiles->Add(elem->GetFileInfo(type));
            if (!fOutput->FindObject(listOfMissingFiles)) fOutput->Add(listOfMissingFiles);
         }
      }

      TPerfStats::Stop();
      // Save memory usage on master
      Long_t vmaxmst, rmaxmst;
      TPerfStats::GetMemValues(vmaxmst, rmaxmst);
      status->SetMemValues(vmaxmst, rmaxmst, kTRUE);

      SafeDelete(fSelector);

   } else {
      if (fExitStatus != kAborted) {

         if (!sync) {
            // Reinit selector (with multi-sessioning we must do this until
            // TSelector::GetSelector() is optimized to i) avoid reloading of an
            // unchanged selector and ii) invalidate existing instances of
            // reloaded selector)
            if (ReinitSelector(fQuery) == -1) {
               Info("Finalize", "problems reinitializing selector \"%s\"",
                    fQuery->GetSelecImp()->GetName());
               return -1;
            }
         }

         if (fPacketizer)
            if (TList *failedPackets = fPacketizer->GetFailedPackets()) {
               fPacketizer->SetFailedPackets(0);
               failedPackets->SetName("FailedPackets");
               AddOutputObject(failedPackets);

               TStatus *status = (TStatus *)GetOutput("PROOF_Status");
               if (!status) AddOutputObject((status = new TStatus()));
               status->Add("Some packets were not processed! Check the the"
                           " 'FailedPackets' list in the output list");
            }

         // Some input parameters may be needed in Terminate
         fSelector->SetInputList(fInput);

         TList *output = fSelector->GetOutputList();
         if (output) {
            TIter next(fOutput);
            while(TObject* obj = next()) {
               if (fProof->IsParallel() || DrawCanvas(obj) == 1)
                  // Either parallel or not a canvas or not able to display it:
                  // just add to the list
                  output->Add(obj);
            }
         } else {
            Warning("Finalize", "undefined output list in the selector! Protocol error?");
         }

         // We need to do this because the output list can be modified in TSelector::Terminate
         // in a way to invalidate existing objects; so we clean the links when still valid and
         // we re-copy back later
         fOutput->SetOwner(kFALSE);
         fOutput->Clear("nodelete");

         // Map output objects to selector members
         SetSelectorDataMembersFromOutputList();

         PDB(kLoop,1) Info("Finalize","Call Terminate()");
         // This is the end of merging
         SetMerging(kFALSE);
         // We measure the merge time
         fProof->fQuerySTW.Reset();
         // Call Terminate now
         fSelector->Terminate();

         rv = fSelector->GetStatus();

         // Copy the output list back and clean the selector's list
         TIter it(output);
         while(TObject* o = it()) {
            fOutput->Add(o);
         }

         // Save the output list in the current query, if any
         if (fQuery) {
            fQuery->SetOutputList(fOutput);
            // Set in finalized state (cannot be done twice)
            fQuery->SetFinalized();
         } else {
            Warning("Finalize","current TQueryResult object is undefined!");
         }

         if (!fCreateSelObj) {
            fInput->Remove(fSelector);
            fOutput->Remove(fSelector);
            if (output) output->Remove(fSelector);
            fSelector = 0;
         }

         // We have transferred copy of the output objects in TQueryResult,
         // so now we can cleanup the selector, making sure that we do not
         // touch the output objects
         if (output) { output->SetOwner(kFALSE); output->Clear("nodelete"); }
         if (fCreateSelObj) SafeDelete(fSelector);

         // Delete fOutput (not needed anymore, cannot be finalized twice),
         // making sure that the objects saved in TQueryResult are not deleted
         fOutput->SetOwner(kFALSE);
         fOutput->Clear("nodelete");
         SafeDelete(fOutput);

      } else {

         // Cleanup
         fOutput->SetOwner();
         SafeDelete(fSelector);
         if (!fCreateSelObj) fSelector = 0;
      }
   }
   PDB(kGlobal,1) Info("Process","exit");

   if (!IsClient()) {
      Info("Finalize", "finalization on %s finished", gProofServ->GetPrefix());
   }
   fProof->FinalizationDone();

   return rv;
}

//______________________________________________________________________________
Long64_t TProofPlayerRemote::Finalize(TQueryResult *qr)
{
   // Finalize the results of a query already processed.

   PDB(kGlobal,1) Info("Finalize(TQueryResult *)","Enter");

   if (!IsClient()) {
      Info("Finalize(TQueryResult *)",
           "method to be executed only on the clients");
      return -1;
   }

   if (!qr) {
      Info("Finalize(TQueryResult *)", "query undefined");
      return -1;
   }

   if (qr->IsFinalized()) {
      Info("Finalize(TQueryResult *)", "query already finalized");
      return -1;
   }

   // Reset the list
   if (!fOutput)
      fOutput = new THashList;
   else
      fOutput->Clear();

   // Make sure that the temporary output list is empty
   if (fOutputLists) {
      fOutputLists->Delete();
      delete fOutputLists;
      fOutputLists = 0;
   }

   // Re-init the selector
   gSystem->RedirectOutput(fProof->fLogFileName);

   // Import the output list
   TList *tmp = (TList *) qr->GetOutputList();
   if (!tmp) {
      gSystem->RedirectOutput(0);
      Info("Finalize(TQueryResult *)", "outputlist is empty");
      return -1;
   }
   TList *out = fOutput;
   if (fProof->fProtocol < 11)
      out = new TList;
   TIter nxo(tmp);
   TObject *o = 0;
   while ((o = nxo()))
      out->Add(o->Clone());

   // Adopts the list
   if (fProof->fProtocol < 11) {
      out->SetOwner();
      StoreOutput(out);
   }
   gSystem->RedirectOutput(0);

   SetSelectorDataMembersFromOutputList();

   // Finalize it
   SetCurrentQuery(qr);
   Long64_t rc = Finalize();
   RestorePreviousQuery();

   return rc;
}

//______________________________________________________________________________
Bool_t TProofPlayerRemote::SendSelector(const char* selector_file)
{
   // Send the selector file(s) to master or worker nodes.

   // Check input
   if (!selector_file) {
      Info("SendSelector", "Invalid input: selector (file) name undefined");
      return kFALSE;
   }

   if (!strchr(gSystem->BaseName(selector_file), '.')) {
      if (gDebug > 1)
         Info("SendSelector", "selector name '%s' does not contain a '.':"
              " nothing to send, it will be loaded from a library", selector_file);
      return kTRUE;
   }

   // Extract the fine name first
   TString selec = selector_file;
   TString aclicMode;
   TString arguments;
   TString io;
   selec = gSystem->SplitAclicMode(selec, aclicMode, arguments, io);

   // Expand possible envs or '~'
   gSystem->ExpandPathName(selec);

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

   // Header file
   TString header = selec;
   header.Remove(header.Last('.'));
   header += ".h";
   if (gSystem->AccessPathName(header, kReadPermission)) {
      TString h = header;
      header.Remove(header.Last('.'));
      header += ".hh";
      if (gSystem->AccessPathName(header, kReadPermission)) {
         Info("SendSelector",
              "header file not found: tried: %s %s", h.Data(), header.Data());
         return kFALSE;
      }
   }

   // Send files now
   if (fProof->SendFile(selec, (TProof::kBinary | TProof::kForward | TProof::kCp | TProof::kCpBin)) == -1) {
      Info("SendSelector", "problems sending implementation file %s", selec.Data());
      return kFALSE;
   }
   if (fProof->SendFile(header, (TProof::kBinary | TProof::kForward | TProof::kCp)) == -1) {
      Info("SendSelector", "problems sending header file %s", header.Data());
      return kFALSE;
   }

   return kTRUE;
}

//______________________________________________________________________________
void TProofPlayerRemote::MergeOutput(Bool_t saveMemValues)
{
   // Merge objects in output the lists.

   PDB(kOutput,1) Info("MergeOutput","Enter");

   TObject *obj = 0;
   if (fOutputLists) {

      TIter next(fOutputLists);

      TList *list;
      while ( (list = (TList *) next()) ) {

         if (!(obj = fOutput->FindObject(list->GetName()))) {
            obj = list->First();
            list->Remove(obj);
            fOutput->Add(obj);
         }

         if ( list->IsEmpty() ) continue;

         TMethodCall callEnv;
         if (obj->IsA())
            callEnv.InitWithPrototype(obj->IsA(), "Merge", "TCollection*");
         if (callEnv.IsValid()) {
            callEnv.SetParam((Long_t) list);
            callEnv.Execute(obj);
         } else {
            // No Merge interface, return individual objects
            while ( (obj = list->First()) ) {
               fOutput->Add(obj);
               list->Remove(obj);
            }
         }
      }
      SafeDelete(fOutputLists);

   } else {

      PDB(kOutput,1) Info("MergeOutput","fOutputLists empty");
   }

   if (!IsClient() || fProof->IsLite()) {
      // Merge the output files created on workers, if any
      MergeOutputFiles();
   }

   // If there are TProofOutputFile objects we have to make sure that the internal
   // information is consistent for the cases where this object is going to be merged
   // again (e.g. when using submergers or in a multi-master setup). This may not be
   // the case because the first coming in is taken as reference and it has the
   // internal dir and raw dir of the originating worker.
   TString key;
   TNamed *nm = 0;
   TList rmlist;
   TIter nxo(fOutput);
   while ((obj = nxo())) {
      TProofOutputFile *pf = dynamic_cast<TProofOutputFile *>(obj);
      if (pf) {
         if (gProofServ) {
            PDB(kOutput,2) Info("MergeOutput","found TProofOutputFile '%s'", obj->GetName());
            TString dir(pf->GetOutputFileName());
            PDB(kOutput,2) Info("MergeOutput","outputfilename: '%s'", dir.Data());
            // The dir
            if (dir.Last('/') != kNPOS) dir.Remove(dir.Last('/')+1);
            PDB(kOutput,2) Info("MergeOutput","dir: '%s'", dir.Data());
            pf->SetDir(dir);
            // The raw dir; for xrootd based system we include the 'localroot', if any
            TUrl u(dir);
            dir = u.GetFile();
            TString pfx  = gEnv->GetValue("Path.Localroot","");
            if (!pfx.IsNull() &&
               (!strcmp(u.GetProtocol(), "root") || !strcmp(u.GetProtocol(), "xrd")))
               dir.Insert(0, pfx);
            PDB(kOutput,2) Info("MergeOutput","rawdir: '%s'", dir.Data());
            pf->SetDir(dir, kTRUE);
            // The worker ordinal
            pf->SetWorkerOrdinal(gProofServ ? gProofServ->GetOrdinal() : "0");
            // The saved output file name, if any
            key.Form("PROOF_OutputFileName_%s", pf->GetFileName());
            if ((nm = (TNamed *) fOutput->FindObject(key.Data()))) {
               pf->SetOutputFileName(nm->GetTitle());
               rmlist.Add(nm);
            } else if (TestBit(TVirtualProofPlayer::kIsSubmerger)) {
               pf->SetOutputFileName(0);
               pf->ResetBit(TProofOutputFile::kOutputFileNameSet);
            }
            // The filename (order is important to exclude '.merger' from the key)
            dir = pf->GetFileName();
            if (TestBit(TVirtualProofPlayer::kIsSubmerger)) {
               dir += ".merger";
               pf->SetMerged(kFALSE);
            } else {
               if (dir.EndsWith(".merger")) dir.Remove(dir.Last('.'));
            }
            pf->SetFileName(dir);
         } else if (fProof->IsLite()) {
            // The ordinal
            pf->SetWorkerOrdinal("0");
            // The dir
            pf->SetDir(gSystem->DirName(pf->GetOutputFileName()));
            // The filename and raw dir
            TUrl u(pf->GetOutputFileName(), kTRUE);
            pf->SetFileName(gSystem->BaseName(u.GetFile()));
            pf->SetDir(gSystem->DirName(u.GetFile()), kTRUE);
            // Notify the output path
            Printf("\nOutput file: %s", pf->GetOutputFileName());
         }
      } else {
         PDB(kOutput,2) Info("MergeOutput","output object '%s' is not a TProofOutputFile", obj->GetName());
      }
   }

   // Remove temporary objects from fOutput
   if (rmlist.GetSize() > 0) {
      TIter nxrm(&rmlist);
      while ((obj = nxrm()))
         fOutput->Remove(obj);
      rmlist.SetOwner(kTRUE);
   }

   // If requested (typically in case of submerger to count possible side-effects in that process)
   // save the measured memory usage
   if (saveMemValues) {
      TPerfStats::Stop();
      // Save memory usage on master
      Long_t vmaxmst, rmaxmst;
      TPerfStats::GetMemValues(vmaxmst, rmaxmst);
      TStatus *status = (TStatus *) fOutput->FindObject("PROOF_Status");
      if (status) status->SetMemValues(vmaxmst, rmaxmst, kFALSE);
   }

   PDB(kOutput,1) fOutput->Print();
   PDB(kOutput,1) Info("MergeOutput","leave (%d object(s))", fOutput->GetSize());
}

//______________________________________________________________________________
void TProofPlayerRemote::Progress(Long64_t total, Long64_t processed)
{
   // Progress signal.

   if (IsClient()) {
      fProof->Progress(total, processed);
   } else {
      // Send to the previous tier
      TMessage m(kPROOF_PROGRESS);
      m << total << processed;
      gProofServ->GetSocket()->Send(m);
   }
}

//______________________________________________________________________________
void TProofPlayerRemote::Progress(Long64_t total, Long64_t processed,
                                  Long64_t bytesread,
                                  Float_t initTime, Float_t procTime,
                                  Float_t evtrti, Float_t mbrti)
{
   // Progress signal.

   PDB(kGlobal,1)
      Info("Progress","%lld %lld %lld %f %f %f %f", total, processed, bytesread,
                                             initTime, procTime, evtrti, mbrti);

   if (IsClient()) {
      fProof->Progress(total, processed, bytesread, initTime, procTime, evtrti, mbrti);
   } else {
      // Send to the previous tier
      TMessage m(kPROOF_PROGRESS);
      m << total << processed << bytesread << initTime << procTime << evtrti << mbrti;
      gProofServ->GetSocket()->Send(m);
   }
}

//______________________________________________________________________________
void TProofPlayerRemote::Progress(TProofProgressInfo *pi)
{
   // Progress signal.

   if (pi) {
      PDB(kGlobal,1)
         Info("Progress","%lld %lld %lld %f %f %f %f %d %f", pi->fTotal, pi->fProcessed, pi->fBytesRead,
                           pi->fInitTime, pi->fProcTime, pi->fEvtRateI, pi->fMBRateI,
                           pi->fActWorkers, pi->fEffSessions);

      if (IsClient()) {
         fProof->Progress(pi->fTotal, pi->fProcessed, pi->fBytesRead,
                           pi->fInitTime, pi->fProcTime,
                           pi->fEvtRateI, pi->fMBRateI,
                           pi->fActWorkers, pi->fTotSessions, pi->fEffSessions);
      } else {
         // Send to the previous tier
         TMessage m(kPROOF_PROGRESS);
         m << pi;
         gProofServ->GetSocket()->Send(m);
      }
   } else {
      Warning("Progress","TProofProgressInfo object undefined!");
   }
}


//______________________________________________________________________________
void TProofPlayerRemote::Feedback(TList *objs)
{
   // Feedback signal.

   fProof->Feedback(objs);
}

//______________________________________________________________________________
void TProofPlayerRemote::StopProcess(Bool_t abort, Int_t)
{
   // Stop process after this event.

   if (fPacketizer != 0)
      fPacketizer->StopProcess(abort, kFALSE);
   if (abort == kTRUE)
      fExitStatus = kAborted;
   else
      fExitStatus = kStopped;
}

//______________________________________________________________________________
Int_t TProofPlayerRemote::AddOutputObject(TObject *obj)
{
   // Incorporate the received object 'obj' into the output list fOutput.
   // The latter is created if not existing.
   // This method short cuts 'StoreOutput + MergeOutput' optimizing the memory
   // consumption.
   // Returns -1 in case of error, 1 if the object has been merged into another
   // one (so that its ownership has not been taken and can be deleted), and 0
   // otherwise.

   PDB(kOutput,1)
      Info("AddOutputObject","Enter: %p (%s)", obj, obj ? obj->ClassName() : "undef");

   // We must something to process
   if (!obj) {
      PDB(kOutput,1) Info("AddOutputObject","Invalid input (obj == 0x0)");
      return -1;
   }

   // Create the output list, if not yet done
   if (!fOutput)
      fOutput = new THashList;

   // Flag about merging
   Bool_t merged = kTRUE;

   // Process event lists first
   TList *elists = dynamic_cast<TList *> (obj);
   if (elists && !strcmp(elists->GetName(), "PROOF_EventListsList")) {

      // Create a global event list, result of merging the event lists
      // coresponding to the various data set elements
      TEventList *evlist = new TEventList("PROOF_EventList");

      // Iterate the list of event list segments
      TIter nxevl(elists);
      TEventList *evl = 0;
      while ((evl = dynamic_cast<TEventList *> (nxevl()))) {

         // Find the file offset (fDSet is the current TDSet instance)
         // locating the element by name
         TIter nxelem(fDSet->GetListOfElements());
         TDSetElement *elem = 0;
         while ((elem = dynamic_cast<TDSetElement *> (nxelem()))) {
            if (!strcmp(elem->GetFileName(), evl->GetName()))
               break;
         }
         if (!elem) {
            Error("AddOutputObject", "Found an event list for %s, but no object with"
                                     " the same name in the TDSet", evl->GetName());
            continue;
         }
         Long64_t offset = elem->GetTDSetOffset();

         // Shift the list by the number of first event in that file
         Long64_t *arr = evl->GetList();
         Int_t num = evl->GetN();
         if (arr && offset > 0)
            for (Int_t i = 0; i < num; i++)
               arr[i] += offset;

         // Add to the global event list
         evlist->Add(evl);
      }

      // Incorporate the resulting global list in fOutput
      SetLastMergingMsg(evlist);
      Incorporate(evlist, fOutput, merged);
      NotifyMemory(evlist);

      // Delete the global list if merged
      if (merged)
         SafeDelete(evlist);

      // The original object has been transformed in something else; we do
      // not have ownership on it
      return 1;
   }

   // Check if we need to merge files
   TProofOutputFile *pf = dynamic_cast<TProofOutputFile*>(obj);
   if (pf) {
      fMergeFiles = kTRUE;
      if (!IsClient() || fProof->IsLite()) {
         if (pf->IsMerge()) {
            Bool_t hasfout = (pf->GetOutputFileName() &&
                              strlen(pf->GetOutputFileName()) > 0 &&
                              pf->TestBit(TProofOutputFile::kOutputFileNameSet)) ? kTRUE : kFALSE;
            Bool_t setfout = (!hasfout || TestBit(TVirtualProofPlayer::kIsSubmerger)) ? kTRUE : kFALSE;
            if (setfout) {

               TString ddir, ddopts;
               if (gProofServ) {
                  ddir.Form("%s/", gProofServ->GetDataDir());
                  if (gProofServ->GetDataDirOpts()) ddopts = gProofServ->GetDataDirOpts();
               }
               // Set the output file
               TString outfile(pf->GetOutputFileName());
               outfile.ReplaceAll("<datadir>/", ddir.Data());
               if (!ddopts.IsNull()) outfile += TString::Format("?%s", ddopts.Data());
               pf->SetOutputFileName(outfile);

               if (gProofServ) {
                  // If submerger, save first the existing filename, if any
                  if (TestBit(TVirtualProofPlayer::kIsSubmerger) && hasfout) {
                     TString key = TString::Format("PROOF_OutputFileName_%s", pf->GetFileName());
                     if (!fOutput->FindObject(key.Data()))
                        fOutput->Add(new TNamed(key.Data(), pf->GetOutputFileName()));
                  }
                  TString of;
                  TProofServ::GetLocalServer(of);
                  if (of.IsNull()) {
                     // Assume an xroot server running on the machine
                     of.Form("root://%s/", gSystem->HostName());
                     if (gSystem->Getenv("XRDPORT")) {
                        TString sp(gSystem->Getenv("XRDPORT"));
                        if (sp.IsDigit())
                           of.Form("root://%s:%s/", gSystem->HostName(), sp.Data());
                     }
                  }
                  TString sessionPath(gProofServ->GetSessionDir());
                  TProofServ::FilterLocalroot(sessionPath, of);
                  of += TString::Format("%s/%s", sessionPath.Data(), pf->GetFileName());
                  if (TestBit(TVirtualProofPlayer::kIsSubmerger)) {
                     if (!of.EndsWith(".merger")) of += ".merger";
                  } else {
                     if (of.EndsWith(".merger")) of.Remove(of.Last('.'));
                  }
                  pf->SetOutputFileName(of);
               }
            }
            // Notify
            PDB(kOutput, 1) pf->Print();
         }
      } else {
         // On clients notify the output path
         Printf("Output file: %s", pf->GetOutputFileName());
      }
   }

   // For other objects we just run the incorporation procedure
   SetLastMergingMsg(obj);
   Incorporate(obj, fOutput, merged);
   NotifyMemory(obj);

   // We are done
   return (merged ? 1 : 0);
}

//______________________________________________________________________________
void TProofPlayerRemote::RedirectOutput(Bool_t on)
{
   // Control output redirection to TProof::fLogFileW

   if (on && fProof && fProof->fLogFileW) {
      TProofServ::SetErrorHandlerFile(fProof->fLogFileW);
      fErrorHandler = SetErrorHandler(TProofServ::ErrorHandler);
   } else if (!on) {
      if (fErrorHandler) {
         TProofServ::SetErrorHandlerFile(0);
         SetErrorHandler(fErrorHandler);
      }
   }
}

//______________________________________________________________________________
void TProofPlayerRemote::AddOutput(TList *out)
{
   // Incorporate the content of the received output list 'out' into the final
   // output list fOutput. The latter is created if not existing.
   // This method short cuts 'StoreOutput + MergeOutput' limiting the memory
   // consumption.

   PDB(kOutput,1) Info("AddOutput","Enter");

   // We must something to process
   if (!out) {
      PDB(kOutput,1) Info("AddOutput","Invalid input (out == 0x0)");
      return;
   }

   // Create the output list, if not yet done
   if (!fOutput)
      fOutput = new THashList;

   // Process event lists first
   Bool_t merged = kTRUE;
   TList *elists = dynamic_cast<TList *> (out->FindObject("PROOF_EventListsList"));
   if (elists) {

      // Create a global event list, result of merging the event lists
      // corresponding to the various data set elements
      TEventList *evlist = new TEventList("PROOF_EventList");

      // Iterate the list of event list segments
      TIter nxevl(elists);
      TEventList *evl = 0;
      while ((evl = dynamic_cast<TEventList *> (nxevl()))) {

         // Find the file offset (fDSet is the current TDSet instance)
         // locating the element by name
         TIter nxelem(fDSet->GetListOfElements());
         TDSetElement *elem = 0;
         while ((elem = dynamic_cast<TDSetElement *> (nxelem()))) {
            if (!strcmp(elem->GetFileName(), evl->GetName()))
               break;
         }
         if (!elem) {
            Error("AddOutput", "Found an event list for %s, but no object with"
                               " the same name in the TDSet", evl->GetName());
            continue;
         }
         Long64_t offset = elem->GetTDSetOffset();

         // Shift the list by the number of first event in that file
         Long64_t *arr = evl->GetList();
         Int_t num = evl->GetN();
         if (arr && offset > 0)
            for (Int_t i = 0; i < num; i++)
               arr[i] += offset;

         // Add to the global event list
         evlist->Add(evl);
      }

      // Remove and delete the events lists object to avoid spoiling iteration
      // during next steps
      out->Remove(elists);
      delete elists;

      // Incorporate the resulting global list in fOutput
      SetLastMergingMsg(evlist);
      Incorporate(evlist, fOutput, merged);
      NotifyMemory(evlist);
   }

   // Iterate on the remaining objects in the received list
   TIter nxo(out);
   TObject *obj = 0;
   while ((obj = nxo())) {
      SetLastMergingMsg(obj);
      Incorporate(obj, fOutput, merged);
      // If not merged, drop from the temporary list, as the ownership
      // passes to fOutput
      if (!merged)
         out->Remove(obj);
      NotifyMemory(obj);
   }

   // Done
   return;
}

//______________________________________________________________________________
void TProofPlayerRemote::NotifyMemory(TObject *obj)
{
   // Printout the memory record after merging object 'obj'
   // This record is used by the memory monitor

   if (fProof && (!IsClient() || fProof->IsLite())){
      ProcInfo_t pi;
      if (!gSystem->GetProcInfo(&pi)){
         // For PROOF-Lite we redirect this output to a the open log file so that the
         // memory monitor can pick these messages up
         RedirectOutput(fProof->IsLite());
         Info("NotifyMemory|Svc", "Memory %ld virtual %ld resident after merging object %s",
                                  pi.fMemVirtual, pi.fMemResident, obj->GetName());
         RedirectOutput(0);
      }
      // Record also values for monitoring
      TPerfStats::SetMemValues();
   }
}

//______________________________________________________________________________
void TProofPlayerRemote::SetLastMergingMsg(TObject *obj)
{
   // Set the message to be notified in case of exception

   TString lastMsg = TString::Format("while merging object '%s'", obj->GetName());
   TProofServ::SetLastMsg(lastMsg);
}

//______________________________________________________________________________
Int_t TProofPlayerRemote::Incorporate(TObject *newobj, TList *outlist, Bool_t &merged)
{
   // Incorporate object 'newobj' in the list 'outlist'.
   // The object is merged with an object of the same name already existing in
   // the list, or just added.
   // The boolean merged is set to kFALSE when the object is just added to 'outlist';
   // this happens if the Merge() method does not exist or if a object named as 'obj'
   // is not already in the list. If the obj is not 'merged' than it should not be
   // deleted, unless outlist is not owner of its objects.
   // Return 0 on success, -1 on error.

   merged = kTRUE;

   PDB(kOutput,1)
      Info("Incorporate", "enter: obj: %p (%s), list: %p",
                          newobj, newobj ? newobj->ClassName() : "undef", outlist);

   // The object and list must exist
   if (!newobj || !outlist) {
      Error("Incorporate","Invalid inputs: obj: %p, list: %p", newobj, outlist);
      return -1;
   }

   // Special treatment for histograms in autobin mode
   Bool_t specialH =
      (!fProof || !fProof->TestBit(TProof::kIsClient) || fProof->IsLite()) ? kTRUE : kFALSE;
   if (specialH && newobj->InheritsFrom(TH1::Class())) {
      if (!HandleHistogram(newobj, merged)) {
         if (merged) {
            PDB(kOutput,1) Info("Incorporate", "histogram object '%s' merged", newobj->GetName());
         } else {
            PDB(kOutput,1) Info("Incorporate", "histogram object '%s' added to the"
                                " appropriate list for delayed merging", newobj->GetName());
         }
         return 0;
      }
   }

   // Check if an object with the same name exists already
   TObject *obj = outlist->FindObject(newobj->GetName());

   // If no, add the new object and return
   if (!obj) {
      outlist->Add(newobj);
      merged = kFALSE;
      // Done
      return 0;
   }

   // Locate the Merge(TCollection *) method
   TMethodCall callEnv;
   if (obj->IsA())
      callEnv.InitWithPrototype(obj->IsA(), "Merge", "TCollection*");
   if (callEnv.IsValid()) {
      // Found: put the object in a one-element list
      static TList *xlist = new TList;
      xlist->Add(newobj);
      // Call the method
      callEnv.SetParam((Long_t) xlist);
      callEnv.Execute(obj);
      // Ready for next call
      xlist->Clear();
   } else {
      // Not found: return individual objects
      outlist->Add(newobj);
      merged = kFALSE;
   }

   // Done
   return 0;
}

//______________________________________________________________________________
TObject *TProofPlayerRemote::HandleHistogram(TObject *obj, Bool_t &merged)
{
   // Low statistic histograms need a special treatment when using autobin

   TH1 *h = dynamic_cast<TH1 *>(obj);
   if (!h) {
      // Not an histo
      return obj;
   }

   // This is only used if we return (TObject *)0 and there is only one case
   // when we set this to kTRUE
   merged = kFALSE;

   // Does is still needs binning ?
   Bool_t tobebinned = (h->GetBuffer()) ? kTRUE : kFALSE;

   // Number of entries
   Int_t nent = h->GetBufferLength();
   PDB(kOutput,2) Info("HandleHistogram", "h:%s ent:%d, buffer size: %d",
                       h->GetName(), nent, h->GetBufferSize());

   // Attach to the list in the outputlists, if any
   TList *list = 0;
   if (!fOutputLists) {
      PDB(kOutput,2) Info("HandleHistogram", "create fOutputLists");
      fOutputLists = new TList;
      fOutputLists->SetOwner();
   }
   list = (TList *) fOutputLists->FindObject(h->GetName());

   TH1 *href = 0;
   if (tobebinned) {

      // The histogram needs to be projected in a reasonable range: we
      // do this at the end with all the histos, so we need to create
      // a list here
      if (!list) {
         // Create the list
         list = new TList;
         list->SetName(h->GetName());
         list->SetOwner();
         fOutputLists->Add(list);
         // Move in it any previously merged object from the output list
         if (fOutput && (href = (TH1 *) fOutput->FindObject(h->GetName()))) {
            fOutput->Remove(href);
            list->Add(href);
         }
      }
      TIter nxh(list);
      while ((href = (TH1 *) nxh())) {
         if (href->GetBuffer() && href->GetBufferLength() < nent) break;
      }
      if (href) {
         list->AddBefore(href, h);
      } else {
         list->Add(h);
      }
      // Done
      return (TObject *)0;

   } else {

      if (list) {
         TIter nxh(list);
         while ((href = (TH1 *) nxh())) {
            if (href->GetBuffer() || href->GetEntries() < nent) break;
         }
         if (href) {
            list->AddBefore(href, h);
         } else {
            list->Add(h);
         }
         // Done
         return (TObject *)0;

      } else {
         // Check if we can 'Add' the histogram to an existing one; this is more efficient
         // then using Merge
         TH1 *hout = (TH1*) fOutput->FindObject(h->GetName());
         if (hout) {
            // Remove the existing histo from the output list ...
            fOutput->Remove(hout);
            // ... and create either the list to merge in one-go at the end
            // (more efficient than merging one by one) or, if too big, merge
            // these two and start the 'one-by-one' technology
            Int_t hsz = h->GetNbinsX() * h->GetNbinsY() * h->GetNbinsZ();
            if (fMergeTH1OneByOne || (gProofServ && hsz > gProofServ->GetMsgSizeHWM())) {
               list = new TList;
               list->Add(hout);
               h->Merge(list);
               list->SetOwner();
               delete list;
               return h;
            } else {
               list = new TList;
               list->SetName(h->GetName());
               list->SetOwner();
               fOutputLists->Add(list);
               // Add the existing and the incoming histos
               list->Add(hout);
               list->Add(h);
               // Done
               return (TObject *)0;
            }
         } else {
            // This is the first one; add it to the output list
            fOutput->Add(h);
            return (TObject *)0;
         }
      }
   }
   PDB(kOutput,1) Info("HandleHistogram", "leaving");
}

//______________________________________________________________________________
Bool_t TProofPlayerRemote::HistoSameAxis(TH1 *h0, TH1 *h1)
{
   // Return kTRUE is the histograms 'h0' and 'h1' have the same binning and ranges
   // on the axis (i.e. if they can be just Add-ed for merging).

   Bool_t rc = kFALSE;
   if (!h0 || !h1) return rc;

   TAxis *a0 = 0, *a1 = 0;

   // Check X
   a0 = h0->GetXaxis();
   a1 = h1->GetXaxis();
   if (a0->GetNbins() == a1->GetNbins())
      if (TMath::Abs(a0->GetXmax() - a1->GetXmax()) < 1.e-9)
         if (TMath::Abs(a0->GetXmin() - a1->GetXmin()) < 1.e-9) rc = kTRUE;

   // Check Y, if needed
   if (h0->GetDimension() > 1) {
      rc = kFALSE;
      a0 = h0->GetYaxis();
      a1 = h1->GetYaxis();
      if (a0->GetNbins() == a1->GetNbins())
         if (TMath::Abs(a0->GetXmax() - a1->GetXmax()) < 1.e-9)
            if (TMath::Abs(a0->GetXmin() - a1->GetXmin()) < 1.e-9) rc = kTRUE;
   }

   // Check Z, if needed
   if (h0->GetDimension() > 2) {
      rc = kFALSE;
      a0 = h0->GetZaxis();
      a1 = h1->GetZaxis();
      if (a0->GetNbins() == a1->GetNbins())
         if (TMath::Abs(a0->GetXmax() - a1->GetXmax()) < 1.e-9)
            if (TMath::Abs(a0->GetXmin() - a1->GetXmin()) < 1.e-9) rc = kTRUE;
   }

   // Done
   return rc;
}

//______________________________________________________________________________
void TProofPlayerRemote::StoreOutput(TList *out)
{
   // Store received output list.

   PDB(kOutput,1) Info("StoreOutput","Enter");

   if ( out == 0 ) {
      PDB(kOutput,1) Info("StoreOutput","Leave (empty)");
      return;
   }

   TIter next(out);
   out->SetOwner(kFALSE);  // take ownership of the contents

   if (fOutputLists == 0) {
      PDB(kOutput,2) Info("StoreOutput","Create fOutputLists");
      fOutputLists = new TList;
      fOutputLists->SetOwner();
   }
   // process eventlists first
   TList* lists = dynamic_cast<TList*> (out->FindObject("PROOF_EventListsList"));
   if (lists) {
      out->Remove(lists);
      TEventList *mainList = new TEventList("PROOF_EventList");
      out->Add(mainList);
      TIter it(lists);
      TEventList *aList;
      while ( (aList = dynamic_cast<TEventList*> (it())) ) {
         // find file offset
         TIter nxe(fDSet->GetListOfElements());
         TDSetElement *elem;
         while ( (elem = dynamic_cast<TDSetElement*> (nxe())) ) {
            if (strcmp(elem->GetFileName(), aList->GetName()) == 0)
               break;
         }
         if (!elem) {
            Error("StoreOutput", "found the EventList for %s, but no object with that name "
                                 "in the TDSet", aList->GetName());
            continue;
         }
         Long64_t offset = elem->GetTDSetOffset();

         // shift the list by the number of first event in that file
         Long64_t *arr = aList->GetList();
         Int_t num = aList->GetN();
         if (arr && offset)
            for (int i = 0; i < num; i++)
               arr[i] += offset;

         mainList->Add(aList);           // add to the main list
      }
      delete lists;
   }

   TObject *obj;
   while( (obj = next()) ) {
      PDB(kOutput,2) Info("StoreOutput","find list for '%s'", obj->GetName() );

      TList *list = (TList *) fOutputLists->FindObject( obj->GetName() );
      if ( list == 0 ) {
         PDB(kOutput,2) Info("StoreOutput", "list for '%s' not found (creating)", obj->GetName());
         list = new TList;
         list->SetName( obj->GetName() );
         list->SetOwner();
         fOutputLists->Add( list );
      }
      list->Add( obj );
   }

   delete out;
   PDB(kOutput,1) Info("StoreOutput", "leave");
}

//______________________________________________________________________________
TList *TProofPlayerRemote::MergeFeedback()
{
   // Merge feedback lists.

   PDB(kFeedback,1)
      Info("MergeFeedback","Enter");

   if ( fFeedbackLists == 0 ) {
      PDB(kFeedback,1)
         Info("MergeFeedback","Leave (no output)");
      return 0;
   }

   TList *fb = new TList;   // collection of feedback objects
   fb->SetOwner();

   TIter next(fFeedbackLists);

   TMap *map;
   while ( (map = (TMap*) next()) ) {

      PDB(kFeedback,2)
         Info("MergeFeedback", "map %s size: %d", map->GetName(), map->GetSize());

      // turn map into list ...

      TList *list = new TList;
      TIter keys(map);

#ifndef R__TH1MERGEFIXED
      Int_t nbmx = -1;
      TObject *oref = 0;
#endif
      while ( TObject *key = keys() ) {
         TObject *o = map->GetValue(key);
         TH1 *h = dynamic_cast<TH1 *>(o);
#ifndef R__TH1MERGEFIXED
         // Temporary fix for to cope with the problem in TH1::Merge.
         // We need to use a reference histo the one with the largest number
         // of bins so that the histos from all submasters can be correctly
         // fit in
         if (h && !strncmp(o->GetName(),"PROOF_",6)) {
            if (h->GetNbinsX() > nbmx) {
               nbmx=  h->GetNbinsX();
               oref = o;
            }
         }
#endif
         if (h) {
            TIter nxh(list);
            TH1 *href= 0;
            while ((href = (TH1 *)nxh())) {
               if (h->GetBuffer()) {
                  if (href->GetBuffer() && href->GetBufferLength() < h->GetBufferLength()) break;
               } else {
                  if (href->GetBuffer() || href->GetEntries() < h->GetEntries()) break;
               }
            }
            if (href) {
               list->AddBefore(href, h);
            } else {
               list->Add(h);
            }
         } else {
            list->Add(o);
         }
      }

      // clone first object, remove from list
#ifdef R__TH1MERGEFIXED
      TObject *obj = list->First();
#else
      TObject *obj = (oref) ? oref : list->First();
#endif
      list->Remove(obj);
      obj = obj->Clone();
      fb->Add(obj);

      if ( list->IsEmpty() ) {
         delete list;
         continue;
      }

      // merge list with clone
      TMethodCall callEnv;
      if (obj->IsA())
         callEnv.InitWithPrototype(obj->IsA(), "Merge", "TCollection*");
      if (callEnv.IsValid()) {
         callEnv.SetParam((Long_t) list);
         callEnv.Execute(obj);
      } else {
         // No Merge interface, return copy of individual objects
         while ( (obj = list->First()) ) {
            fb->Add(obj->Clone());
            list->Remove(obj);
         }
      }

      delete list;
   }

   PDB(kFeedback,1)
      Info("MergeFeedback","Leave (%d object(s))", fb->GetSize());

   return fb;
}

//______________________________________________________________________________
void TProofPlayerRemote::StoreFeedback(TObject *slave, TList *out)
{
   // Store feedback results from the specified slave.

   PDB(kFeedback,1)
      Info("StoreFeedback","Enter");

   if ( out == 0 ) {
      PDB(kFeedback,1)
         Info("StoreFeedback","Leave (empty)");
      return;
   }

   if ( IsClient() ) {
      // in client
      Feedback(out);
      delete out;
      return;
   }

   if (fFeedbackLists == 0) {
      PDB(kFeedback,2) Info("StoreFeedback","Create fFeedbackLists");
      fFeedbackLists = new TList;
      fFeedbackLists->SetOwner();
   }

   TIter next(out);
   out->SetOwner(kFALSE);  // take ownership of the contents

   const char *ord = ((TSlave*) slave)->GetOrdinal();

   TObject *obj;
   while( (obj = next()) ) {
      PDB(kFeedback,2)
         Info("StoreFeedback","%s: Find '%s'", ord, obj->GetName() );
      TMap *map = (TMap*) fFeedbackLists->FindObject(obj->GetName());
      if ( map == 0 ) {
         PDB(kFeedback,2)
            Info("StoreFeedback", "%s: map for '%s' not found (creating)", ord, obj->GetName());
         // Map must not be owner (ownership is with regards to the keys (only))
         map = new TMap;
         map->SetName(obj->GetName());
         fFeedbackLists->Add(map);
      } else {
         PDB(kFeedback,2)
            Info("StoreFeedback","%s: removing previous value", ord);
         if (map->GetValue(slave))
            delete map->GetValue(slave);
         map->Remove(slave);
      }
      map->Add(slave, obj);
      PDB(kFeedback,2)
         Info("StoreFeedback","%s: %s, size: %d", ord, obj->GetName(), map->GetSize());
   }

   delete out;
   PDB(kFeedback,1)
      Info("StoreFeedback","Leave");
}

//______________________________________________________________________________
void TProofPlayerRemote::SetupFeedback()
{
   // Setup reporting of feedback objects.

   if (IsClient()) return; // Client does not need timer

   fFeedback = (TList*) fInput->FindObject("FeedbackList");

   PDB(kFeedback,1) Info("SetupFeedback","\"FeedbackList\" %sfound",
      fFeedback == 0 ? "NOT ":"");

   if (fFeedback == 0 || fFeedback->GetSize() == 0) return;

   // OK, feedback was requested, setup the timer
   SafeDelete(fFeedbackTimer);
   fFeedbackPeriod = 2000;
   TProof::GetParameter(fInput, "PROOF_FeedbackPeriod", fFeedbackPeriod);
   fFeedbackTimer = new TTimer;
   fFeedbackTimer->SetObject(this);
   fFeedbackTimer->Start(fFeedbackPeriod, kTRUE);
}

//______________________________________________________________________________
void TProofPlayerRemote::StopFeedback()
{
   // Stop reporting of feedback objects.

   if (fFeedbackTimer == 0) return;

   PDB(kFeedback,1) Info("StopFeedback","Stop Timer");

   SafeDelete(fFeedbackTimer);
}

//______________________________________________________________________________
Bool_t TProofPlayerRemote::HandleTimer(TTimer *)
{
   // Send feedback objects to client.

   PDB(kFeedback,2) Info("HandleTimer","Entry");

   if (fFeedbackTimer == 0) return kFALSE; // timer already switched off

   // process local feedback objects

   TList *fb = new TList;
   fb->SetOwner();

   TIter next(fFeedback);
   while( TObjString *name = (TObjString*) next() ) {
      TObject *o = fOutput->FindObject(name->GetName());
      if (o != 0) {
         fb->Add(o->Clone());
         // remove the corresponding entry from the feedback list
         TMap *m = 0;
         if (fFeedbackLists &&
            (m = (TMap *) fFeedbackLists->FindObject(name->GetName()))) {
            fFeedbackLists->Remove(m);
            m->DeleteValues();
            delete m;
         }
      }
   }

   if (fb->GetSize() > 0) {
      StoreFeedback(this, fb); // adopts fb
   } else {
      delete fb;
   }

   if (fFeedbackLists == 0) {
      fFeedbackTimer->Start(fFeedbackPeriod, kTRUE);   // maybe next time
      return kFALSE;
   }

   fb = MergeFeedback();

   PDB(kFeedback,2) Info("HandleTimer","Sending %d objects", fb->GetSize());

   TMessage m(kPROOF_FEEDBACK);
   m << fb;

   // send message to client;
   gProofServ->GetSocket()->Send(m);

   delete fb;

   fFeedbackTimer->Start(fFeedbackPeriod, kTRUE);

   return kFALSE; // ignored?
}

//______________________________________________________________________________
TDSetElement *TProofPlayerRemote::GetNextPacket(TSlave *slave, TMessage *r)
{
   // Get next packet for specified slave.

   // The first call to this determines the end of initialization
   SetInitTime();

   if (fProcPackets) {
      Int_t bin = fProcPackets->GetXaxis()->FindBin(slave->GetOrdinal());
      if (bin >= 0) {
         if (fProcPackets->GetBinContent(bin) > 0)
            fProcPackets->Fill(slave->GetOrdinal(), -1);
      }
   }

   TDSetElement *e = fPacketizer->GetNextPacket( slave, r );

   if (e == 0) {
      PDB(kPacketizer,2) 
         Info("GetNextPacket","%s: done!", slave->GetOrdinal());
   } else if (e == (TDSetElement*) -1) {
      PDB(kPacketizer,2)
         Info("GetNextPacket","%s: waiting ...", slave->GetOrdinal());
   } else {
      PDB(kPacketizer,2)
         Info("GetNextPacket","%s (%s): '%s' '%s' '%s' %lld %lld",
              slave->GetOrdinal(), slave->GetName(), e->GetFileName(),
              e->GetDirectory(), e->GetObjName(), e->GetFirst(), e->GetNum());
      if (fProcPackets) fProcPackets->Fill(slave->GetOrdinal(), 1);
   }

   return e;
}

//______________________________________________________________________________
Bool_t TProofPlayerRemote::IsClient() const
{
   // Is the player running on the client?

   return fProof ? fProof->TestBit(TProof::kIsClient) : kFALSE;
}

//______________________________________________________________________________
Long64_t TProofPlayerRemote::DrawSelect(TDSet *set, const char *varexp,
                                        const char *selection, Option_t *option,
                                        Long64_t nentries, Long64_t firstentry)
{
   // Draw (support for TChain::Draw()).
   // Returns -1 in case of error or number of selected events in case of success.

   if (!fgDrawInputPars) {
      fgDrawInputPars = new THashList;
      fgDrawInputPars->Add(new TObjString("FeedbackList"));
      fgDrawInputPars->Add(new TObjString("PROOF_ChainWeight"));
      fgDrawInputPars->Add(new TObjString("PROOF_LineColor"));
      fgDrawInputPars->Add(new TObjString("PROOF_LineStyle"));
      fgDrawInputPars->Add(new TObjString("PROOF_LineWidth"));
      fgDrawInputPars->Add(new TObjString("PROOF_MarkerColor"));
      fgDrawInputPars->Add(new TObjString("PROOF_MarkerStyle"));
      fgDrawInputPars->Add(new TObjString("PROOF_MarkerSize"));
      fgDrawInputPars->Add(new TObjString("PROOF_FillColor"));
      fgDrawInputPars->Add(new TObjString("PROOF_FillStyle"));
      fgDrawInputPars->Add(new TObjString("PROOF_ListOfAliases"));
   }

   TString selector, objname;
   if (GetDrawArgs(varexp, selection, option, selector, objname) != 0) {
      Error("DrawSelect", "parsing arguments");
      return -1;
   }

   TNamed *varexpobj = new TNamed("varexp", varexp);
   TNamed *selectionobj = new TNamed("selection", selection);

   // Save the current input list
   TObject *o = 0;
   TList *savedInput = new TList;
   TIter nxi(fInput);
   while ((o = nxi())) {
      savedInput->Add(o);
      TString n(o->GetName());
      if (fgDrawInputPars &&
          !fgDrawInputPars->FindObject(o->GetName()) &&
          !n.BeginsWith("alias:")) fInput->Remove(o);
   }

   fInput->Add(varexpobj);
   fInput->Add(selectionobj);

   // Make sure we have an object name
   if (objname == "") objname = "htemp";

   fProof->AddFeedback(objname);
   Long64_t r = Process(set, selector, option, nentries, firstentry);
   fProof->RemoveFeedback(objname);

   fInput->Remove(varexpobj);
   fInput->Remove(selectionobj);
   if (TNamed *opt = dynamic_cast<TNamed*> (fInput->FindObject("PROOF_OPTIONS"))) {
      fInput->Remove(opt);
      delete opt;
   }

   delete varexpobj;
   delete selectionobj;

   // Restore the input list
   fInput->Clear();
   TIter nxsi(savedInput);
   while ((o = nxsi()))
      fInput->Add(o);
   savedInput->SetOwner(kFALSE);
   delete savedInput;

   return r;
}

//______________________________________________________________________________
void TProofPlayerRemote::SetInitTime()
{
   // Set init time

   if (fPacketizer)
      fPacketizer->SetInitTime();
}

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


ClassImp(TProofPlayerSlave)

//______________________________________________________________________________
void TProofPlayerSlave::SetupFeedback()
{
   // Setup feedback.

   TList *fb = (TList*) fInput->FindObject("FeedbackList");
   if (fb) {
      PDB(kFeedback,1)
         Info("SetupFeedback","\"FeedbackList\" found: %d objects", fb->GetSize());
   } else {
      PDB(kFeedback,1)
         Info("SetupFeedback","\"FeedbackList\" NOT found");
   }

   if (fb == 0 || fb->GetSize() == 0) return;

   // OK, feedback was requested, setup the timer

   SafeDelete(fFeedbackTimer);
   fFeedbackPeriod = 2000;
   TProof::GetParameter(fInput, "PROOF_FeedbackPeriod", fFeedbackPeriod);
   fFeedbackTimer = new TTimer;
   fFeedbackTimer->SetObject(this);
   fFeedbackTimer->Start(fFeedbackPeriod, kTRUE);

   fFeedback = fb;
}

//______________________________________________________________________________
void TProofPlayerSlave::StopFeedback()
{
   // Stop feedback.

   if (fFeedbackTimer == 0) return;

   PDB(kFeedback,1) Info("StopFeedback","Stop Timer");

   SafeDelete(fFeedbackTimer);
}

//______________________________________________________________________________
Bool_t TProofPlayerSlave::HandleTimer(TTimer *)
{
   // Handle timer event.

   PDB(kFeedback,2) Info("HandleTimer","Entry");

   // If in sequential (0-slave-PROOF) mode we do not have a packetizer
   // so we also send the info to update the progress bar.
   if (gProofServ) {
      Bool_t sendm = kFALSE;
      TMessage m(kPROOF_PROGRESS);
      if (gProofServ->IsMaster() && !gProofServ->IsParallel()) {
         sendm = kTRUE;
         if (gProofServ->GetProtocol() > 25) {
            m << GetProgressStatus();
         } else if (gProofServ->GetProtocol() > 11) {
            TProofProgressStatus *ps = GetProgressStatus();
            m << fTotalEvents << ps->GetEntries() << ps->GetBytesRead()
              << (Float_t) -1. << (Float_t) ps->GetProcTime()
              << (Float_t) ps->GetRate() << (Float_t) -1.;
         } else {
            m << fTotalEvents << GetEventsProcessed();
         }
      }
      if (sendm) gProofServ->GetSocket()->Send(m);
   }

   if (fFeedback == 0) return kFALSE;

   TList *fb = new TList;
   fb->SetOwner(kFALSE);

   if (fOutput == 0) {
      fOutput = (THashList *) fSelector->GetOutputList();
   }

   if (fOutput) {
      TIter next(fFeedback);
      while( TObjString *name = (TObjString*) next() ) {
         // TODO: find object in memory ... maybe allow only in fOutput ?
         TObject *o = fOutput->FindObject(name->GetName());
         if (o != 0) fb->Add(o);
      }
   }

   PDB(kFeedback,2) Info("HandleTimer","Sending %d objects", fb->GetSize());

   TMessage m(kPROOF_FEEDBACK);
   m << fb;

   // send message to client;
   gProofServ->GetSocket()->Send(m);

   delete fb;

   fFeedbackTimer->Start(fFeedbackPeriod, kTRUE);

   return kFALSE; // ignored?
}

//______________________________________________________________________________
void TProofPlayerSlave::HandleGetTreeHeader(TMessage *mess)
{
   // Handle tree header request.

   TMessage answ(kPROOF_GETTREEHEADER);

   TDSet *dset;
   (*mess) >> dset;
   dset->Reset();
   TDSetElement *e = dset->Next();
   Long64_t entries = 0;
   TFile *f = 0;
   TTree *t = 0;
   if (!e) {
      PDB(kGlobal, 1) Info("HandleGetTreeHeader", "empty TDSet");
   } else {
      f = TFile::Open(e->GetFileName());
      t = 0;
      if (f) {
         t = (TTree*) f->Get(e->GetObjName());
         if (t) {
            t->SetMaxVirtualSize(0);
            t->DropBaskets();
            entries = t->GetEntries();

            // compute #entries in all the files
            while ((e = dset->Next()) != 0) {
               TFile *f1 = TFile::Open(e->GetFileName());
               if (f1) {
                  TTree *t1 = (TTree*) f1->Get(e->GetObjName());
                  if (t1) {
                     entries += t1->GetEntries();
                     delete t1;
                  }
                  delete f1;
               }
            }
            t->SetMaxEntryLoop(entries);   // this field will hold the total number of entries ;)
         }
      }
   }
   if (t)
      answ << TString("Success") << t;
   else
      answ << TString("Failed") << t;

   fSocket->Send(answ);

   SafeDelete(t);
   SafeDelete(f);
}


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

ClassImp(TProofPlayerSuperMaster)

//______________________________________________________________________________
Long64_t TProofPlayerSuperMaster::Process(TDSet *dset, const char *selector_file,
                                          Option_t *option, Long64_t nentries,
                                          Long64_t first)
{
   // Process specified TDSet on PROOF. Runs on super master.
   // The return value is -1 in case of error and TSelector::GetStatus() in
   // in case of success.

   fProgressStatus->Reset();
   PDB(kGlobal,1) Info("Process","Enter");

   TProofSuperMaster *proof = dynamic_cast<TProofSuperMaster*>(GetProof());
   if (!proof) return -1;

   delete fOutput;
   fOutput = new THashList;

   TPerfStats::Start(fInput, fOutput);

   if (!SendSelector(selector_file)) {
      Error("Process", "sending selector %s", selector_file);
      return -1;
   }

   TCleanup clean(this);
   SetupFeedback();

   if (proof->IsMaster()) {

      // make sure the DSet is valid
      if (!dset->ElementsValid()) {
         proof->ValidateDSet(dset);
         if (!dset->ElementsValid()) {
            Error("Process", "could not validate TDSet");
            return -1;
         }
      }

      TList msds;
      msds.SetOwner(); // This will delete TPairs

      TList keyholder; // List to clean up key part of the pairs
      keyholder.SetOwner();
      TList valueholder; // List to clean up value part of the pairs
      valueholder.SetOwner();

      // Construct msd list using the slaves
      TIter nextslave(proof->GetListOfActiveSlaves());
      while (TSlave *sl = dynamic_cast<TSlave*>(nextslave())) {
         TList *submasters = 0;
         TPair *msd = dynamic_cast<TPair*>(msds.FindObject(sl->GetMsd()));
         if (!msd) {
            submasters = new TList;
            submasters->SetName(sl->GetMsd());
            keyholder.Add(submasters);
            TList *setelements = new TSortedList(kSortDescending);
            setelements->SetName(TString(sl->GetMsd())+"_Elements");
            valueholder.Add(setelements);
            msds.Add(new TPair(submasters, setelements));
         } else {
            submasters = dynamic_cast<TList*>(msd->Key());
         }
         if (submasters) submasters->Add(sl);
      }

      // Add TDSetElements to msd list
      Long64_t cur = 0; //start of next element
      TIter nextelement(dset->GetListOfElements());
      while (TDSetElement *elem = dynamic_cast<TDSetElement*>(nextelement())) {

         if (elem->GetNum()<1) continue; // get rid of empty elements

         if (nentries !=-1 && cur>=first+nentries) {
            // we are done
            break;
         }

         if (cur+elem->GetNum()-1<first) {
            //element is before first requested entry
            cur+=elem->GetNum();
            continue;
         }

         if (cur<first) {
            //modify element to get proper start
            elem->SetNum(elem->GetNum()-(first-cur));
            elem->SetFirst(elem->GetFirst()+first-cur);
            cur=first;
         }

         if (nentries==-1 || cur+elem->GetNum()<=first+nentries) {
            cur+=elem->GetNum();
         } else {
            //modify element to get proper end
            elem->SetNum(first+nentries-cur);
            cur=first+nentries;
         }

         TPair *msd = dynamic_cast<TPair*>(msds.FindObject(elem->GetMsd()));
         if (!msd) {
            Error("Process", "data requires mass storage domain '%s'"
                  " which is not accessible in this proof session",
                  elem->GetMsd());
            return -1;
         } else {
            TList *elements = dynamic_cast<TList*>(msd->Value());
            if (elements) elements->Add(elem);
         }
      }

      TList usedmasters;
      TIter nextmsd(msds.MakeIterator());
      while (TPair *msd = dynamic_cast<TPair*>(nextmsd())) {
         TList *submasters = dynamic_cast<TList*>(msd->Key());
         TList *setelements = dynamic_cast<TList*>(msd->Value());

         // distribute elements over the masters
         Int_t nmasters = submasters ? submasters->GetSize() : -1;
         Int_t nelements = setelements ? setelements->GetSize() : -1;
         for (Int_t i=0; i<nmasters; i++) {

            Long64_t nent = 0;
            TDSet set(dset->GetType(), dset->GetObjName(),
                      dset->GetDirectory());
            for (Int_t j = (i*nelements)/nmasters;
                       j < ((i+1)*nelements)/nmasters;
                       j++) {
               TDSetElement *elem = setelements ?
                  dynamic_cast<TDSetElement*>(setelements->At(j)) : (TDSetElement *)0;
               if (elem) {
                  set.Add(elem->GetFileName(), elem->GetObjName(),
                        elem->GetDirectory(), elem->GetFirst(),
                        elem->GetNum(), elem->GetMsd());
                  nent += elem->GetNum();
               } else {
                  Warning("Process", "not a TDSetElement object");
               }
            }

            if (set.GetListOfElements()->GetSize()>0) {
               TMessage mesg(kPROOF_PROCESS);
               TString fn(gSystem->BaseName(selector_file));
               TString opt = option;
               mesg << &set << fn << fInput << opt << Long64_t(-1) << Long64_t(0);

               TSlave *sl = dynamic_cast<TSlave*>(submasters->At(i));
               if (sl) {
                  PDB(kGlobal,1) Info("Process",
                                    "Sending TDSet with %d elements to submaster %s",
                                    set.GetListOfElements()->GetSize(),
                                    sl->GetOrdinal());
                  sl->GetSocket()->Send(mesg);
                  usedmasters.Add(sl);

                  // setup progress info
                  fSlaves.AddLast(sl);
                  fSlaveProgress.Set(fSlaveProgress.GetSize()+1);
                  fSlaveProgress[fSlaveProgress.GetSize()-1] = 0;
                  fSlaveTotals.Set(fSlaveTotals.GetSize()+1);
                  fSlaveTotals[fSlaveTotals.GetSize()-1] = nent;
                  fSlaveBytesRead.Set(fSlaveBytesRead.GetSize()+1);
                  fSlaveBytesRead[fSlaveBytesRead.GetSize()-1] = 0;
                  fSlaveInitTime.Set(fSlaveInitTime.GetSize()+1);
                  fSlaveInitTime[fSlaveInitTime.GetSize()-1] = -1.;
                  fSlaveProcTime.Set(fSlaveProcTime.GetSize()+1);
                  fSlaveProcTime[fSlaveProcTime.GetSize()-1] = -1.;
                  fSlaveEvtRti.Set(fSlaveEvtRti.GetSize()+1);
                  fSlaveEvtRti[fSlaveEvtRti.GetSize()-1] = -1.;
                  fSlaveMBRti.Set(fSlaveMBRti.GetSize()+1);
                  fSlaveMBRti[fSlaveMBRti.GetSize()-1] = -1.;
                  fSlaveActW.Set(fSlaveActW.GetSize()+1);
                  fSlaveActW[fSlaveActW.GetSize()-1] = 0;
                  fSlaveTotS.Set(fSlaveTotS.GetSize()+1);
                  fSlaveTotS[fSlaveTotS.GetSize()-1] = 0;
                  fSlaveEffS.Set(fSlaveEffS.GetSize()+1);
                  fSlaveEffS[fSlaveEffS.GetSize()-1] = 0.;
               } else {
                  Warning("Process", "not a TSlave object");
               }
            }
         }
      }

      if ( !IsClient() ) HandleTimer(0);
      PDB(kGlobal,1) Info("Process","Calling Collect");
      proof->Collect(&usedmasters);
      HandleTimer(0);

   }

   StopFeedback();

   PDB(kGlobal,1) Info("Process","Calling Merge Output");
   MergeOutput();

   TPerfStats::Stop();

   return 0;
}

//______________________________________________________________________________
void TProofPlayerSuperMaster::Progress(TSlave *sl, Long64_t total, Long64_t processed)
{
   // Report progress.

   Int_t idx = fSlaves.IndexOf(sl);
   fSlaveProgress[idx] = processed;
   if (fSlaveTotals[idx] != total)
      Warning("Progress", "total events has changed for slave %s", sl->GetName());
   fSlaveTotals[idx] = total;

   Long64_t tot = 0;
   Int_t i;
   for (i = 0; i < fSlaveTotals.GetSize(); i++) tot += fSlaveTotals[i];
   Long64_t proc = 0;
   for (i = 0; i < fSlaveProgress.GetSize(); i++) proc += fSlaveProgress[i];

   Progress(tot, proc);
}

//______________________________________________________________________________
void TProofPlayerSuperMaster::Progress(TSlave *sl, Long64_t total,
                                       Long64_t processed, Long64_t bytesread,
                                       Float_t initTime, Float_t procTime,
                                       Float_t evtrti, Float_t mbrti)
{
   // Report progress.

   PDB(kGlobal,2)
      Info("Progress","%s: %lld %lld %f %f %f %f", sl->GetName(),
                      processed, bytesread, initTime, procTime, evtrti, mbrti);

   Int_t idx = fSlaves.IndexOf(sl);
   if (fSlaveTotals[idx] != total)
      Warning("Progress", "total events has changed for slave %s", sl->GetName());
   fSlaveTotals[idx] = total;
   fSlaveProgress[idx] = processed;
   fSlaveBytesRead[idx] = bytesread;
   fSlaveInitTime[idx] = (initTime > -1.) ? initTime : fSlaveInitTime[idx];
   fSlaveProcTime[idx] = (procTime > -1.) ? procTime : fSlaveProcTime[idx];
   fSlaveEvtRti[idx] = (evtrti > -1.) ? evtrti : fSlaveEvtRti[idx];
   fSlaveMBRti[idx] = (mbrti > -1.) ? mbrti : fSlaveMBRti[idx];

   Int_t i;
   Long64_t tot = 0;
   Long64_t proc = 0;
   Long64_t bytes = 0;
   Float_t init = -1.;
   Float_t ptime = -1.;
   Float_t erti = 0.;
   Float_t srti = 0.;
   Int_t nerti = 0;
   Int_t nsrti = 0;
   for (i = 0; i < fSlaveTotals.GetSize(); i++) {
      tot += fSlaveTotals[i];
      if (i < fSlaveProgress.GetSize())
         proc += fSlaveProgress[i];
      if (i < fSlaveBytesRead.GetSize())
         bytes += fSlaveBytesRead[i];
      if (i < fSlaveInitTime.GetSize())
         if (fSlaveInitTime[i] > -1. && (init < 0. || fSlaveInitTime[i] < init))
            init = fSlaveInitTime[i];
      if (i < fSlaveProcTime.GetSize())
         if (fSlaveProcTime[i] > -1. && (ptime < 0. || fSlaveProcTime[i] > ptime))
            ptime = fSlaveProcTime[i];
      if (i < fSlaveEvtRti.GetSize())
         if (fSlaveEvtRti[i] > -1.) {
            erti += fSlaveEvtRti[i];
            nerti++;
         }
      if (i < fSlaveMBRti.GetSize())
         if (fSlaveMBRti[i] > -1.) {
            srti += fSlaveMBRti[i];
            nsrti++;
         }
   }
   srti = (nsrti > 0) ? srti / nerti : 0.;

   Progress(tot, proc, bytes, init, ptime, erti, srti);
}

//______________________________________________________________________________
void TProofPlayerSuperMaster::Progress(TSlave *wrk, TProofProgressInfo *pi)
{
   // Progress signal.

   if (pi) {
      PDB(kGlobal,2)
         Info("Progress","%s: %lld %lld %lld %f %f %f %f %d %f", wrk->GetOrdinal(),
                         pi->fTotal, pi->fProcessed, pi->fBytesRead,
                         pi->fInitTime, pi->fProcTime, pi->fEvtRateI, pi->fMBRateI,
                         pi->fActWorkers, pi->fEffSessions);

      Int_t idx = fSlaves.IndexOf(wrk);
      if (fSlaveTotals[idx] != pi->fTotal)
         Warning("Progress", "total events has changed for worker %s", wrk->GetName());
      fSlaveTotals[idx] = pi->fTotal;
      fSlaveProgress[idx] = pi->fProcessed;
      fSlaveBytesRead[idx] = pi->fBytesRead;
      fSlaveInitTime[idx] = (pi->fInitTime > -1.) ? pi->fInitTime : fSlaveInitTime[idx];
      fSlaveProcTime[idx] = (pi->fProcTime > -1.) ? pi->fProcTime : fSlaveProcTime[idx];
      fSlaveEvtRti[idx] = (pi->fEvtRateI > -1.) ? pi->fEvtRateI : fSlaveEvtRti[idx];
      fSlaveMBRti[idx] = (pi->fMBRateI > -1.) ? pi->fMBRateI : fSlaveMBRti[idx];
      fSlaveActW[idx] = (pi->fActWorkers > -1) ? pi->fActWorkers : fSlaveActW[idx];
      fSlaveTotS[idx] = (pi->fTotSessions > -1) ? pi->fTotSessions : fSlaveTotS[idx];
      fSlaveEffS[idx] = (pi->fEffSessions > -1.) ? pi->fEffSessions : fSlaveEffS[idx];

      Int_t i;
      Int_t nerti = 0;
      Int_t nsrti = 0;
      TProofProgressInfo pisum(0, 0, 0, -1., -1., 0., 0., 0, 0, 0.);
      for (i = 0; i < fSlaveTotals.GetSize(); i++) {
         pisum.fTotal += fSlaveTotals[i];
         if (i < fSlaveProgress.GetSize())
            pisum.fProcessed += fSlaveProgress[i];
         if (i < fSlaveBytesRead.GetSize())
            pisum.fBytesRead += fSlaveBytesRead[i];
         if (i < fSlaveInitTime.GetSize())
            if (fSlaveInitTime[i] > -1. && (pisum.fInitTime < 0. || fSlaveInitTime[i] < pisum.fInitTime))
               pisum.fInitTime = fSlaveInitTime[i];
         if (i < fSlaveProcTime.GetSize())
            if (fSlaveProcTime[i] > -1. && (pisum.fProcTime < 0. || fSlaveProcTime[i] > pisum.fProcTime))
               pisum.fProcTime = fSlaveProcTime[i];
         if (i < fSlaveEvtRti.GetSize())
            if (fSlaveEvtRti[i] > -1.) {
               pisum.fEvtRateI += fSlaveEvtRti[i];
               nerti++;
            }
         if (i < fSlaveMBRti.GetSize())
            if (fSlaveMBRti[i] > -1.) {
               pisum.fMBRateI += fSlaveMBRti[i];
               nsrti++;
            }
         if (i < fSlaveActW.GetSize())
            pisum.fActWorkers += fSlaveActW[i];
         if (i < fSlaveTotS.GetSize())
            if (fSlaveTotS[i] > -1 && (pisum.fTotSessions < 0. || fSlaveTotS[i] > pisum.fTotSessions))
               pisum.fTotSessions = fSlaveTotS[i];
         if (i < fSlaveEffS.GetSize())
            if (fSlaveEffS[i] > -1. && (pisum.fEffSessions < 0. || fSlaveEffS[i] > pisum.fEffSessions))
               pisum.fEffSessions = fSlaveEffS[i];
      }
      pisum.fMBRateI = (nsrti > 0) ? pisum.fMBRateI / nerti : 0.;

      Progress(&pisum);
   }
}

//______________________________________________________________________________
Bool_t TProofPlayerSuperMaster::HandleTimer(TTimer *)
{
   // Send progress and feedback to client.

   if (fFeedbackTimer == 0) return kFALSE; // timer stopped already

   Int_t i;
   Long64_t tot = 0;
   Long64_t proc = 0;
   Long64_t bytes = 0;
   Float_t init = -1.;
   Float_t ptime = -1.;
   Float_t erti = 0.;
   Float_t srti = 0.;
   Int_t nerti = 0;
   Int_t nsrti = 0;
   for (i = 0; i < fSlaveTotals.GetSize(); i++) {
      tot += fSlaveTotals[i];
      if (i < fSlaveProgress.GetSize())
         proc += fSlaveProgress[i];
      if (i < fSlaveBytesRead.GetSize())
         bytes += fSlaveBytesRead[i];
      if (i < fSlaveInitTime.GetSize())
         if (fSlaveInitTime[i] > -1. && (init < 0. || fSlaveInitTime[i] < init))
            init = fSlaveInitTime[i];
      if (i < fSlaveProcTime.GetSize())
         if (fSlaveProcTime[i] > -1. && (ptime < 0. || fSlaveProcTime[i] > ptime))
            ptime = fSlaveProcTime[i];
      if (i < fSlaveEvtRti.GetSize())
         if (fSlaveEvtRti[i] > -1.) {
            erti += fSlaveEvtRti[i];
            nerti++;
         }
      if (i < fSlaveMBRti.GetSize())
         if (fSlaveMBRti[i] > -1.) {
            srti += fSlaveMBRti[i];
            nsrti++;
         }
   }
   erti = (nerti > 0) ? erti / nerti : 0.;
   srti = (nsrti > 0) ? srti / nerti : 0.;

   TMessage m(kPROOF_PROGRESS);
   if (gProofServ->GetProtocol() > 25) {
      // Fill the message now
      TProofProgressInfo pi(tot, proc, bytes, init, ptime,
                            erti, srti, -1,
                            gProofServ->GetTotSessions(), gProofServ->GetEffSessions());
      m << &pi;
   } else {

      m << tot << proc << bytes << init << ptime << erti << srti;
   }

   // send message to client;
   gProofServ->GetSocket()->Send(m);

   if (fReturnFeedback)
      return TProofPlayerRemote::HandleTimer(0);
   else
      return kFALSE;
}

//______________________________________________________________________________
void TProofPlayerSuperMaster::SetupFeedback()
{
   // Setup reporting of feedback objects and progress messages.

   if (IsClient()) return; // Client does not need timer

   TProofPlayerRemote::SetupFeedback();

   if (fFeedbackTimer) {
      fReturnFeedback = kTRUE;
      return;
   } else {
      fReturnFeedback = kFALSE;
   }

   // setup the timer for progress message
   SafeDelete(fFeedbackTimer);
   fFeedbackPeriod = 2000;
   TProof::GetParameter(fInput, "PROOF_FeedbackPeriod", fFeedbackPeriod);
   fFeedbackTimer = new TTimer;
   fFeedbackTimer->SetObject(this);
   fFeedbackTimer->Start(fFeedbackPeriod, kTRUE);
}
 TProofPlayer.cxx:1
 TProofPlayer.cxx:2
 TProofPlayer.cxx:3
 TProofPlayer.cxx:4
 TProofPlayer.cxx:5
 TProofPlayer.cxx:6
 TProofPlayer.cxx:7
 TProofPlayer.cxx:8
 TProofPlayer.cxx:9
 TProofPlayer.cxx:10
 TProofPlayer.cxx:11
 TProofPlayer.cxx:12
 TProofPlayer.cxx:13
 TProofPlayer.cxx:14
 TProofPlayer.cxx:15
 TProofPlayer.cxx:16
 TProofPlayer.cxx:17
 TProofPlayer.cxx:18
 TProofPlayer.cxx:19
 TProofPlayer.cxx:20
 TProofPlayer.cxx:21
 TProofPlayer.cxx:22
 TProofPlayer.cxx:23
 TProofPlayer.cxx:24
 TProofPlayer.cxx:25
 TProofPlayer.cxx:26
 TProofPlayer.cxx:27
 TProofPlayer.cxx:28
 TProofPlayer.cxx:29
 TProofPlayer.cxx:30
 TProofPlayer.cxx:31
 TProofPlayer.cxx:32
 TProofPlayer.cxx:33
 TProofPlayer.cxx:34
 TProofPlayer.cxx:35
 TProofPlayer.cxx:36
 TProofPlayer.cxx:37
 TProofPlayer.cxx:38
 TProofPlayer.cxx:39
 TProofPlayer.cxx:40
 TProofPlayer.cxx:41
 TProofPlayer.cxx:42
 TProofPlayer.cxx:43
 TProofPlayer.cxx:44
 TProofPlayer.cxx:45
 TProofPlayer.cxx:46
 TProofPlayer.cxx:47
 TProofPlayer.cxx:48
 TProofPlayer.cxx:49
 TProofPlayer.cxx:50
 TProofPlayer.cxx:51
 TProofPlayer.cxx:52
 TProofPlayer.cxx:53
 TProofPlayer.cxx:54
 TProofPlayer.cxx:55
 TProofPlayer.cxx:56
 TProofPlayer.cxx:57
 TProofPlayer.cxx:58
 TProofPlayer.cxx:59
 TProofPlayer.cxx:60
 TProofPlayer.cxx:61
 TProofPlayer.cxx:62
 TProofPlayer.cxx:63
 TProofPlayer.cxx:64
 TProofPlayer.cxx:65
 TProofPlayer.cxx:66
 TProofPlayer.cxx:67
 TProofPlayer.cxx:68
 TProofPlayer.cxx:69
 TProofPlayer.cxx:70
 TProofPlayer.cxx:71
 TProofPlayer.cxx:72
 TProofPlayer.cxx:73
 TProofPlayer.cxx:74
 TProofPlayer.cxx:75
 TProofPlayer.cxx:76
 TProofPlayer.cxx:77
 TProofPlayer.cxx:78
 TProofPlayer.cxx:79
 TProofPlayer.cxx:80
 TProofPlayer.cxx:81
 TProofPlayer.cxx:82
 TProofPlayer.cxx:83
 TProofPlayer.cxx:84
 TProofPlayer.cxx:85
 TProofPlayer.cxx:86
 TProofPlayer.cxx:87
 TProofPlayer.cxx:88
 TProofPlayer.cxx:89
 TProofPlayer.cxx:90
 TProofPlayer.cxx:91
 TProofPlayer.cxx:92
 TProofPlayer.cxx:93
 TProofPlayer.cxx:94
 TProofPlayer.cxx:95
 TProofPlayer.cxx:96
 TProofPlayer.cxx:97
 TProofPlayer.cxx:98
 TProofPlayer.cxx:99
 TProofPlayer.cxx:100
 TProofPlayer.cxx:101
 TProofPlayer.cxx:102
 TProofPlayer.cxx:103
 TProofPlayer.cxx:104
 TProofPlayer.cxx:105
 TProofPlayer.cxx:106
 TProofPlayer.cxx:107
 TProofPlayer.cxx:108
 TProofPlayer.cxx:109
 TProofPlayer.cxx:110
 TProofPlayer.cxx:111
 TProofPlayer.cxx:112
 TProofPlayer.cxx:113
 TProofPlayer.cxx:114
 TProofPlayer.cxx:115
 TProofPlayer.cxx:116
 TProofPlayer.cxx:117
 TProofPlayer.cxx:118
 TProofPlayer.cxx:119
 TProofPlayer.cxx:120
 TProofPlayer.cxx:121
 TProofPlayer.cxx:122
 TProofPlayer.cxx:123
 TProofPlayer.cxx:124
 TProofPlayer.cxx:125
 TProofPlayer.cxx:126
 TProofPlayer.cxx:127
 TProofPlayer.cxx:128
 TProofPlayer.cxx:129
 TProofPlayer.cxx:130
 TProofPlayer.cxx:131
 TProofPlayer.cxx:132
 TProofPlayer.cxx:133
 TProofPlayer.cxx:134
 TProofPlayer.cxx:135
 TProofPlayer.cxx:136
 TProofPlayer.cxx:137
 TProofPlayer.cxx:138
 TProofPlayer.cxx:139
 TProofPlayer.cxx:140
 TProofPlayer.cxx:141
 TProofPlayer.cxx:142
 TProofPlayer.cxx:143
 TProofPlayer.cxx:144
 TProofPlayer.cxx:145
 TProofPlayer.cxx:146
 TProofPlayer.cxx:147
 TProofPlayer.cxx:148
 TProofPlayer.cxx:149
 TProofPlayer.cxx:150
 TProofPlayer.cxx:151
 TProofPlayer.cxx:152
 TProofPlayer.cxx:153
 TProofPlayer.cxx:154
 TProofPlayer.cxx:155
 TProofPlayer.cxx:156
 TProofPlayer.cxx:157
 TProofPlayer.cxx:158
 TProofPlayer.cxx:159
 TProofPlayer.cxx:160
 TProofPlayer.cxx:161
 TProofPlayer.cxx:162
 TProofPlayer.cxx:163
 TProofPlayer.cxx:164
 TProofPlayer.cxx:165
 TProofPlayer.cxx:166
 TProofPlayer.cxx:167
 TProofPlayer.cxx:168
 TProofPlayer.cxx:169
 TProofPlayer.cxx:170
 TProofPlayer.cxx:171
 TProofPlayer.cxx:172
 TProofPlayer.cxx:173
 TProofPlayer.cxx:174
 TProofPlayer.cxx:175
 TProofPlayer.cxx:176
 TProofPlayer.cxx:177
 TProofPlayer.cxx:178
 TProofPlayer.cxx:179
 TProofPlayer.cxx:180
 TProofPlayer.cxx:181
 TProofPlayer.cxx:182
 TProofPlayer.cxx:183
 TProofPlayer.cxx:184
 TProofPlayer.cxx:185
 TProofPlayer.cxx:186
 TProofPlayer.cxx:187
 TProofPlayer.cxx:188
 TProofPlayer.cxx:189
 TProofPlayer.cxx:190
 TProofPlayer.cxx:191
 TProofPlayer.cxx:192
 TProofPlayer.cxx:193
 TProofPlayer.cxx:194
 TProofPlayer.cxx:195
 TProofPlayer.cxx:196
 TProofPlayer.cxx:197
 TProofPlayer.cxx:198
 TProofPlayer.cxx:199
 TProofPlayer.cxx:200
 TProofPlayer.cxx:201
 TProofPlayer.cxx:202
 TProofPlayer.cxx:203
 TProofPlayer.cxx:204
 TProofPlayer.cxx:205
 TProofPlayer.cxx:206
 TProofPlayer.cxx:207
 TProofPlayer.cxx:208
 TProofPlayer.cxx:209
 TProofPlayer.cxx:210
 TProofPlayer.cxx:211
 TProofPlayer.cxx:212
 TProofPlayer.cxx:213
 TProofPlayer.cxx:214
 TProofPlayer.cxx:215
 TProofPlayer.cxx:216
 TProofPlayer.cxx:217
 TProofPlayer.cxx:218
 TProofPlayer.cxx:219
 TProofPlayer.cxx:220
 TProofPlayer.cxx:221
 TProofPlayer.cxx:222
 TProofPlayer.cxx:223
 TProofPlayer.cxx:224
 TProofPlayer.cxx:225
 TProofPlayer.cxx:226
 TProofPlayer.cxx:227
 TProofPlayer.cxx:228
 TProofPlayer.cxx:229
 TProofPlayer.cxx:230
 TProofPlayer.cxx:231
 TProofPlayer.cxx:232
 TProofPlayer.cxx:233
 TProofPlayer.cxx:234
 TProofPlayer.cxx:235
 TProofPlayer.cxx:236
 TProofPlayer.cxx:237
 TProofPlayer.cxx:238
 TProofPlayer.cxx:239
 TProofPlayer.cxx:240
 TProofPlayer.cxx:241
 TProofPlayer.cxx:242
 TProofPlayer.cxx:243
 TProofPlayer.cxx:244
 TProofPlayer.cxx:245
 TProofPlayer.cxx:246
 TProofPlayer.cxx:247
 TProofPlayer.cxx:248
 TProofPlayer.cxx:249
 TProofPlayer.cxx:250
 TProofPlayer.cxx:251
 TProofPlayer.cxx:252
 TProofPlayer.cxx:253
 TProofPlayer.cxx:254
 TProofPlayer.cxx:255
 TProofPlayer.cxx:256
 TProofPlayer.cxx:257
 TProofPlayer.cxx:258
 TProofPlayer.cxx:259
 TProofPlayer.cxx:260
 TProofPlayer.cxx:261
 TProofPlayer.cxx:262
 TProofPlayer.cxx:263
 TProofPlayer.cxx:264
 TProofPlayer.cxx:265
 TProofPlayer.cxx:266
 TProofPlayer.cxx:267
 TProofPlayer.cxx:268
 TProofPlayer.cxx:269
 TProofPlayer.cxx:270
 TProofPlayer.cxx:271
 TProofPlayer.cxx:272
 TProofPlayer.cxx:273
 TProofPlayer.cxx:274
 TProofPlayer.cxx:275
 TProofPlayer.cxx:276
 TProofPlayer.cxx:277
 TProofPlayer.cxx:278
 TProofPlayer.cxx:279
 TProofPlayer.cxx:280
 TProofPlayer.cxx:281
 TProofPlayer.cxx:282
 TProofPlayer.cxx:283
 TProofPlayer.cxx:284
 TProofPlayer.cxx:285
 TProofPlayer.cxx:286
 TProofPlayer.cxx:287
 TProofPlayer.cxx:288
 TProofPlayer.cxx:289
 TProofPlayer.cxx:290
 TProofPlayer.cxx:291
 TProofPlayer.cxx:292
 TProofPlayer.cxx:293
 TProofPlayer.cxx:294
 TProofPlayer.cxx:295
 TProofPlayer.cxx:296
 TProofPlayer.cxx:297
 TProofPlayer.cxx:298
 TProofPlayer.cxx:299
 TProofPlayer.cxx:300
 TProofPlayer.cxx:301
 TProofPlayer.cxx:302
 TProofPlayer.cxx:303
 TProofPlayer.cxx:304
 TProofPlayer.cxx:305
 TProofPlayer.cxx:306
 TProofPlayer.cxx:307
 TProofPlayer.cxx:308
 TProofPlayer.cxx:309
 TProofPlayer.cxx:310
 TProofPlayer.cxx:311
 TProofPlayer.cxx:312
 TProofPlayer.cxx:313
 TProofPlayer.cxx:314
 TProofPlayer.cxx:315
 TProofPlayer.cxx:316
 TProofPlayer.cxx:317
 TProofPlayer.cxx:318
 TProofPlayer.cxx:319
 TProofPlayer.cxx:320
 TProofPlayer.cxx:321
 TProofPlayer.cxx:322
 TProofPlayer.cxx:323
 TProofPlayer.cxx:324
 TProofPlayer.cxx:325
 TProofPlayer.cxx:326
 TProofPlayer.cxx:327
 TProofPlayer.cxx:328
 TProofPlayer.cxx:329
 TProofPlayer.cxx:330
 TProofPlayer.cxx:331
 TProofPlayer.cxx:332
 TProofPlayer.cxx:333
 TProofPlayer.cxx:334
 TProofPlayer.cxx:335
 TProofPlayer.cxx:336
 TProofPlayer.cxx:337
 TProofPlayer.cxx:338
 TProofPlayer.cxx:339
 TProofPlayer.cxx:340
 TProofPlayer.cxx:341
 TProofPlayer.cxx:342
 TProofPlayer.cxx:343
 TProofPlayer.cxx:344
 TProofPlayer.cxx:345
 TProofPlayer.cxx:346
 TProofPlayer.cxx:347
 TProofPlayer.cxx:348
 TProofPlayer.cxx:349
 TProofPlayer.cxx:350
 TProofPlayer.cxx:351
 TProofPlayer.cxx:352
 TProofPlayer.cxx:353
 TProofPlayer.cxx:354
 TProofPlayer.cxx:355
 TProofPlayer.cxx:356
 TProofPlayer.cxx:357
 TProofPlayer.cxx:358
 TProofPlayer.cxx:359
 TProofPlayer.cxx:360
 TProofPlayer.cxx:361
 TProofPlayer.cxx:362
 TProofPlayer.cxx:363
 TProofPlayer.cxx:364
 TProofPlayer.cxx:365
 TProofPlayer.cxx:366
 TProofPlayer.cxx:367
 TProofPlayer.cxx:368
 TProofPlayer.cxx:369
 TProofPlayer.cxx:370
 TProofPlayer.cxx:371
 TProofPlayer.cxx:372
 TProofPlayer.cxx:373
 TProofPlayer.cxx:374
 TProofPlayer.cxx:375
 TProofPlayer.cxx:376
 TProofPlayer.cxx:377
 TProofPlayer.cxx:378
 TProofPlayer.cxx:379
 TProofPlayer.cxx:380
 TProofPlayer.cxx:381
 TProofPlayer.cxx:382
 TProofPlayer.cxx:383
 TProofPlayer.cxx:384
 TProofPlayer.cxx:385
 TProofPlayer.cxx:386
 TProofPlayer.cxx:387
 TProofPlayer.cxx:388
 TProofPlayer.cxx:389
 TProofPlayer.cxx:390
 TProofPlayer.cxx:391
 TProofPlayer.cxx:392
 TProofPlayer.cxx:393
 TProofPlayer.cxx:394
 TProofPlayer.cxx:395
 TProofPlayer.cxx:396
 TProofPlayer.cxx:397
 TProofPlayer.cxx:398
 TProofPlayer.cxx:399
 TProofPlayer.cxx:400
 TProofPlayer.cxx:401
 TProofPlayer.cxx:402
 TProofPlayer.cxx:403
 TProofPlayer.cxx:404
 TProofPlayer.cxx:405
 TProofPlayer.cxx:406
 TProofPlayer.cxx:407
 TProofPlayer.cxx:408
 TProofPlayer.cxx:409
 TProofPlayer.cxx:410
 TProofPlayer.cxx:411
 TProofPlayer.cxx:412
 TProofPlayer.cxx:413
 TProofPlayer.cxx:414
 TProofPlayer.cxx:415
 TProofPlayer.cxx:416
 TProofPlayer.cxx:417
 TProofPlayer.cxx:418
 TProofPlayer.cxx:419
 TProofPlayer.cxx:420
 TProofPlayer.cxx:421
 TProofPlayer.cxx:422
 TProofPlayer.cxx:423
 TProofPlayer.cxx:424
 TProofPlayer.cxx:425
 TProofPlayer.cxx:426
 TProofPlayer.cxx:427
 TProofPlayer.cxx:428
 TProofPlayer.cxx:429
 TProofPlayer.cxx:430
 TProofPlayer.cxx:431
 TProofPlayer.cxx:432
 TProofPlayer.cxx:433
 TProofPlayer.cxx:434
 TProofPlayer.cxx:435
 TProofPlayer.cxx:436
 TProofPlayer.cxx:437
 TProofPlayer.cxx:438
 TProofPlayer.cxx:439
 TProofPlayer.cxx:440
 TProofPlayer.cxx:441
 TProofPlayer.cxx:442
 TProofPlayer.cxx:443
 TProofPlayer.cxx:444
 TProofPlayer.cxx:445
 TProofPlayer.cxx:446
 TProofPlayer.cxx:447
 TProofPlayer.cxx:448
 TProofPlayer.cxx:449
 TProofPlayer.cxx:450
 TProofPlayer.cxx:451
 TProofPlayer.cxx:452
 TProofPlayer.cxx:453
 TProofPlayer.cxx:454
 TProofPlayer.cxx:455
 TProofPlayer.cxx:456
 TProofPlayer.cxx:457
 TProofPlayer.cxx:458
 TProofPlayer.cxx:459
 TProofPlayer.cxx:460
 TProofPlayer.cxx:461
 TProofPlayer.cxx:462
 TProofPlayer.cxx:463
 TProofPlayer.cxx:464
 TProofPlayer.cxx:465
 TProofPlayer.cxx:466
 TProofPlayer.cxx:467
 TProofPlayer.cxx:468
 TProofPlayer.cxx:469
 TProofPlayer.cxx:470
 TProofPlayer.cxx:471
 TProofPlayer.cxx:472
 TProofPlayer.cxx:473
 TProofPlayer.cxx:474
 TProofPlayer.cxx:475
 TProofPlayer.cxx:476
 TProofPlayer.cxx:477
 TProofPlayer.cxx:478
 TProofPlayer.cxx:479
 TProofPlayer.cxx:480
 TProofPlayer.cxx:481
 TProofPlayer.cxx:482
 TProofPlayer.cxx:483
 TProofPlayer.cxx:484
 TProofPlayer.cxx:485
 TProofPlayer.cxx:486
 TProofPlayer.cxx:487
 TProofPlayer.cxx:488
 TProofPlayer.cxx:489
 TProofPlayer.cxx:490
 TProofPlayer.cxx:491
 TProofPlayer.cxx:492
 TProofPlayer.cxx:493
 TProofPlayer.cxx:494
 TProofPlayer.cxx:495
 TProofPlayer.cxx:496
 TProofPlayer.cxx:497
 TProofPlayer.cxx:498
 TProofPlayer.cxx:499
 TProofPlayer.cxx:500
 TProofPlayer.cxx:501
 TProofPlayer.cxx:502
 TProofPlayer.cxx:503
 TProofPlayer.cxx:504
 TProofPlayer.cxx:505
 TProofPlayer.cxx:506
 TProofPlayer.cxx:507
 TProofPlayer.cxx:508
 TProofPlayer.cxx:509
 TProofPlayer.cxx:510
 TProofPlayer.cxx:511
 TProofPlayer.cxx:512
 TProofPlayer.cxx:513
 TProofPlayer.cxx:514
 TProofPlayer.cxx:515
 TProofPlayer.cxx:516
 TProofPlayer.cxx:517
 TProofPlayer.cxx:518
 TProofPlayer.cxx:519
 TProofPlayer.cxx:520
 TProofPlayer.cxx:521
 TProofPlayer.cxx:522
 TProofPlayer.cxx:523
 TProofPlayer.cxx:524
 TProofPlayer.cxx:525
 TProofPlayer.cxx:526
 TProofPlayer.cxx:527
 TProofPlayer.cxx:528
 TProofPlayer.cxx:529
 TProofPlayer.cxx:530
 TProofPlayer.cxx:531
 TProofPlayer.cxx:532
 TProofPlayer.cxx:533
 TProofPlayer.cxx:534
 TProofPlayer.cxx:535
 TProofPlayer.cxx:536
 TProofPlayer.cxx:537
 TProofPlayer.cxx:538
 TProofPlayer.cxx:539
 TProofPlayer.cxx:540
 TProofPlayer.cxx:541
 TProofPlayer.cxx:542
 TProofPlayer.cxx:543
 TProofPlayer.cxx:544
 TProofPlayer.cxx:545
 TProofPlayer.cxx:546
 TProofPlayer.cxx:547
 TProofPlayer.cxx:548
 TProofPlayer.cxx:549
 TProofPlayer.cxx:550
 TProofPlayer.cxx:551
 TProofPlayer.cxx:552
 TProofPlayer.cxx:553
 TProofPlayer.cxx:554
 TProofPlayer.cxx:555
 TProofPlayer.cxx:556
 TProofPlayer.cxx:557
 TProofPlayer.cxx:558
 TProofPlayer.cxx:559
 TProofPlayer.cxx:560
 TProofPlayer.cxx:561
 TProofPlayer.cxx:562
 TProofPlayer.cxx:563
 TProofPlayer.cxx:564
 TProofPlayer.cxx:565
 TProofPlayer.cxx:566
 TProofPlayer.cxx:567
 TProofPlayer.cxx:568
 TProofPlayer.cxx:569
 TProofPlayer.cxx:570
 TProofPlayer.cxx:571
 TProofPlayer.cxx:572
 TProofPlayer.cxx:573
 TProofPlayer.cxx:574
 TProofPlayer.cxx:575
 TProofPlayer.cxx:576
 TProofPlayer.cxx:577
 TProofPlayer.cxx:578
 TProofPlayer.cxx:579
 TProofPlayer.cxx:580
 TProofPlayer.cxx:581
 TProofPlayer.cxx:582
 TProofPlayer.cxx:583
 TProofPlayer.cxx:584
 TProofPlayer.cxx:585
 TProofPlayer.cxx:586
 TProofPlayer.cxx:587
 TProofPlayer.cxx:588
 TProofPlayer.cxx:589
 TProofPlayer.cxx:590
 TProofPlayer.cxx:591
 TProofPlayer.cxx:592
 TProofPlayer.cxx:593
 TProofPlayer.cxx:594
 TProofPlayer.cxx:595
 TProofPlayer.cxx:596
 TProofPlayer.cxx:597
 TProofPlayer.cxx:598
 TProofPlayer.cxx:599
 TProofPlayer.cxx:600
 TProofPlayer.cxx:601
 TProofPlayer.cxx:602
 TProofPlayer.cxx:603
 TProofPlayer.cxx:604
 TProofPlayer.cxx:605
 TProofPlayer.cxx:606
 TProofPlayer.cxx:607
 TProofPlayer.cxx:608
 TProofPlayer.cxx:609
 TProofPlayer.cxx:610
 TProofPlayer.cxx:611
 TProofPlayer.cxx:612
 TProofPlayer.cxx:613
 TProofPlayer.cxx:614
 TProofPlayer.cxx:615
 TProofPlayer.cxx:616
 TProofPlayer.cxx:617
 TProofPlayer.cxx:618
 TProofPlayer.cxx:619
 TProofPlayer.cxx:620
 TProofPlayer.cxx:621
 TProofPlayer.cxx:622
 TProofPlayer.cxx:623
 TProofPlayer.cxx:624
 TProofPlayer.cxx:625
 TProofPlayer.cxx:626
 TProofPlayer.cxx:627
 TProofPlayer.cxx:628
 TProofPlayer.cxx:629
 TProofPlayer.cxx:630
 TProofPlayer.cxx:631
 TProofPlayer.cxx:632
 TProofPlayer.cxx:633
 TProofPlayer.cxx:634
 TProofPlayer.cxx:635
 TProofPlayer.cxx:636
 TProofPlayer.cxx:637
 TProofPlayer.cxx:638
 TProofPlayer.cxx:639
 TProofPlayer.cxx:640
 TProofPlayer.cxx:641
 TProofPlayer.cxx:642
 TProofPlayer.cxx:643
 TProofPlayer.cxx:644
 TProofPlayer.cxx:645
 TProofPlayer.cxx:646
 TProofPlayer.cxx:647
 TProofPlayer.cxx:648
 TProofPlayer.cxx:649
 TProofPlayer.cxx:650
 TProofPlayer.cxx:651
 TProofPlayer.cxx:652
 TProofPlayer.cxx:653
 TProofPlayer.cxx:654
 TProofPlayer.cxx:655
 TProofPlayer.cxx:656
 TProofPlayer.cxx:657
 TProofPlayer.cxx:658
 TProofPlayer.cxx:659
 TProofPlayer.cxx:660
 TProofPlayer.cxx:661
 TProofPlayer.cxx:662
 TProofPlayer.cxx:663
 TProofPlayer.cxx:664
 TProofPlayer.cxx:665
 TProofPlayer.cxx:666
 TProofPlayer.cxx:667
 TProofPlayer.cxx:668
 TProofPlayer.cxx:669
 TProofPlayer.cxx:670
 TProofPlayer.cxx:671
 TProofPlayer.cxx:672
 TProofPlayer.cxx:673
 TProofPlayer.cxx:674
 TProofPlayer.cxx:675
 TProofPlayer.cxx:676
 TProofPlayer.cxx:677
 TProofPlayer.cxx:678
 TProofPlayer.cxx:679
 TProofPlayer.cxx:680
 TProofPlayer.cxx:681
 TProofPlayer.cxx:682
 TProofPlayer.cxx:683
 TProofPlayer.cxx:684
 TProofPlayer.cxx:685
 TProofPlayer.cxx:686
 TProofPlayer.cxx:687
 TProofPlayer.cxx:688
 TProofPlayer.cxx:689
 TProofPlayer.cxx:690
 TProofPlayer.cxx:691
 TProofPlayer.cxx:692
 TProofPlayer.cxx:693
 TProofPlayer.cxx:694
 TProofPlayer.cxx:695
 TProofPlayer.cxx:696
 TProofPlayer.cxx:697
 TProofPlayer.cxx:698
 TProofPlayer.cxx:699
 TProofPlayer.cxx:700
 TProofPlayer.cxx:701
 TProofPlayer.cxx:702
 TProofPlayer.cxx:703
 TProofPlayer.cxx:704
 TProofPlayer.cxx:705
 TProofPlayer.cxx:706
 TProofPlayer.cxx:707
 TProofPlayer.cxx:708
 TProofPlayer.cxx:709
 TProofPlayer.cxx:710
 TProofPlayer.cxx:711
 TProofPlayer.cxx:712
 TProofPlayer.cxx:713
 TProofPlayer.cxx:714
 TProofPlayer.cxx:715
 TProofPlayer.cxx:716
 TProofPlayer.cxx:717
 TProofPlayer.cxx:718
 TProofPlayer.cxx:719
 TProofPlayer.cxx:720
 TProofPlayer.cxx:721
 TProofPlayer.cxx:722
 TProofPlayer.cxx:723
 TProofPlayer.cxx:724
 TProofPlayer.cxx:725
 TProofPlayer.cxx:726
 TProofPlayer.cxx:727
 TProofPlayer.cxx:728
 TProofPlayer.cxx:729
 TProofPlayer.cxx:730
 TProofPlayer.cxx:731
 TProofPlayer.cxx:732
 TProofPlayer.cxx:733
 TProofPlayer.cxx:734
 TProofPlayer.cxx:735
 TProofPlayer.cxx:736
 TProofPlayer.cxx:737
 TProofPlayer.cxx:738
 TProofPlayer.cxx:739
 TProofPlayer.cxx:740
 TProofPlayer.cxx:741
 TProofPlayer.cxx:742
 TProofPlayer.cxx:743
 TProofPlayer.cxx:744
 TProofPlayer.cxx:745
 TProofPlayer.cxx:746
 TProofPlayer.cxx:747
 TProofPlayer.cxx:748
 TProofPlayer.cxx:749
 TProofPlayer.cxx:750
 TProofPlayer.cxx:751
 TProofPlayer.cxx:752
 TProofPlayer.cxx:753
 TProofPlayer.cxx:754
 TProofPlayer.cxx:755
 TProofPlayer.cxx:756
 TProofPlayer.cxx:757
 TProofPlayer.cxx:758
 TProofPlayer.cxx:759
 TProofPlayer.cxx:760
 TProofPlayer.cxx:761
 TProofPlayer.cxx:762
 TProofPlayer.cxx:763
 TProofPlayer.cxx:764
 TProofPlayer.cxx:765
 TProofPlayer.cxx:766
 TProofPlayer.cxx:767
 TProofPlayer.cxx:768
 TProofPlayer.cxx:769
 TProofPlayer.cxx:770
 TProofPlayer.cxx:771
 TProofPlayer.cxx:772
 TProofPlayer.cxx:773
 TProofPlayer.cxx:774
 TProofPlayer.cxx:775
 TProofPlayer.cxx:776
 TProofPlayer.cxx:777
 TProofPlayer.cxx:778
 TProofPlayer.cxx:779
 TProofPlayer.cxx:780
 TProofPlayer.cxx:781
 TProofPlayer.cxx:782
 TProofPlayer.cxx:783
 TProofPlayer.cxx:784
 TProofPlayer.cxx:785
 TProofPlayer.cxx:786
 TProofPlayer.cxx:787
 TProofPlayer.cxx:788
 TProofPlayer.cxx:789
 TProofPlayer.cxx:790
 TProofPlayer.cxx:791
 TProofPlayer.cxx:792
 TProofPlayer.cxx:793
 TProofPlayer.cxx:794
 TProofPlayer.cxx:795
 TProofPlayer.cxx:796
 TProofPlayer.cxx:797
 TProofPlayer.cxx:798
 TProofPlayer.cxx:799
 TProofPlayer.cxx:800
 TProofPlayer.cxx:801
 TProofPlayer.cxx:802
 TProofPlayer.cxx:803
 TProofPlayer.cxx:804
 TProofPlayer.cxx:805
 TProofPlayer.cxx:806
 TProofPlayer.cxx:807
 TProofPlayer.cxx:808
 TProofPlayer.cxx:809
 TProofPlayer.cxx:810
 TProofPlayer.cxx:811
 TProofPlayer.cxx:812
 TProofPlayer.cxx:813
 TProofPlayer.cxx:814
 TProofPlayer.cxx:815
 TProofPlayer.cxx:816
 TProofPlayer.cxx:817
 TProofPlayer.cxx:818
 TProofPlayer.cxx:819
 TProofPlayer.cxx:820
 TProofPlayer.cxx:821
 TProofPlayer.cxx:822
 TProofPlayer.cxx:823
 TProofPlayer.cxx:824
 TProofPlayer.cxx:825
 TProofPlayer.cxx:826
 TProofPlayer.cxx:827
 TProofPlayer.cxx:828
 TProofPlayer.cxx:829
 TProofPlayer.cxx:830
 TProofPlayer.cxx:831
 TProofPlayer.cxx:832
 TProofPlayer.cxx:833
 TProofPlayer.cxx:834
 TProofPlayer.cxx:835
 TProofPlayer.cxx:836
 TProofPlayer.cxx:837
 TProofPlayer.cxx:838
 TProofPlayer.cxx:839
 TProofPlayer.cxx:840
 TProofPlayer.cxx:841
 TProofPlayer.cxx:842
 TProofPlayer.cxx:843
 TProofPlayer.cxx:844
 TProofPlayer.cxx:845
 TProofPlayer.cxx:846
 TProofPlayer.cxx:847
 TProofPlayer.cxx:848
 TProofPlayer.cxx:849
 TProofPlayer.cxx:850
 TProofPlayer.cxx:851
 TProofPlayer.cxx:852
 TProofPlayer.cxx:853
 TProofPlayer.cxx:854
 TProofPlayer.cxx:855
 TProofPlayer.cxx:856
 TProofPlayer.cxx:857
 TProofPlayer.cxx:858
 TProofPlayer.cxx:859
 TProofPlayer.cxx:860
 TProofPlayer.cxx:861
 TProofPlayer.cxx:862
 TProofPlayer.cxx:863
 TProofPlayer.cxx:864
 TProofPlayer.cxx:865
 TProofPlayer.cxx:866
 TProofPlayer.cxx:867
 TProofPlayer.cxx:868
 TProofPlayer.cxx:869
 TProofPlayer.cxx:870
 TProofPlayer.cxx:871
 TProofPlayer.cxx:872
 TProofPlayer.cxx:873
 TProofPlayer.cxx:874
 TProofPlayer.cxx:875
 TProofPlayer.cxx:876
 TProofPlayer.cxx:877
 TProofPlayer.cxx:878
 TProofPlayer.cxx:879
 TProofPlayer.cxx:880
 TProofPlayer.cxx:881
 TProofPlayer.cxx:882
 TProofPlayer.cxx:883
 TProofPlayer.cxx:884
 TProofPlayer.cxx:885
 TProofPlayer.cxx:886
 TProofPlayer.cxx:887
 TProofPlayer.cxx:888
 TProofPlayer.cxx:889
 TProofPlayer.cxx:890
 TProofPlayer.cxx:891
 TProofPlayer.cxx:892
 TProofPlayer.cxx:893
 TProofPlayer.cxx:894
 TProofPlayer.cxx:895
 TProofPlayer.cxx:896
 TProofPlayer.cxx:897
 TProofPlayer.cxx:898
 TProofPlayer.cxx:899
 TProofPlayer.cxx:900
 TProofPlayer.cxx:901
 TProofPlayer.cxx:902
 TProofPlayer.cxx:903
 TProofPlayer.cxx:904
 TProofPlayer.cxx:905
 TProofPlayer.cxx:906
 TProofPlayer.cxx:907
 TProofPlayer.cxx:908
 TProofPlayer.cxx:909
 TProofPlayer.cxx:910
 TProofPlayer.cxx:911
 TProofPlayer.cxx:912
 TProofPlayer.cxx:913
 TProofPlayer.cxx:914
 TProofPlayer.cxx:915
 TProofPlayer.cxx:916
 TProofPlayer.cxx:917
 TProofPlayer.cxx:918
 TProofPlayer.cxx:919
 TProofPlayer.cxx:920
 TProofPlayer.cxx:921
 TProofPlayer.cxx:922
 TProofPlayer.cxx:923
 TProofPlayer.cxx:924
 TProofPlayer.cxx:925
 TProofPlayer.cxx:926
 TProofPlayer.cxx:927
 TProofPlayer.cxx:928
 TProofPlayer.cxx:929
 TProofPlayer.cxx:930
 TProofPlayer.cxx:931
 TProofPlayer.cxx:932
 TProofPlayer.cxx:933
 TProofPlayer.cxx:934
 TProofPlayer.cxx:935
 TProofPlayer.cxx:936
 TProofPlayer.cxx:937
 TProofPlayer.cxx:938
 TProofPlayer.cxx:939
 TProofPlayer.cxx:940
 TProofPlayer.cxx:941
 TProofPlayer.cxx:942
 TProofPlayer.cxx:943
 TProofPlayer.cxx:944
 TProofPlayer.cxx:945
 TProofPlayer.cxx:946
 TProofPlayer.cxx:947
 TProofPlayer.cxx:948
 TProofPlayer.cxx:949
 TProofPlayer.cxx:950
 TProofPlayer.cxx:951
 TProofPlayer.cxx:952
 TProofPlayer.cxx:953
 TProofPlayer.cxx:954
 TProofPlayer.cxx:955
 TProofPlayer.cxx:956
 TProofPlayer.cxx:957
 TProofPlayer.cxx:958
 TProofPlayer.cxx:959
 TProofPlayer.cxx:960
 TProofPlayer.cxx:961
 TProofPlayer.cxx:962
 TProofPlayer.cxx:963
 TProofPlayer.cxx:964
 TProofPlayer.cxx:965
 TProofPlayer.cxx:966
 TProofPlayer.cxx:967
 TProofPlayer.cxx:968
 TProofPlayer.cxx:969
 TProofPlayer.cxx:970
 TProofPlayer.cxx:971
 TProofPlayer.cxx:972
 TProofPlayer.cxx:973
 TProofPlayer.cxx:974
 TProofPlayer.cxx:975
 TProofPlayer.cxx:976
 TProofPlayer.cxx:977
 TProofPlayer.cxx:978
 TProofPlayer.cxx:979
 TProofPlayer.cxx:980
 TProofPlayer.cxx:981
 TProofPlayer.cxx:982
 TProofPlayer.cxx:983
 TProofPlayer.cxx:984
 TProofPlayer.cxx:985
 TProofPlayer.cxx:986
 TProofPlayer.cxx:987
 TProofPlayer.cxx:988
 TProofPlayer.cxx:989
 TProofPlayer.cxx:990
 TProofPlayer.cxx:991
 TProofPlayer.cxx:992
 TProofPlayer.cxx:993
 TProofPlayer.cxx:994
 TProofPlayer.cxx:995
 TProofPlayer.cxx:996
 TProofPlayer.cxx:997
 TProofPlayer.cxx:998
 TProofPlayer.cxx:999
 TProofPlayer.cxx:1000
 TProofPlayer.cxx:1001
 TProofPlayer.cxx:1002
 TProofPlayer.cxx:1003
 TProofPlayer.cxx:1004
 TProofPlayer.cxx:1005
 TProofPlayer.cxx:1006
 TProofPlayer.cxx:1007
 TProofPlayer.cxx:1008
 TProofPlayer.cxx:1009
 TProofPlayer.cxx:1010
 TProofPlayer.cxx:1011
 TProofPlayer.cxx:1012
 TProofPlayer.cxx:1013
 TProofPlayer.cxx:1014
 TProofPlayer.cxx:1015
 TProofPlayer.cxx:1016
 TProofPlayer.cxx:1017
 TProofPlayer.cxx:1018
 TProofPlayer.cxx:1019
 TProofPlayer.cxx:1020
 TProofPlayer.cxx:1021
 TProofPlayer.cxx:1022
 TProofPlayer.cxx:1023
 TProofPlayer.cxx:1024
 TProofPlayer.cxx:1025
 TProofPlayer.cxx:1026
 TProofPlayer.cxx:1027
 TProofPlayer.cxx:1028
 TProofPlayer.cxx:1029
 TProofPlayer.cxx:1030
 TProofPlayer.cxx:1031
 TProofPlayer.cxx:1032
 TProofPlayer.cxx:1033
 TProofPlayer.cxx:1034
 TProofPlayer.cxx:1035
 TProofPlayer.cxx:1036
 TProofPlayer.cxx:1037
 TProofPlayer.cxx:1038
 TProofPlayer.cxx:1039
 TProofPlayer.cxx:1040
 TProofPlayer.cxx:1041
 TProofPlayer.cxx:1042
 TProofPlayer.cxx:1043
 TProofPlayer.cxx:1044
 TProofPlayer.cxx:1045
 TProofPlayer.cxx:1046
 TProofPlayer.cxx:1047
 TProofPlayer.cxx:1048
 TProofPlayer.cxx:1049
 TProofPlayer.cxx:1050
 TProofPlayer.cxx:1051
 TProofPlayer.cxx:1052
 TProofPlayer.cxx:1053
 TProofPlayer.cxx:1054
 TProofPlayer.cxx:1055
 TProofPlayer.cxx:1056
 TProofPlayer.cxx:1057
 TProofPlayer.cxx:1058
 TProofPlayer.cxx:1059
 TProofPlayer.cxx:1060
 TProofPlayer.cxx:1061
 TProofPlayer.cxx:1062
 TProofPlayer.cxx:1063
 TProofPlayer.cxx:1064
 TProofPlayer.cxx:1065
 TProofPlayer.cxx:1066
 TProofPlayer.cxx:1067
 TProofPlayer.cxx:1068
 TProofPlayer.cxx:1069
 TProofPlayer.cxx:1070
 TProofPlayer.cxx:1071
 TProofPlayer.cxx:1072
 TProofPlayer.cxx:1073
 TProofPlayer.cxx:1074
 TProofPlayer.cxx:1075
 TProofPlayer.cxx:1076
 TProofPlayer.cxx:1077
 TProofPlayer.cxx:1078
 TProofPlayer.cxx:1079
 TProofPlayer.cxx:1080
 TProofPlayer.cxx:1081
 TProofPlayer.cxx:1082
 TProofPlayer.cxx:1083
 TProofPlayer.cxx:1084
 TProofPlayer.cxx:1085
 TProofPlayer.cxx:1086
 TProofPlayer.cxx:1087
 TProofPlayer.cxx:1088
 TProofPlayer.cxx:1089
 TProofPlayer.cxx:1090
 TProofPlayer.cxx:1091
 TProofPlayer.cxx:1092
 TProofPlayer.cxx:1093
 TProofPlayer.cxx:1094
 TProofPlayer.cxx:1095
 TProofPlayer.cxx:1096
 TProofPlayer.cxx:1097
 TProofPlayer.cxx:1098
 TProofPlayer.cxx:1099
 TProofPlayer.cxx:1100
 TProofPlayer.cxx:1101
 TProofPlayer.cxx:1102
 TProofPlayer.cxx:1103
 TProofPlayer.cxx:1104
 TProofPlayer.cxx:1105
 TProofPlayer.cxx:1106
 TProofPlayer.cxx:1107
 TProofPlayer.cxx:1108
 TProofPlayer.cxx:1109
 TProofPlayer.cxx:1110
 TProofPlayer.cxx:1111
 TProofPlayer.cxx:1112
 TProofPlayer.cxx:1113
 TProofPlayer.cxx:1114
 TProofPlayer.cxx:1115
 TProofPlayer.cxx:1116
 TProofPlayer.cxx:1117
 TProofPlayer.cxx:1118
 TProofPlayer.cxx:1119
 TProofPlayer.cxx:1120
 TProofPlayer.cxx:1121
 TProofPlayer.cxx:1122
 TProofPlayer.cxx:1123
 TProofPlayer.cxx:1124
 TProofPlayer.cxx:1125
 TProofPlayer.cxx:1126
 TProofPlayer.cxx:1127
 TProofPlayer.cxx:1128
 TProofPlayer.cxx:1129
 TProofPlayer.cxx:1130
 TProofPlayer.cxx:1131
 TProofPlayer.cxx:1132
 TProofPlayer.cxx:1133
 TProofPlayer.cxx:1134
 TProofPlayer.cxx:1135
 TProofPlayer.cxx:1136
 TProofPlayer.cxx:1137
 TProofPlayer.cxx:1138
 TProofPlayer.cxx:1139
 TProofPlayer.cxx:1140
 TProofPlayer.cxx:1141
 TProofPlayer.cxx:1142
 TProofPlayer.cxx:1143
 TProofPlayer.cxx:1144
 TProofPlayer.cxx:1145
 TProofPlayer.cxx:1146
 TProofPlayer.cxx:1147
 TProofPlayer.cxx:1148
 TProofPlayer.cxx:1149
 TProofPlayer.cxx:1150
 TProofPlayer.cxx:1151
 TProofPlayer.cxx:1152
 TProofPlayer.cxx:1153
 TProofPlayer.cxx:1154
 TProofPlayer.cxx:1155
 TProofPlayer.cxx:1156
 TProofPlayer.cxx:1157
 TProofPlayer.cxx:1158
 TProofPlayer.cxx:1159
 TProofPlayer.cxx:1160
 TProofPlayer.cxx:1161
 TProofPlayer.cxx:1162
 TProofPlayer.cxx:1163
 TProofPlayer.cxx:1164
 TProofPlayer.cxx:1165
 TProofPlayer.cxx:1166
 TProofPlayer.cxx:1167
 TProofPlayer.cxx:1168
 TProofPlayer.cxx:1169
 TProofPlayer.cxx:1170
 TProofPlayer.cxx:1171
 TProofPlayer.cxx:1172
 TProofPlayer.cxx:1173
 TProofPlayer.cxx:1174
 TProofPlayer.cxx:1175
 TProofPlayer.cxx:1176
 TProofPlayer.cxx:1177
 TProofPlayer.cxx:1178
 TProofPlayer.cxx:1179
 TProofPlayer.cxx:1180
 TProofPlayer.cxx:1181
 TProofPlayer.cxx:1182
 TProofPlayer.cxx:1183
 TProofPlayer.cxx:1184
 TProofPlayer.cxx:1185
 TProofPlayer.cxx:1186
 TProofPlayer.cxx:1187
 TProofPlayer.cxx:1188
 TProofPlayer.cxx:1189
 TProofPlayer.cxx:1190
 TProofPlayer.cxx:1191
 TProofPlayer.cxx:1192
 TProofPlayer.cxx:1193
 TProofPlayer.cxx:1194
 TProofPlayer.cxx:1195
 TProofPlayer.cxx:1196
 TProofPlayer.cxx:1197
 TProofPlayer.cxx:1198
 TProofPlayer.cxx:1199
 TProofPlayer.cxx:1200
 TProofPlayer.cxx:1201
 TProofPlayer.cxx:1202
 TProofPlayer.cxx:1203
 TProofPlayer.cxx:1204
 TProofPlayer.cxx:1205
 TProofPlayer.cxx:1206
 TProofPlayer.cxx:1207
 TProofPlayer.cxx:1208
 TProofPlayer.cxx:1209
 TProofPlayer.cxx:1210
 TProofPlayer.cxx:1211
 TProofPlayer.cxx:1212
 TProofPlayer.cxx:1213
 TProofPlayer.cxx:1214
 TProofPlayer.cxx:1215
 TProofPlayer.cxx:1216
 TProofPlayer.cxx:1217
 TProofPlayer.cxx:1218
 TProofPlayer.cxx:1219
 TProofPlayer.cxx:1220
 TProofPlayer.cxx:1221
 TProofPlayer.cxx:1222
 TProofPlayer.cxx:1223
 TProofPlayer.cxx:1224
 TProofPlayer.cxx:1225
 TProofPlayer.cxx:1226
 TProofPlayer.cxx:1227
 TProofPlayer.cxx:1228
 TProofPlayer.cxx:1229
 TProofPlayer.cxx:1230
 TProofPlayer.cxx:1231
 TProofPlayer.cxx:1232
 TProofPlayer.cxx:1233
 TProofPlayer.cxx:1234
 TProofPlayer.cxx:1235
 TProofPlayer.cxx:1236
 TProofPlayer.cxx:1237
 TProofPlayer.cxx:1238
 TProofPlayer.cxx:1239
 TProofPlayer.cxx:1240
 TProofPlayer.cxx:1241
 TProofPlayer.cxx:1242
 TProofPlayer.cxx:1243
 TProofPlayer.cxx:1244
 TProofPlayer.cxx:1245
 TProofPlayer.cxx:1246
 TProofPlayer.cxx:1247
 TProofPlayer.cxx:1248
 TProofPlayer.cxx:1249
 TProofPlayer.cxx:1250
 TProofPlayer.cxx:1251
 TProofPlayer.cxx:1252
 TProofPlayer.cxx:1253
 TProofPlayer.cxx:1254
 TProofPlayer.cxx:1255
 TProofPlayer.cxx:1256
 TProofPlayer.cxx:1257
 TProofPlayer.cxx:1258
 TProofPlayer.cxx:1259
 TProofPlayer.cxx:1260
 TProofPlayer.cxx:1261
 TProofPlayer.cxx:1262
 TProofPlayer.cxx:1263
 TProofPlayer.cxx:1264
 TProofPlayer.cxx:1265
 TProofPlayer.cxx:1266
 TProofPlayer.cxx:1267
 TProofPlayer.cxx:1268
 TProofPlayer.cxx:1269
 TProofPlayer.cxx:1270
 TProofPlayer.cxx:1271
 TProofPlayer.cxx:1272
 TProofPlayer.cxx:1273
 TProofPlayer.cxx:1274
 TProofPlayer.cxx:1275
 TProofPlayer.cxx:1276
 TProofPlayer.cxx:1277
 TProofPlayer.cxx:1278
 TProofPlayer.cxx:1279
 TProofPlayer.cxx:1280
 TProofPlayer.cxx:1281
 TProofPlayer.cxx:1282
 TProofPlayer.cxx:1283
 TProofPlayer.cxx:1284
 TProofPlayer.cxx:1285
 TProofPlayer.cxx:1286
 TProofPlayer.cxx:1287
 TProofPlayer.cxx:1288
 TProofPlayer.cxx:1289
 TProofPlayer.cxx:1290
 TProofPlayer.cxx:1291
 TProofPlayer.cxx:1292
 TProofPlayer.cxx:1293
 TProofPlayer.cxx:1294
 TProofPlayer.cxx:1295
 TProofPlayer.cxx:1296
 TProofPlayer.cxx:1297
 TProofPlayer.cxx:1298
 TProofPlayer.cxx:1299
 TProofPlayer.cxx:1300
 TProofPlayer.cxx:1301
 TProofPlayer.cxx:1302
 TProofPlayer.cxx:1303
 TProofPlayer.cxx:1304
 TProofPlayer.cxx:1305
 TProofPlayer.cxx:1306
 TProofPlayer.cxx:1307
 TProofPlayer.cxx:1308
 TProofPlayer.cxx:1309
 TProofPlayer.cxx:1310
 TProofPlayer.cxx:1311
 TProofPlayer.cxx:1312
 TProofPlayer.cxx:1313
 TProofPlayer.cxx:1314
 TProofPlayer.cxx:1315
 TProofPlayer.cxx:1316
 TProofPlayer.cxx:1317
 TProofPlayer.cxx:1318
 TProofPlayer.cxx:1319
 TProofPlayer.cxx:1320
 TProofPlayer.cxx:1321
 TProofPlayer.cxx:1322
 TProofPlayer.cxx:1323
 TProofPlayer.cxx:1324
 TProofPlayer.cxx:1325
 TProofPlayer.cxx:1326
 TProofPlayer.cxx:1327
 TProofPlayer.cxx:1328
 TProofPlayer.cxx:1329
 TProofPlayer.cxx:1330
 TProofPlayer.cxx:1331
 TProofPlayer.cxx:1332
 TProofPlayer.cxx:1333
 TProofPlayer.cxx:1334
 TProofPlayer.cxx:1335
 TProofPlayer.cxx:1336
 TProofPlayer.cxx:1337
 TProofPlayer.cxx:1338
 TProofPlayer.cxx:1339
 TProofPlayer.cxx:1340
 TProofPlayer.cxx:1341
 TProofPlayer.cxx:1342
 TProofPlayer.cxx:1343
 TProofPlayer.cxx:1344
 TProofPlayer.cxx:1345
 TProofPlayer.cxx:1346
 TProofPlayer.cxx:1347
 TProofPlayer.cxx:1348
 TProofPlayer.cxx:1349
 TProofPlayer.cxx:1350
 TProofPlayer.cxx:1351
 TProofPlayer.cxx:1352
 TProofPlayer.cxx:1353
 TProofPlayer.cxx:1354
 TProofPlayer.cxx:1355
 TProofPlayer.cxx:1356
 TProofPlayer.cxx:1357
 TProofPlayer.cxx:1358
 TProofPlayer.cxx:1359
 TProofPlayer.cxx:1360
 TProofPlayer.cxx:1361
 TProofPlayer.cxx:1362
 TProofPlayer.cxx:1363
 TProofPlayer.cxx:1364
 TProofPlayer.cxx:1365
 TProofPlayer.cxx:1366
 TProofPlayer.cxx:1367
 TProofPlayer.cxx:1368
 TProofPlayer.cxx:1369
 TProofPlayer.cxx:1370
 TProofPlayer.cxx:1371
 TProofPlayer.cxx:1372
 TProofPlayer.cxx:1373
 TProofPlayer.cxx:1374
 TProofPlayer.cxx:1375
 TProofPlayer.cxx:1376
 TProofPlayer.cxx:1377
 TProofPlayer.cxx:1378
 TProofPlayer.cxx:1379
 TProofPlayer.cxx:1380
 TProofPlayer.cxx:1381
 TProofPlayer.cxx:1382
 TProofPlayer.cxx:1383
 TProofPlayer.cxx:1384
 TProofPlayer.cxx:1385
 TProofPlayer.cxx:1386
 TProofPlayer.cxx:1387
 TProofPlayer.cxx:1388
 TProofPlayer.cxx:1389
 TProofPlayer.cxx:1390
 TProofPlayer.cxx:1391
 TProofPlayer.cxx:1392
 TProofPlayer.cxx:1393
 TProofPlayer.cxx:1394
 TProofPlayer.cxx:1395
 TProofPlayer.cxx:1396
 TProofPlayer.cxx:1397
 TProofPlayer.cxx:1398
 TProofPlayer.cxx:1399
 TProofPlayer.cxx:1400
 TProofPlayer.cxx:1401
 TProofPlayer.cxx:1402
 TProofPlayer.cxx:1403
 TProofPlayer.cxx:1404
 TProofPlayer.cxx:1405
 TProofPlayer.cxx:1406
 TProofPlayer.cxx:1407
 TProofPlayer.cxx:1408
 TProofPlayer.cxx:1409
 TProofPlayer.cxx:1410
 TProofPlayer.cxx:1411
 TProofPlayer.cxx:1412
 TProofPlayer.cxx:1413
 TProofPlayer.cxx:1414
 TProofPlayer.cxx:1415
 TProofPlayer.cxx:1416
 TProofPlayer.cxx:1417
 TProofPlayer.cxx:1418
 TProofPlayer.cxx:1419
 TProofPlayer.cxx:1420
 TProofPlayer.cxx:1421
 TProofPlayer.cxx:1422
 TProofPlayer.cxx:1423
 TProofPlayer.cxx:1424
 TProofPlayer.cxx:1425
 TProofPlayer.cxx:1426
 TProofPlayer.cxx:1427
 TProofPlayer.cxx:1428
 TProofPlayer.cxx:1429
 TProofPlayer.cxx:1430
 TProofPlayer.cxx:1431
 TProofPlayer.cxx:1432
 TProofPlayer.cxx:1433
 TProofPlayer.cxx:1434
 TProofPlayer.cxx:1435
 TProofPlayer.cxx:1436
 TProofPlayer.cxx:1437
 TProofPlayer.cxx:1438
 TProofPlayer.cxx:1439
 TProofPlayer.cxx:1440
 TProofPlayer.cxx:1441
 TProofPlayer.cxx:1442
 TProofPlayer.cxx:1443
 TProofPlayer.cxx:1444
 TProofPlayer.cxx:1445
 TProofPlayer.cxx:1446
 TProofPlayer.cxx:1447
 TProofPlayer.cxx:1448
 TProofPlayer.cxx:1449
 TProofPlayer.cxx:1450
 TProofPlayer.cxx:1451
 TProofPlayer.cxx:1452
 TProofPlayer.cxx:1453
 TProofPlayer.cxx:1454
 TProofPlayer.cxx:1455
 TProofPlayer.cxx:1456
 TProofPlayer.cxx:1457
 TProofPlayer.cxx:1458
 TProofPlayer.cxx:1459
 TProofPlayer.cxx:1460
 TProofPlayer.cxx:1461
 TProofPlayer.cxx:1462
 TProofPlayer.cxx:1463
 TProofPlayer.cxx:1464
 TProofPlayer.cxx:1465
 TProofPlayer.cxx:1466
 TProofPlayer.cxx:1467
 TProofPlayer.cxx:1468
 TProofPlayer.cxx:1469
 TProofPlayer.cxx:1470
 TProofPlayer.cxx:1471
 TProofPlayer.cxx:1472
 TProofPlayer.cxx:1473
 TProofPlayer.cxx:1474
 TProofPlayer.cxx:1475
 TProofPlayer.cxx:1476
 TProofPlayer.cxx:1477
 TProofPlayer.cxx:1478
 TProofPlayer.cxx:1479
 TProofPlayer.cxx:1480
 TProofPlayer.cxx:1481
 TProofPlayer.cxx:1482
 TProofPlayer.cxx:1483
 TProofPlayer.cxx:1484
 TProofPlayer.cxx:1485
 TProofPlayer.cxx:1486
 TProofPlayer.cxx:1487
 TProofPlayer.cxx:1488
 TProofPlayer.cxx:1489
 TProofPlayer.cxx:1490
 TProofPlayer.cxx:1491
 TProofPlayer.cxx:1492
 TProofPlayer.cxx:1493
 TProofPlayer.cxx:1494
 TProofPlayer.cxx:1495
 TProofPlayer.cxx:1496
 TProofPlayer.cxx:1497
 TProofPlayer.cxx:1498
 TProofPlayer.cxx:1499
 TProofPlayer.cxx:1500
 TProofPlayer.cxx:1501
 TProofPlayer.cxx:1502
 TProofPlayer.cxx:1503
 TProofPlayer.cxx:1504
 TProofPlayer.cxx:1505
 TProofPlayer.cxx:1506
 TProofPlayer.cxx:1507
 TProofPlayer.cxx:1508
 TProofPlayer.cxx:1509
 TProofPlayer.cxx:1510
 TProofPlayer.cxx:1511
 TProofPlayer.cxx:1512
 TProofPlayer.cxx:1513
 TProofPlayer.cxx:1514
 TProofPlayer.cxx:1515
 TProofPlayer.cxx:1516
 TProofPlayer.cxx:1517
 TProofPlayer.cxx:1518
 TProofPlayer.cxx:1519
 TProofPlayer.cxx:1520
 TProofPlayer.cxx:1521
 TProofPlayer.cxx:1522
 TProofPlayer.cxx:1523
 TProofPlayer.cxx:1524
 TProofPlayer.cxx:1525
 TProofPlayer.cxx:1526
 TProofPlayer.cxx:1527
 TProofPlayer.cxx:1528
 TProofPlayer.cxx:1529
 TProofPlayer.cxx:1530
 TProofPlayer.cxx:1531
 TProofPlayer.cxx:1532
 TProofPlayer.cxx:1533
 TProofPlayer.cxx:1534
 TProofPlayer.cxx:1535
 TProofPlayer.cxx:1536
 TProofPlayer.cxx:1537
 TProofPlayer.cxx:1538
 TProofPlayer.cxx:1539
 TProofPlayer.cxx:1540
 TProofPlayer.cxx:1541
 TProofPlayer.cxx:1542
 TProofPlayer.cxx:1543
 TProofPlayer.cxx:1544
 TProofPlayer.cxx:1545
 TProofPlayer.cxx:1546
 TProofPlayer.cxx:1547
 TProofPlayer.cxx:1548
 TProofPlayer.cxx:1549
 TProofPlayer.cxx:1550
 TProofPlayer.cxx:1551
 TProofPlayer.cxx:1552
 TProofPlayer.cxx:1553
 TProofPlayer.cxx:1554
 TProofPlayer.cxx:1555
 TProofPlayer.cxx:1556
 TProofPlayer.cxx:1557
 TProofPlayer.cxx:1558
 TProofPlayer.cxx:1559
 TProofPlayer.cxx:1560
 TProofPlayer.cxx:1561
 TProofPlayer.cxx:1562
 TProofPlayer.cxx:1563
 TProofPlayer.cxx:1564
 TProofPlayer.cxx:1565
 TProofPlayer.cxx:1566
 TProofPlayer.cxx:1567
 TProofPlayer.cxx:1568
 TProofPlayer.cxx:1569
 TProofPlayer.cxx:1570
 TProofPlayer.cxx:1571
 TProofPlayer.cxx:1572
 TProofPlayer.cxx:1573
 TProofPlayer.cxx:1574
 TProofPlayer.cxx:1575
 TProofPlayer.cxx:1576
 TProofPlayer.cxx:1577
 TProofPlayer.cxx:1578
 TProofPlayer.cxx:1579
 TProofPlayer.cxx:1580
 TProofPlayer.cxx:1581
 TProofPlayer.cxx:1582
 TProofPlayer.cxx:1583
 TProofPlayer.cxx:1584
 TProofPlayer.cxx:1585
 TProofPlayer.cxx:1586
 TProofPlayer.cxx:1587
 TProofPlayer.cxx:1588
 TProofPlayer.cxx:1589
 TProofPlayer.cxx:1590
 TProofPlayer.cxx:1591
 TProofPlayer.cxx:1592
 TProofPlayer.cxx:1593
 TProofPlayer.cxx:1594
 TProofPlayer.cxx:1595
 TProofPlayer.cxx:1596
 TProofPlayer.cxx:1597
 TProofPlayer.cxx:1598
 TProofPlayer.cxx:1599
 TProofPlayer.cxx:1600
 TProofPlayer.cxx:1601
 TProofPlayer.cxx:1602
 TProofPlayer.cxx:1603
 TProofPlayer.cxx:1604
 TProofPlayer.cxx:1605
 TProofPlayer.cxx:1606
 TProofPlayer.cxx:1607
 TProofPlayer.cxx:1608
 TProofPlayer.cxx:1609
 TProofPlayer.cxx:1610
 TProofPlayer.cxx:1611
 TProofPlayer.cxx:1612
 TProofPlayer.cxx:1613
 TProofPlayer.cxx:1614
 TProofPlayer.cxx:1615
 TProofPlayer.cxx:1616
 TProofPlayer.cxx:1617
 TProofPlayer.cxx:1618
 TProofPlayer.cxx:1619
 TProofPlayer.cxx:1620
 TProofPlayer.cxx:1621
 TProofPlayer.cxx:1622
 TProofPlayer.cxx:1623
 TProofPlayer.cxx:1624
 TProofPlayer.cxx:1625
 TProofPlayer.cxx:1626
 TProofPlayer.cxx:1627
 TProofPlayer.cxx:1628
 TProofPlayer.cxx:1629
 TProofPlayer.cxx:1630
 TProofPlayer.cxx:1631
 TProofPlayer.cxx:1632
 TProofPlayer.cxx:1633
 TProofPlayer.cxx:1634
 TProofPlayer.cxx:1635
 TProofPlayer.cxx:1636
 TProofPlayer.cxx:1637
 TProofPlayer.cxx:1638
 TProofPlayer.cxx:1639
 TProofPlayer.cxx:1640
 TProofPlayer.cxx:1641
 TProofPlayer.cxx:1642
 TProofPlayer.cxx:1643
 TProofPlayer.cxx:1644
 TProofPlayer.cxx:1645
 TProofPlayer.cxx:1646
 TProofPlayer.cxx:1647
 TProofPlayer.cxx:1648
 TProofPlayer.cxx:1649
 TProofPlayer.cxx:1650
 TProofPlayer.cxx:1651
 TProofPlayer.cxx:1652
 TProofPlayer.cxx:1653
 TProofPlayer.cxx:1654
 TProofPlayer.cxx:1655
 TProofPlayer.cxx:1656
 TProofPlayer.cxx:1657
 TProofPlayer.cxx:1658
 TProofPlayer.cxx:1659
 TProofPlayer.cxx:1660
 TProofPlayer.cxx:1661
 TProofPlayer.cxx:1662
 TProofPlayer.cxx:1663
 TProofPlayer.cxx:1664
 TProofPlayer.cxx:1665
 TProofPlayer.cxx:1666
 TProofPlayer.cxx:1667
 TProofPlayer.cxx:1668
 TProofPlayer.cxx:1669
 TProofPlayer.cxx:1670
 TProofPlayer.cxx:1671
 TProofPlayer.cxx:1672
 TProofPlayer.cxx:1673
 TProofPlayer.cxx:1674
 TProofPlayer.cxx:1675
 TProofPlayer.cxx:1676
 TProofPlayer.cxx:1677
 TProofPlayer.cxx:1678
 TProofPlayer.cxx:1679
 TProofPlayer.cxx:1680
 TProofPlayer.cxx:1681
 TProofPlayer.cxx:1682
 TProofPlayer.cxx:1683
 TProofPlayer.cxx:1684
 TProofPlayer.cxx:1685
 TProofPlayer.cxx:1686
 TProofPlayer.cxx:1687
 TProofPlayer.cxx:1688
 TProofPlayer.cxx:1689
 TProofPlayer.cxx:1690
 TProofPlayer.cxx:1691
 TProofPlayer.cxx:1692
 TProofPlayer.cxx:1693
 TProofPlayer.cxx:1694
 TProofPlayer.cxx:1695
 TProofPlayer.cxx:1696
 TProofPlayer.cxx:1697
 TProofPlayer.cxx:1698
 TProofPlayer.cxx:1699
 TProofPlayer.cxx:1700
 TProofPlayer.cxx:1701
 TProofPlayer.cxx:1702
 TProofPlayer.cxx:1703
 TProofPlayer.cxx:1704
 TProofPlayer.cxx:1705
 TProofPlayer.cxx:1706
 TProofPlayer.cxx:1707
 TProofPlayer.cxx:1708
 TProofPlayer.cxx:1709
 TProofPlayer.cxx:1710
 TProofPlayer.cxx:1711
 TProofPlayer.cxx:1712
 TProofPlayer.cxx:1713
 TProofPlayer.cxx:1714
 TProofPlayer.cxx:1715
 TProofPlayer.cxx:1716
 TProofPlayer.cxx:1717
 TProofPlayer.cxx:1718
 TProofPlayer.cxx:1719
 TProofPlayer.cxx:1720
 TProofPlayer.cxx:1721
 TProofPlayer.cxx:1722
 TProofPlayer.cxx:1723
 TProofPlayer.cxx:1724
 TProofPlayer.cxx:1725
 TProofPlayer.cxx:1726
 TProofPlayer.cxx:1727
 TProofPlayer.cxx:1728
 TProofPlayer.cxx:1729
 TProofPlayer.cxx:1730
 TProofPlayer.cxx:1731
 TProofPlayer.cxx:1732
 TProofPlayer.cxx:1733
 TProofPlayer.cxx:1734
 TProofPlayer.cxx:1735
 TProofPlayer.cxx:1736
 TProofPlayer.cxx:1737
 TProofPlayer.cxx:1738
 TProofPlayer.cxx:1739
 TProofPlayer.cxx:1740
 TProofPlayer.cxx:1741
 TProofPlayer.cxx:1742
 TProofPlayer.cxx:1743
 TProofPlayer.cxx:1744
 TProofPlayer.cxx:1745
 TProofPlayer.cxx:1746
 TProofPlayer.cxx:1747
 TProofPlayer.cxx:1748
 TProofPlayer.cxx:1749
 TProofPlayer.cxx:1750
 TProofPlayer.cxx:1751
 TProofPlayer.cxx:1752
 TProofPlayer.cxx:1753
 TProofPlayer.cxx:1754
 TProofPlayer.cxx:1755
 TProofPlayer.cxx:1756
 TProofPlayer.cxx:1757
 TProofPlayer.cxx:1758
 TProofPlayer.cxx:1759
 TProofPlayer.cxx:1760
 TProofPlayer.cxx:1761
 TProofPlayer.cxx:1762
 TProofPlayer.cxx:1763
 TProofPlayer.cxx:1764
 TProofPlayer.cxx:1765
 TProofPlayer.cxx:1766
 TProofPlayer.cxx:1767
 TProofPlayer.cxx:1768
 TProofPlayer.cxx:1769
 TProofPlayer.cxx:1770
 TProofPlayer.cxx:1771
 TProofPlayer.cxx:1772
 TProofPlayer.cxx:1773
 TProofPlayer.cxx:1774
 TProofPlayer.cxx:1775
 TProofPlayer.cxx:1776
 TProofPlayer.cxx:1777
 TProofPlayer.cxx:1778
 TProofPlayer.cxx:1779
 TProofPlayer.cxx:1780
 TProofPlayer.cxx:1781
 TProofPlayer.cxx:1782
 TProofPlayer.cxx:1783
 TProofPlayer.cxx:1784
 TProofPlayer.cxx:1785
 TProofPlayer.cxx:1786
 TProofPlayer.cxx:1787
 TProofPlayer.cxx:1788
 TProofPlayer.cxx:1789
 TProofPlayer.cxx:1790
 TProofPlayer.cxx:1791
 TProofPlayer.cxx:1792
 TProofPlayer.cxx:1793
 TProofPlayer.cxx:1794
 TProofPlayer.cxx:1795
 TProofPlayer.cxx:1796
 TProofPlayer.cxx:1797
 TProofPlayer.cxx:1798
 TProofPlayer.cxx:1799
 TProofPlayer.cxx:1800
 TProofPlayer.cxx:1801
 TProofPlayer.cxx:1802
 TProofPlayer.cxx:1803
 TProofPlayer.cxx:1804
 TProofPlayer.cxx:1805
 TProofPlayer.cxx:1806
 TProofPlayer.cxx:1807
 TProofPlayer.cxx:1808
 TProofPlayer.cxx:1809
 TProofPlayer.cxx:1810
 TProofPlayer.cxx:1811
 TProofPlayer.cxx:1812
 TProofPlayer.cxx:1813
 TProofPlayer.cxx:1814
 TProofPlayer.cxx:1815
 TProofPlayer.cxx:1816
 TProofPlayer.cxx:1817
 TProofPlayer.cxx:1818
 TProofPlayer.cxx:1819
 TProofPlayer.cxx:1820
 TProofPlayer.cxx:1821
 TProofPlayer.cxx:1822
 TProofPlayer.cxx:1823
 TProofPlayer.cxx:1824
 TProofPlayer.cxx:1825
 TProofPlayer.cxx:1826
 TProofPlayer.cxx:1827
 TProofPlayer.cxx:1828
 TProofPlayer.cxx:1829
 TProofPlayer.cxx:1830
 TProofPlayer.cxx:1831
 TProofPlayer.cxx:1832
 TProofPlayer.cxx:1833
 TProofPlayer.cxx:1834
 TProofPlayer.cxx:1835
 TProofPlayer.cxx:1836
 TProofPlayer.cxx:1837
 TProofPlayer.cxx:1838
 TProofPlayer.cxx:1839
 TProofPlayer.cxx:1840
 TProofPlayer.cxx:1841
 TProofPlayer.cxx:1842
 TProofPlayer.cxx:1843
 TProofPlayer.cxx:1844
 TProofPlayer.cxx:1845
 TProofPlayer.cxx:1846
 TProofPlayer.cxx:1847
 TProofPlayer.cxx:1848
 TProofPlayer.cxx:1849
 TProofPlayer.cxx:1850
 TProofPlayer.cxx:1851
 TProofPlayer.cxx:1852
 TProofPlayer.cxx:1853
 TProofPlayer.cxx:1854
 TProofPlayer.cxx:1855
 TProofPlayer.cxx:1856
 TProofPlayer.cxx:1857
 TProofPlayer.cxx:1858
 TProofPlayer.cxx:1859
 TProofPlayer.cxx:1860
 TProofPlayer.cxx:1861
 TProofPlayer.cxx:1862
 TProofPlayer.cxx:1863
 TProofPlayer.cxx:1864
 TProofPlayer.cxx:1865
 TProofPlayer.cxx:1866
 TProofPlayer.cxx:1867
 TProofPlayer.cxx:1868
 TProofPlayer.cxx:1869
 TProofPlayer.cxx:1870
 TProofPlayer.cxx:1871
 TProofPlayer.cxx:1872
 TProofPlayer.cxx:1873
 TProofPlayer.cxx:1874
 TProofPlayer.cxx:1875
 TProofPlayer.cxx:1876
 TProofPlayer.cxx:1877
 TProofPlayer.cxx:1878
 TProofPlayer.cxx:1879
 TProofPlayer.cxx:1880
 TProofPlayer.cxx:1881
 TProofPlayer.cxx:1882
 TProofPlayer.cxx:1883
 TProofPlayer.cxx:1884
 TProofPlayer.cxx:1885
 TProofPlayer.cxx:1886
 TProofPlayer.cxx:1887
 TProofPlayer.cxx:1888
 TProofPlayer.cxx:1889
 TProofPlayer.cxx:1890
 TProofPlayer.cxx:1891
 TProofPlayer.cxx:1892
 TProofPlayer.cxx:1893
 TProofPlayer.cxx:1894
 TProofPlayer.cxx:1895
 TProofPlayer.cxx:1896
 TProofPlayer.cxx:1897
 TProofPlayer.cxx:1898
 TProofPlayer.cxx:1899
 TProofPlayer.cxx:1900
 TProofPlayer.cxx:1901
 TProofPlayer.cxx:1902
 TProofPlayer.cxx:1903
 TProofPlayer.cxx:1904
 TProofPlayer.cxx:1905
 TProofPlayer.cxx:1906
 TProofPlayer.cxx:1907
 TProofPlayer.cxx:1908
 TProofPlayer.cxx:1909
 TProofPlayer.cxx:1910
 TProofPlayer.cxx:1911
 TProofPlayer.cxx:1912
 TProofPlayer.cxx:1913
 TProofPlayer.cxx:1914
 TProofPlayer.cxx:1915
 TProofPlayer.cxx:1916
 TProofPlayer.cxx:1917
 TProofPlayer.cxx:1918
 TProofPlayer.cxx:1919
 TProofPlayer.cxx:1920
 TProofPlayer.cxx:1921
 TProofPlayer.cxx:1922
 TProofPlayer.cxx:1923
 TProofPlayer.cxx:1924
 TProofPlayer.cxx:1925
 TProofPlayer.cxx:1926
 TProofPlayer.cxx:1927
 TProofPlayer.cxx:1928
 TProofPlayer.cxx:1929
 TProofPlayer.cxx:1930
 TProofPlayer.cxx:1931
 TProofPlayer.cxx:1932
 TProofPlayer.cxx:1933
 TProofPlayer.cxx:1934
 TProofPlayer.cxx:1935
 TProofPlayer.cxx:1936
 TProofPlayer.cxx:1937
 TProofPlayer.cxx:1938
 TProofPlayer.cxx:1939
 TProofPlayer.cxx:1940
 TProofPlayer.cxx:1941
 TProofPlayer.cxx:1942
 TProofPlayer.cxx:1943
 TProofPlayer.cxx:1944
 TProofPlayer.cxx:1945
 TProofPlayer.cxx:1946
 TProofPlayer.cxx:1947
 TProofPlayer.cxx:1948
 TProofPlayer.cxx:1949
 TProofPlayer.cxx:1950
 TProofPlayer.cxx:1951
 TProofPlayer.cxx:1952
 TProofPlayer.cxx:1953
 TProofPlayer.cxx:1954
 TProofPlayer.cxx:1955
 TProofPlayer.cxx:1956
 TProofPlayer.cxx:1957
 TProofPlayer.cxx:1958
 TProofPlayer.cxx:1959
 TProofPlayer.cxx:1960
 TProofPlayer.cxx:1961
 TProofPlayer.cxx:1962
 TProofPlayer.cxx:1963
 TProofPlayer.cxx:1964
 TProofPlayer.cxx:1965
 TProofPlayer.cxx:1966
 TProofPlayer.cxx:1967
 TProofPlayer.cxx:1968
 TProofPlayer.cxx:1969
 TProofPlayer.cxx:1970
 TProofPlayer.cxx:1971
 TProofPlayer.cxx:1972
 TProofPlayer.cxx:1973
 TProofPlayer.cxx:1974
 TProofPlayer.cxx:1975
 TProofPlayer.cxx:1976
 TProofPlayer.cxx:1977
 TProofPlayer.cxx:1978
 TProofPlayer.cxx:1979
 TProofPlayer.cxx:1980
 TProofPlayer.cxx:1981
 TProofPlayer.cxx:1982
 TProofPlayer.cxx:1983
 TProofPlayer.cxx:1984
 TProofPlayer.cxx:1985
 TProofPlayer.cxx:1986
 TProofPlayer.cxx:1987
 TProofPlayer.cxx:1988
 TProofPlayer.cxx:1989
 TProofPlayer.cxx:1990
 TProofPlayer.cxx:1991
 TProofPlayer.cxx:1992
 TProofPlayer.cxx:1993
 TProofPlayer.cxx:1994
 TProofPlayer.cxx:1995
 TProofPlayer.cxx:1996
 TProofPlayer.cxx:1997
 TProofPlayer.cxx:1998
 TProofPlayer.cxx:1999
 TProofPlayer.cxx:2000
 TProofPlayer.cxx:2001
 TProofPlayer.cxx:2002
 TProofPlayer.cxx:2003
 TProofPlayer.cxx:2004
 TProofPlayer.cxx:2005
 TProofPlayer.cxx:2006
 TProofPlayer.cxx:2007
 TProofPlayer.cxx:2008
 TProofPlayer.cxx:2009
 TProofPlayer.cxx:2010
 TProofPlayer.cxx:2011
 TProofPlayer.cxx:2012
 TProofPlayer.cxx:2013
 TProofPlayer.cxx:2014
 TProofPlayer.cxx:2015
 TProofPlayer.cxx:2016
 TProofPlayer.cxx:2017
 TProofPlayer.cxx:2018
 TProofPlayer.cxx:2019
 TProofPlayer.cxx:2020
 TProofPlayer.cxx:2021
 TProofPlayer.cxx:2022
 TProofPlayer.cxx:2023
 TProofPlayer.cxx:2024
 TProofPlayer.cxx:2025
 TProofPlayer.cxx:2026
 TProofPlayer.cxx:2027
 TProofPlayer.cxx:2028
 TProofPlayer.cxx:2029
 TProofPlayer.cxx:2030
 TProofPlayer.cxx:2031
 TProofPlayer.cxx:2032
 TProofPlayer.cxx:2033
 TProofPlayer.cxx:2034
 TProofPlayer.cxx:2035
 TProofPlayer.cxx:2036
 TProofPlayer.cxx:2037
 TProofPlayer.cxx:2038
 TProofPlayer.cxx:2039
 TProofPlayer.cxx:2040
 TProofPlayer.cxx:2041
 TProofPlayer.cxx:2042
 TProofPlayer.cxx:2043
 TProofPlayer.cxx:2044
 TProofPlayer.cxx:2045
 TProofPlayer.cxx:2046
 TProofPlayer.cxx:2047
 TProofPlayer.cxx:2048
 TProofPlayer.cxx:2049
 TProofPlayer.cxx:2050
 TProofPlayer.cxx:2051
 TProofPlayer.cxx:2052
 TProofPlayer.cxx:2053
 TProofPlayer.cxx:2054
 TProofPlayer.cxx:2055
 TProofPlayer.cxx:2056
 TProofPlayer.cxx:2057
 TProofPlayer.cxx:2058
 TProofPlayer.cxx:2059
 TProofPlayer.cxx:2060
 TProofPlayer.cxx:2061
 TProofPlayer.cxx:2062
 TProofPlayer.cxx:2063
 TProofPlayer.cxx:2064
 TProofPlayer.cxx:2065
 TProofPlayer.cxx:2066
 TProofPlayer.cxx:2067
 TProofPlayer.cxx:2068
 TProofPlayer.cxx:2069
 TProofPlayer.cxx:2070
 TProofPlayer.cxx:2071
 TProofPlayer.cxx:2072
 TProofPlayer.cxx:2073
 TProofPlayer.cxx:2074
 TProofPlayer.cxx:2075
 TProofPlayer.cxx:2076
 TProofPlayer.cxx:2077
 TProofPlayer.cxx:2078
 TProofPlayer.cxx:2079
 TProofPlayer.cxx:2080
 TProofPlayer.cxx:2081
 TProofPlayer.cxx:2082
 TProofPlayer.cxx:2083
 TProofPlayer.cxx:2084
 TProofPlayer.cxx:2085
 TProofPlayer.cxx:2086
 TProofPlayer.cxx:2087
 TProofPlayer.cxx:2088
 TProofPlayer.cxx:2089
 TProofPlayer.cxx:2090
 TProofPlayer.cxx:2091
 TProofPlayer.cxx:2092
 TProofPlayer.cxx:2093
 TProofPlayer.cxx:2094
 TProofPlayer.cxx:2095
 TProofPlayer.cxx:2096
 TProofPlayer.cxx:2097
 TProofPlayer.cxx:2098
 TProofPlayer.cxx:2099
 TProofPlayer.cxx:2100
 TProofPlayer.cxx:2101
 TProofPlayer.cxx:2102
 TProofPlayer.cxx:2103
 TProofPlayer.cxx:2104
 TProofPlayer.cxx:2105
 TProofPlayer.cxx:2106
 TProofPlayer.cxx:2107
 TProofPlayer.cxx:2108
 TProofPlayer.cxx:2109
 TProofPlayer.cxx:2110
 TProofPlayer.cxx:2111
 TProofPlayer.cxx:2112
 TProofPlayer.cxx:2113
 TProofPlayer.cxx:2114
 TProofPlayer.cxx:2115
 TProofPlayer.cxx:2116
 TProofPlayer.cxx:2117
 TProofPlayer.cxx:2118
 TProofPlayer.cxx:2119
 TProofPlayer.cxx:2120
 TProofPlayer.cxx:2121
 TProofPlayer.cxx:2122
 TProofPlayer.cxx:2123
 TProofPlayer.cxx:2124
 TProofPlayer.cxx:2125
 TProofPlayer.cxx:2126
 TProofPlayer.cxx:2127
 TProofPlayer.cxx:2128
 TProofPlayer.cxx:2129
 TProofPlayer.cxx:2130
 TProofPlayer.cxx:2131
 TProofPlayer.cxx:2132
 TProofPlayer.cxx:2133
 TProofPlayer.cxx:2134
 TProofPlayer.cxx:2135
 TProofPlayer.cxx:2136
 TProofPlayer.cxx:2137
 TProofPlayer.cxx:2138
 TProofPlayer.cxx:2139
 TProofPlayer.cxx:2140
 TProofPlayer.cxx:2141
 TProofPlayer.cxx:2142
 TProofPlayer.cxx:2143
 TProofPlayer.cxx:2144
 TProofPlayer.cxx:2145
 TProofPlayer.cxx:2146
 TProofPlayer.cxx:2147
 TProofPlayer.cxx:2148
 TProofPlayer.cxx:2149
 TProofPlayer.cxx:2150
 TProofPlayer.cxx:2151
 TProofPlayer.cxx:2152
 TProofPlayer.cxx:2153
 TProofPlayer.cxx:2154
 TProofPlayer.cxx:2155
 TProofPlayer.cxx:2156
 TProofPlayer.cxx:2157
 TProofPlayer.cxx:2158
 TProofPlayer.cxx:2159
 TProofPlayer.cxx:2160
 TProofPlayer.cxx:2161
 TProofPlayer.cxx:2162
 TProofPlayer.cxx:2163
 TProofPlayer.cxx:2164
 TProofPlayer.cxx:2165
 TProofPlayer.cxx:2166
 TProofPlayer.cxx:2167
 TProofPlayer.cxx:2168
 TProofPlayer.cxx:2169
 TProofPlayer.cxx:2170
 TProofPlayer.cxx:2171
 TProofPlayer.cxx:2172
 TProofPlayer.cxx:2173
 TProofPlayer.cxx:2174
 TProofPlayer.cxx:2175
 TProofPlayer.cxx:2176
 TProofPlayer.cxx:2177
 TProofPlayer.cxx:2178
 TProofPlayer.cxx:2179
 TProofPlayer.cxx:2180
 TProofPlayer.cxx:2181
 TProofPlayer.cxx:2182
 TProofPlayer.cxx:2183
 TProofPlayer.cxx:2184
 TProofPlayer.cxx:2185
 TProofPlayer.cxx:2186
 TProofPlayer.cxx:2187
 TProofPlayer.cxx:2188
 TProofPlayer.cxx:2189
 TProofPlayer.cxx:2190
 TProofPlayer.cxx:2191
 TProofPlayer.cxx:2192
 TProofPlayer.cxx:2193
 TProofPlayer.cxx:2194
 TProofPlayer.cxx:2195
 TProofPlayer.cxx:2196
 TProofPlayer.cxx:2197
 TProofPlayer.cxx:2198
 TProofPlayer.cxx:2199
 TProofPlayer.cxx:2200
 TProofPlayer.cxx:2201
 TProofPlayer.cxx:2202
 TProofPlayer.cxx:2203
 TProofPlayer.cxx:2204
 TProofPlayer.cxx:2205
 TProofPlayer.cxx:2206
 TProofPlayer.cxx:2207
 TProofPlayer.cxx:2208
 TProofPlayer.cxx:2209
 TProofPlayer.cxx:2210
 TProofPlayer.cxx:2211
 TProofPlayer.cxx:2212
 TProofPlayer.cxx:2213
 TProofPlayer.cxx:2214
 TProofPlayer.cxx:2215
 TProofPlayer.cxx:2216
 TProofPlayer.cxx:2217
 TProofPlayer.cxx:2218
 TProofPlayer.cxx:2219
 TProofPlayer.cxx:2220
 TProofPlayer.cxx:2221
 TProofPlayer.cxx:2222
 TProofPlayer.cxx:2223
 TProofPlayer.cxx:2224
 TProofPlayer.cxx:2225
 TProofPlayer.cxx:2226
 TProofPlayer.cxx:2227
 TProofPlayer.cxx:2228
 TProofPlayer.cxx:2229
 TProofPlayer.cxx:2230
 TProofPlayer.cxx:2231
 TProofPlayer.cxx:2232
 TProofPlayer.cxx:2233
 TProofPlayer.cxx:2234
 TProofPlayer.cxx:2235
 TProofPlayer.cxx:2236
 TProofPlayer.cxx:2237
 TProofPlayer.cxx:2238
 TProofPlayer.cxx:2239
 TProofPlayer.cxx:2240
 TProofPlayer.cxx:2241
 TProofPlayer.cxx:2242
 TProofPlayer.cxx:2243
 TProofPlayer.cxx:2244
 TProofPlayer.cxx:2245
 TProofPlayer.cxx:2246
 TProofPlayer.cxx:2247
 TProofPlayer.cxx:2248
 TProofPlayer.cxx:2249
 TProofPlayer.cxx:2250
 TProofPlayer.cxx:2251
 TProofPlayer.cxx:2252
 TProofPlayer.cxx:2253
 TProofPlayer.cxx:2254
 TProofPlayer.cxx:2255
 TProofPlayer.cxx:2256
 TProofPlayer.cxx:2257
 TProofPlayer.cxx:2258
 TProofPlayer.cxx:2259
 TProofPlayer.cxx:2260
 TProofPlayer.cxx:2261
 TProofPlayer.cxx:2262
 TProofPlayer.cxx:2263
 TProofPlayer.cxx:2264
 TProofPlayer.cxx:2265
 TProofPlayer.cxx:2266
 TProofPlayer.cxx:2267
 TProofPlayer.cxx:2268
 TProofPlayer.cxx:2269
 TProofPlayer.cxx:2270
 TProofPlayer.cxx:2271
 TProofPlayer.cxx:2272
 TProofPlayer.cxx:2273
 TProofPlayer.cxx:2274
 TProofPlayer.cxx:2275
 TProofPlayer.cxx:2276
 TProofPlayer.cxx:2277
 TProofPlayer.cxx:2278
 TProofPlayer.cxx:2279
 TProofPlayer.cxx:2280
 TProofPlayer.cxx:2281
 TProofPlayer.cxx:2282
 TProofPlayer.cxx:2283
 TProofPlayer.cxx:2284
 TProofPlayer.cxx:2285
 TProofPlayer.cxx:2286
 TProofPlayer.cxx:2287
 TProofPlayer.cxx:2288
 TProofPlayer.cxx:2289
 TProofPlayer.cxx:2290
 TProofPlayer.cxx:2291
 TProofPlayer.cxx:2292
 TProofPlayer.cxx:2293
 TProofPlayer.cxx:2294
 TProofPlayer.cxx:2295
 TProofPlayer.cxx:2296
 TProofPlayer.cxx:2297
 TProofPlayer.cxx:2298
 TProofPlayer.cxx:2299
 TProofPlayer.cxx:2300
 TProofPlayer.cxx:2301
 TProofPlayer.cxx:2302
 TProofPlayer.cxx:2303
 TProofPlayer.cxx:2304
 TProofPlayer.cxx:2305
 TProofPlayer.cxx:2306
 TProofPlayer.cxx:2307
 TProofPlayer.cxx:2308
 TProofPlayer.cxx:2309
 TProofPlayer.cxx:2310
 TProofPlayer.cxx:2311
 TProofPlayer.cxx:2312
 TProofPlayer.cxx:2313
 TProofPlayer.cxx:2314
 TProofPlayer.cxx:2315
 TProofPlayer.cxx:2316
 TProofPlayer.cxx:2317
 TProofPlayer.cxx:2318
 TProofPlayer.cxx:2319
 TProofPlayer.cxx:2320
 TProofPlayer.cxx:2321
 TProofPlayer.cxx:2322
 TProofPlayer.cxx:2323
 TProofPlayer.cxx:2324
 TProofPlayer.cxx:2325
 TProofPlayer.cxx:2326
 TProofPlayer.cxx:2327
 TProofPlayer.cxx:2328
 TProofPlayer.cxx:2329
 TProofPlayer.cxx:2330
 TProofPlayer.cxx:2331
 TProofPlayer.cxx:2332
 TProofPlayer.cxx:2333
 TProofPlayer.cxx:2334
 TProofPlayer.cxx:2335
 TProofPlayer.cxx:2336
 TProofPlayer.cxx:2337
 TProofPlayer.cxx:2338
 TProofPlayer.cxx:2339
 TProofPlayer.cxx:2340
 TProofPlayer.cxx:2341
 TProofPlayer.cxx:2342
 TProofPlayer.cxx:2343
 TProofPlayer.cxx:2344
 TProofPlayer.cxx:2345
 TProofPlayer.cxx:2346
 TProofPlayer.cxx:2347
 TProofPlayer.cxx:2348
 TProofPlayer.cxx:2349
 TProofPlayer.cxx:2350
 TProofPlayer.cxx:2351
 TProofPlayer.cxx:2352
 TProofPlayer.cxx:2353
 TProofPlayer.cxx:2354
 TProofPlayer.cxx:2355
 TProofPlayer.cxx:2356
 TProofPlayer.cxx:2357
 TProofPlayer.cxx:2358
 TProofPlayer.cxx:2359
 TProofPlayer.cxx:2360
 TProofPlayer.cxx:2361
 TProofPlayer.cxx:2362
 TProofPlayer.cxx:2363
 TProofPlayer.cxx:2364
 TProofPlayer.cxx:2365
 TProofPlayer.cxx:2366
 TProofPlayer.cxx:2367
 TProofPlayer.cxx:2368
 TProofPlayer.cxx:2369
 TProofPlayer.cxx:2370
 TProofPlayer.cxx:2371
 TProofPlayer.cxx:2372
 TProofPlayer.cxx:2373
 TProofPlayer.cxx:2374
 TProofPlayer.cxx:2375
 TProofPlayer.cxx:2376
 TProofPlayer.cxx:2377
 TProofPlayer.cxx:2378
 TProofPlayer.cxx:2379
 TProofPlayer.cxx:2380
 TProofPlayer.cxx:2381
 TProofPlayer.cxx:2382
 TProofPlayer.cxx:2383
 TProofPlayer.cxx:2384
 TProofPlayer.cxx:2385
 TProofPlayer.cxx:2386
 TProofPlayer.cxx:2387
 TProofPlayer.cxx:2388
 TProofPlayer.cxx:2389
 TProofPlayer.cxx:2390
 TProofPlayer.cxx:2391
 TProofPlayer.cxx:2392
 TProofPlayer.cxx:2393
 TProofPlayer.cxx:2394
 TProofPlayer.cxx:2395
 TProofPlayer.cxx:2396
 TProofPlayer.cxx:2397
 TProofPlayer.cxx:2398
 TProofPlayer.cxx:2399
 TProofPlayer.cxx:2400
 TProofPlayer.cxx:2401
 TProofPlayer.cxx:2402
 TProofPlayer.cxx:2403
 TProofPlayer.cxx:2404
 TProofPlayer.cxx:2405
 TProofPlayer.cxx:2406
 TProofPlayer.cxx:2407
 TProofPlayer.cxx:2408
 TProofPlayer.cxx:2409
 TProofPlayer.cxx:2410
 TProofPlayer.cxx:2411
 TProofPlayer.cxx:2412
 TProofPlayer.cxx:2413
 TProofPlayer.cxx:2414
 TProofPlayer.cxx:2415
 TProofPlayer.cxx:2416
 TProofPlayer.cxx:2417
 TProofPlayer.cxx:2418
 TProofPlayer.cxx:2419
 TProofPlayer.cxx:2420
 TProofPlayer.cxx:2421
 TProofPlayer.cxx:2422
 TProofPlayer.cxx:2423
 TProofPlayer.cxx:2424
 TProofPlayer.cxx:2425
 TProofPlayer.cxx:2426
 TProofPlayer.cxx:2427
 TProofPlayer.cxx:2428
 TProofPlayer.cxx:2429
 TProofPlayer.cxx:2430
 TProofPlayer.cxx:2431
 TProofPlayer.cxx:2432
 TProofPlayer.cxx:2433
 TProofPlayer.cxx:2434
 TProofPlayer.cxx:2435
 TProofPlayer.cxx:2436
 TProofPlayer.cxx:2437
 TProofPlayer.cxx:2438
 TProofPlayer.cxx:2439
 TProofPlayer.cxx:2440
 TProofPlayer.cxx:2441
 TProofPlayer.cxx:2442
 TProofPlayer.cxx:2443
 TProofPlayer.cxx:2444
 TProofPlayer.cxx:2445
 TProofPlayer.cxx:2446
 TProofPlayer.cxx:2447
 TProofPlayer.cxx:2448
 TProofPlayer.cxx:2449
 TProofPlayer.cxx:2450
 TProofPlayer.cxx:2451
 TProofPlayer.cxx:2452
 TProofPlayer.cxx:2453
 TProofPlayer.cxx:2454
 TProofPlayer.cxx:2455
 TProofPlayer.cxx:2456
 TProofPlayer.cxx:2457
 TProofPlayer.cxx:2458
 TProofPlayer.cxx:2459
 TProofPlayer.cxx:2460
 TProofPlayer.cxx:2461
 TProofPlayer.cxx:2462
 TProofPlayer.cxx:2463
 TProofPlayer.cxx:2464
 TProofPlayer.cxx:2465
 TProofPlayer.cxx:2466
 TProofPlayer.cxx:2467
 TProofPlayer.cxx:2468
 TProofPlayer.cxx:2469
 TProofPlayer.cxx:2470
 TProofPlayer.cxx:2471
 TProofPlayer.cxx:2472
 TProofPlayer.cxx:2473
 TProofPlayer.cxx:2474
 TProofPlayer.cxx:2475
 TProofPlayer.cxx:2476
 TProofPlayer.cxx:2477
 TProofPlayer.cxx:2478
 TProofPlayer.cxx:2479
 TProofPlayer.cxx:2480
 TProofPlayer.cxx:2481
 TProofPlayer.cxx:2482
 TProofPlayer.cxx:2483
 TProofPlayer.cxx:2484
 TProofPlayer.cxx:2485
 TProofPlayer.cxx:2486
 TProofPlayer.cxx:2487
 TProofPlayer.cxx:2488
 TProofPlayer.cxx:2489
 TProofPlayer.cxx:2490
 TProofPlayer.cxx:2491
 TProofPlayer.cxx:2492
 TProofPlayer.cxx:2493
 TProofPlayer.cxx:2494
 TProofPlayer.cxx:2495
 TProofPlayer.cxx:2496
 TProofPlayer.cxx:2497
 TProofPlayer.cxx:2498
 TProofPlayer.cxx:2499
 TProofPlayer.cxx:2500
 TProofPlayer.cxx:2501
 TProofPlayer.cxx:2502
 TProofPlayer.cxx:2503
 TProofPlayer.cxx:2504
 TProofPlayer.cxx:2505
 TProofPlayer.cxx:2506
 TProofPlayer.cxx:2507
 TProofPlayer.cxx:2508
 TProofPlayer.cxx:2509
 TProofPlayer.cxx:2510
 TProofPlayer.cxx:2511
 TProofPlayer.cxx:2512
 TProofPlayer.cxx:2513
 TProofPlayer.cxx:2514
 TProofPlayer.cxx:2515
 TProofPlayer.cxx:2516
 TProofPlayer.cxx:2517
 TProofPlayer.cxx:2518
 TProofPlayer.cxx:2519
 TProofPlayer.cxx:2520
 TProofPlayer.cxx:2521
 TProofPlayer.cxx:2522
 TProofPlayer.cxx:2523
 TProofPlayer.cxx:2524
 TProofPlayer.cxx:2525
 TProofPlayer.cxx:2526
 TProofPlayer.cxx:2527
 TProofPlayer.cxx:2528
 TProofPlayer.cxx:2529
 TProofPlayer.cxx:2530
 TProofPlayer.cxx:2531
 TProofPlayer.cxx:2532
 TProofPlayer.cxx:2533
 TProofPlayer.cxx:2534
 TProofPlayer.cxx:2535
 TProofPlayer.cxx:2536
 TProofPlayer.cxx:2537
 TProofPlayer.cxx:2538
 TProofPlayer.cxx:2539
 TProofPlayer.cxx:2540
 TProofPlayer.cxx:2541
 TProofPlayer.cxx:2542
 TProofPlayer.cxx:2543
 TProofPlayer.cxx:2544
 TProofPlayer.cxx:2545
 TProofPlayer.cxx:2546
 TProofPlayer.cxx:2547
 TProofPlayer.cxx:2548
 TProofPlayer.cxx:2549
 TProofPlayer.cxx:2550
 TProofPlayer.cxx:2551
 TProofPlayer.cxx:2552
 TProofPlayer.cxx:2553
 TProofPlayer.cxx:2554
 TProofPlayer.cxx:2555
 TProofPlayer.cxx:2556
 TProofPlayer.cxx:2557
 TProofPlayer.cxx:2558
 TProofPlayer.cxx:2559
 TProofPlayer.cxx:2560
 TProofPlayer.cxx:2561
 TProofPlayer.cxx:2562
 TProofPlayer.cxx:2563
 TProofPlayer.cxx:2564
 TProofPlayer.cxx:2565
 TProofPlayer.cxx:2566
 TProofPlayer.cxx:2567
 TProofPlayer.cxx:2568
 TProofPlayer.cxx:2569
 TProofPlayer.cxx:2570
 TProofPlayer.cxx:2571
 TProofPlayer.cxx:2572
 TProofPlayer.cxx:2573
 TProofPlayer.cxx:2574
 TProofPlayer.cxx:2575
 TProofPlayer.cxx:2576
 TProofPlayer.cxx:2577
 TProofPlayer.cxx:2578
 TProofPlayer.cxx:2579
 TProofPlayer.cxx:2580
 TProofPlayer.cxx:2581
 TProofPlayer.cxx:2582
 TProofPlayer.cxx:2583
 TProofPlayer.cxx:2584
 TProofPlayer.cxx:2585
 TProofPlayer.cxx:2586
 TProofPlayer.cxx:2587
 TProofPlayer.cxx:2588
 TProofPlayer.cxx:2589
 TProofPlayer.cxx:2590
 TProofPlayer.cxx:2591
 TProofPlayer.cxx:2592
 TProofPlayer.cxx:2593
 TProofPlayer.cxx:2594
 TProofPlayer.cxx:2595
 TProofPlayer.cxx:2596
 TProofPlayer.cxx:2597
 TProofPlayer.cxx:2598
 TProofPlayer.cxx:2599
 TProofPlayer.cxx:2600
 TProofPlayer.cxx:2601
 TProofPlayer.cxx:2602
 TProofPlayer.cxx:2603
 TProofPlayer.cxx:2604
 TProofPlayer.cxx:2605
 TProofPlayer.cxx:2606
 TProofPlayer.cxx:2607
 TProofPlayer.cxx:2608
 TProofPlayer.cxx:2609
 TProofPlayer.cxx:2610
 TProofPlayer.cxx:2611
 TProofPlayer.cxx:2612
 TProofPlayer.cxx:2613
 TProofPlayer.cxx:2614
 TProofPlayer.cxx:2615
 TProofPlayer.cxx:2616
 TProofPlayer.cxx:2617
 TProofPlayer.cxx:2618
 TProofPlayer.cxx:2619
 TProofPlayer.cxx:2620
 TProofPlayer.cxx:2621
 TProofPlayer.cxx:2622
 TProofPlayer.cxx:2623
 TProofPlayer.cxx:2624
 TProofPlayer.cxx:2625
 TProofPlayer.cxx:2626
 TProofPlayer.cxx:2627
 TProofPlayer.cxx:2628
 TProofPlayer.cxx:2629
 TProofPlayer.cxx:2630
 TProofPlayer.cxx:2631
 TProofPlayer.cxx:2632
 TProofPlayer.cxx:2633
 TProofPlayer.cxx:2634
 TProofPlayer.cxx:2635
 TProofPlayer.cxx:2636
 TProofPlayer.cxx:2637
 TProofPlayer.cxx:2638
 TProofPlayer.cxx:2639
 TProofPlayer.cxx:2640
 TProofPlayer.cxx:2641
 TProofPlayer.cxx:2642
 TProofPlayer.cxx:2643
 TProofPlayer.cxx:2644
 TProofPlayer.cxx:2645
 TProofPlayer.cxx:2646
 TProofPlayer.cxx:2647
 TProofPlayer.cxx:2648
 TProofPlayer.cxx:2649
 TProofPlayer.cxx:2650
 TProofPlayer.cxx:2651
 TProofPlayer.cxx:2652
 TProofPlayer.cxx:2653
 TProofPlayer.cxx:2654
 TProofPlayer.cxx:2655
 TProofPlayer.cxx:2656
 TProofPlayer.cxx:2657
 TProofPlayer.cxx:2658
 TProofPlayer.cxx:2659
 TProofPlayer.cxx:2660
 TProofPlayer.cxx:2661
 TProofPlayer.cxx:2662
 TProofPlayer.cxx:2663
 TProofPlayer.cxx:2664
 TProofPlayer.cxx:2665
 TProofPlayer.cxx:2666
 TProofPlayer.cxx:2667
 TProofPlayer.cxx:2668
 TProofPlayer.cxx:2669
 TProofPlayer.cxx:2670
 TProofPlayer.cxx:2671
 TProofPlayer.cxx:2672
 TProofPlayer.cxx:2673
 TProofPlayer.cxx:2674
 TProofPlayer.cxx:2675
 TProofPlayer.cxx:2676
 TProofPlayer.cxx:2677
 TProofPlayer.cxx:2678
 TProofPlayer.cxx:2679
 TProofPlayer.cxx:2680
 TProofPlayer.cxx:2681
 TProofPlayer.cxx:2682
 TProofPlayer.cxx:2683
 TProofPlayer.cxx:2684
 TProofPlayer.cxx:2685
 TProofPlayer.cxx:2686
 TProofPlayer.cxx:2687
 TProofPlayer.cxx:2688
 TProofPlayer.cxx:2689
 TProofPlayer.cxx:2690
 TProofPlayer.cxx:2691
 TProofPlayer.cxx:2692
 TProofPlayer.cxx:2693
 TProofPlayer.cxx:2694
 TProofPlayer.cxx:2695
 TProofPlayer.cxx:2696
 TProofPlayer.cxx:2697
 TProofPlayer.cxx:2698
 TProofPlayer.cxx:2699
 TProofPlayer.cxx:2700
 TProofPlayer.cxx:2701
 TProofPlayer.cxx:2702
 TProofPlayer.cxx:2703
 TProofPlayer.cxx:2704
 TProofPlayer.cxx:2705
 TProofPlayer.cxx:2706
 TProofPlayer.cxx:2707
 TProofPlayer.cxx:2708
 TProofPlayer.cxx:2709
 TProofPlayer.cxx:2710
 TProofPlayer.cxx:2711
 TProofPlayer.cxx:2712
 TProofPlayer.cxx:2713
 TProofPlayer.cxx:2714
 TProofPlayer.cxx:2715
 TProofPlayer.cxx:2716
 TProofPlayer.cxx:2717
 TProofPlayer.cxx:2718
 TProofPlayer.cxx:2719
 TProofPlayer.cxx:2720
 TProofPlayer.cxx:2721
 TProofPlayer.cxx:2722
 TProofPlayer.cxx:2723
 TProofPlayer.cxx:2724
 TProofPlayer.cxx:2725
 TProofPlayer.cxx:2726
 TProofPlayer.cxx:2727
 TProofPlayer.cxx:2728
 TProofPlayer.cxx:2729
 TProofPlayer.cxx:2730
 TProofPlayer.cxx:2731
 TProofPlayer.cxx:2732
 TProofPlayer.cxx:2733
 TProofPlayer.cxx:2734
 TProofPlayer.cxx:2735
 TProofPlayer.cxx:2736
 TProofPlayer.cxx:2737
 TProofPlayer.cxx:2738
 TProofPlayer.cxx:2739
 TProofPlayer.cxx:2740
 TProofPlayer.cxx:2741
 TProofPlayer.cxx:2742
 TProofPlayer.cxx:2743
 TProofPlayer.cxx:2744
 TProofPlayer.cxx:2745
 TProofPlayer.cxx:2746
 TProofPlayer.cxx:2747
 TProofPlayer.cxx:2748
 TProofPlayer.cxx:2749
 TProofPlayer.cxx:2750
 TProofPlayer.cxx:2751
 TProofPlayer.cxx:2752
 TProofPlayer.cxx:2753
 TProofPlayer.cxx:2754
 TProofPlayer.cxx:2755
 TProofPlayer.cxx:2756
 TProofPlayer.cxx:2757
 TProofPlayer.cxx:2758
 TProofPlayer.cxx:2759
 TProofPlayer.cxx:2760
 TProofPlayer.cxx:2761
 TProofPlayer.cxx:2762
 TProofPlayer.cxx:2763
 TProofPlayer.cxx:2764
 TProofPlayer.cxx:2765
 TProofPlayer.cxx:2766
 TProofPlayer.cxx:2767
 TProofPlayer.cxx:2768
 TProofPlayer.cxx:2769
 TProofPlayer.cxx:2770
 TProofPlayer.cxx:2771
 TProofPlayer.cxx:2772
 TProofPlayer.cxx:2773
 TProofPlayer.cxx:2774
 TProofPlayer.cxx:2775
 TProofPlayer.cxx:2776
 TProofPlayer.cxx:2777
 TProofPlayer.cxx:2778
 TProofPlayer.cxx:2779
 TProofPlayer.cxx:2780
 TProofPlayer.cxx:2781
 TProofPlayer.cxx:2782
 TProofPlayer.cxx:2783
 TProofPlayer.cxx:2784
 TProofPlayer.cxx:2785
 TProofPlayer.cxx:2786
 TProofPlayer.cxx:2787
 TProofPlayer.cxx:2788
 TProofPlayer.cxx:2789
 TProofPlayer.cxx:2790
 TProofPlayer.cxx:2791
 TProofPlayer.cxx:2792
 TProofPlayer.cxx:2793
 TProofPlayer.cxx:2794
 TProofPlayer.cxx:2795
 TProofPlayer.cxx:2796
 TProofPlayer.cxx:2797
 TProofPlayer.cxx:2798
 TProofPlayer.cxx:2799
 TProofPlayer.cxx:2800
 TProofPlayer.cxx:2801
 TProofPlayer.cxx:2802
 TProofPlayer.cxx:2803
 TProofPlayer.cxx:2804
 TProofPlayer.cxx:2805
 TProofPlayer.cxx:2806
 TProofPlayer.cxx:2807
 TProofPlayer.cxx:2808
 TProofPlayer.cxx:2809
 TProofPlayer.cxx:2810
 TProofPlayer.cxx:2811
 TProofPlayer.cxx:2812
 TProofPlayer.cxx:2813
 TProofPlayer.cxx:2814
 TProofPlayer.cxx:2815
 TProofPlayer.cxx:2816
 TProofPlayer.cxx:2817
 TProofPlayer.cxx:2818
 TProofPlayer.cxx:2819
 TProofPlayer.cxx:2820
 TProofPlayer.cxx:2821
 TProofPlayer.cxx:2822
 TProofPlayer.cxx:2823
 TProofPlayer.cxx:2824
 TProofPlayer.cxx:2825
 TProofPlayer.cxx:2826
 TProofPlayer.cxx:2827
 TProofPlayer.cxx:2828
 TProofPlayer.cxx:2829
 TProofPlayer.cxx:2830
 TProofPlayer.cxx:2831
 TProofPlayer.cxx:2832
 TProofPlayer.cxx:2833
 TProofPlayer.cxx:2834
 TProofPlayer.cxx:2835
 TProofPlayer.cxx:2836
 TProofPlayer.cxx:2837
 TProofPlayer.cxx:2838
 TProofPlayer.cxx:2839
 TProofPlayer.cxx:2840
 TProofPlayer.cxx:2841
 TProofPlayer.cxx:2842
 TProofPlayer.cxx:2843
 TProofPlayer.cxx:2844
 TProofPlayer.cxx:2845
 TProofPlayer.cxx:2846
 TProofPlayer.cxx:2847
 TProofPlayer.cxx:2848
 TProofPlayer.cxx:2849
 TProofPlayer.cxx:2850
 TProofPlayer.cxx:2851
 TProofPlayer.cxx:2852
 TProofPlayer.cxx:2853
 TProofPlayer.cxx:2854
 TProofPlayer.cxx:2855
 TProofPlayer.cxx:2856
 TProofPlayer.cxx:2857
 TProofPlayer.cxx:2858
 TProofPlayer.cxx:2859
 TProofPlayer.cxx:2860
 TProofPlayer.cxx:2861
 TProofPlayer.cxx:2862
 TProofPlayer.cxx:2863
 TProofPlayer.cxx:2864
 TProofPlayer.cxx:2865
 TProofPlayer.cxx:2866
 TProofPlayer.cxx:2867
 TProofPlayer.cxx:2868
 TProofPlayer.cxx:2869
 TProofPlayer.cxx:2870
 TProofPlayer.cxx:2871
 TProofPlayer.cxx:2872
 TProofPlayer.cxx:2873
 TProofPlayer.cxx:2874
 TProofPlayer.cxx:2875
 TProofPlayer.cxx:2876
 TProofPlayer.cxx:2877
 TProofPlayer.cxx:2878
 TProofPlayer.cxx:2879
 TProofPlayer.cxx:2880
 TProofPlayer.cxx:2881
 TProofPlayer.cxx:2882
 TProofPlayer.cxx:2883
 TProofPlayer.cxx:2884
 TProofPlayer.cxx:2885
 TProofPlayer.cxx:2886
 TProofPlayer.cxx:2887
 TProofPlayer.cxx:2888
 TProofPlayer.cxx:2889
 TProofPlayer.cxx:2890
 TProofPlayer.cxx:2891
 TProofPlayer.cxx:2892
 TProofPlayer.cxx:2893
 TProofPlayer.cxx:2894
 TProofPlayer.cxx:2895
 TProofPlayer.cxx:2896
 TProofPlayer.cxx:2897
 TProofPlayer.cxx:2898
 TProofPlayer.cxx:2899
 TProofPlayer.cxx:2900
 TProofPlayer.cxx:2901
 TProofPlayer.cxx:2902
 TProofPlayer.cxx:2903
 TProofPlayer.cxx:2904
 TProofPlayer.cxx:2905
 TProofPlayer.cxx:2906
 TProofPlayer.cxx:2907
 TProofPlayer.cxx:2908
 TProofPlayer.cxx:2909
 TProofPlayer.cxx:2910
 TProofPlayer.cxx:2911
 TProofPlayer.cxx:2912
 TProofPlayer.cxx:2913
 TProofPlayer.cxx:2914
 TProofPlayer.cxx:2915
 TProofPlayer.cxx:2916
 TProofPlayer.cxx:2917
 TProofPlayer.cxx:2918
 TProofPlayer.cxx:2919
 TProofPlayer.cxx:2920
 TProofPlayer.cxx:2921
 TProofPlayer.cxx:2922
 TProofPlayer.cxx:2923
 TProofPlayer.cxx:2924
 TProofPlayer.cxx:2925
 TProofPlayer.cxx:2926
 TProofPlayer.cxx:2927
 TProofPlayer.cxx:2928
 TProofPlayer.cxx:2929
 TProofPlayer.cxx:2930
 TProofPlayer.cxx:2931
 TProofPlayer.cxx:2932
 TProofPlayer.cxx:2933
 TProofPlayer.cxx:2934
 TProofPlayer.cxx:2935
 TProofPlayer.cxx:2936
 TProofPlayer.cxx:2937
 TProofPlayer.cxx:2938
 TProofPlayer.cxx:2939
 TProofPlayer.cxx:2940
 TProofPlayer.cxx:2941
 TProofPlayer.cxx:2942
 TProofPlayer.cxx:2943
 TProofPlayer.cxx:2944
 TProofPlayer.cxx:2945
 TProofPlayer.cxx:2946
 TProofPlayer.cxx:2947
 TProofPlayer.cxx:2948
 TProofPlayer.cxx:2949
 TProofPlayer.cxx:2950
 TProofPlayer.cxx:2951
 TProofPlayer.cxx:2952
 TProofPlayer.cxx:2953
 TProofPlayer.cxx:2954
 TProofPlayer.cxx:2955
 TProofPlayer.cxx:2956
 TProofPlayer.cxx:2957
 TProofPlayer.cxx:2958
 TProofPlayer.cxx:2959
 TProofPlayer.cxx:2960
 TProofPlayer.cxx:2961
 TProofPlayer.cxx:2962
 TProofPlayer.cxx:2963
 TProofPlayer.cxx:2964
 TProofPlayer.cxx:2965
 TProofPlayer.cxx:2966
 TProofPlayer.cxx:2967
 TProofPlayer.cxx:2968
 TProofPlayer.cxx:2969
 TProofPlayer.cxx:2970
 TProofPlayer.cxx:2971
 TProofPlayer.cxx:2972
 TProofPlayer.cxx:2973
 TProofPlayer.cxx:2974
 TProofPlayer.cxx:2975
 TProofPlayer.cxx:2976
 TProofPlayer.cxx:2977
 TProofPlayer.cxx:2978
 TProofPlayer.cxx:2979
 TProofPlayer.cxx:2980
 TProofPlayer.cxx:2981
 TProofPlayer.cxx:2982
 TProofPlayer.cxx:2983
 TProofPlayer.cxx:2984
 TProofPlayer.cxx:2985
 TProofPlayer.cxx:2986
 TProofPlayer.cxx:2987
 TProofPlayer.cxx:2988
 TProofPlayer.cxx:2989
 TProofPlayer.cxx:2990
 TProofPlayer.cxx:2991
 TProofPlayer.cxx:2992
 TProofPlayer.cxx:2993
 TProofPlayer.cxx:2994
 TProofPlayer.cxx:2995
 TProofPlayer.cxx:2996
 TProofPlayer.cxx:2997
 TProofPlayer.cxx:2998
 TProofPlayer.cxx:2999
 TProofPlayer.cxx:3000
 TProofPlayer.cxx:3001
 TProofPlayer.cxx:3002
 TProofPlayer.cxx:3003
 TProofPlayer.cxx:3004
 TProofPlayer.cxx:3005
 TProofPlayer.cxx:3006
 TProofPlayer.cxx:3007
 TProofPlayer.cxx:3008
 TProofPlayer.cxx:3009
 TProofPlayer.cxx:3010
 TProofPlayer.cxx:3011
 TProofPlayer.cxx:3012
 TProofPlayer.cxx:3013
 TProofPlayer.cxx:3014
 TProofPlayer.cxx:3015
 TProofPlayer.cxx:3016
 TProofPlayer.cxx:3017
 TProofPlayer.cxx:3018
 TProofPlayer.cxx:3019
 TProofPlayer.cxx:3020
 TProofPlayer.cxx:3021
 TProofPlayer.cxx:3022
 TProofPlayer.cxx:3023
 TProofPlayer.cxx:3024
 TProofPlayer.cxx:3025
 TProofPlayer.cxx:3026
 TProofPlayer.cxx:3027
 TProofPlayer.cxx:3028
 TProofPlayer.cxx:3029
 TProofPlayer.cxx:3030
 TProofPlayer.cxx:3031
 TProofPlayer.cxx:3032
 TProofPlayer.cxx:3033
 TProofPlayer.cxx:3034
 TProofPlayer.cxx:3035
 TProofPlayer.cxx:3036
 TProofPlayer.cxx:3037
 TProofPlayer.cxx:3038
 TProofPlayer.cxx:3039
 TProofPlayer.cxx:3040
 TProofPlayer.cxx:3041
 TProofPlayer.cxx:3042
 TProofPlayer.cxx:3043
 TProofPlayer.cxx:3044
 TProofPlayer.cxx:3045
 TProofPlayer.cxx:3046
 TProofPlayer.cxx:3047
 TProofPlayer.cxx:3048
 TProofPlayer.cxx:3049
 TProofPlayer.cxx:3050
 TProofPlayer.cxx:3051
 TProofPlayer.cxx:3052
 TProofPlayer.cxx:3053
 TProofPlayer.cxx:3054
 TProofPlayer.cxx:3055
 TProofPlayer.cxx:3056
 TProofPlayer.cxx:3057
 TProofPlayer.cxx:3058
 TProofPlayer.cxx:3059
 TProofPlayer.cxx:3060
 TProofPlayer.cxx:3061
 TProofPlayer.cxx:3062
 TProofPlayer.cxx:3063
 TProofPlayer.cxx:3064
 TProofPlayer.cxx:3065
 TProofPlayer.cxx:3066
 TProofPlayer.cxx:3067
 TProofPlayer.cxx:3068
 TProofPlayer.cxx:3069
 TProofPlayer.cxx:3070
 TProofPlayer.cxx:3071
 TProofPlayer.cxx:3072
 TProofPlayer.cxx:3073
 TProofPlayer.cxx:3074
 TProofPlayer.cxx:3075
 TProofPlayer.cxx:3076
 TProofPlayer.cxx:3077
 TProofPlayer.cxx:3078
 TProofPlayer.cxx:3079
 TProofPlayer.cxx:3080
 TProofPlayer.cxx:3081
 TProofPlayer.cxx:3082
 TProofPlayer.cxx:3083
 TProofPlayer.cxx:3084
 TProofPlayer.cxx:3085
 TProofPlayer.cxx:3086
 TProofPlayer.cxx:3087
 TProofPlayer.cxx:3088
 TProofPlayer.cxx:3089
 TProofPlayer.cxx:3090
 TProofPlayer.cxx:3091
 TProofPlayer.cxx:3092
 TProofPlayer.cxx:3093
 TProofPlayer.cxx:3094
 TProofPlayer.cxx:3095
 TProofPlayer.cxx:3096
 TProofPlayer.cxx:3097
 TProofPlayer.cxx:3098
 TProofPlayer.cxx:3099
 TProofPlayer.cxx:3100
 TProofPlayer.cxx:3101
 TProofPlayer.cxx:3102
 TProofPlayer.cxx:3103
 TProofPlayer.cxx:3104
 TProofPlayer.cxx:3105
 TProofPlayer.cxx:3106
 TProofPlayer.cxx:3107
 TProofPlayer.cxx:3108
 TProofPlayer.cxx:3109
 TProofPlayer.cxx:3110
 TProofPlayer.cxx:3111
 TProofPlayer.cxx:3112
 TProofPlayer.cxx:3113
 TProofPlayer.cxx:3114
 TProofPlayer.cxx:3115
 TProofPlayer.cxx:3116
 TProofPlayer.cxx:3117
 TProofPlayer.cxx:3118
 TProofPlayer.cxx:3119
 TProofPlayer.cxx:3120
 TProofPlayer.cxx:3121
 TProofPlayer.cxx:3122
 TProofPlayer.cxx:3123
 TProofPlayer.cxx:3124
 TProofPlayer.cxx:3125
 TProofPlayer.cxx:3126
 TProofPlayer.cxx:3127
 TProofPlayer.cxx:3128
 TProofPlayer.cxx:3129
 TProofPlayer.cxx:3130
 TProofPlayer.cxx:3131
 TProofPlayer.cxx:3132
 TProofPlayer.cxx:3133
 TProofPlayer.cxx:3134
 TProofPlayer.cxx:3135
 TProofPlayer.cxx:3136
 TProofPlayer.cxx:3137
 TProofPlayer.cxx:3138
 TProofPlayer.cxx:3139
 TProofPlayer.cxx:3140
 TProofPlayer.cxx:3141
 TProofPlayer.cxx:3142
 TProofPlayer.cxx:3143
 TProofPlayer.cxx:3144
 TProofPlayer.cxx:3145
 TProofPlayer.cxx:3146
 TProofPlayer.cxx:3147
 TProofPlayer.cxx:3148
 TProofPlayer.cxx:3149
 TProofPlayer.cxx:3150
 TProofPlayer.cxx:3151
 TProofPlayer.cxx:3152
 TProofPlayer.cxx:3153
 TProofPlayer.cxx:3154
 TProofPlayer.cxx:3155
 TProofPlayer.cxx:3156
 TProofPlayer.cxx:3157
 TProofPlayer.cxx:3158
 TProofPlayer.cxx:3159
 TProofPlayer.cxx:3160
 TProofPlayer.cxx:3161
 TProofPlayer.cxx:3162
 TProofPlayer.cxx:3163
 TProofPlayer.cxx:3164
 TProofPlayer.cxx:3165
 TProofPlayer.cxx:3166
 TProofPlayer.cxx:3167
 TProofPlayer.cxx:3168
 TProofPlayer.cxx:3169
 TProofPlayer.cxx:3170
 TProofPlayer.cxx:3171
 TProofPlayer.cxx:3172
 TProofPlayer.cxx:3173
 TProofPlayer.cxx:3174
 TProofPlayer.cxx:3175
 TProofPlayer.cxx:3176
 TProofPlayer.cxx:3177
 TProofPlayer.cxx:3178
 TProofPlayer.cxx:3179
 TProofPlayer.cxx:3180
 TProofPlayer.cxx:3181
 TProofPlayer.cxx:3182
 TProofPlayer.cxx:3183
 TProofPlayer.cxx:3184
 TProofPlayer.cxx:3185
 TProofPlayer.cxx:3186
 TProofPlayer.cxx:3187
 TProofPlayer.cxx:3188
 TProofPlayer.cxx:3189
 TProofPlayer.cxx:3190
 TProofPlayer.cxx:3191
 TProofPlayer.cxx:3192
 TProofPlayer.cxx:3193
 TProofPlayer.cxx:3194
 TProofPlayer.cxx:3195
 TProofPlayer.cxx:3196
 TProofPlayer.cxx:3197
 TProofPlayer.cxx:3198
 TProofPlayer.cxx:3199
 TProofPlayer.cxx:3200
 TProofPlayer.cxx:3201
 TProofPlayer.cxx:3202
 TProofPlayer.cxx:3203
 TProofPlayer.cxx:3204
 TProofPlayer.cxx:3205
 TProofPlayer.cxx:3206
 TProofPlayer.cxx:3207
 TProofPlayer.cxx:3208
 TProofPlayer.cxx:3209
 TProofPlayer.cxx:3210
 TProofPlayer.cxx:3211
 TProofPlayer.cxx:3212
 TProofPlayer.cxx:3213
 TProofPlayer.cxx:3214
 TProofPlayer.cxx:3215
 TProofPlayer.cxx:3216
 TProofPlayer.cxx:3217
 TProofPlayer.cxx:3218
 TProofPlayer.cxx:3219
 TProofPlayer.cxx:3220
 TProofPlayer.cxx:3221
 TProofPlayer.cxx:3222
 TProofPlayer.cxx:3223
 TProofPlayer.cxx:3224
 TProofPlayer.cxx:3225
 TProofPlayer.cxx:3226
 TProofPlayer.cxx:3227
 TProofPlayer.cxx:3228
 TProofPlayer.cxx:3229
 TProofPlayer.cxx:3230
 TProofPlayer.cxx:3231
 TProofPlayer.cxx:3232
 TProofPlayer.cxx:3233
 TProofPlayer.cxx:3234
 TProofPlayer.cxx:3235
 TProofPlayer.cxx:3236
 TProofPlayer.cxx:3237
 TProofPlayer.cxx:3238
 TProofPlayer.cxx:3239
 TProofPlayer.cxx:3240
 TProofPlayer.cxx:3241
 TProofPlayer.cxx:3242
 TProofPlayer.cxx:3243
 TProofPlayer.cxx:3244
 TProofPlayer.cxx:3245
 TProofPlayer.cxx:3246
 TProofPlayer.cxx:3247
 TProofPlayer.cxx:3248
 TProofPlayer.cxx:3249
 TProofPlayer.cxx:3250
 TProofPlayer.cxx:3251
 TProofPlayer.cxx:3252
 TProofPlayer.cxx:3253
 TProofPlayer.cxx:3254
 TProofPlayer.cxx:3255
 TProofPlayer.cxx:3256
 TProofPlayer.cxx:3257
 TProofPlayer.cxx:3258
 TProofPlayer.cxx:3259
 TProofPlayer.cxx:3260
 TProofPlayer.cxx:3261
 TProofPlayer.cxx:3262
 TProofPlayer.cxx:3263
 TProofPlayer.cxx:3264
 TProofPlayer.cxx:3265
 TProofPlayer.cxx:3266
 TProofPlayer.cxx:3267
 TProofPlayer.cxx:3268
 TProofPlayer.cxx:3269
 TProofPlayer.cxx:3270
 TProofPlayer.cxx:3271
 TProofPlayer.cxx:3272
 TProofPlayer.cxx:3273
 TProofPlayer.cxx:3274
 TProofPlayer.cxx:3275
 TProofPlayer.cxx:3276
 TProofPlayer.cxx:3277
 TProofPlayer.cxx:3278
 TProofPlayer.cxx:3279
 TProofPlayer.cxx:3280
 TProofPlayer.cxx:3281
 TProofPlayer.cxx:3282
 TProofPlayer.cxx:3283
 TProofPlayer.cxx:3284
 TProofPlayer.cxx:3285
 TProofPlayer.cxx:3286
 TProofPlayer.cxx:3287
 TProofPlayer.cxx:3288
 TProofPlayer.cxx:3289
 TProofPlayer.cxx:3290
 TProofPlayer.cxx:3291
 TProofPlayer.cxx:3292
 TProofPlayer.cxx:3293
 TProofPlayer.cxx:3294
 TProofPlayer.cxx:3295
 TProofPlayer.cxx:3296
 TProofPlayer.cxx:3297
 TProofPlayer.cxx:3298
 TProofPlayer.cxx:3299
 TProofPlayer.cxx:3300
 TProofPlayer.cxx:3301
 TProofPlayer.cxx:3302
 TProofPlayer.cxx:3303
 TProofPlayer.cxx:3304
 TProofPlayer.cxx:3305
 TProofPlayer.cxx:3306
 TProofPlayer.cxx:3307
 TProofPlayer.cxx:3308
 TProofPlayer.cxx:3309
 TProofPlayer.cxx:3310
 TProofPlayer.cxx:3311
 TProofPlayer.cxx:3312
 TProofPlayer.cxx:3313
 TProofPlayer.cxx:3314
 TProofPlayer.cxx:3315
 TProofPlayer.cxx:3316
 TProofPlayer.cxx:3317
 TProofPlayer.cxx:3318
 TProofPlayer.cxx:3319
 TProofPlayer.cxx:3320
 TProofPlayer.cxx:3321
 TProofPlayer.cxx:3322
 TProofPlayer.cxx:3323
 TProofPlayer.cxx:3324
 TProofPlayer.cxx:3325
 TProofPlayer.cxx:3326
 TProofPlayer.cxx:3327
 TProofPlayer.cxx:3328
 TProofPlayer.cxx:3329
 TProofPlayer.cxx:3330
 TProofPlayer.cxx:3331
 TProofPlayer.cxx:3332
 TProofPlayer.cxx:3333
 TProofPlayer.cxx:3334
 TProofPlayer.cxx:3335
 TProofPlayer.cxx:3336
 TProofPlayer.cxx:3337
 TProofPlayer.cxx:3338
 TProofPlayer.cxx:3339
 TProofPlayer.cxx:3340
 TProofPlayer.cxx:3341
 TProofPlayer.cxx:3342
 TProofPlayer.cxx:3343
 TProofPlayer.cxx:3344
 TProofPlayer.cxx:3345
 TProofPlayer.cxx:3346
 TProofPlayer.cxx:3347
 TProofPlayer.cxx:3348
 TProofPlayer.cxx:3349
 TProofPlayer.cxx:3350
 TProofPlayer.cxx:3351
 TProofPlayer.cxx:3352
 TProofPlayer.cxx:3353
 TProofPlayer.cxx:3354
 TProofPlayer.cxx:3355
 TProofPlayer.cxx:3356
 TProofPlayer.cxx:3357
 TProofPlayer.cxx:3358
 TProofPlayer.cxx:3359
 TProofPlayer.cxx:3360
 TProofPlayer.cxx:3361
 TProofPlayer.cxx:3362
 TProofPlayer.cxx:3363
 TProofPlayer.cxx:3364
 TProofPlayer.cxx:3365
 TProofPlayer.cxx:3366
 TProofPlayer.cxx:3367
 TProofPlayer.cxx:3368
 TProofPlayer.cxx:3369
 TProofPlayer.cxx:3370
 TProofPlayer.cxx:3371
 TProofPlayer.cxx:3372
 TProofPlayer.cxx:3373
 TProofPlayer.cxx:3374
 TProofPlayer.cxx:3375
 TProofPlayer.cxx:3376
 TProofPlayer.cxx:3377
 TProofPlayer.cxx:3378
 TProofPlayer.cxx:3379
 TProofPlayer.cxx:3380
 TProofPlayer.cxx:3381
 TProofPlayer.cxx:3382
 TProofPlayer.cxx:3383
 TProofPlayer.cxx:3384
 TProofPlayer.cxx:3385
 TProofPlayer.cxx:3386
 TProofPlayer.cxx:3387
 TProofPlayer.cxx:3388
 TProofPlayer.cxx:3389
 TProofPlayer.cxx:3390
 TProofPlayer.cxx:3391
 TProofPlayer.cxx:3392
 TProofPlayer.cxx:3393
 TProofPlayer.cxx:3394
 TProofPlayer.cxx:3395
 TProofPlayer.cxx:3396
 TProofPlayer.cxx:3397
 TProofPlayer.cxx:3398
 TProofPlayer.cxx:3399
 TProofPlayer.cxx:3400
 TProofPlayer.cxx:3401
 TProofPlayer.cxx:3402
 TProofPlayer.cxx:3403
 TProofPlayer.cxx:3404
 TProofPlayer.cxx:3405
 TProofPlayer.cxx:3406
 TProofPlayer.cxx:3407
 TProofPlayer.cxx:3408
 TProofPlayer.cxx:3409
 TProofPlayer.cxx:3410
 TProofPlayer.cxx:3411
 TProofPlayer.cxx:3412
 TProofPlayer.cxx:3413
 TProofPlayer.cxx:3414
 TProofPlayer.cxx:3415
 TProofPlayer.cxx:3416
 TProofPlayer.cxx:3417
 TProofPlayer.cxx:3418
 TProofPlayer.cxx:3419
 TProofPlayer.cxx:3420
 TProofPlayer.cxx:3421
 TProofPlayer.cxx:3422
 TProofPlayer.cxx:3423
 TProofPlayer.cxx:3424
 TProofPlayer.cxx:3425
 TProofPlayer.cxx:3426
 TProofPlayer.cxx:3427
 TProofPlayer.cxx:3428
 TProofPlayer.cxx:3429
 TProofPlayer.cxx:3430
 TProofPlayer.cxx:3431
 TProofPlayer.cxx:3432
 TProofPlayer.cxx:3433
 TProofPlayer.cxx:3434
 TProofPlayer.cxx:3435
 TProofPlayer.cxx:3436
 TProofPlayer.cxx:3437
 TProofPlayer.cxx:3438
 TProofPlayer.cxx:3439
 TProofPlayer.cxx:3440
 TProofPlayer.cxx:3441
 TProofPlayer.cxx:3442
 TProofPlayer.cxx:3443
 TProofPlayer.cxx:3444
 TProofPlayer.cxx:3445
 TProofPlayer.cxx:3446
 TProofPlayer.cxx:3447
 TProofPlayer.cxx:3448
 TProofPlayer.cxx:3449
 TProofPlayer.cxx:3450
 TProofPlayer.cxx:3451
 TProofPlayer.cxx:3452
 TProofPlayer.cxx:3453
 TProofPlayer.cxx:3454
 TProofPlayer.cxx:3455
 TProofPlayer.cxx:3456
 TProofPlayer.cxx:3457
 TProofPlayer.cxx:3458
 TProofPlayer.cxx:3459
 TProofPlayer.cxx:3460
 TProofPlayer.cxx:3461
 TProofPlayer.cxx:3462
 TProofPlayer.cxx:3463
 TProofPlayer.cxx:3464
 TProofPlayer.cxx:3465
 TProofPlayer.cxx:3466
 TProofPlayer.cxx:3467
 TProofPlayer.cxx:3468
 TProofPlayer.cxx:3469
 TProofPlayer.cxx:3470
 TProofPlayer.cxx:3471
 TProofPlayer.cxx:3472
 TProofPlayer.cxx:3473
 TProofPlayer.cxx:3474
 TProofPlayer.cxx:3475
 TProofPlayer.cxx:3476
 TProofPlayer.cxx:3477
 TProofPlayer.cxx:3478
 TProofPlayer.cxx:3479
 TProofPlayer.cxx:3480
 TProofPlayer.cxx:3481
 TProofPlayer.cxx:3482
 TProofPlayer.cxx:3483
 TProofPlayer.cxx:3484
 TProofPlayer.cxx:3485
 TProofPlayer.cxx:3486
 TProofPlayer.cxx:3487
 TProofPlayer.cxx:3488
 TProofPlayer.cxx:3489
 TProofPlayer.cxx:3490
 TProofPlayer.cxx:3491
 TProofPlayer.cxx:3492
 TProofPlayer.cxx:3493
 TProofPlayer.cxx:3494
 TProofPlayer.cxx:3495
 TProofPlayer.cxx:3496
 TProofPlayer.cxx:3497
 TProofPlayer.cxx:3498
 TProofPlayer.cxx:3499
 TProofPlayer.cxx:3500
 TProofPlayer.cxx:3501
 TProofPlayer.cxx:3502
 TProofPlayer.cxx:3503
 TProofPlayer.cxx:3504
 TProofPlayer.cxx:3505
 TProofPlayer.cxx:3506
 TProofPlayer.cxx:3507
 TProofPlayer.cxx:3508
 TProofPlayer.cxx:3509
 TProofPlayer.cxx:3510
 TProofPlayer.cxx:3511
 TProofPlayer.cxx:3512
 TProofPlayer.cxx:3513
 TProofPlayer.cxx:3514
 TProofPlayer.cxx:3515
 TProofPlayer.cxx:3516
 TProofPlayer.cxx:3517
 TProofPlayer.cxx:3518
 TProofPlayer.cxx:3519
 TProofPlayer.cxx:3520
 TProofPlayer.cxx:3521
 TProofPlayer.cxx:3522
 TProofPlayer.cxx:3523
 TProofPlayer.cxx:3524
 TProofPlayer.cxx:3525
 TProofPlayer.cxx:3526
 TProofPlayer.cxx:3527
 TProofPlayer.cxx:3528
 TProofPlayer.cxx:3529
 TProofPlayer.cxx:3530
 TProofPlayer.cxx:3531
 TProofPlayer.cxx:3532
 TProofPlayer.cxx:3533
 TProofPlayer.cxx:3534
 TProofPlayer.cxx:3535
 TProofPlayer.cxx:3536
 TProofPlayer.cxx:3537
 TProofPlayer.cxx:3538
 TProofPlayer.cxx:3539
 TProofPlayer.cxx:3540
 TProofPlayer.cxx:3541
 TProofPlayer.cxx:3542
 TProofPlayer.cxx:3543
 TProofPlayer.cxx:3544
 TProofPlayer.cxx:3545
 TProofPlayer.cxx:3546
 TProofPlayer.cxx:3547
 TProofPlayer.cxx:3548
 TProofPlayer.cxx:3549
 TProofPlayer.cxx:3550
 TProofPlayer.cxx:3551
 TProofPlayer.cxx:3552
 TProofPlayer.cxx:3553
 TProofPlayer.cxx:3554
 TProofPlayer.cxx:3555
 TProofPlayer.cxx:3556
 TProofPlayer.cxx:3557
 TProofPlayer.cxx:3558
 TProofPlayer.cxx:3559
 TProofPlayer.cxx:3560
 TProofPlayer.cxx:3561
 TProofPlayer.cxx:3562
 TProofPlayer.cxx:3563
 TProofPlayer.cxx:3564
 TProofPlayer.cxx:3565
 TProofPlayer.cxx:3566
 TProofPlayer.cxx:3567
 TProofPlayer.cxx:3568
 TProofPlayer.cxx:3569
 TProofPlayer.cxx:3570
 TProofPlayer.cxx:3571
 TProofPlayer.cxx:3572
 TProofPlayer.cxx:3573
 TProofPlayer.cxx:3574
 TProofPlayer.cxx:3575
 TProofPlayer.cxx:3576
 TProofPlayer.cxx:3577
 TProofPlayer.cxx:3578
 TProofPlayer.cxx:3579
 TProofPlayer.cxx:3580
 TProofPlayer.cxx:3581
 TProofPlayer.cxx:3582
 TProofPlayer.cxx:3583
 TProofPlayer.cxx:3584
 TProofPlayer.cxx:3585
 TProofPlayer.cxx:3586
 TProofPlayer.cxx:3587
 TProofPlayer.cxx:3588
 TProofPlayer.cxx:3589
 TProofPlayer.cxx:3590
 TProofPlayer.cxx:3591
 TProofPlayer.cxx:3592
 TProofPlayer.cxx:3593
 TProofPlayer.cxx:3594
 TProofPlayer.cxx:3595
 TProofPlayer.cxx:3596
 TProofPlayer.cxx:3597
 TProofPlayer.cxx:3598
 TProofPlayer.cxx:3599
 TProofPlayer.cxx:3600
 TProofPlayer.cxx:3601
 TProofPlayer.cxx:3602
 TProofPlayer.cxx:3603
 TProofPlayer.cxx:3604
 TProofPlayer.cxx:3605
 TProofPlayer.cxx:3606
 TProofPlayer.cxx:3607
 TProofPlayer.cxx:3608
 TProofPlayer.cxx:3609
 TProofPlayer.cxx:3610
 TProofPlayer.cxx:3611
 TProofPlayer.cxx:3612
 TProofPlayer.cxx:3613
 TProofPlayer.cxx:3614
 TProofPlayer.cxx:3615
 TProofPlayer.cxx:3616
 TProofPlayer.cxx:3617
 TProofPlayer.cxx:3618
 TProofPlayer.cxx:3619
 TProofPlayer.cxx:3620
 TProofPlayer.cxx:3621
 TProofPlayer.cxx:3622
 TProofPlayer.cxx:3623
 TProofPlayer.cxx:3624
 TProofPlayer.cxx:3625
 TProofPlayer.cxx:3626
 TProofPlayer.cxx:3627
 TProofPlayer.cxx:3628
 TProofPlayer.cxx:3629
 TProofPlayer.cxx:3630
 TProofPlayer.cxx:3631
 TProofPlayer.cxx:3632
 TProofPlayer.cxx:3633
 TProofPlayer.cxx:3634
 TProofPlayer.cxx:3635
 TProofPlayer.cxx:3636
 TProofPlayer.cxx:3637
 TProofPlayer.cxx:3638
 TProofPlayer.cxx:3639
 TProofPlayer.cxx:3640
 TProofPlayer.cxx:3641
 TProofPlayer.cxx:3642
 TProofPlayer.cxx:3643
 TProofPlayer.cxx:3644
 TProofPlayer.cxx:3645
 TProofPlayer.cxx:3646
 TProofPlayer.cxx:3647
 TProofPlayer.cxx:3648
 TProofPlayer.cxx:3649
 TProofPlayer.cxx:3650
 TProofPlayer.cxx:3651
 TProofPlayer.cxx:3652
 TProofPlayer.cxx:3653
 TProofPlayer.cxx:3654
 TProofPlayer.cxx:3655
 TProofPlayer.cxx:3656
 TProofPlayer.cxx:3657
 TProofPlayer.cxx:3658
 TProofPlayer.cxx:3659
 TProofPlayer.cxx:3660
 TProofPlayer.cxx:3661
 TProofPlayer.cxx:3662
 TProofPlayer.cxx:3663
 TProofPlayer.cxx:3664
 TProofPlayer.cxx:3665
 TProofPlayer.cxx:3666
 TProofPlayer.cxx:3667
 TProofPlayer.cxx:3668
 TProofPlayer.cxx:3669
 TProofPlayer.cxx:3670
 TProofPlayer.cxx:3671
 TProofPlayer.cxx:3672
 TProofPlayer.cxx:3673
 TProofPlayer.cxx:3674
 TProofPlayer.cxx:3675
 TProofPlayer.cxx:3676
 TProofPlayer.cxx:3677
 TProofPlayer.cxx:3678
 TProofPlayer.cxx:3679
 TProofPlayer.cxx:3680
 TProofPlayer.cxx:3681
 TProofPlayer.cxx:3682
 TProofPlayer.cxx:3683
 TProofPlayer.cxx:3684
 TProofPlayer.cxx:3685
 TProofPlayer.cxx:3686
 TProofPlayer.cxx:3687
 TProofPlayer.cxx:3688
 TProofPlayer.cxx:3689
 TProofPlayer.cxx:3690
 TProofPlayer.cxx:3691
 TProofPlayer.cxx:3692
 TProofPlayer.cxx:3693
 TProofPlayer.cxx:3694
 TProofPlayer.cxx:3695
 TProofPlayer.cxx:3696
 TProofPlayer.cxx:3697
 TProofPlayer.cxx:3698
 TProofPlayer.cxx:3699
 TProofPlayer.cxx:3700
 TProofPlayer.cxx:3701
 TProofPlayer.cxx:3702
 TProofPlayer.cxx:3703
 TProofPlayer.cxx:3704
 TProofPlayer.cxx:3705
 TProofPlayer.cxx:3706
 TProofPlayer.cxx:3707
 TProofPlayer.cxx:3708
 TProofPlayer.cxx:3709
 TProofPlayer.cxx:3710
 TProofPlayer.cxx:3711
 TProofPlayer.cxx:3712
 TProofPlayer.cxx:3713
 TProofPlayer.cxx:3714
 TProofPlayer.cxx:3715
 TProofPlayer.cxx:3716
 TProofPlayer.cxx:3717
 TProofPlayer.cxx:3718
 TProofPlayer.cxx:3719
 TProofPlayer.cxx:3720
 TProofPlayer.cxx:3721
 TProofPlayer.cxx:3722
 TProofPlayer.cxx:3723
 TProofPlayer.cxx:3724
 TProofPlayer.cxx:3725
 TProofPlayer.cxx:3726
 TProofPlayer.cxx:3727
 TProofPlayer.cxx:3728
 TProofPlayer.cxx:3729
 TProofPlayer.cxx:3730
 TProofPlayer.cxx:3731
 TProofPlayer.cxx:3732
 TProofPlayer.cxx:3733
 TProofPlayer.cxx:3734
 TProofPlayer.cxx:3735
 TProofPlayer.cxx:3736
 TProofPlayer.cxx:3737
 TProofPlayer.cxx:3738
 TProofPlayer.cxx:3739
 TProofPlayer.cxx:3740
 TProofPlayer.cxx:3741
 TProofPlayer.cxx:3742
 TProofPlayer.cxx:3743
 TProofPlayer.cxx:3744
 TProofPlayer.cxx:3745
 TProofPlayer.cxx:3746
 TProofPlayer.cxx:3747
 TProofPlayer.cxx:3748
 TProofPlayer.cxx:3749
 TProofPlayer.cxx:3750
 TProofPlayer.cxx:3751
 TProofPlayer.cxx:3752
 TProofPlayer.cxx:3753
 TProofPlayer.cxx:3754
 TProofPlayer.cxx:3755
 TProofPlayer.cxx:3756
 TProofPlayer.cxx:3757
 TProofPlayer.cxx:3758
 TProofPlayer.cxx:3759
 TProofPlayer.cxx:3760
 TProofPlayer.cxx:3761
 TProofPlayer.cxx:3762
 TProofPlayer.cxx:3763
 TProofPlayer.cxx:3764
 TProofPlayer.cxx:3765
 TProofPlayer.cxx:3766
 TProofPlayer.cxx:3767
 TProofPlayer.cxx:3768
 TProofPlayer.cxx:3769
 TProofPlayer.cxx:3770
 TProofPlayer.cxx:3771
 TProofPlayer.cxx:3772
 TProofPlayer.cxx:3773
 TProofPlayer.cxx:3774
 TProofPlayer.cxx:3775
 TProofPlayer.cxx:3776
 TProofPlayer.cxx:3777
 TProofPlayer.cxx:3778
 TProofPlayer.cxx:3779
 TProofPlayer.cxx:3780
 TProofPlayer.cxx:3781
 TProofPlayer.cxx:3782
 TProofPlayer.cxx:3783
 TProofPlayer.cxx:3784
 TProofPlayer.cxx:3785
 TProofPlayer.cxx:3786
 TProofPlayer.cxx:3787
 TProofPlayer.cxx:3788
 TProofPlayer.cxx:3789
 TProofPlayer.cxx:3790
 TProofPlayer.cxx:3791
 TProofPlayer.cxx:3792
 TProofPlayer.cxx:3793
 TProofPlayer.cxx:3794
 TProofPlayer.cxx:3795
 TProofPlayer.cxx:3796
 TProofPlayer.cxx:3797
 TProofPlayer.cxx:3798
 TProofPlayer.cxx:3799
 TProofPlayer.cxx:3800
 TProofPlayer.cxx:3801
 TProofPlayer.cxx:3802
 TProofPlayer.cxx:3803
 TProofPlayer.cxx:3804
 TProofPlayer.cxx:3805
 TProofPlayer.cxx:3806
 TProofPlayer.cxx:3807
 TProofPlayer.cxx:3808
 TProofPlayer.cxx:3809
 TProofPlayer.cxx:3810
 TProofPlayer.cxx:3811
 TProofPlayer.cxx:3812
 TProofPlayer.cxx:3813
 TProofPlayer.cxx:3814
 TProofPlayer.cxx:3815
 TProofPlayer.cxx:3816
 TProofPlayer.cxx:3817
 TProofPlayer.cxx:3818
 TProofPlayer.cxx:3819
 TProofPlayer.cxx:3820
 TProofPlayer.cxx:3821
 TProofPlayer.cxx:3822
 TProofPlayer.cxx:3823
 TProofPlayer.cxx:3824
 TProofPlayer.cxx:3825
 TProofPlayer.cxx:3826
 TProofPlayer.cxx:3827
 TProofPlayer.cxx:3828
 TProofPlayer.cxx:3829
 TProofPlayer.cxx:3830
 TProofPlayer.cxx:3831
 TProofPlayer.cxx:3832
 TProofPlayer.cxx:3833
 TProofPlayer.cxx:3834
 TProofPlayer.cxx:3835
 TProofPlayer.cxx:3836
 TProofPlayer.cxx:3837
 TProofPlayer.cxx:3838
 TProofPlayer.cxx:3839
 TProofPlayer.cxx:3840
 TProofPlayer.cxx:3841
 TProofPlayer.cxx:3842
 TProofPlayer.cxx:3843
 TProofPlayer.cxx:3844
 TProofPlayer.cxx:3845
 TProofPlayer.cxx:3846
 TProofPlayer.cxx:3847
 TProofPlayer.cxx:3848
 TProofPlayer.cxx:3849
 TProofPlayer.cxx:3850
 TProofPlayer.cxx:3851
 TProofPlayer.cxx:3852
 TProofPlayer.cxx:3853
 TProofPlayer.cxx:3854
 TProofPlayer.cxx:3855
 TProofPlayer.cxx:3856
 TProofPlayer.cxx:3857
 TProofPlayer.cxx:3858
 TProofPlayer.cxx:3859
 TProofPlayer.cxx:3860
 TProofPlayer.cxx:3861
 TProofPlayer.cxx:3862
 TProofPlayer.cxx:3863
 TProofPlayer.cxx:3864
 TProofPlayer.cxx:3865
 TProofPlayer.cxx:3866
 TProofPlayer.cxx:3867
 TProofPlayer.cxx:3868
 TProofPlayer.cxx:3869
 TProofPlayer.cxx:3870
 TProofPlayer.cxx:3871
 TProofPlayer.cxx:3872
 TProofPlayer.cxx:3873
 TProofPlayer.cxx:3874
 TProofPlayer.cxx:3875
 TProofPlayer.cxx:3876
 TProofPlayer.cxx:3877
 TProofPlayer.cxx:3878
 TProofPlayer.cxx:3879
 TProofPlayer.cxx:3880
 TProofPlayer.cxx:3881
 TProofPlayer.cxx:3882
 TProofPlayer.cxx:3883
 TProofPlayer.cxx:3884
 TProofPlayer.cxx:3885
 TProofPlayer.cxx:3886
 TProofPlayer.cxx:3887
 TProofPlayer.cxx:3888
 TProofPlayer.cxx:3889
 TProofPlayer.cxx:3890
 TProofPlayer.cxx:3891
 TProofPlayer.cxx:3892
 TProofPlayer.cxx:3893
 TProofPlayer.cxx:3894
 TProofPlayer.cxx:3895
 TProofPlayer.cxx:3896
 TProofPlayer.cxx:3897
 TProofPlayer.cxx:3898
 TProofPlayer.cxx:3899
 TProofPlayer.cxx:3900
 TProofPlayer.cxx:3901
 TProofPlayer.cxx:3902
 TProofPlayer.cxx:3903
 TProofPlayer.cxx:3904
 TProofPlayer.cxx:3905
 TProofPlayer.cxx:3906
 TProofPlayer.cxx:3907
 TProofPlayer.cxx:3908
 TProofPlayer.cxx:3909
 TProofPlayer.cxx:3910
 TProofPlayer.cxx:3911
 TProofPlayer.cxx:3912
 TProofPlayer.cxx:3913
 TProofPlayer.cxx:3914
 TProofPlayer.cxx:3915
 TProofPlayer.cxx:3916
 TProofPlayer.cxx:3917
 TProofPlayer.cxx:3918
 TProofPlayer.cxx:3919
 TProofPlayer.cxx:3920
 TProofPlayer.cxx:3921
 TProofPlayer.cxx:3922
 TProofPlayer.cxx:3923
 TProofPlayer.cxx:3924
 TProofPlayer.cxx:3925
 TProofPlayer.cxx:3926
 TProofPlayer.cxx:3927
 TProofPlayer.cxx:3928
 TProofPlayer.cxx:3929
 TProofPlayer.cxx:3930
 TProofPlayer.cxx:3931
 TProofPlayer.cxx:3932
 TProofPlayer.cxx:3933
 TProofPlayer.cxx:3934
 TProofPlayer.cxx:3935
 TProofPlayer.cxx:3936
 TProofPlayer.cxx:3937
 TProofPlayer.cxx:3938
 TProofPlayer.cxx:3939
 TProofPlayer.cxx:3940
 TProofPlayer.cxx:3941
 TProofPlayer.cxx:3942
 TProofPlayer.cxx:3943
 TProofPlayer.cxx:3944
 TProofPlayer.cxx:3945
 TProofPlayer.cxx:3946
 TProofPlayer.cxx:3947
 TProofPlayer.cxx:3948
 TProofPlayer.cxx:3949
 TProofPlayer.cxx:3950
 TProofPlayer.cxx:3951
 TProofPlayer.cxx:3952
 TProofPlayer.cxx:3953
 TProofPlayer.cxx:3954
 TProofPlayer.cxx:3955
 TProofPlayer.cxx:3956
 TProofPlayer.cxx:3957
 TProofPlayer.cxx:3958
 TProofPlayer.cxx:3959
 TProofPlayer.cxx:3960
 TProofPlayer.cxx:3961
 TProofPlayer.cxx:3962
 TProofPlayer.cxx:3963
 TProofPlayer.cxx:3964
 TProofPlayer.cxx:3965
 TProofPlayer.cxx:3966
 TProofPlayer.cxx:3967
 TProofPlayer.cxx:3968
 TProofPlayer.cxx:3969
 TProofPlayer.cxx:3970
 TProofPlayer.cxx:3971
 TProofPlayer.cxx:3972
 TProofPlayer.cxx:3973
 TProofPlayer.cxx:3974
 TProofPlayer.cxx:3975
 TProofPlayer.cxx:3976
 TProofPlayer.cxx:3977
 TProofPlayer.cxx:3978
 TProofPlayer.cxx:3979
 TProofPlayer.cxx:3980
 TProofPlayer.cxx:3981
 TProofPlayer.cxx:3982
 TProofPlayer.cxx:3983
 TProofPlayer.cxx:3984
 TProofPlayer.cxx:3985
 TProofPlayer.cxx:3986
 TProofPlayer.cxx:3987
 TProofPlayer.cxx:3988
 TProofPlayer.cxx:3989
 TProofPlayer.cxx:3990
 TProofPlayer.cxx:3991
 TProofPlayer.cxx:3992
 TProofPlayer.cxx:3993
 TProofPlayer.cxx:3994
 TProofPlayer.cxx:3995
 TProofPlayer.cxx:3996
 TProofPlayer.cxx:3997
 TProofPlayer.cxx:3998
 TProofPlayer.cxx:3999
 TProofPlayer.cxx:4000
 TProofPlayer.cxx:4001
 TProofPlayer.cxx:4002
 TProofPlayer.cxx:4003
 TProofPlayer.cxx:4004
 TProofPlayer.cxx:4005
 TProofPlayer.cxx:4006
 TProofPlayer.cxx:4007
 TProofPlayer.cxx:4008
 TProofPlayer.cxx:4009
 TProofPlayer.cxx:4010
 TProofPlayer.cxx:4011
 TProofPlayer.cxx:4012
 TProofPlayer.cxx:4013
 TProofPlayer.cxx:4014
 TProofPlayer.cxx:4015
 TProofPlayer.cxx:4016
 TProofPlayer.cxx:4017
 TProofPlayer.cxx:4018
 TProofPlayer.cxx:4019
 TProofPlayer.cxx:4020
 TProofPlayer.cxx:4021
 TProofPlayer.cxx:4022
 TProofPlayer.cxx:4023
 TProofPlayer.cxx:4024
 TProofPlayer.cxx:4025
 TProofPlayer.cxx:4026
 TProofPlayer.cxx:4027
 TProofPlayer.cxx:4028
 TProofPlayer.cxx:4029
 TProofPlayer.cxx:4030
 TProofPlayer.cxx:4031
 TProofPlayer.cxx:4032
 TProofPlayer.cxx:4033
 TProofPlayer.cxx:4034
 TProofPlayer.cxx:4035
 TProofPlayer.cxx:4036
 TProofPlayer.cxx:4037
 TProofPlayer.cxx:4038
 TProofPlayer.cxx:4039
 TProofPlayer.cxx:4040
 TProofPlayer.cxx:4041
 TProofPlayer.cxx:4042
 TProofPlayer.cxx:4043
 TProofPlayer.cxx:4044
 TProofPlayer.cxx:4045
 TProofPlayer.cxx:4046
 TProofPlayer.cxx:4047
 TProofPlayer.cxx:4048
 TProofPlayer.cxx:4049
 TProofPlayer.cxx:4050
 TProofPlayer.cxx:4051
 TProofPlayer.cxx:4052
 TProofPlayer.cxx:4053
 TProofPlayer.cxx:4054
 TProofPlayer.cxx:4055
 TProofPlayer.cxx:4056
 TProofPlayer.cxx:4057
 TProofPlayer.cxx:4058
 TProofPlayer.cxx:4059
 TProofPlayer.cxx:4060
 TProofPlayer.cxx:4061
 TProofPlayer.cxx:4062
 TProofPlayer.cxx:4063
 TProofPlayer.cxx:4064
 TProofPlayer.cxx:4065
 TProofPlayer.cxx:4066
 TProofPlayer.cxx:4067
 TProofPlayer.cxx:4068
 TProofPlayer.cxx:4069
 TProofPlayer.cxx:4070
 TProofPlayer.cxx:4071
 TProofPlayer.cxx:4072
 TProofPlayer.cxx:4073
 TProofPlayer.cxx:4074
 TProofPlayer.cxx:4075
 TProofPlayer.cxx:4076
 TProofPlayer.cxx:4077
 TProofPlayer.cxx:4078
 TProofPlayer.cxx:4079
 TProofPlayer.cxx:4080
 TProofPlayer.cxx:4081
 TProofPlayer.cxx:4082
 TProofPlayer.cxx:4083
 TProofPlayer.cxx:4084
 TProofPlayer.cxx:4085
 TProofPlayer.cxx:4086
 TProofPlayer.cxx:4087
 TProofPlayer.cxx:4088
 TProofPlayer.cxx:4089
 TProofPlayer.cxx:4090
 TProofPlayer.cxx:4091
 TProofPlayer.cxx:4092
 TProofPlayer.cxx:4093
 TProofPlayer.cxx:4094
 TProofPlayer.cxx:4095
 TProofPlayer.cxx:4096
 TProofPlayer.cxx:4097
 TProofPlayer.cxx:4098
 TProofPlayer.cxx:4099
 TProofPlayer.cxx:4100
 TProofPlayer.cxx:4101
 TProofPlayer.cxx:4102
 TProofPlayer.cxx:4103
 TProofPlayer.cxx:4104
 TProofPlayer.cxx:4105
 TProofPlayer.cxx:4106
 TProofPlayer.cxx:4107
 TProofPlayer.cxx:4108
 TProofPlayer.cxx:4109
 TProofPlayer.cxx:4110
 TProofPlayer.cxx:4111
 TProofPlayer.cxx:4112
 TProofPlayer.cxx:4113
 TProofPlayer.cxx:4114
 TProofPlayer.cxx:4115
 TProofPlayer.cxx:4116
 TProofPlayer.cxx:4117
 TProofPlayer.cxx:4118
 TProofPlayer.cxx:4119
 TProofPlayer.cxx:4120
 TProofPlayer.cxx:4121
 TProofPlayer.cxx:4122
 TProofPlayer.cxx:4123
 TProofPlayer.cxx:4124
 TProofPlayer.cxx:4125
 TProofPlayer.cxx:4126
 TProofPlayer.cxx:4127
 TProofPlayer.cxx:4128
 TProofPlayer.cxx:4129
 TProofPlayer.cxx:4130
 TProofPlayer.cxx:4131
 TProofPlayer.cxx:4132
 TProofPlayer.cxx:4133
 TProofPlayer.cxx:4134
 TProofPlayer.cxx:4135
 TProofPlayer.cxx:4136
 TProofPlayer.cxx:4137
 TProofPlayer.cxx:4138
 TProofPlayer.cxx:4139
 TProofPlayer.cxx:4140
 TProofPlayer.cxx:4141
 TProofPlayer.cxx:4142
 TProofPlayer.cxx:4143
 TProofPlayer.cxx:4144
 TProofPlayer.cxx:4145
 TProofPlayer.cxx:4146
 TProofPlayer.cxx:4147
 TProofPlayer.cxx:4148
 TProofPlayer.cxx:4149
 TProofPlayer.cxx:4150
 TProofPlayer.cxx:4151
 TProofPlayer.cxx:4152
 TProofPlayer.cxx:4153
 TProofPlayer.cxx:4154
 TProofPlayer.cxx:4155
 TProofPlayer.cxx:4156
 TProofPlayer.cxx:4157
 TProofPlayer.cxx:4158
 TProofPlayer.cxx:4159
 TProofPlayer.cxx:4160
 TProofPlayer.cxx:4161
 TProofPlayer.cxx:4162
 TProofPlayer.cxx:4163
 TProofPlayer.cxx:4164
 TProofPlayer.cxx:4165
 TProofPlayer.cxx:4166
 TProofPlayer.cxx:4167
 TProofPlayer.cxx:4168
 TProofPlayer.cxx:4169
 TProofPlayer.cxx:4170
 TProofPlayer.cxx:4171
 TProofPlayer.cxx:4172
 TProofPlayer.cxx:4173
 TProofPlayer.cxx:4174
 TProofPlayer.cxx:4175
 TProofPlayer.cxx:4176
 TProofPlayer.cxx:4177
 TProofPlayer.cxx:4178
 TProofPlayer.cxx:4179
 TProofPlayer.cxx:4180
 TProofPlayer.cxx:4181
 TProofPlayer.cxx:4182
 TProofPlayer.cxx:4183
 TProofPlayer.cxx:4184
 TProofPlayer.cxx:4185
 TProofPlayer.cxx:4186
 TProofPlayer.cxx:4187
 TProofPlayer.cxx:4188
 TProofPlayer.cxx:4189
 TProofPlayer.cxx:4190
 TProofPlayer.cxx:4191
 TProofPlayer.cxx:4192
 TProofPlayer.cxx:4193
 TProofPlayer.cxx:4194
 TProofPlayer.cxx:4195
 TProofPlayer.cxx:4196
 TProofPlayer.cxx:4197
 TProofPlayer.cxx:4198
 TProofPlayer.cxx:4199
 TProofPlayer.cxx:4200
 TProofPlayer.cxx:4201
 TProofPlayer.cxx:4202
 TProofPlayer.cxx:4203
 TProofPlayer.cxx:4204
 TProofPlayer.cxx:4205
 TProofPlayer.cxx:4206
 TProofPlayer.cxx:4207
 TProofPlayer.cxx:4208
 TProofPlayer.cxx:4209
 TProofPlayer.cxx:4210
 TProofPlayer.cxx:4211
 TProofPlayer.cxx:4212
 TProofPlayer.cxx:4213
 TProofPlayer.cxx:4214
 TProofPlayer.cxx:4215
 TProofPlayer.cxx:4216
 TProofPlayer.cxx:4217
 TProofPlayer.cxx:4218
 TProofPlayer.cxx:4219
 TProofPlayer.cxx:4220
 TProofPlayer.cxx:4221
 TProofPlayer.cxx:4222
 TProofPlayer.cxx:4223
 TProofPlayer.cxx:4224
 TProofPlayer.cxx:4225
 TProofPlayer.cxx:4226
 TProofPlayer.cxx:4227
 TProofPlayer.cxx:4228
 TProofPlayer.cxx:4229
 TProofPlayer.cxx:4230
 TProofPlayer.cxx:4231
 TProofPlayer.cxx:4232
 TProofPlayer.cxx:4233
 TProofPlayer.cxx:4234
 TProofPlayer.cxx:4235
 TProofPlayer.cxx:4236
 TProofPlayer.cxx:4237
 TProofPlayer.cxx:4238
 TProofPlayer.cxx:4239
 TProofPlayer.cxx:4240
 TProofPlayer.cxx:4241
 TProofPlayer.cxx:4242
 TProofPlayer.cxx:4243
 TProofPlayer.cxx:4244
 TProofPlayer.cxx:4245
 TProofPlayer.cxx:4246
 TProofPlayer.cxx:4247
 TProofPlayer.cxx:4248
 TProofPlayer.cxx:4249
 TProofPlayer.cxx:4250
 TProofPlayer.cxx:4251
 TProofPlayer.cxx:4252
 TProofPlayer.cxx:4253
 TProofPlayer.cxx:4254
 TProofPlayer.cxx:4255
 TProofPlayer.cxx:4256
 TProofPlayer.cxx:4257
 TProofPlayer.cxx:4258
 TProofPlayer.cxx:4259
 TProofPlayer.cxx:4260
 TProofPlayer.cxx:4261
 TProofPlayer.cxx:4262
 TProofPlayer.cxx:4263
 TProofPlayer.cxx:4264
 TProofPlayer.cxx:4265
 TProofPlayer.cxx:4266
 TProofPlayer.cxx:4267
 TProofPlayer.cxx:4268
 TProofPlayer.cxx:4269
 TProofPlayer.cxx:4270
 TProofPlayer.cxx:4271
 TProofPlayer.cxx:4272
 TProofPlayer.cxx:4273
 TProofPlayer.cxx:4274
 TProofPlayer.cxx:4275
 TProofPlayer.cxx:4276
 TProofPlayer.cxx:4277
 TProofPlayer.cxx:4278
 TProofPlayer.cxx:4279
 TProofPlayer.cxx:4280
 TProofPlayer.cxx:4281
 TProofPlayer.cxx:4282
 TProofPlayer.cxx:4283
 TProofPlayer.cxx:4284
 TProofPlayer.cxx:4285
 TProofPlayer.cxx:4286
 TProofPlayer.cxx:4287
 TProofPlayer.cxx:4288
 TProofPlayer.cxx:4289
 TProofPlayer.cxx:4290
 TProofPlayer.cxx:4291
 TProofPlayer.cxx:4292
 TProofPlayer.cxx:4293
 TProofPlayer.cxx:4294
 TProofPlayer.cxx:4295
 TProofPlayer.cxx:4296
 TProofPlayer.cxx:4297
 TProofPlayer.cxx:4298
 TProofPlayer.cxx:4299
 TProofPlayer.cxx:4300
 TProofPlayer.cxx:4301
 TProofPlayer.cxx:4302
 TProofPlayer.cxx:4303
 TProofPlayer.cxx:4304
 TProofPlayer.cxx:4305
 TProofPlayer.cxx:4306
 TProofPlayer.cxx:4307
 TProofPlayer.cxx:4308
 TProofPlayer.cxx:4309
 TProofPlayer.cxx:4310
 TProofPlayer.cxx:4311
 TProofPlayer.cxx:4312
 TProofPlayer.cxx:4313
 TProofPlayer.cxx:4314
 TProofPlayer.cxx:4315
 TProofPlayer.cxx:4316
 TProofPlayer.cxx:4317
 TProofPlayer.cxx:4318
 TProofPlayer.cxx:4319
 TProofPlayer.cxx:4320
 TProofPlayer.cxx:4321
 TProofPlayer.cxx:4322
 TProofPlayer.cxx:4323
 TProofPlayer.cxx:4324
 TProofPlayer.cxx:4325
 TProofPlayer.cxx:4326
 TProofPlayer.cxx:4327
 TProofPlayer.cxx:4328
 TProofPlayer.cxx:4329
 TProofPlayer.cxx:4330
 TProofPlayer.cxx:4331
 TProofPlayer.cxx:4332
 TProofPlayer.cxx:4333
 TProofPlayer.cxx:4334
 TProofPlayer.cxx:4335
 TProofPlayer.cxx:4336
 TProofPlayer.cxx:4337
 TProofPlayer.cxx:4338
 TProofPlayer.cxx:4339
 TProofPlayer.cxx:4340
 TProofPlayer.cxx:4341
 TProofPlayer.cxx:4342
 TProofPlayer.cxx:4343
 TProofPlayer.cxx:4344
 TProofPlayer.cxx:4345
 TProofPlayer.cxx:4346
 TProofPlayer.cxx:4347
 TProofPlayer.cxx:4348
 TProofPlayer.cxx:4349
 TProofPlayer.cxx:4350
 TProofPlayer.cxx:4351
 TProofPlayer.cxx:4352
 TProofPlayer.cxx:4353
 TProofPlayer.cxx:4354
 TProofPlayer.cxx:4355
 TProofPlayer.cxx:4356
 TProofPlayer.cxx:4357
 TProofPlayer.cxx:4358
 TProofPlayer.cxx:4359
 TProofPlayer.cxx:4360
 TProofPlayer.cxx:4361
 TProofPlayer.cxx:4362
 TProofPlayer.cxx:4363
 TProofPlayer.cxx:4364
 TProofPlayer.cxx:4365
 TProofPlayer.cxx:4366
 TProofPlayer.cxx:4367
 TProofPlayer.cxx:4368
 TProofPlayer.cxx:4369
 TProofPlayer.cxx:4370
 TProofPlayer.cxx:4371
 TProofPlayer.cxx:4372
 TProofPlayer.cxx:4373
 TProofPlayer.cxx:4374
 TProofPlayer.cxx:4375
 TProofPlayer.cxx:4376
 TProofPlayer.cxx:4377
 TProofPlayer.cxx:4378
 TProofPlayer.cxx:4379
 TProofPlayer.cxx:4380
 TProofPlayer.cxx:4381
 TProofPlayer.cxx:4382
 TProofPlayer.cxx:4383
 TProofPlayer.cxx:4384
 TProofPlayer.cxx:4385
 TProofPlayer.cxx:4386
 TProofPlayer.cxx:4387
 TProofPlayer.cxx:4388
 TProofPlayer.cxx:4389
 TProofPlayer.cxx:4390
 TProofPlayer.cxx:4391
 TProofPlayer.cxx:4392
 TProofPlayer.cxx:4393
 TProofPlayer.cxx:4394
 TProofPlayer.cxx:4395
 TProofPlayer.cxx:4396
 TProofPlayer.cxx:4397
 TProofPlayer.cxx:4398
 TProofPlayer.cxx:4399
 TProofPlayer.cxx:4400
 TProofPlayer.cxx:4401
 TProofPlayer.cxx:4402
 TProofPlayer.cxx:4403
 TProofPlayer.cxx:4404
 TProofPlayer.cxx:4405
 TProofPlayer.cxx:4406
 TProofPlayer.cxx:4407
 TProofPlayer.cxx:4408
 TProofPlayer.cxx:4409
 TProofPlayer.cxx:4410
 TProofPlayer.cxx:4411
 TProofPlayer.cxx:4412
 TProofPlayer.cxx:4413
 TProofPlayer.cxx:4414
 TProofPlayer.cxx:4415
 TProofPlayer.cxx:4416
 TProofPlayer.cxx:4417
 TProofPlayer.cxx:4418
 TProofPlayer.cxx:4419
 TProofPlayer.cxx:4420
 TProofPlayer.cxx:4421
 TProofPlayer.cxx:4422
 TProofPlayer.cxx:4423
 TProofPlayer.cxx:4424
 TProofPlayer.cxx:4425
 TProofPlayer.cxx:4426
 TProofPlayer.cxx:4427
 TProofPlayer.cxx:4428
 TProofPlayer.cxx:4429
 TProofPlayer.cxx:4430
 TProofPlayer.cxx:4431
 TProofPlayer.cxx:4432
 TProofPlayer.cxx:4433
 TProofPlayer.cxx:4434
 TProofPlayer.cxx:4435
 TProofPlayer.cxx:4436
 TProofPlayer.cxx:4437
 TProofPlayer.cxx:4438
 TProofPlayer.cxx:4439
 TProofPlayer.cxx:4440
 TProofPlayer.cxx:4441
 TProofPlayer.cxx:4442
 TProofPlayer.cxx:4443
 TProofPlayer.cxx:4444
 TProofPlayer.cxx:4445
 TProofPlayer.cxx:4446
 TProofPlayer.cxx:4447
 TProofPlayer.cxx:4448
 TProofPlayer.cxx:4449
 TProofPlayer.cxx:4450
 TProofPlayer.cxx:4451
 TProofPlayer.cxx:4452
 TProofPlayer.cxx:4453
 TProofPlayer.cxx:4454
 TProofPlayer.cxx:4455
 TProofPlayer.cxx:4456
 TProofPlayer.cxx:4457
 TProofPlayer.cxx:4458
 TProofPlayer.cxx:4459
 TProofPlayer.cxx:4460
 TProofPlayer.cxx:4461
 TProofPlayer.cxx:4462
 TProofPlayer.cxx:4463
 TProofPlayer.cxx:4464
 TProofPlayer.cxx:4465
 TProofPlayer.cxx:4466
 TProofPlayer.cxx:4467
 TProofPlayer.cxx:4468
 TProofPlayer.cxx:4469
 TProofPlayer.cxx:4470
 TProofPlayer.cxx:4471
 TProofPlayer.cxx:4472
 TProofPlayer.cxx:4473
 TProofPlayer.cxx:4474
 TProofPlayer.cxx:4475
 TProofPlayer.cxx:4476
 TProofPlayer.cxx:4477
 TProofPlayer.cxx:4478
 TProofPlayer.cxx:4479
 TProofPlayer.cxx:4480
 TProofPlayer.cxx:4481
 TProofPlayer.cxx:4482
 TProofPlayer.cxx:4483
 TProofPlayer.cxx:4484
 TProofPlayer.cxx:4485
 TProofPlayer.cxx:4486
 TProofPlayer.cxx:4487
 TProofPlayer.cxx:4488
 TProofPlayer.cxx:4489
 TProofPlayer.cxx:4490
 TProofPlayer.cxx:4491
 TProofPlayer.cxx:4492
 TProofPlayer.cxx:4493
 TProofPlayer.cxx:4494
 TProofPlayer.cxx:4495
 TProofPlayer.cxx:4496
 TProofPlayer.cxx:4497
 TProofPlayer.cxx:4498
 TProofPlayer.cxx:4499
 TProofPlayer.cxx:4500
 TProofPlayer.cxx:4501
 TProofPlayer.cxx:4502
 TProofPlayer.cxx:4503
 TProofPlayer.cxx:4504
 TProofPlayer.cxx:4505
 TProofPlayer.cxx:4506
 TProofPlayer.cxx:4507
 TProofPlayer.cxx:4508
 TProofPlayer.cxx:4509
 TProofPlayer.cxx:4510
 TProofPlayer.cxx:4511
 TProofPlayer.cxx:4512
 TProofPlayer.cxx:4513
 TProofPlayer.cxx:4514
 TProofPlayer.cxx:4515
 TProofPlayer.cxx:4516
 TProofPlayer.cxx:4517
 TProofPlayer.cxx:4518
 TProofPlayer.cxx:4519
 TProofPlayer.cxx:4520
 TProofPlayer.cxx:4521
 TProofPlayer.cxx:4522
 TProofPlayer.cxx:4523
 TProofPlayer.cxx:4524
 TProofPlayer.cxx:4525
 TProofPlayer.cxx:4526
 TProofPlayer.cxx:4527
 TProofPlayer.cxx:4528
 TProofPlayer.cxx:4529
 TProofPlayer.cxx:4530
 TProofPlayer.cxx:4531
 TProofPlayer.cxx:4532
 TProofPlayer.cxx:4533
 TProofPlayer.cxx:4534
 TProofPlayer.cxx:4535
 TProofPlayer.cxx:4536
 TProofPlayer.cxx:4537
 TProofPlayer.cxx:4538
 TProofPlayer.cxx:4539
 TProofPlayer.cxx:4540
 TProofPlayer.cxx:4541
 TProofPlayer.cxx:4542
 TProofPlayer.cxx:4543
 TProofPlayer.cxx:4544
 TProofPlayer.cxx:4545
 TProofPlayer.cxx:4546
 TProofPlayer.cxx:4547
 TProofPlayer.cxx:4548
 TProofPlayer.cxx:4549
 TProofPlayer.cxx:4550
 TProofPlayer.cxx:4551
 TProofPlayer.cxx:4552
 TProofPlayer.cxx:4553
 TProofPlayer.cxx:4554
 TProofPlayer.cxx:4555
 TProofPlayer.cxx:4556
 TProofPlayer.cxx:4557
 TProofPlayer.cxx:4558
 TProofPlayer.cxx:4559
 TProofPlayer.cxx:4560
 TProofPlayer.cxx:4561
 TProofPlayer.cxx:4562
 TProofPlayer.cxx:4563
 TProofPlayer.cxx:4564
 TProofPlayer.cxx:4565
 TProofPlayer.cxx:4566
 TProofPlayer.cxx:4567
 TProofPlayer.cxx:4568
 TProofPlayer.cxx:4569
 TProofPlayer.cxx:4570
 TProofPlayer.cxx:4571
 TProofPlayer.cxx:4572
 TProofPlayer.cxx:4573
 TProofPlayer.cxx:4574
 TProofPlayer.cxx:4575
 TProofPlayer.cxx:4576
 TProofPlayer.cxx:4577
 TProofPlayer.cxx:4578
 TProofPlayer.cxx:4579
 TProofPlayer.cxx:4580
 TProofPlayer.cxx:4581
 TProofPlayer.cxx:4582
 TProofPlayer.cxx:4583
 TProofPlayer.cxx:4584
 TProofPlayer.cxx:4585
 TProofPlayer.cxx:4586
 TProofPlayer.cxx:4587
 TProofPlayer.cxx:4588
 TProofPlayer.cxx:4589
 TProofPlayer.cxx:4590
 TProofPlayer.cxx:4591
 TProofPlayer.cxx:4592
 TProofPlayer.cxx:4593
 TProofPlayer.cxx:4594
 TProofPlayer.cxx:4595
 TProofPlayer.cxx:4596
 TProofPlayer.cxx:4597
 TProofPlayer.cxx:4598
 TProofPlayer.cxx:4599
 TProofPlayer.cxx:4600
 TProofPlayer.cxx:4601
 TProofPlayer.cxx:4602
 TProofPlayer.cxx:4603
 TProofPlayer.cxx:4604
 TProofPlayer.cxx:4605
 TProofPlayer.cxx:4606
 TProofPlayer.cxx:4607
 TProofPlayer.cxx:4608
 TProofPlayer.cxx:4609
 TProofPlayer.cxx:4610
 TProofPlayer.cxx:4611
 TProofPlayer.cxx:4612
 TProofPlayer.cxx:4613
 TProofPlayer.cxx:4614
 TProofPlayer.cxx:4615
 TProofPlayer.cxx:4616
 TProofPlayer.cxx:4617
 TProofPlayer.cxx:4618
 TProofPlayer.cxx:4619
 TProofPlayer.cxx:4620
 TProofPlayer.cxx:4621
 TProofPlayer.cxx:4622
 TProofPlayer.cxx:4623
 TProofPlayer.cxx:4624
 TProofPlayer.cxx:4625
 TProofPlayer.cxx:4626
 TProofPlayer.cxx:4627
 TProofPlayer.cxx:4628
 TProofPlayer.cxx:4629
 TProofPlayer.cxx:4630
 TProofPlayer.cxx:4631
 TProofPlayer.cxx:4632
 TProofPlayer.cxx:4633
 TProofPlayer.cxx:4634
 TProofPlayer.cxx:4635
 TProofPlayer.cxx:4636
 TProofPlayer.cxx:4637
 TProofPlayer.cxx:4638
 TProofPlayer.cxx:4639
 TProofPlayer.cxx:4640
 TProofPlayer.cxx:4641
 TProofPlayer.cxx:4642
 TProofPlayer.cxx:4643
 TProofPlayer.cxx:4644
 TProofPlayer.cxx:4645
 TProofPlayer.cxx:4646
 TProofPlayer.cxx:4647
 TProofPlayer.cxx:4648
 TProofPlayer.cxx:4649
 TProofPlayer.cxx:4650
 TProofPlayer.cxx:4651
 TProofPlayer.cxx:4652
 TProofPlayer.cxx:4653
 TProofPlayer.cxx:4654
 TProofPlayer.cxx:4655
 TProofPlayer.cxx:4656
 TProofPlayer.cxx:4657
 TProofPlayer.cxx:4658
 TProofPlayer.cxx:4659
 TProofPlayer.cxx:4660
 TProofPlayer.cxx:4661
 TProofPlayer.cxx:4662
 TProofPlayer.cxx:4663
 TProofPlayer.cxx:4664
 TProofPlayer.cxx:4665
 TProofPlayer.cxx:4666
 TProofPlayer.cxx:4667
 TProofPlayer.cxx:4668
 TProofPlayer.cxx:4669
 TProofPlayer.cxx:4670
 TProofPlayer.cxx:4671
 TProofPlayer.cxx:4672
 TProofPlayer.cxx:4673
 TProofPlayer.cxx:4674
 TProofPlayer.cxx:4675
 TProofPlayer.cxx:4676
 TProofPlayer.cxx:4677
 TProofPlayer.cxx:4678
 TProofPlayer.cxx:4679
 TProofPlayer.cxx:4680
 TProofPlayer.cxx:4681
 TProofPlayer.cxx:4682
 TProofPlayer.cxx:4683
 TProofPlayer.cxx:4684
 TProofPlayer.cxx:4685
 TProofPlayer.cxx:4686
 TProofPlayer.cxx:4687
 TProofPlayer.cxx:4688
 TProofPlayer.cxx:4689
 TProofPlayer.cxx:4690
 TProofPlayer.cxx:4691
 TProofPlayer.cxx:4692
 TProofPlayer.cxx:4693
 TProofPlayer.cxx:4694
 TProofPlayer.cxx:4695
 TProofPlayer.cxx:4696
 TProofPlayer.cxx:4697
 TProofPlayer.cxx:4698
 TProofPlayer.cxx:4699
 TProofPlayer.cxx:4700
 TProofPlayer.cxx:4701
 TProofPlayer.cxx:4702
 TProofPlayer.cxx:4703
 TProofPlayer.cxx:4704
 TProofPlayer.cxx:4705
 TProofPlayer.cxx:4706
 TProofPlayer.cxx:4707
 TProofPlayer.cxx:4708
 TProofPlayer.cxx:4709
 TProofPlayer.cxx:4710
 TProofPlayer.cxx:4711
 TProofPlayer.cxx:4712
 TProofPlayer.cxx:4713
 TProofPlayer.cxx:4714
 TProofPlayer.cxx:4715
 TProofPlayer.cxx:4716
 TProofPlayer.cxx:4717
 TProofPlayer.cxx:4718
 TProofPlayer.cxx:4719
 TProofPlayer.cxx:4720
 TProofPlayer.cxx:4721
 TProofPlayer.cxx:4722
 TProofPlayer.cxx:4723
 TProofPlayer.cxx:4724
 TProofPlayer.cxx:4725
 TProofPlayer.cxx:4726
 TProofPlayer.cxx:4727
 TProofPlayer.cxx:4728
 TProofPlayer.cxx:4729
 TProofPlayer.cxx:4730
 TProofPlayer.cxx:4731
 TProofPlayer.cxx:4732
 TProofPlayer.cxx:4733
 TProofPlayer.cxx:4734
 TProofPlayer.cxx:4735
 TProofPlayer.cxx:4736
 TProofPlayer.cxx:4737
 TProofPlayer.cxx:4738
 TProofPlayer.cxx:4739
 TProofPlayer.cxx:4740
 TProofPlayer.cxx:4741
 TProofPlayer.cxx:4742
 TProofPlayer.cxx:4743
 TProofPlayer.cxx:4744
 TProofPlayer.cxx:4745
 TProofPlayer.cxx:4746
 TProofPlayer.cxx:4747
 TProofPlayer.cxx:4748
 TProofPlayer.cxx:4749
 TProofPlayer.cxx:4750
 TProofPlayer.cxx:4751
 TProofPlayer.cxx:4752
 TProofPlayer.cxx:4753