ROOT logo
// @(#)root/proofplayer:$Id: TProofPlayer.cxx 40699 2011-08-25 10:36:29Z rdm $
// 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 "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"

// 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)
      Info ("Notify","called!");

   fPlayer->SetBit(TProofPlayer::kDispatchOneEvent);

   // Needed for the next shot
   Reset();
   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)
      Info ("Notify","called!");

   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), fSelectorClass(0),
     fFeedbackTimer(0), fFeedbackPeriod(2000),
     fEvIter(0), fSelStatus(0),
     fTotalEvents(0), fQueryResults(0), fQuery(0), fDrawQueries(0),
     fMaxDrawQueries(1), fStopTimer(0), fStopTimerMtx(0), fDispatchTimer(0)
{
   // Default ctor.

   fInput         = new TList;
   fExitStatus    = kFinished;
   fProgressStatus = new TProofProgressStatus();
   SetProcessing(kFALSE);

   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(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;
}

//______________________________________________________________________________
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);

   SafeDelete(fSelector);
   fSelectorClass = 0;
   Int_t version = -1;
   TRY {
      // Get selector files from cache
      if (gProofServ) {
         gProofServ->GetCacheLock()->Lock();
         gProofServ->CopyFromCache(selector_file, 1);
      }

      if (!(fSelector = TSelector::GetSelector(selector_file))) {
         Error("Process", "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();
      }

      fSelectorClass = fSelector->IsA();
      version = fSelector->Version();

      fOutput = 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);

      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->IsOk()) {
            PDB(kLoop,1) Info("Process","Call SlaveBegin(0)");
            fSelector->SlaveBegin(0);  // Init is called explicitly
                                       // from GetNextEvent()
         }
      }

   } CATCH(excode) {
      SetProcessing(kFALSE);
      Error("Process","exception %d caught", excode);
      gProofServ->GetCacheLock()->Unlock();
      return -1;
   } ENDTRY;

   // 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
   Long64_t readbytesatstart = TFile::GetFileBytesRead();
   Long64_t readcallsatstart = TFile::GetFileReadCalls();
   // 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 {

      // Get the frequency for checking memory consumption and logging information
      TParameter<Long64_t> *par = (TParameter<Long64_t>*)fInput->FindObject("PROOF_MemLogFreq");
      Long64_t singleshot = 1, memlogfreq = (par) ? par->GetVal() : 100;
      Bool_t warnHWMres = kTRUE, warnHWMvir = kTRUE;
      TString lastMsg, wmsg;

      // 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;
         SetProcessing(kFALSE);
      } else if (!wmsg.IsNull()) {
         Warning("Process", "%s", wmsg.Data());
      }

      TPair *currentElem = 0;
      // The event loop on the worker
      while ((entry = fEvIter->GetNextEvent()) >= 0 && fSelStatus->IsOk() &&
              fSelector->GetAbort() == TSelector::kContinue) {

         // This is needed by the inflate infrastructure to calculate
         // sleeping times
         SetProcessing(kTRUE);

         // Give the possibility to the selector to access additional info in the
         // incoming packet
         lastMsg = "(unfortunately no detailed info is available about current 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->TestBit(TDSet::kEmpty)) {
               lastMsg.Form("while processing cycle:%lld - check logs for possible stacktrace", entry);
            } else {
               TDSetElement *elem = dynamic_cast<TDSetElement *>(currentElem->Value());
               TString fn = (elem) ? elem->GetFileName() : "<undef>";
               lastMsg.Form("while processing dset:'%s', file:'%s', event:%lld"
                            " - check logs for possible stacktrace", dset->GetName(), fn.Data(), entry);
            }
         }
         // This will be sent to clients in case of exceptions ...
         TProofServ::SetLastMsg(lastMsg);

         if (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) {
               SetProcessing(kFALSE);
               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->IsOk()) {
            fProgressStatus->IncEntries();
            fProgressStatus->SetBytesRead(TFile::GetFileBytesRead()-readbytesatstart);
            fProgressStatus->SetReadCalls(TFile::GetFileReadCalls()-readcallsatstart);
            if (gMonitoringWriter)
               gMonitoringWriter->SendProcessingProgress(fProgressStatus->GetEntries(),
                       TFile::GetFileBytesRead()-readbytesatstart, kFALSE);
         }
         // Check the memory footprint, if required
         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;
            SetProcessing(kFALSE);
            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);
         }
         SetProcessing(kFALSE);
         if (!fSelStatus->IsOk() || 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;
      }
      SetProcessing(kFALSE);
   } ENDTRY;

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

   // Final memory footprint
   Long64_t singleshot = 1;
   Bool_t warnHWMres = kTRUE, warnHWMvir = kTRUE;
   TString wmsg;
   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()-readbytesatstart, kFALSE);
      gMonitoringWriter->SendProcessingStatus("DONE");
   }

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

   StopFeedback();

   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 *)o)->SetWorkerOrdinal(gProofServ->GetOrdinal());
            if (!strcmp(((TProofOutputFile *)o)->GetDir(),""))
               ((TProofOutputFile *)o)->SetDir(gProofServ->GetSessionDir());
         }
      }

      MapOutputListToDataMembers();

      if (fSelStatus->IsOk()) {
         if (version == 0) {
            PDB(kLoop,1) Info("Process","Call Terminate()");
            fSelector->Terminate();
         } else {
            PDB(kLoop,1) Info("Process","Call SlaveTerminate()");
            fSelector->SlaveTerminate();
            if (IsClient() && fSelStatus->IsOk()) {
               PDB(kLoop,1) Info("Process","Call Terminate()");
               fSelector->Terminate();
            }
         }
      }
      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;
}

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

   if (mfreq > 0 && GetEventsProcessed()%mfreq == 0) {
      // Record the memory information
      ProcInfo_t pi;
      if (!gSystem->GetProcInfo(&pi)){
         wmsg = "";
         Info("CheckMemUsage|Svc", "Memory %ld virtual %ld resident event %lld",
                                   pi.fMemVirtual, pi.fMemResident, GetEventsProcessed());
         // 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;
            }
         }
      }
   }
   // 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()
{
   // 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;
}

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

ClassImp(TProofPlayerLocal)


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

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);
}

//______________________________________________________________________________
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 usemerge = 0;
   if (TProof::GetParameter(fInput, "PROOF_UseTH1Merge", usemerge) != 0)
      usemerge = gEnv->GetValue("ProofPlayer.UseTH1Merge", 0);
   fUseTH1Merge = (usemerge == 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 explicitely 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) {
            tmpStatus = new TStatus();
            AddOutputObject(tmpStatus);
         }
         // 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 TList;
   else
      fOutput->Clear();

   SafeDelete(fFeedbackLists);

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

   if(!SendSelector(selector_file)) return -1;

   TMessage mesg(kPROOF_PROCESS);
   TString fn(gSystem->BaseName(selector_file));

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

   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);

      const char *datapack = (fProof->IsLite()) ? "TPacketizer" : "TPacketizerAdaptive";
      if (InitPacketizer(dset, nentries, first, "TPacketizerUnit", datapack) != 0) {
         Error("Process", "cannot init the packetizer");
         fExitStatus = kAborted;
         return -1;
      }

      // Reset start, this is now managed by the packetizer
      first = 0;
      // Try to have 100 messages about memory, unless a different number is given by the user
      if (!fProof->GetParameter("PROOF_MemLogFreq")){
         Long64_t memlogfreq = fPacketizer->GetTotalEntries()/(fProof->GetParallel()*100);
         memlogfreq = (memlogfreq > 0) ? memlogfreq : 1;
         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());

   } 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));
      }

      // 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");
      }

      SafeDelete(fSelector);
      fSelectorClass = 0;
      if (!(fSelector = TSelector::GetSelector(selector_file))) {
         if (!sync)
            gSystem->RedirectOutput(0);
         return -1;
      }
      fSelectorClass = fSelector->IsA();
      fSelector->SetInputList(fInput);
      fSelector->SetOption(option);

      PDB(kLoop,1) Info("Process","Call Begin(0)");
      fSelector->Begin(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) {
      mesg << 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();

   PDB(kGlobal,1) Info("Process","Calling Broadcast");
   fProof->Broadcast(mesg);

   // 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
            if (fQuery)
               fQuery->SetProcessInfo(0, 0., fPacketizer->GetBytesRead(),
                                             fPacketizer->GetInitTime(),
                                             fPacketizer->GetProcTime());
         }
         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());
         }
      }
      StopFeedback();

      if (!IsClient() || GetExitStatus() != TProofPlayer::kAborted)
         return Finalize(kFALSE,sync);
      else
         return -1;
   }
}

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

   PDB(kSubmerger,1) Info("MergeOutputFiles", "enter: fOutput size: %d", fOutput->GetSize());
   PDB(kSubmerger,1) 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(kSubmerger,2) pf->Print();

            if (pf->IsMerge()) {

               // Point to the merger
               TFileMerger *filemerger = pf->GetFileMerger();
               if (!filemerger) {
                  Error("MergeOutputFiles", "file merger is null in TProofOutputFile! Protocol error?");
                  pf->Print();
                  continue;
               }
               // Set the output file
               if (!filemerger->OutputFile(pf->GetOutputFileName())) {
                  Error("MergeOutputFiles", "cannot open the output file");
                  continue;
               }
               // If only one instance the list in the merger is not yet created: do it now
               if (!pf->IsMerged()) {
                  TString fileLoc = TString::Format("%s/%s", pf->GetDir(), pf->GetFileName());
                  filemerger->AddFile(fileLoc);
               }
               // 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())) {
                     gSystem->Unlink(url->GetString());
                  }
               }
               // Reset the merger
               filemerger->Reset();

            } else {

               // 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);
            }
         }
      }
   }

   // 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(kSubmerger,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) {
                  status = new TStatus();
                  AddOutputObject(status);
               }
               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);

         TIter next(fOutput);
         TList *output = fSelector->GetOutputList();
         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);
         }

         SetSelectorDataMembersFromOutputList();

         PDB(kLoop,1) Info("Finalize","Call Terminate()");
         fOutput->Clear("nodelete");
         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!");
         }

         // 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
         output->SetOwner(kFALSE);
         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);
         SafeDelete(fOutput);
      }
   }
   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 TList;
   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 *)", "ouputlist 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()
{
   // 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) {
         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 teh '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 {
         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);
   }

   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 TList;

   // 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()) {
         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) {
               // 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;
               if (gSystem->Getenv("LOCALDATASERVER")) {
                  of = gSystem->Getenv("LOCALDATASERVER");
               } else {
                  // 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(":%s", sp.Data());
                  }
               }
               TString sessionPath(gProofServ->GetSessionDir());
               // Take into account a prefix, if included and if xrootd
               TString sproto = TUrl(sessionPath).GetProtocol();
               TString pfx  = gEnv->GetValue("Path.Localroot","");
               if (!pfx.IsNull() && sessionPath.BeginsWith(pfx) &&
                  (sproto == "root" || sproto == "xrd"))
                  sessionPath.Remove(0, pfx.Length());
               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 TList;

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

         if (!fUseTH1Merge) {
            // 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) {
               // Do they have the same binning and ranges?
               Bool_t samebin = HistoSameAxis(hout, h);
               if (samebin) {
                  hout->Add(h);
                  PDB(kOutput,2)
                     Info("HandleHistogram", "histogram '%s' just added", h->GetName());
                  merged = kTRUE; // So it will be deleted
                  return (TObject *)0;
               } else {
                  // 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 (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;
            }

         } else {

            // Histogram has already been projected
            Int_t hsz = h->GetNbinsX() * h->GetNbinsY() * h->GetNbinsZ();
            if (gProofServ && hsz > gProofServ->GetMsgSizeHWM()) {
               // Large histo: merge one-by-one
               return obj;
            } else {
               // Create the list to merge in one-go at the end (more efficient
               // than merging one by one)
               list = new TList;
               list->SetName(h->GetName());
               list->SetOwner();
               fOutputLists->Add(list);
               list->Add(h);
               // Done
               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();

   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());
   }

   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"));
   }

   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())) 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 = 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 TList;

   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