// @(#)root/proofx:$Id$
// Author: G.Ganis Nov 2011

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

//////////////////////////////////////////////////////////////////////////
//                                                                      //
// TProofPerfAnalysis                                                       //
//                                                                      //
// Set of tools to analyse the performance tree                         //
//                                                                      //
//////////////////////////////////////////////////////////////////////////
#include <errno.h>

#include "TProofPerfAnalysis.h"
#include "TCanvas.h"
#include "TFile.h"
#include "TGraph.h"
#include "TH1F.h"
#include "TH2F.h"
#include "THashList.h"
#include "TKey.h"
#include "TList.h"
#include "TSortedList.h"
#include "TPerfStats.h"
#include "TRegexp.h"
#include "TStyle.h"
#include "TSystem.h"
#include "TTree.h"
#include "TMath.h"

//
// Auxilliary internal classes
//_______________________________________________________________________
class TProofPerfAnalysis::TWrkInfo : public TNamed {
public:
   TWrkInfo(const char *ord, const char *name) :
      TNamed(ord, name), fPackets(0), fRemotePackets(0), fEventsProcessed(0),
      fBytesRead(0), fLatency(0), fProcTime(0), fCpuTime(0), fStart(0), fStop(-1),
      fRateT(0), fRateRemoteT(0), fMBRateT(0), fMBRateRemoteT(0), fLatencyT(0) { }
   virtual ~TWrkInfo() { SafeDelete(fRateT); SafeDelete(fRateRemoteT);
                         SafeDelete(fMBRateT); SafeDelete(fMBRateRemoteT);
                         SafeDelete(fLatencyT); }

   Int_t     fPackets;          // Number of packets processed
   Int_t     fRemotePackets;    // Number of processed packet from non-local files
   Long64_t  fEventsProcessed;  // Tot events processed
   Long64_t  fBytesRead;        // Tot bytes read
   Double_t  fLatency;          // Tot latency
   Double_t  fProcTime;         // Tot proc time
   Double_t  fCpuTime;          // Tot CPU time

   Float_t   fStart;            // Start time
   Float_t   fStop;             // Stop time

   TGraph   *fRateT;             // Event processing rate vs time
   TGraph   *fRateRemoteT;       // Event processing rate of remote packets vs time
   TGraph   *fMBRateT;            // Byte processing rate vs time
   TGraph   *fMBRateRemoteT;      // Byte processing rate of remote packets vs time
   TGraph   *fLatencyT;          // Packet latency vs time

   Double_t  AvgRate() { if (fProcTime > 0) return (fEventsProcessed/fProcTime); return -1.; }
   Double_t  AvgIO() { if (fProcTime > 0) return (fBytesRead/fProcTime); return -1.; }

   void Print(Option_t * = "") const {
      Printf(" +++ TWrkInfo ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ");
      Printf(" +++ Worker:             %s, %s", GetName(), GetTitle());
      Printf(" +++ Activity interval:  %f -> %f", fStart, fStop);
      Printf(" +++ Amounts processed:  %d packets (%d remote), %lld evts, %lld bytes",
                                       fPackets, fRemotePackets, fEventsProcessed, fBytesRead);
      if (fProcTime) {
         Printf(" +++ Processing time:    %f s (CPU: %f s)", fProcTime, fCpuTime);
         Printf(" +++ Averages:           %f evts/s, %f MB/s", (Double_t)fEventsProcessed / fProcTime, (Double_t)fBytesRead /1024./1024./fProcTime);
      }
      Printf(" +++ Total latency:      %f", fLatency);
      Printf(" +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ");
   }

   Int_t Compare(const TObject *o) const { TWrkInfo *wi = (TWrkInfo *)o;
                                           if (wi) {
                                             if (fStop < wi->fStop) {
                                                return -1;
                                             } else if (fStop == wi->fStop) {
                                                return 0;
                                             }
                                          }
                                          return 1; }
};


class TProofPerfAnalysis::TPackInfo : public TNamed {
public:
   TPackInfo(const char *ord, const char *host) :  TNamed(ord, host), fStart(0), fStop(-1), fSize(0), fMBRate(0.) { }
   TPackInfo(const char *ord, const char *host, Float_t start, Float_t stop, Long64_t sz, Double_t mbr)
            :  TNamed(ord, host), fStart(start), fStop(stop), fSize(sz), fMBRate(mbr) { }
   Float_t   fStart;            // When the packet has been assigned
   Float_t   fStop;             // When the packet has been finished
   Long64_t  fSize;             // Packet size
   Double_t  fMBRate;           // Processing rate MB/s
   void Print(Option_t *opt= "") const {
      if (!strcmp(opt, "S")) {
         Printf("       \t%10lld evts, \t%12.2f MB/s, \t%12.3f -> %12.3f s", fSize, fMBRate, fStart, fStop);
      } else {
         Printf("   %s:\t%s  \t%10lld evts, \t%12.2f MB/s, \t%12.3f -> %12.3f s", GetTitle(), GetName(), fSize, fMBRate, fStart, fStop);
      }
   }
};

class TProofPerfAnalysis::TWrkInfoFile : public TNamed {
public:
   TWrkInfoFile(const char *ord, const char *name) :  TNamed(ord, name) { }
   ~TWrkInfoFile() {fPackets.SetOwner(kFALSE); fPackets.Clear("nodelete");}
   TList     fPackets;          // Packest from this file processed by this worker
   void Print(Option_t *opt= "") const {
      if (!strcmp(opt, "R")) {
         Printf(" Worker: %s,\tpacket(s): %d", GetName(), fPackets.GetSize());
      } else {
         Printf(" Worker: %s,\t%d packet(s) from file: %s", GetName(), fPackets.GetSize(), GetTitle());
      }
      TIter nxp(&fPackets);
      TObject *o = 0;
      while ((o = nxp())) { o->Print("S"); }
   }
};

class TProofPerfAnalysis::TWrkEntry : public TObject {
public:
   TWrkEntry(Double_t xx, Double_t er, Double_t mbr, Double_t pt) : fXx(xx), fEvtRate(er), fMBRate(mbr), fProcTime(pt) { }
   Double_t fXx;             // Bin center
   Double_t fEvtRate;        // Event processing rate from this worker for this packet
   Double_t fMBRate;         // I/O processing rate from this worker for this packet
   Double_t fProcTime;       // Processing time
   void Print(Option_t * = "") const { Printf("%.4f \t%.3f evt/s \t%.3f MB/s \t%.3f s ", fXx, fEvtRate, fMBRate, fProcTime); }
};

//_______________________________________________________________________
class TProofPerfAnalysis::TFileInfo : public TNamed {
public:
   TFileInfo(const char *name, const char *srv) :
      TNamed(name, srv), fPackets(0), fRPackets(0), fStart(0), fStop(-1),
      fSizeAvg(0), fSizeMax(-1.), fSizeMin(-1.),
      fMBRateAvg(0), fMBRateMax(-1.), fMBRateMin(-1.), fSizeP(0),
      fRateP(0), fRatePRemote(0), fMBRateP(0), fMBRatePRemote(0) { }
   virtual ~TFileInfo() {SafeDelete(fSizeP);
                         SafeDelete(fRateP); SafeDelete(fRatePRemote);
                         SafeDelete(fMBRateP); SafeDelete(fMBRatePRemote);
                         fPackList.SetOwner(kTRUE); fPackList.Clear();
                         fWrkList.SetOwner(kTRUE); fWrkList.Clear();
                         fRWrkList.SetOwner(kTRUE); fRWrkList.Clear();}

   Int_t     fPackets;          // Number of packets from this file
   Int_t     fRPackets;         // Number of different remote workers processing this file

   TList     fPackList;          // List of packet info
   TList     fWrkList;          // List of worker names processing this packet
   TList     fRWrkList;         // List of remote worker names processing this packet

   Float_t   fStart;            // When the first packet has been assigned
   Float_t   fStop;             // When the last packet has been finished

   Long64_t  fSizeAvg;          // Average Packet size
   Long64_t  fSizeMax;          // Max packet size
   Long64_t  fSizeMin;          // Min packet size

   Double_t  fMBRateAvg;        // Average MB rate
   Double_t  fMBRateMax;        // Max MB rate
   Double_t  fMBRateMin;        // Min MB rate

   TGraph   *fSizeP;             // Packet size vs packet (all)
   TGraph   *fRateP;             // Event processing rate vs packet (all)
   TGraph   *fRatePRemote;       // Event processing rate vs packet (remote workers)
   TGraph   *fMBRateP;           // Byte processing rate vs packet (all)
   TGraph   *fMBRatePRemote;     // Byte processing rate vs packet (remote workers)

   void Print(Option_t *opt = "") const {
      Printf(" +++ TFileInfo ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ");
      Printf(" +++ Server:         %s", GetTitle());
      Printf(" +++ File:           %s", GetName());
      Printf(" +++ Processing interval:  %f -> %f", fStart, fStop);
      Printf(" +++ Packets:         %d (%d remote)", fPackets, fRPackets);
      Printf(" +++ Processing wrks: %d (%d remote)", fWrkList.GetSize(), fRWrkList.GetSize());
      if (!strcmp(opt, "P")) fPackList.Print();
      if (!strcmp(opt, "WP")) fWrkList.Print("R");
      if (fPackets > 0) {
         Printf(" +++ MB rates:       %f MB/s (avg), %f MB/s (min), %f MB/s (max)",
                fMBRateAvg / fPackets, fMBRateMin, fMBRateMax);
         Printf(" +++ Sizes:          %lld  (avg), %lld (min), %lld (max)",
                fSizeAvg / fPackets, fSizeMin, fSizeMax);
      }
      Printf(" +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ");
   }

   Int_t Compare(const TObject *o) const { TFileInfo *wi = (TFileInfo *)o;
                                           if (wi) {
                                             if (fStop < wi->fStop) {
                                                return -1;
                                             } else if (fStop == wi->fStop) {
                                                return 0;
                                             }
                                          }
                                          return 1; }
};

Bool_t TProofPerfAnalysis::fgDebug = kTRUE;
//________________________________________________________________________
TProofPerfAnalysis::TProofPerfAnalysis(const char *perffile,
                               const char *title, const char *treename)
               : TNamed(perffile, title), fFile(0), fTreeName(treename), fTree(0),
                 fInitTime(-1.), fMergeTime(-1.), fMaxTime(-1.),
                 fEvents(0), fPackets(0),
                 fEvtRateMax(-1.), fMBRateMax(-1.), fLatencyMax(-1.),
                 fEvtRate(0), fEvtRateRun(0), fMBRate(0), fMBRateRun(0),
                 fEvtRateAvgMax(-1.), fMBRateAvgMax(-1.),
                 fEvtRateAvg(-1.), fMBRateAvg(0),
                 fFileResult(""), fSaveResult(kFALSE),
                 fDebug(0)
{
   // Constructor: open the file and attach to the tree

   // Use default title, if not specified
   if (!title) SetTitle("PROOF Performance Analysis");

   fTree = 0;
   fFile = TFile::Open(perffile);
   if (!fFile || (fFile && fFile->IsZombie())) {
      SafeDelete(fFile);
      Error("TProofPerfAnalysis", "problems opening file '%s'",
                              perffile ? perffile : "<undef>");
      SetBit(TObject::kInvalidObject);
      return;
   }

   // Set the subdirectory name, if any
   if (fTreeName.Contains("/")) {
      fDirName = gSystem->DirName(fTreeName);
      fTreeName = gSystem->BaseName(fTreeName);
   }

   // Adjust the name, if requested
   if (fTreeName.BeginsWith("+"))
      fTreeName.Replace(0, 1, "PROOF_PerfStats");

   // Point to the right TDirectory
   TDirectory *dir = fFile;
   if (!fDirName.IsNull()) {
      if (!(dir = dynamic_cast<TDirectory *>(fFile->Get(fDirName)))) {
         Error("TProofPerfAnalysis", "directory '%s' not found or not loadable", fDirName.Data());
         fFile->Close();
         SafeDelete(fFile);
         SetBit(TObject::kInvalidObject);
         return;
      }
   }

   // Load the performance tree
   LoadTree(dir);
   if (!fTree) {
      Error("TProofPerfAnalysis", "tree '%s' not found or not loadable", fTreeName.Data());
      fFile->Close();
      SafeDelete(fFile);
      SetBit(TObject::kInvalidObject);
      return;
   }
   if (fgDebug)
      Printf(" +++ TTree '%s' has %lld entries", fTreeName.Data(), fTree->GetEntries());

   // Init worker information
   FillWrkInfo();

   // Init file information
   FillFileInfo();

   // Done
   return;
}

//________________________________________________________________________
TProofPerfAnalysis::TProofPerfAnalysis(TTree *tree, const char *title)
               : TNamed("", title), fFile(0), fTree(0),
                 fInitTime(-1.), fMergeTime(-1.), fMaxTime(-1.),
                 fEvents(0), fPackets(0),
                 fEvtRateMax(-1.), fMBRateMax(-1.), fLatencyMax(-1.),
                 fEvtRate(0), fEvtRateRun(0), fMBRate(0), fMBRateRun(0),
                 fEvtRateAvgMax(-1.), fMBRateAvgMax(-1.),
                 fEvtRateAvg(-1.), fMBRateAvg(0),
                 fDebug(0)
{
   // Constructor: open the file and attach to the tree

   // The tree must be defined
   if (!tree) {
      SetBit(TObject::kInvalidObject);
      return;
   }

   // Use default title, if not specified
   if (!title) SetTitle("PROOF Performance Analysis");

   fTree = tree;
   fTreeName = fTree->GetName();
   SetName(TString::Format("heap_%s", fTreeName.Data()));

   // Adjust the name, if requested
   if (fTreeName.BeginsWith("+"))
      fTreeName.Replace(0, 1, "PROOF_PerfStats");

   if (fgDebug)
      Printf(" +++ TTree '%s' has %lld entries", fTreeName.Data(), fTree->GetEntries());

   // Init worker information
   FillWrkInfo();

   // Init file information
   FillFileInfo();

   // Done
   return;
}

//________________________________________________________________________
TProofPerfAnalysis::~TProofPerfAnalysis()
{
   // Destructor: detach the tree and close the file

   SafeDelete(fEvents);
   SafeDelete(fPackets);
   if (fFile) fFile->Close();
   SafeDelete(fFile);
}

//________________________________________________________________________
TString TProofPerfAnalysis::GetCanvasTitle(const char *t)
{
   // If defined, add '- <this title>' to the canvas title 't'

   if (fTitle.IsNull()) return TString(t);

   TString newt;
   if (t && strlen(t) > 0) {
      newt.Form("%s - %s", t, GetTitle());
   } else {
      newt = GetTitle();
   }
   // Done
   return newt;
}

//________________________________________________________________________
void TProofPerfAnalysis::LoadTree(TDirectory *dir)
{
   // Load tree fTreeName from directory 'dir'. If not found, look for the
   // first TTree in the directory (and sub-directories) with the name containing
   // fTreeName.
   // The tree pointer is saved in fTree.

   fTree = 0;
   if (!dir) return;

   // Try first the full name in the top directory
   if ((fTree = dynamic_cast<TTree *>(dir->Get(fTreeName)))) return;

   TRegexp re(fTreeName);
   // Now look inside: iter on the list of keys first
   TIter nxk(dir->GetListOfKeys());
   TKey *k = 0;
   while ((k = (TKey *) nxk())) {
      if (!strcmp(k->GetClassName(), "TDirectoryFile")) {
         TDirectory *kdir = (TDirectory *) dir->Get(k->GetName());
         LoadTree(kdir);
         if (fTree) return;
      } else if (!strcmp(k->GetClassName(), "TTree")) {
         TString tn(k->GetName());
         if (tn.Index(re) != kNPOS) {
            if ((fTree = dynamic_cast<TTree *>(dir->Get(tn)))) {
               fTreeName = tn;
               if (fgDebug) Printf(" +++ Found and loaded TTree '%s'", tn.Data());
               return;
            }
         }
      }
   }

   // Nothing found
   return;
}

//________________________________________________________________________
void TProofPerfAnalysis::FileDist(Bool_t writedet)
{
   // Analyse the file distribution. If writedet, underling details are
   // written out to a text file.

   if (!IsValid()) {
      Error("FileDist","not a valid instance - do nothing");
      return;
   }

   // Fill file info
   TList *wrkList = new TList;
   TList *srvList = new TList;
   GetWrkFileList(wrkList, srvList);
   Info("FileDist", "%d workers were active during this query", wrkList->GetSize());
   Info("FileDist", "%d servers were active during this query", srvList->GetSize());

   // Fill the worker-data server mapping
   TIter nxs(srvList);
   TIter nxw(wrkList);
   TNamed *sn = 0, *wn = 0;
   while ((sn = (TNamed *)nxs())) {
      nxw.Reset();
      while ((wn = (TNamed *) nxw())) {
         if (!strcmp(TUrl(sn->GetName()).GetHostFQDN(), wn->GetTitle())) {
            sn->SetTitle(wn->GetName());
         }
      }
   }

   // Reorder the lists following the title
   TList *nwl = new TList;
   TList *nsl = new TList;
   nxw.Reset();
   while ((wn = (TNamed *) nxw())) {
      TIter nnxw(nwl);
      TNamed *nwn = 0;
      while ((nwn = (TNamed *) nnxw())) {
         if (CompareOrd(wn->GetName(), nwn->GetName()) < 0) {
            nwl->AddBefore(nwn, wn);
            break;
         }
      }
      if (!nwn) nwl->Add(wn);
      // Find the server name, if any
      nxs.Reset();
      while ((sn = (TNamed *)nxs())) {
         if (!strcmp(sn->GetTitle(), wn->GetName())) {
            TIter nnxs(nsl);
            TNamed *nsn = 0;
            while ((nsn = (TNamed *) nnxs())) {
               if (CompareOrd(sn->GetTitle(), nsn->GetTitle()) < 0) {
                  nsl->AddBefore(nsn, sn);
                  break;
               }
            }
            if (!nsn) nsl->Add(sn);
            break;
         }
      }
      if (sn) srvList->Remove(sn);
   }
   // Add remaining servers at the end
   nxs.Reset();
   while ((sn = (TNamed *)nxs())) {
      nsl->Add(sn);
   }
   // Clean the orginal lists
   wrkList->SetOwner(kFALSE);
   srvList->SetOwner(kFALSE);
   delete wrkList;
   delete srvList;
   wrkList = nwl;
   srvList = nsl;

   // Notify
   wrkList->ls();
   srvList->ls();

   // Separate out the case with only one file server
   if (srvList->GetSize() == 1) {

      Printf("\n +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ ");
      Printf(" + Only one data server found: full analysis meaningful  + ");
      Printf(" + only when there are more file servers                 + ");
      Printf(" +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ \n");


      // Create a 1D histo for cross packets
      TH1F *hxpak = new TH1F("hxpak", "MBytes / Worker",
                                    wrkList->GetSize(), 0., (Double_t)wrkList->GetSize());
      hxpak->SetDirectory(0);
      hxpak->SetMinimum(0.);
      hxpak->GetXaxis()->SetTitle("Worker");

      // Set the labels
      Int_t j = 1;
      TIter nxsw(wrkList);
      while ((wn = (TNamed *)nxsw())) {
         hxpak->GetXaxis()->SetBinLabel(j++, wn->GetName());
      }

      // Fill the histograms
      FillFileDistOneSrv(hxpak, writedet);

      // Display histos
      gStyle->SetOptStat(0);

      TCanvas *c2 = new TCanvas("cv-hxpak",  GetCanvasTitle(hxpak->GetTitle()), 800,350,700,700);
      c2->cd();
      DoDraw(hxpak);
      c2->Update();

   } else {
      // Create a 1D histo for file distribution
      TH1F *hfdis = new TH1F("hfdis", "Packet dist",
                           srvList->GetSize(), 0., (Double_t)srvList->GetSize());
      hfdis->SetDirectory(0);
      hfdis->SetMinimum(0);
      hfdis->GetXaxis()->SetTitle("Server");
      TH1F *hbdis = new TH1F("hbdis", "MBytes dist",
                           srvList->GetSize(), 0., (Double_t)srvList->GetSize());
      hbdis->SetDirectory(0);
      hbdis->SetMinimum(0);
      hbdis->GetXaxis()->SetTitle("Server");
      // Create a 2D histo for cross packets
      TH2F *hxpak = new TH2F("hxpak", "MBytes / {Worker,Server}",
                                    srvList->GetSize(), 0., (Double_t)srvList->GetSize(),
                                    wrkList->GetSize(), 0., (Double_t)wrkList->GetSize());
      hxpak->SetDirectory(0);
      hxpak->GetYaxis()->SetTitle("Worker");
      hxpak->GetXaxis()->SetTitle("Server");
      hxpak->GetXaxis()->SetTitleOffset(1.4);
      hxpak->GetYaxis()->SetTitleOffset(1.7);

      // Set the labels
      Int_t j = 1;
      TIter nxsw(wrkList);
      while ((wn = (TNamed *)nxsw())) {
         hxpak->GetYaxis()->SetBinLabel(j++, wn->GetName());
      }
      j = 1;
      TIter nxss(srvList);
      while ((sn = (TNamed *)nxss())) {
         hfdis->GetXaxis()->SetBinLabel(j, sn->GetName());
         hbdis->GetXaxis()->SetBinLabel(j, sn->GetName());
         hxpak->GetXaxis()->SetBinLabel(j++, sn->GetName());
      }

      // Fill the histograms
      FillFileDist(hfdis, hbdis, hxpak, writedet);

      j = 1;
      nxss.Reset();
      while ((sn = (TNamed *)nxss())) {
         TString lab(sn->GetName());
         lab = TUrl(sn->GetName()).GetHost();
         if (strcmp(sn->GetTitle(), "remote") && lab.Index(".") != kNPOS) lab.Remove(lab.Index("."));
         hfdis->GetXaxis()->SetBinLabel(j, lab);
         hbdis->GetXaxis()->SetBinLabel(j, lab);
         hxpak->GetXaxis()->SetBinLabel(j++, lab);
      }

      // Display histos
      gStyle->SetOptStat(0);

      TCanvas *c1 = new TCanvas("cv-hfdis", GetCanvasTitle(hfdis->GetTitle()), 800,50,700,700);
      c1->Divide(1,2);
      TPad *pad1 = (TPad *) c1->GetPad(1);
      TPad *pad2 = (TPad *) c1->GetPad(2);
      pad1->cd();
      DoDraw(hfdis);
      pad2->cd();
      DoDraw(hbdis);
      c1->Update();

      TCanvas *c2 = new TCanvas("cv-hxpak",  GetCanvasTitle(hxpak->GetTitle()), 500,350,700,700);
      c2->cd();
      DoDraw(hxpak, "lego");
      c2->Update();
   }
   // Done
   return;
}

//________________________________________________________________________
void TProofPerfAnalysis::GetWrkFileList(TList *wl, TList *sl)
{
   // Fill file info

   if (!wl || !sl) return;

   // Extract information
   TPerfEvent pe;
   TPerfEvent* pep = &pe;
   fTree->SetBranchAddress("PerfEvents", &pep);
   Long64_t entries = fTree->GetEntries();
   TNamed *wn = 0, *sn = 0;
   for (Long64_t k=0; k<entries; k++) {
      fTree->GetEntry(k);
      // Analyse only packets
      if (pe.fType != TVirtualPerfStats::kPacket) continue;
      // Find out the worker instance
      TString wrk(TUrl(pe.fSlaveName.Data()).GetHostFQDN());
      wn = (TNamed *) wl->FindObject(pe.fSlave.Data());
      if (!wn) {
         wn = new TNamed(pe.fSlave.Data(), wrk.Data());
         wl->Add(wn);
      }
      // Find out the file server instance
      TUrl uf(pe.fFileName);
      TString srv(uf.GetUrl());
      Int_t ifn = srv.Index(uf.GetFile());
      if (ifn != kNPOS) srv.Remove(ifn);
      sn = (TNamed *) sl->FindObject(srv.Data());
      if (!sn) {
         sn = new TNamed(srv.Data(), "remote");
         sl->Add(sn);
      }
   }

   // Done
   return;
}

//________________________________________________________________________
Int_t TProofPerfAnalysis::CompareOrd(const char *ord1, const char *ord2)
{
   // Return -1 if ord1 comes before ord2, 0 i they are equal,
   // 1 if ord1 comes after ord2

   TString o1(ord1), o2(ord2), p1, p2;
   Int_t o1d = 0, o2d = 0;
   if ((o1d = o1.CountChar('.')) > (o2d = o2.CountChar('.'))) {
      return 1;
   } else if (o1d < o2d) {
      return -1;
   } else {
      o1.ReplaceAll(".", " ");
      o2.ReplaceAll(".", " ");
      Bool_t b1 = o1.Tokenize(p1, o1d, " ");
      Bool_t b2 = o2.Tokenize(p2, o2d, " ");
      while (b1 && b2) {
         if (p1.Atoi() > p2.Atoi()) {
            return 1;
         } else if (p1.Atoi() < p2.Atoi()) {
            return -1;
         } else {
            b1 = o1.Tokenize(p1, o1d, " ");
            b2 = o2.Tokenize(p2, o2d, " ");
         }
      }
      if (b1 && !b2) {
         return 1;
      } else if (b2 && !b1) {
         return -1;
      } else {
         return 0;
      }
   }
}

//________________________________________________________________________
void TProofPerfAnalysis::FillFileDist(TH1F *hf, TH1F *hb, TH2F *hx, Bool_t wdet)
{
   // Fill file info

   if (!hf || !hb || !hx) return;

   TString fnout;
   FILE *fout = 0;
   if (wdet) {
      fnout.Form("%s-FileDist-Details.txt", GetName());
      if (!(fout = fopen(fnout.Data(), "w"))) {
         Warning("FillFileDist", "asked to save details in '%s' but file could"
                                 " not be open (errno: %d)", fnout.Data(), (int)errno);
      } else {
         Info("FillFileDist", "saving details to '%s'", fnout.Data());
      }
   }
   // Extract information
   TPerfEvent pe;
   TPerfEvent* pep = &pe;
   fTree->SetBranchAddress("PerfEvents",&pep);
   Long64_t entries = fTree->GetEntries();
   for (Long64_t k=0; k<entries; k++) {
      fTree->GetEntry(k);
      // Analyse only packets
      if (pe.fType != TVirtualPerfStats::kPacket) continue;
      // Find out the labels ...
      TString wrk(pe.fSlave.Data());
      TUrl uf(pe.fFileName);
      TString srv(uf.GetUrl());
      Int_t ifn = srv.Index(uf.GetFile());
      if (ifn != kNPOS) srv.Remove(ifn);
      // ... and the bins
      Double_t xhf = hf->GetXaxis()->GetBinCenter(hf->GetXaxis()->FindBin(srv.Data()));
      Double_t xhx = hx->GetXaxis()->GetBinCenter(hx->GetXaxis()->FindBin(srv.Data()));
      Double_t yhx = hx->GetYaxis()->GetBinCenter(hx->GetYaxis()->FindBin(wrk.Data()));
      // Save details, if asked
      if (fout)
         fprintf(fout, "%s,%s -> %f,%f (%f)\n",
                       srv.Data(), wrk.Data(), xhx, yhx, pe.fBytesRead / 1024.);
      // Fill now
      hf->Fill(xhf);
      hb->Fill(xhf, pe.fBytesRead / 1024. / 1024.);
      hx->Fill(xhx, yhx, pe.fBytesRead / 1024. / 1024.);
   }
   if (fout) fclose(fout);
   // Done
   return;
}

//________________________________________________________________________
void TProofPerfAnalysis::FillFileDistOneSrv(TH1F *hx, Bool_t wdet)
{
   // Fill file info when there is only one file server

   if (!hx) return;

   TString fnout;
   FILE *fout = 0;
   if (wdet) {
      fnout.Form("%s-FileDist-Details.txt", GetName());
      if (!(fout = fopen(fnout.Data(), "w"))) {
         Warning("FillFileDistOneSrv", "asked to save details in '%s' but file could"
                                       " not be open (errno: %d)", fnout.Data(), (int)errno);
      } else {
         Info("FillFileDistOneSrv", "saving details to '%s'", fnout.Data());
      }
   }
   // Extract information
   TPerfEvent pe;
   TPerfEvent* pep = &pe;
   fTree->SetBranchAddress("PerfEvents",&pep);
   Long64_t entries = fTree->GetEntries();
   for (Long64_t k=0; k<entries; k++) {
      fTree->GetEntry(k);
      // Analyse only packets
      if (pe.fType != TVirtualPerfStats::kPacket) continue;
      // Find out the labels ...
      TString wrk(pe.fSlave.Data());
      TUrl uf(pe.fFileName);
      TString srv(uf.GetUrl());
      Int_t ifn = srv.Index(uf.GetFile());
      if (ifn != kNPOS) srv.Remove(ifn);
      // ... and the bins
      Double_t xhx = hx->GetXaxis()->GetBinCenter(hx->GetXaxis()->FindBin(wrk.Data()));
      // Save details, if asked
      if (fout)
         fprintf(fout, "%s,%s -> %f (%f)\n",
                       srv.Data(), wrk.Data(), xhx, pe.fBytesRead / 1024.);
      // Fill now
      hx->Fill(xhx, pe.fBytesRead / 1024. / 1024.);
   }
   if (fout) fclose(fout);
   // Done
   return;
}

//________________________________________________________________________
void TProofPerfAnalysis::WorkerActivity()
{
   // Measure the worker activity

   if (!IsValid()) {
      Error("WorkerActivity","not a valid instance - do nothing");
      return;
   }

   // Fill basic worker info
   if (!WrkInfoOK()) FillWrkInfo();
   if (!WrkInfoOK()) {
      Error("WorkerActivity", "workers information not available - do nothing");
      return;
   }

   TObject *o = 0;
   // Create the histograms with activity vs time
   if ((o = gDirectory->FindObject("act10"))) delete o;
   Float_t t0 = fMergeTime - 2.* (fMaxTime - fMergeTime);
   Float_t t1 = 2.*fInitTime;
   if (t1 > t0) t1 = t0;
   TH1F *hact10 = new TH1F("act10", "Worker activity start (seconds)", 50, 0., t1);
   hact10->GetXaxis()->SetTitle("Query Processing Time (s)");
   if ((o = gDirectory->FindObject("act11"))) delete o;
   TH1F *hact11 = new TH1F("act11", "Worker activity stop (seconds)", 50, t0, fMaxTime);
   hact11->GetXaxis()->SetTitle("Query Processing Time (s)");
   if ((o = gDirectory->FindObject("act2"))) delete o;
   TH1F *hact2 = new TH1F("act2", "End of activity (seconds)", 50, t0, fMaxTime);
   hact2->GetXaxis()->SetTitle("Query Processing Time (s)");

   // Fine-tune stat printing
   Int_t curoptstat = gStyle->GetOptStat();
   gStyle->SetOptStat(1100);

   // Create the sorted list
   TIter nxw(&fWrksInfo);
   TWrkInfo *wi = 0;
   while ((wi = (TWrkInfo *)nxw())) {
      Int_t j = 0;
      for (j = 1; j < hact10->GetNbinsX()+1 ; j++) {
         if (wi->fStart < hact10->GetBinLowEdge(j))
            hact10->Fill(hact10->GetBinCenter(j));
      }
      for (j = 1; j < hact11->GetNbinsX()+1 ; j++) {
         if (wi->fStop > hact11->GetBinLowEdge(j))
            hact11->Fill(hact11->GetBinCenter(j));
      }
      hact2->Fill(wi->fStop);
   }

   // Display histos
   TCanvas *c1 = new TCanvas("perf", GetCanvasTitle("Activity histos"), 800,10,700,780);
   c1->Divide(1,2);
   TPad *pad1 = (TPad *) c1->GetPad(1);
   pad1->Divide(2,1);
   TPad *pad10 = (TPad *) pad1->GetPad(1);
   TPad *pad11 = (TPad *) pad1->GetPad(2);
   pad10->cd();
   DoDraw(hact10);
   pad11->cd();
   DoDraw(hact11);
   TPad *pad2 = (TPad *) c1->GetPad(2);
   pad2->cd();
   DoDraw(hact2);
   c1->cd();
   c1->Update();

   // Restore stat options
   gStyle->SetOptStat(curoptstat);

   // Done
   return;
}

//________________________________________________________________________
void TProofPerfAnalysis::PrintWrkInfo(Int_t showlast)
{
   // Print information for all or the slowest showlast workers.
   // Use showlast < 0 to print all

   // Create the sorted list
   Int_t k = fWrksInfo.GetSize();
   TIter nxw(&fWrksInfo);
   TWrkInfo *wi = 0;
   while ((wi = (TWrkInfo *)nxw())) {
      // Print info about slowest workers
      k--;
      if (showlast < 0 || k < showlast) wi->Print();
   }
}

//________________________________________________________________________
void TProofPerfAnalysis::PrintWrkInfo(const char *wn)
{
   // Print information for worker 'wn' (ordinal) or on the machine whose
   // ordinal or fqdn matches 'wn'. Multiple specifications separated by ','
   // or ' ' are supported, as well as wildcards '*', e.g. '0.2*,lxb10* lxf2323.doma.in"

   if (!wn || (wn && strlen(wn) <= 0)) {
      Error("PrintWrkInfo", "worker name or host must be defined!");
      return;
   }

   // Check exact name
   TWrkInfo *wi = (TWrkInfo *) fWrksInfo.FindObject(wn);
   if (wi) {
      wi->Print();
   } else {
      // Check matching
      TString ww(wn), w;
      TIter nxw(&fWrksInfo);
      while ((wi = (TWrkInfo *)nxw())) {
         TString n(wi->GetName()), t(wi->GetTitle());
         Ssiz_t from = 0;
         while (ww.Tokenize(w, from, "[, ]")) {
            TRegexp re(w, kTRUE);
            if (n.Index(re) != kNPOS || t.Index(re) != kNPOS) wi->Print();
         }
      }
   }
}

//________________________________________________________________________
void TProofPerfAnalysis::PrintFileInfo(Int_t showlast, const char *opt, const char *out)
{
   // Print information for all or the slowest showlast workers.
   // Use showlast < 0 to print all

   RedirectHandle_t rh;
   if (out && strlen(out) > 0) gSystem->RedirectOutput(out, "w", &rh);

   // Create the sorted list
   Int_t k = fFilesInfo.GetSize();
   TIter nxf(&fFilesInfo);
   TFileInfo *fi = 0;
   while ((fi = (TFileInfo *)nxf())) {
      // Print info about files processed last
      k--;
      if (showlast < 0 || k < showlast) fi->Print(opt);
   }

   if (out && strlen(out) > 0) gSystem->RedirectOutput(0, 0, &rh);
}

//________________________________________________________________________
void TProofPerfAnalysis::PrintFileInfo(const char *fn, const char *opt, const char *out)
{
   // Print information for file 'fn' (path including directory) or server 'fn'.
   // Multiple specifications separated by ','
   // or ' ' are supported, as well as wildcards '*', e.g. 'pippo.root, h4mu*,lxb10*"

   if (!fn || (fn && strlen(fn) <= 0)) {
      Error("PrintFileInfo", "file path must be defined!");
      return;
   }

   RedirectHandle_t rh;
   if (out && strlen(out) > 0) gSystem->RedirectOutput(out, "w", &rh);

   // Check exact name
   TFileInfo *fi = (TFileInfo *) fFilesInfo.FindObject(fn);
   if (fi) {
      fi->Print(opt);
   } else {
      // Check matching
      TString fw(fn), f;
      TIter nxf(&fFilesInfo);
      while ((fi = (TFileInfo *)nxf())) {
         TString n(fi->GetName()), s(fi->GetTitle());
         Ssiz_t from = 0;
         while (fw.Tokenize(f, from, "[, ]")) {
            TRegexp re(f, kTRUE);
            if (n.Index(re) != kNPOS || s.Index(re) != kNPOS) fi->Print(opt);
         }
      }
   }

   if (out && strlen(out) > 0) gSystem->RedirectOutput(0, 0, &rh);
}

//________________________________________________________________________
void TProofPerfAnalysis::FillWrkInfo(Bool_t force)
{
   // Fill basic worker info; if 'force' rescan the TTree even already done

   // Nothing to do if already called
   if (fWrksInfo.GetSize() > 0 && !force) return;

   // Cleanup existing information
   fWrksInfo.SetOwner(kTRUE);
   fWrksInfo.Clear();
   fInitTime = -1.;
   fMergeTime = -1.;
   fMaxTime = -1.;
   fEvtRateMax = -1.;
   fMBRateMax = -1.;
   fLatencyMax = -1.;

   TList *wl = new TList;
   // Extract worker information
   TPerfEvent pe;
   TPerfEvent* pep = &pe;
   fTree->SetBranchAddress("PerfEvents",&pep);
   Long64_t entries = fTree->GetEntries();

   // First determine binning for global rates
   Int_t nraw = entries * 2, jj = 0, kk = 0;
   Double_t *xraw = new Double_t[nraw];
   for (Long64_t k=0; k<entries; k++) {
      fTree->GetEntry(k);
      // Analyse only packets
      if (pe.fType == TVirtualPerfStats::kPacket) {
         Float_t stop = pe.fTimeStamp.GetSec() + 1e-9*pe.fTimeStamp.GetNanoSec();
         Float_t start = stop - pe.fProcTime;
         // Bins
         xraw[jj++] = start;
         xraw[jj++] = stop;
      }
   }
   Int_t nbins = jj;
   Int_t *jidx = new Int_t[nbins];
   memset(jidx, 0, nbins * sizeof(Int_t));
   TMath::Sort(nbins, xraw, jidx, kFALSE);
   Double_t *xbins = new Double_t[nbins];
   jj = 0;
   for (kk = 0; kk < nbins; kk++) {
      Double_t xtmp = xraw[jidx[kk]];
      if (jj == 0 || xtmp > xbins[jj - 1] + .5) {
         xbins[jj] = xtmp;
         jj++;
      }
   }
   nbins = jj;
   delete [] xraw;
   delete [] jidx;

   // Create the global histograms
   Int_t nbin = nbins - 1;
   TObject *o = 0;
   if ((o = gDirectory->FindObject("gEvtRate"))) delete o;
   fEvtRate = new TH1F("gEvtRate", "Total event processing rate (evt/s)", nbin, xbins);
   fEvtRate->SetMinimum(0.);
   fEvtRate->SetStats(kFALSE);
   fEvtRate->SetFillColor(kCyan-8);
   fEvtRate->GetXaxis()->SetTitle("Query Processing Time (s)");
   if ((o = gDirectory->FindObject("gEvtRateAvg"))) delete o;
   fEvtRateRun = new TH1F("gEvtRateAvg", "Event processing rate running average (evt/s)", nbin, xbins);
   fEvtRateRun->SetMinimum(0.);
   fEvtRateRun->SetStats(kFALSE);
   fEvtRateRun->SetLineColor(kBlue);
   fEvtRateRun->GetXaxis()->SetTitle("Query Processing Time (s)");
   if ((o = gDirectory->FindObject("gMBRate"))) delete o;
   fMBRate = new TH1F("gMBRate", "Total processing rate (MB/s)", nbin, xbins);
   fMBRate->SetMinimum(0.);
   fMBRate->SetStats(kFALSE);
   fMBRate->SetFillColor(kCyan-8);
   fMBRate->GetXaxis()->SetTitle("Query Processing Time (s)");
   if ((o = gDirectory->FindObject("gMBRateAvg"))) delete o;
   fMBRateRun = new TH1F("gMBRateAvg", "Processing rate running average (MB/s)", nbin, xbins);
   fMBRateRun->SetMinimum(0.);
   fMBRateRun->SetStats(kFALSE);
   fMBRateRun->SetLineColor(kBlue);
   fMBRateRun->GetXaxis()->SetTitle("Query Processing Time (s)");
   // Not needed any longer
   delete [] xbins;

   THashList gBins;
   TList *gwl = 0, *gbl = 0;

   // Extract the worker info now
   TWrkInfo *wi = 0;
   for (Long64_t k=0; k<entries; k++) {
      fTree->GetEntry(k);
      // Analyse only packets
      if (pe.fType == TVirtualPerfStats::kPacket) {
         // Find out the worker instance
         if (!(wi = (TWrkInfo *) wl->FindObject(pe.fSlave.Data()))) {
            wi = new TWrkInfo(pe.fSlave.Data(), pe.fSlaveName.Data());
            wl->Add(wi);
            wi->fRateT = new TGraph(100);
            wi->fRateRemoteT = new TGraph(100);
            wi->fMBRateT = new TGraph(100);
            wi->fMBRateRemoteT = new TGraph(100);
            wi->fLatencyT = new TGraph(100);
         }
         // Add Info now
         Float_t stop = pe.fTimeStamp.GetSec() + 1e-9*pe.fTimeStamp.GetNanoSec();
         Float_t start = stop - pe.fProcTime;
         if (wi->fPackets <= 0) {
            wi->fStart = start;
         } else {
            wi->fStop = stop;
         }
         TUrl uf(pe.fFileName), uw(pe.fSlaveName);
         fMaxTime = stop;
         wi->fEventsProcessed += pe.fEventsProcessed;
         wi->fBytesRead += pe.fBytesRead;
         wi->fLatency += pe.fLatency;
         wi->fProcTime += pe.fProcTime;
         wi->fCpuTime += pe.fCpuTime;
         // Fill graphs
         Double_t tt = stop;
         Double_t ert = pe.fEventsProcessed / pe.fProcTime ;
         Double_t brt = pe.fBytesRead / pe.fProcTime / 1024. / 1024. ;
         wi->fRateT->SetPoint(wi->fPackets, tt, ert);
         if (brt > 0.) wi->fMBRateT->SetPoint(wi->fPackets, tt, brt);
         wi->fLatencyT->SetPoint(wi->fPackets, tt, pe.fLatency);
         if (!pe.fFileName.IsNull() && strcmp(uf.GetHostFQDN(), uw.GetHostFQDN())) {
            wi->fRateRemoteT->SetPoint(wi->fRemotePackets, tt, ert);
            wi->fMBRateRemoteT->SetPoint(wi->fRemotePackets, tt, brt);
            wi->fRemotePackets++;
         }
         wi->fPackets++;
         if (ert > fEvtRateMax) fEvtRateMax = ert;
         if (brt > fMBRateMax) fMBRateMax = brt;
         if (pe.fLatency > fLatencyMax) fLatencyMax = pe.fLatency;

         // Fill global rate histos
         for (kk = 1; kk <= nbins; kk++) {
            Double_t mi = fEvtRate->GetBinLowEdge(kk);
            if (mi > stop) break;
            Double_t wd = fEvtRate->GetBinWidth(kk);
            Double_t mx = mi + wd;
            Double_t xx = fEvtRate->GetBinCenter(kk);
            // Overlap length
            Double_t olap = stop - mi;
            if (start > mi) olap = mx - start;
            if (olap >= 0) {
               TString sb = TString::Format("%d", kk);
               if (!(gbl = (TList *) gBins.FindObject(sb))) {
                  gbl = new TList;
                  gbl->SetName(sb);
                  gBins.Add(gbl);
               }
               if (!(gwl = (TList *) gbl->FindObject(pe.fSlave))) {
                  gwl = new TList;
                  gwl->SetName(pe.fSlave);
                  gbl->Add(gwl);
               }
               gwl->Add(new TWrkEntry(xx, ert, brt, pe.fProcTime));
            }
         }

         // Notify
         if (fDebug > 1) {
            if (pe.fProcTime > 0.) {
               Printf(" +++ %s #:%d at:%fs lat:%fs proc:%fs evts:%lld bytes:%lld (rates:%f evt/s, %f MB/s)",
                     wi->GetName(), wi->fPackets, fMaxTime - pe.fProcTime,
                     pe.fLatency, pe.fProcTime, pe.fEventsProcessed, pe.fBytesRead,
                     ert, brt);
            } else {
               Printf(" +++ %s #:%d at:%fs lat:%fs proc:%fs rate:-- evt/s (-- bytes/s)",
                     wi->GetName(), wi->fPackets, fMaxTime, pe.fLatency, pe.fProcTime);
            }
         }
      } else if (pe.fType == TVirtualPerfStats::kStart) {
         Float_t start = pe.fTimeStamp.GetSec() + 1e-9*pe.fTimeStamp.GetNanoSec();
         if (fDebug > 1) Printf(" +++ %s Start: %f s", pe.fEvtNode.Data(), start);
      } else if (pe.fType == TVirtualPerfStats::kStop) {
         Float_t stop = pe.fTimeStamp.GetSec() + 1e-9*pe.fTimeStamp.GetNanoSec();
         if (fDebug > 1) Printf(" +++ %s Stop: %f s", pe.fEvtNode.Data(), stop);
      } else {
         if (fDebug > 2) Printf(" +++ Event type: %d", pe.fType);
      }
   }

   TIter nxb(&gBins);
   gbl = 0;
   while ((gbl = (TList *) nxb())) {
      gwl = 0;
      TIter nxw(gbl);
      while ((gwl = (TList *) nxw())) {
         Double_t er = 0, br = 0, pt = 0, xx = 0;
         TIter nxp(gwl);
         TWrkEntry *we = 0;
         while ((we = (TWrkEntry *) nxp())) {
            if (we->fProcTime > 0) {
               er += we->fEvtRate * we->fProcTime;
               br += we->fMBRate * we->fProcTime;
               pt += we->fProcTime;
            }
            xx = we->fXx;
         }
         if (pt > 0.) {
            er /= pt;
            br /= pt;
            fEvtRate->Fill(xx, er);
            if (br > 0.) fMBRate->Fill(xx, br);
         }
      }
   }

   // Running averages
   Double_t er = 0, br = 0, pt = 0;
   for (kk = 1; kk < nbins; kk++) {
      Double_t wd = fEvtRate->GetBinWidth(kk);
      Double_t wx = fEvtRate->GetBinCenter(kk);
      Double_t wer = fEvtRate->GetBinContent(kk);
      Double_t wbr = fMBRate->GetBinContent(kk);

      if (kk == 1) {
         er = wer;
         br = wbr;
         pt = wd;
      } else {
         er *= pt;
         br *= pt;
         pt += wd;
         er += wer * wd;
         br += wbr * wd;
         er /= pt;
         br /= pt;
      }
      if (er > fEvtRateAvgMax) fEvtRateAvgMax = er;
      if (br > fMBRateAvgMax) fMBRateAvgMax = br;
      fEvtRateAvg = er;
      fMBRateAvg = br;
      // Fill
      fEvtRateRun->Fill(wx, er);
      fMBRateRun->Fill(wx, br);
   }


   // Final analysis to find relevant times
   TIter nxw(wl);
   while ((wi = (TWrkInfo *) nxw())) {
      fWrksInfo.Add(wi);
      if (wi->fStart > fInitTime) fInitTime = wi->fStart;
      // Resize the graphs
      wi->fRateT->Set(wi->fPackets);
      wi->fRateRemoteT->Set(wi->fRemotePackets);
      wi->fLatencyT->Set(wi->fPackets);
      wi->fMBRateT->Set(wi->fPackets);
      wi->fMBRateRemoteT->Set(wi->fRemotePackets);
   }
   wl->SetOwner(kFALSE);
   delete wl;

   // Final analysis to find relevant times
   fMergeTime = fMaxTime;
   Int_t rsw = (fWrksInfo.GetSize() > 1) ? 2 : 2, ksw = 0;
   TIter nxsw(&fWrksInfo);
   while ((wi = (TWrkInfo *) nxsw())) {
      if (wi->fStop > 0.) ksw++;
      if (ksw == rsw) break;
   }
   if (wi) fMergeTime = wi->fStop;

   // (Re-)create the event and packet distribution histograms
   SafeDelete(fEvents);
   SafeDelete(fPackets);
   fEvents = new TH1F("hevents", "Events per worker", fWrksInfo.GetSize(), -.5, fWrksInfo.GetSize()-.5);
   fEvents->SetDirectory(0);
   fPackets = new TH1F("hpackets", "Packets per worker", fWrksInfo.GetSize(), -.5, fWrksInfo.GetSize()-.5);
   fPackets->SetDirectory(0);
   Int_t j = 0;
   TIter nxwi(&fWrksInfo);
   while ((wi = (TWrkInfo *)nxwi())) {
      fEvents->GetXaxis()->SetBinLabel(j+1, wi->GetName());
      fEvents->Fill(j, wi->fEventsProcessed);
      fPackets->GetXaxis()->SetBinLabel(j+1, wi->GetName());
      fPackets->Fill(j++, wi->fPackets);
   }
   fEvents->SetMinimum(0.);
   fPackets->SetMinimum(0.);
   fEvents->SetFillColor(38);
   fPackets->SetFillColor(38);
   fEvents->GetYaxis()->SetTitle("Events");
   fEvents->GetXaxis()->SetTitle("Worker");
   fPackets->GetYaxis()->SetTitle("Packets");
   fPackets->GetXaxis()->SetTitle("Worker");

   // Print summary
   if (fgDebug) Summary();
}

//________________________________________________________________________
void TProofPerfAnalysis::Summary(Option_t *opt, const char *out)
{
   // Print summary of query. Use opt = 'S' for compact version.
   // Output to 'out' or to screen.

   TString o(out);
   RedirectHandle_t rh;
   if (!o.IsNull()) {
      const char *m = (o.BeginsWith("+")) ? "a" : "w";
      o.Remove(TString::kLeading, '+');
      gSystem->RedirectOutput(o, m, &rh);
   }

   // Print summary
   if (!strcmp(opt, "S")) {
      // Short version
      Printf("%d %f %f %f %f %f %f %f",
              fWrksInfo.GetSize(), fMaxTime, fInitTime, fMaxTime - fMergeTime,
              fEvtRateAvg, fEvtRateAvgMax, fMBRateAvg, fMBRateAvgMax);
   } else {
      // Long version
      Printf(" +++ %d workers were active during this query", fWrksInfo.GetSize());
      Printf(" +++ Total query time: %f secs (init: %f secs, merge: %f secs)",
             fMaxTime, fInitTime, fMaxTime - fMergeTime);
      Printf(" +++ Avg processing rates: %.4f evts/s, %.4f MB/s", fEvtRateAvg, fMBRateAvg);
      Printf(" +++ Max processing rates: %.4f evts/s, %.4f MB/s", fEvtRateAvgMax, fMBRateAvgMax);
   }

   if (!o.IsNull()) gSystem->RedirectOutput(0, 0, &rh);
}

//________________________________________________________________________
void TProofPerfAnalysis::FillFileInfo(Bool_t force)
{
   // Fill basic worker info; if 'force' rescan the TTree even already done

   // Nothing to do if already called
   if (fFilesInfo.GetSize() > 0 && !force) return;

   // Cleanup existing information
   fFilesInfo.SetOwner(kTRUE);
   fFilesInfo.Clear();

   TList *fl = new TList;
   // Extract worker information
   TPerfEvent pe;
   TPerfEvent* pep = &pe;
   fTree->SetBranchAddress("PerfEvents",&pep);
   Long64_t entries = fTree->GetEntries();
   TFileInfo *fi = 0;
   for (Long64_t k=0; k<entries; k++) {
      fTree->GetEntry(k);
      // Analyse only packets
      if (pe.fType == TVirtualPerfStats::kPacket) {
         TUrl uf(pe.fFileName);
         TString srv(uf.GetUrl());
         Int_t ifn = srv.Index(uf.GetFile());
         if (ifn != kNPOS) srv.Remove(ifn);
         // Find out the file instance
         fi = (TFileInfo *) fl->FindObject(uf.GetFile());
         if (!fi) {
            fi = new TFileInfo(uf.GetFile(), srv.Data());
            fl->Add(fi);
            fi->fSizeP = new TGraph(10);
            fi->fRateP = new TGraph(10);
            fi->fRatePRemote = new TGraph(10);
            fi->fMBRateP = new TGraph(10);
            fi->fMBRatePRemote = new TGraph(10);
         }
         // Add Info now
         Float_t stop = pe.fTimeStamp.GetSec() + 1e-9*pe.fTimeStamp.GetNanoSec();
         Float_t start = stop - pe.fProcTime;
         if (fi->fPackets <= 0) {
            fi->fStart = start;
         } else {
            fi->fStop = stop;
         }
         TUrl uw(pe.fSlaveName);

         // Fill size graphs
         fi->fSizeP->SetPoint(fi->fPackets, (Double_t) fi->fPackets, (Double_t) pe.fEventsProcessed);
         fi->fSizeAvg += pe.fEventsProcessed;
         if (pe.fEventsProcessed > fi->fSizeMax || fi->fSizeMax < 0.) fi->fSizeMax = pe.fEventsProcessed;
         if (pe.fEventsProcessed < fi->fSizeMin || fi->fSizeMin < 0.) fi->fSizeMin = pe.fEventsProcessed;

         // Fill rate graphs
         Double_t tt = pe.fTimeStamp.GetSec() + 1e-9*pe.fTimeStamp.GetNanoSec();
         Double_t ert = pe.fEventsProcessed / pe.fProcTime ;
         Double_t brt = pe.fBytesRead / pe.fProcTime / 1024. / 1024. ;
         fi->fRateP->SetPoint(fi->fPackets, tt, ert);
         if (brt > 0.) fi->fMBRateP->SetPoint(fi->fPackets, tt, brt);
         if (!pe.fFileName.IsNull() && strcmp(uf.GetHostFQDN(), uw.GetHostFQDN())) {
            if (!(fi->fRWrkList.FindObject(pe.fSlave))) fi->fRWrkList.Add(new TNamed(pe.fSlave, pe.fSlaveName));
            fi->fRatePRemote->SetPoint(fi->fRPackets, tt, ert);
            fi->fMBRatePRemote->SetPoint(fi->fRPackets, tt, brt);
            fi->fRPackets++;
         }
         fi->fPackets++;
         if (brt > 0) {
            fi->fMBRateAvg += brt;
            if (brt > fi->fMBRateMax || fi->fMBRateMax < 0.) fi->fMBRateMax = brt;
            if (brt < fi->fMBRateMin || fi->fMBRateMin < 0.) fi->fMBRateMin = brt;
         }

         // Packet info
         TPackInfo *pi = new TPackInfo(pe.fSlave, pe.fSlaveName, start, stop, pe.fEventsProcessed, brt);
         fi->fPackList.Add(pi);
         TWrkInfoFile *wif = 0;
         if (!(wif = (TWrkInfoFile *) fi->fWrkList.FindObject(pe.fSlave))) {
            wif = new TWrkInfoFile(pe.fSlave, uf.GetFile());
            fi->fWrkList.Add(wif);
         }
         wif->fPackets.Add(pi);

         // Notify
         if (fDebug > 1) {
            if (pe.fProcTime > 0.) {
               Printf(" +++ %s #:%d at:%fs lat:%fs proc:%fs evts:%lld bytes:%lld (rates:%f evt/s, %f MB/s)",
                     fi->GetName(), fi->fPackets, fMaxTime - pe.fProcTime,
                     pe.fLatency, pe.fProcTime, pe.fEventsProcessed, pe.fBytesRead,
                     ert, brt);
            } else {
               Printf(" +++ %s #:%d at:%fs lat:%fs proc:%fs rate:-- evt/s (-- bytes/s)",
                     fi->GetName(), fi->fPackets, fMaxTime, pe.fLatency, pe.fProcTime);
            }
         }
      } else if (pe.fType == TVirtualPerfStats::kStart) {
         Float_t start = pe.fTimeStamp.GetSec() + 1e-9*pe.fTimeStamp.GetNanoSec();
         if (fDebug > 1) Printf(" +++ %s Start: %f s", pe.fEvtNode.Data(), start);
      } else if (pe.fType == TVirtualPerfStats::kStop) {
         Float_t stop = pe.fTimeStamp.GetSec() + 1e-9*pe.fTimeStamp.GetNanoSec();
         if (fDebug > 1) Printf(" +++ %s Stop: %f s", pe.fEvtNode.Data(), stop);
      } else {
         if (fDebug > 2) Printf(" +++ Event type: %d", pe.fType);
      }
   }
   // Final analysis to find relevant times
   TIter nxf(fl);
   while ((fi = (TFileInfo *) nxf())) {
      fFilesInfo.Add(fi);
      // Resize the graphs
      fi->fRateP->Set(fi->fPackets);
      fi->fRatePRemote->Set(fi->fRPackets);
      fi->fMBRateP->Set(fi->fPackets);
      fi->fMBRatePRemote->Set(fi->fRPackets);
   }
   fl->SetOwner(kFALSE);
   delete fl;

   // Print summary
   if (fgDebug)
      Printf(" +++ %d files were processed during this query", fFilesInfo.GetSize());
}

//________________________________________________________________________
void TProofPerfAnalysis::SetDebug(Int_t d)
{
   // Static setter for the verbosity level

   fDebug = d;
}

//________________________________________________________________________
void TProofPerfAnalysis::DoDraw(TObject *o, Option_t *opt, const char *name)
{
   // Draw object 'o' with options 'opt'
   // Save it with 'name' if in saving mode (see SetSaveResult)

   // Draw
   o->Draw(opt);

   // Save the result
   if (fSaveResult) {
      // Preparation is done in SetSaveResult, here we just update
      TDirectory *curdir = gDirectory;
      TFile *f = TFile::Open(fFileResult, "UPDATE");
      if (f && !f->IsZombie()) {
         const char *n = (name && strlen(name) > 0) ? name : 0;
         o->Write(n);
         f->Close();
      }
      if (f) delete f;
      gDirectory = curdir;
   }
} 
 
//________________________________________________________________________
Int_t TProofPerfAnalysis::SetSaveResult(const char *file, Option_t *mode)
{
   // Set save result mode and validate 'file' according to 'mode'.
   // Return 0 on success, -1 if any problem with the file is encountered
   // (save result mode is not enabled in such a case).
   // If 'file' is null saving is disabled.

   // A null 'file' indicates the will to disable
   if (!file) {
      fFileResult = "";
      fSaveResult = kFALSE;
      // Notify
      Printf("Drawn objects saving disabled");
      return 0;
   }

   // Check if there is a change
   if (!fFileResult.IsNull() && fFileResult == file) {
      // No change
      fSaveResult = kTRUE;
      return 0;
   }
   // New or changed file: validate
   fFileResult = "";
   fSaveResult = kFALSE;
   TDirectory *curdir = gDirectory;
   TFile *f = TFile::Open(file, mode);
   if (!f || f->IsZombie()) {
      if (f) delete f;
      fFileResult = "";
      Error("SetSaveResult", "could not open file '%s' in mode '%s'",
                             file ? file : "(undefined)", mode);
      gDirectory = curdir;
      return -1;
   }
   f->Close();
   delete f;
   gDirectory = curdir;
   // Ok
   fFileResult = file;
   fSaveResult = kTRUE;
   // Notify
   Printf("Drawn objects will be saved in file '%s'", file);
   return 0;
}

//________________________________________________________________________
void TProofPerfAnalysis::SetgDebug(Bool_t on)
{
   // Static setter for the verbosity level

   fgDebug = on;
}
//________________________________________________________________________
void TProofPerfAnalysis::EventDist()
{
   // Display event and packet distribution

   if (!fEvents || !fPackets) {
      Error("EventDist", "distributions not initialized - do nothing");
   }

   // Display histos
   TCanvas *c1 = new TCanvas("evtdist", GetCanvasTitle("Event distributions"),800,10,700,780);
   c1->Divide(1,2);
   TPad *pad1 = (TPad *) c1->GetPad(1);
   pad1->cd();
   fEvents->SetStats(kFALSE);
   DoDraw(fEvents);
   TPad *pad2 = (TPad *) c1->GetPad(2);
   pad2->cd();
   fPackets->SetStats(kFALSE);
   DoDraw(fPackets);
   c1->cd();
   c1->Update();

}

//________________________________________________________________________
void TProofPerfAnalysis::RatePlot(const char *wrks)
{
   // Show event processing or MB processing rate plot vs time

   Bool_t global = (wrks && !strcmp(wrks, "global")) ? kTRUE : kFALSE;

   TH1F *hrt1 = 0, *hrt2 = 0;
   if (global) {
      hrt1 = fEvtRate;
      hrt2 = fMBRate;
   } else {
      // Create the histograms
      TObject *o = 0;
      if ((o = gDirectory->FindObject("rt1"))) delete o;
      hrt1 = new TH1F("rt1", "Evt processing rate (evt/s)", 100, 0., fMaxTime);
      hrt1->SetMinimum(0.);
      hrt1->SetMaximum(1.05*fEvtRateMax);
      hrt1->SetStats(kFALSE);
      hrt1->GetXaxis()->SetTitle("Query Processing Time (s)");
      if ((o = gDirectory->FindObject("rt2"))) delete o;
      hrt2 = new TH1F("rt2", "MB processing rate (MB/s)", 100, 0., fMaxTime);
      hrt2->SetMinimum(0.);
      hrt2->SetMaximum(1.05*fMBRateMax);
      hrt2->SetStats(kFALSE);
      hrt2->GetXaxis()->SetTitle("Query Processing Time (s)");
   }

   // Display histo frames
   TCanvas *c1 = new TCanvas("rates", GetCanvasTitle("Processing rates"), 800,10,700,780);
   c1->Divide(1,2);
   TPad *pad1 = (TPad *) c1->GetPad(1);
   pad1->cd();
   hrt1->Draw();
   if (global) DoDraw(fEvtRateRun, "SAME", "EvtRateRun");
   TPad *pad2 = (TPad *) c1->GetPad(2);
   pad2->cd();
   hrt2->Draw();
   if (global) DoDraw(fMBRateRun, "SAME", "MBRateRun");
   c1->cd();
   c1->Update();

   // Done if global
   if (global) return;

   // Which workers?
   THashList *wl = 0;
   TString ww(wrks);
   if (!ww.IsNull() && ww != "*" && ww != "all") {
      TString w;
      Ssiz_t from = 0;
      while ((ww.Tokenize(w, from, ","))) {
         if (!wl) wl = new THashList();
         wl->Add(new TObjString(w.Data()));
      }
   }

   // Now plot the graphs per worker
   Int_t ci = 40, cir = 30, ic = 0;
   TIter nxw(&fWrksInfo);
   TWrkInfo *wi = 0;
   while ((wi = (TWrkInfo *) nxw())) {
      if (wl && !wl->FindObject(wi->GetName())) continue;
      if (wi->fRateT && wi->fRateT->GetN() > 0) {
         wi->fRateT->SetNameTitle(wi->GetName(), wi->GetTitle());
         pad1->cd();
         wi->fRateT->SetLineColor(ci);
         DoDraw(wi->fRateT, "L", TString::Format("RateT-%s", wi->fRateT->GetName()));
      }
      if (wi->fRateRemoteT && wi->fRateRemoteT->GetN() > 0) {
         wi->fRateRemoteT->SetNameTitle(wi->GetName(), wi->GetTitle());
         pad1->cd();
         wi->fRateRemoteT->SetLineColor(cir);
         DoDraw(wi->fRateRemoteT, "L", TString::Format("RateRemoteT-%s", wi->fRateRemoteT->GetName()));
      }
      if (wi->fMBRateT && wi->fMBRateT->GetN() > 0) {
         wi->fMBRateT->SetNameTitle(wi->GetName(), wi->GetTitle());
         pad2->cd();
         wi->fMBRateT->SetLineColor(ci);
         DoDraw(wi->fMBRateT, "L", TString::Format("MBRateT-%s", wi->fMBRateT->GetName()));
      }
      if (wi->fMBRateRemoteT && wi->fMBRateRemoteT->GetN() > 0) {
         wi->fMBRateRemoteT->SetNameTitle(wi->GetName(), wi->GetTitle());
         pad2->cd();
         wi->fMBRateRemoteT->SetLineColor(cir);
         DoDraw(wi->fMBRateRemoteT, "L", TString::Format("MBRateRemoteT-%s", wi->fMBRateRemoteT->GetName()));
      }
      ic++;
      ci = ic%10 + 40;
      cir = ic%10 + 30;
      c1->cd();
      c1->Update();
   }

   // Cleanup
   if (wl) {
      wl->SetOwner(kTRUE);
      delete wl;
   }
}

//________________________________________________________________________
void TProofPerfAnalysis::LatencyPlot(const char *wrks)
{
   // Show event processing or MB processing rate plot vs time
   // Create the histograms

   TObject *o = 0;
   if ((o = gDirectory->FindObject("lt1"))) delete o;
   TH1F *hlt1 = new TH1F("lt1", "Packet retrieval latency", 100, 0., fMaxTime);
   hlt1->SetMinimum(0.);
   hlt1->SetMaximum(1.05*fLatencyMax);
   hlt1->SetStats(kFALSE);
   hlt1->GetXaxis()->SetTitle("Query Processing Time (s)");
   hlt1->GetYaxis()->SetTitle("Latency (s)");

   // Display histo frames
   TCanvas *c1 = new TCanvas("latency", GetCanvasTitle("Packet Retrieval Latency"), 800,10,700,780);
   hlt1->Draw();
   c1->cd();
   c1->Update();

   // Which workers?
   THashList *wl = 0;
   TString ww(wrks);
   if (!ww.IsNull() && ww != "*" && ww != "all") {
      TString w;
      Ssiz_t from = 0;
      while ((ww.Tokenize(w, from, ","))) {
         if (!wl) wl = new THashList();
         wl->Add(new TObjString(w.Data()));
      }
   }

   // Now plot the graphs per worker
   Int_t ci = 40, ic = 0;
   TIter nxw(&fWrksInfo);
   TWrkInfo *wi = 0;
   while ((wi = (TWrkInfo *) nxw())) {
      if (wl && !wl->FindObject(wi->GetName())) continue;
      if (wi->fLatencyT) {
         wi->fLatencyT->SetNameTitle(wi->GetName(), wi->GetTitle());
         wi->fLatencyT->SetLineColor(ci);
         DoDraw(wi->fLatencyT, "L", TString::Format("LatencyT-%s", wi->fLatencyT->GetName()));
      }
      ic++;
      ci = ic%10 + 40;
      c1->cd();
      c1->Update();
   }

   // Cleanup
   if (wl) {
      wl->SetOwner(kTRUE);
      delete wl;
   }
}

//________________________________________________________________________
void TProofPerfAnalysis::FileProcPlot(const char *fn, const char *out)
{
   // Show event processing or MB processing rate plot vs time

   if (!fn || strlen(fn) <= 0) {
      Error("FileRatePlot", "file name is mandatory!");
      return;
   }
   // Get the file info object
   TFileInfo *fi = (TFileInfo *) fFilesInfo.FindObject(fn);
   if (!fi) {
      Error("FileRatePlot", "TFileInfo object for '%s' not found!", fn);
      return;
   }

   // Output text file, if required
   FILE *fo = stdout;
   if (out && strlen(out) > 0) {
      if (!(fo = fopen(out, "w"))) {
         Warning("FileRatePlot", "problems creating '%s': logging to stdout", out);
         fo = stdout;
      } else {
         Printf(" Details logged to %s", out);
      }
   }

   // Get bins
   Int_t nbins = fi->fPackList.GetSize() * 2;
   Double_t *xraw = new Double_t[nbins];
   Int_t jj = 0;
   TPackInfo *pi = 0;
   TIter nxp(&(fi->fPackList));
   while ((pi = (TPackInfo *) nxp())) {
      // Bins
      xraw[jj++] = pi->fStart;
      xraw[jj++] = pi->fStop;
   }
   Int_t *jidx = new Int_t[nbins];
   memset(jidx, 0, nbins * sizeof(Int_t));
   TMath::Sort(nbins, xraw, jidx, kFALSE);
   Double_t *xbins = new Double_t[nbins];
   Int_t kk =0;
   for (kk = 0; kk < nbins; kk++) {
      xbins[kk] = xraw[jidx[kk]];
   }
   delete [] xraw;
   delete [] jidx;

   // Create the histograms
   Int_t nbin = nbins - 1;
   TObject *o = 0;
   if ((o = gDirectory->FindObject("rt1"))) delete o;
   TH1F *hrt1 = new TH1F("rt1", "Total processing rate (MB/s)", nbins - 1, xbins);
   hrt1->SetMinimum(0.);
   hrt1->SetStats(kFALSE);
   hrt1->GetXaxis()->SetTitle("Query Processing Time (s)");
   if ((o = gDirectory->FindObject("rt2"))) delete o;
   TH1F *hrt2 = new TH1F("rt2", "Number of processing workers", nbins - 1, xbins);
   hrt2->SetMinimum(0.);
   hrt2->SetMaximum(1.2*fWrksInfo.GetSize());
   hrt2->SetStats(kFALSE);
   hrt2->GetXaxis()->SetTitle("Query Processing Time (s)");
   if ((o = gDirectory->FindObject("rt3"))) delete o;
   TH1F *hrt3 = new TH1F("rt3", "Total processing events", nbins - 1, xbins);
   hrt3->SetMinimum(0.);
   hrt3->SetStats(kFALSE);
   hrt3->GetXaxis()->SetTitle("Query Processing Time (s)");
   if ((o = gDirectory->FindObject("rt4"))) delete o;
   TH1F *hrt4 = new TH1F("rt4", "Weighted processing rate (MB/s)", nbins - 1, xbins);
   hrt4->SetMinimum(0.);
   hrt4->SetStats(kFALSE);
   hrt4->GetXaxis()->SetTitle("Query Processing Time (s)");
   // Not needed any longer
   delete [] xbins;

   // Fill histos now
   Int_t ii = 0;
   for (ii = 1; ii <= nbin; ii++) {
      Double_t mi = hrt1->GetBinLowEdge(ii);
      Double_t wd = hrt1->GetBinWidth(ii);
      Double_t mx = mi + wd;
      Double_t xx = hrt1->GetBinCenter(ii);
      fprintf(fo, " Bin: %d/%d [%f, %f]\n", ii, nbin, mi, mx);
      pi = 0;
      kk = 0;
      nxp.Reset();
      while ((pi = (TPackInfo *) nxp())) {
         // Overlap length
         Double_t olap = pi->fStop - mi;
         if (pi->fStart > mi) olap = mx - pi->fStart;
         if (olap >= 0) {
            hrt1->Fill(xx, pi->fMBRate);
            hrt2->Fill(xx, 1.);
            hrt3->Fill(xx, pi->fSize);
            hrt4->Fill(xx, pi->fMBRate * pi->fSize);
            fprintf(fo, "    %d: %s \t%lld \tevts \t%f \tMB/s\n", kk++, pi->GetName(), pi->fSize, pi->fMBRate);
         }
      }
   }
   if (fo != stdout) fclose(fo);

   // Display histo frames
   TCanvas *c1 = new TCanvas("rates", GetCanvasTitle("File processing info"), 800,10,700,780);
   c1->Divide(1,3);
   TPad *pad1 = (TPad *) c1->GetPad(1);
   pad1->cd();
   DoDraw(hrt1);
   TPad *pad2 = (TPad *) c1->GetPad(2);
   pad2->cd();
   DoDraw(hrt2);
   TPad *pad4 = (TPad *) c1->GetPad(3);
   pad4->cd();
   hrt4->Divide(hrt3);
   DoDraw(hrt4);
   c1->cd();
   c1->Update();
}

//________________________________________________________________________
void TProofPerfAnalysis::FileRatePlot(const char *fns)
{
   // Show MB processing rate plot per file vs time

   // Create the histograms
   TObject *o = 0;
   if ((o = gDirectory->FindObject("rt1"))) delete o;
   TH1F *hrt1 = new TH1F("rt1", "Event processing rate per packet (evt/s)", 100, 0., fMaxTime);
   hrt1->SetMinimum(0.);
   hrt1->SetMaximum(1.05*fEvtRateMax);
   hrt1->SetStats(kFALSE);
   hrt1->GetXaxis()->SetTitle("Query Processing Time (s)");
   if ((o = gDirectory->FindObject("rt2"))) delete o;
   TH1F *hrt2 = new TH1F("rt2", "I/O processing rate per packet (MB/s)", 100, 0., fMaxTime);
   hrt2->SetMinimum(0.);
   hrt2->SetMaximum(1.05*fMBRateMax);
   hrt2->SetStats(kFALSE);
   hrt2->GetXaxis()->SetTitle("Query Processing Time (s)");

   // Display histo frames
   TCanvas *c1 = new TCanvas("rates", GetCanvasTitle("Processing rates"), 800,10,700,780);
   c1->Divide(1,2);
   TPad *pad1 = (TPad *) c1->GetPad(1);
   pad1->cd();
   hrt1->Draw();
   TPad *pad2 = (TPad *) c1->GetPad(2);
   pad2->cd();
   hrt2->Draw();
   c1->cd();
   c1->Update();

   // Which workers?
   THashList *fl = 0;
   TString fw(fns);
   if (!fw.IsNull() && fw != "*" && fw != "all") {
      TString w;
      Ssiz_t from = 0;
      while ((fw.Tokenize(w, from, ","))) {
         if (!fl) fl = new THashList();
         fl->Add(new TObjString(w.Data()));
      }
   }

   // Now plot the graphs per worker
   Int_t ci = 40, cir = 30, ic = 0;
   TIter nxf(&fFilesInfo);
   TFileInfo *fi = 0;
   while ((fi = (TFileInfo *) nxf())) {
      if (fl && !fl->FindObject(fi->GetName())) continue;
      if (fi->fRateP && fi->fRateP->GetN() > 0) {
         fi->fRateP->SetNameTitle(fi->GetName(), fi->GetTitle());
         pad1->cd();
         fi->fRateP->SetLineColor(ci);
         DoDraw(fi->fRateP, "L", TString::Format("RateP-%d", ic));
      }
      if (fi->fRatePRemote && fi->fRatePRemote->GetN() > 0) {
         fi->fRatePRemote->SetNameTitle(fi->GetName(), fi->GetTitle());
         pad1->cd();
         fi->fRatePRemote->SetLineColor(cir);
         DoDraw(fi->fRatePRemote, "L", TString::Format("RatePRemote-%d", ic));
      }
      if (fi->fMBRateP && fi->fMBRateP->GetN() > 0) {
         fi->fMBRateP->SetNameTitle(fi->GetName(), fi->GetTitle());
         pad2->cd();
         fi->fMBRateP->SetLineColor(ci);
         DoDraw(fi->fMBRateP, "L", TString::Format("MBRateP-%d", ic));
      }
      if (fi->fMBRatePRemote && fi->fMBRatePRemote->GetN() > 0) {
         fi->fMBRatePRemote->SetNameTitle(fi->GetName(), fi->GetTitle());
         pad2->cd();
         fi->fMBRatePRemote->SetLineColor(cir);
         DoDraw(fi->fMBRatePRemote, "L", TString::Format("MBRatePRemote-%d", ic));
      }
      ic++;
      ci = ic%10 + 40;
      cir = ic%10 + 30;
      c1->cd();
      c1->Update();
   }

   // Cleanup
   if (fl) {
      fl->SetOwner(kTRUE);
      delete fl;
   }
}
 TProofPerfAnalysis.cxx:1
 TProofPerfAnalysis.cxx:2
 TProofPerfAnalysis.cxx:3
 TProofPerfAnalysis.cxx:4
 TProofPerfAnalysis.cxx:5
 TProofPerfAnalysis.cxx:6
 TProofPerfAnalysis.cxx:7
 TProofPerfAnalysis.cxx:8
 TProofPerfAnalysis.cxx:9
 TProofPerfAnalysis.cxx:10
 TProofPerfAnalysis.cxx:11
 TProofPerfAnalysis.cxx:12
 TProofPerfAnalysis.cxx:13
 TProofPerfAnalysis.cxx:14
 TProofPerfAnalysis.cxx:15
 TProofPerfAnalysis.cxx:16
 TProofPerfAnalysis.cxx:17
 TProofPerfAnalysis.cxx:18
 TProofPerfAnalysis.cxx:19
 TProofPerfAnalysis.cxx:20
 TProofPerfAnalysis.cxx:21
 TProofPerfAnalysis.cxx:22
 TProofPerfAnalysis.cxx:23
 TProofPerfAnalysis.cxx:24
 TProofPerfAnalysis.cxx:25
 TProofPerfAnalysis.cxx:26
 TProofPerfAnalysis.cxx:27
 TProofPerfAnalysis.cxx:28
 TProofPerfAnalysis.cxx:29
 TProofPerfAnalysis.cxx:30
 TProofPerfAnalysis.cxx:31
 TProofPerfAnalysis.cxx:32
 TProofPerfAnalysis.cxx:33
 TProofPerfAnalysis.cxx:34
 TProofPerfAnalysis.cxx:35
 TProofPerfAnalysis.cxx:36
 TProofPerfAnalysis.cxx:37
 TProofPerfAnalysis.cxx:38
 TProofPerfAnalysis.cxx:39
 TProofPerfAnalysis.cxx:40
 TProofPerfAnalysis.cxx:41
 TProofPerfAnalysis.cxx:42
 TProofPerfAnalysis.cxx:43
 TProofPerfAnalysis.cxx:44
 TProofPerfAnalysis.cxx:45
 TProofPerfAnalysis.cxx:46
 TProofPerfAnalysis.cxx:47
 TProofPerfAnalysis.cxx:48
 TProofPerfAnalysis.cxx:49
 TProofPerfAnalysis.cxx:50
 TProofPerfAnalysis.cxx:51
 TProofPerfAnalysis.cxx:52
 TProofPerfAnalysis.cxx:53
 TProofPerfAnalysis.cxx:54
 TProofPerfAnalysis.cxx:55
 TProofPerfAnalysis.cxx:56
 TProofPerfAnalysis.cxx:57
 TProofPerfAnalysis.cxx:58
 TProofPerfAnalysis.cxx:59
 TProofPerfAnalysis.cxx:60
 TProofPerfAnalysis.cxx:61
 TProofPerfAnalysis.cxx:62
 TProofPerfAnalysis.cxx:63
 TProofPerfAnalysis.cxx:64
 TProofPerfAnalysis.cxx:65
 TProofPerfAnalysis.cxx:66
 TProofPerfAnalysis.cxx:67
 TProofPerfAnalysis.cxx:68
 TProofPerfAnalysis.cxx:69
 TProofPerfAnalysis.cxx:70
 TProofPerfAnalysis.cxx:71
 TProofPerfAnalysis.cxx:72
 TProofPerfAnalysis.cxx:73
 TProofPerfAnalysis.cxx:74
 TProofPerfAnalysis.cxx:75
 TProofPerfAnalysis.cxx:76
 TProofPerfAnalysis.cxx:77
 TProofPerfAnalysis.cxx:78
 TProofPerfAnalysis.cxx:79
 TProofPerfAnalysis.cxx:80
 TProofPerfAnalysis.cxx:81
 TProofPerfAnalysis.cxx:82
 TProofPerfAnalysis.cxx:83
 TProofPerfAnalysis.cxx:84
 TProofPerfAnalysis.cxx:85
 TProofPerfAnalysis.cxx:86
 TProofPerfAnalysis.cxx:87
 TProofPerfAnalysis.cxx:88
 TProofPerfAnalysis.cxx:89
 TProofPerfAnalysis.cxx:90
 TProofPerfAnalysis.cxx:91
 TProofPerfAnalysis.cxx:92
 TProofPerfAnalysis.cxx:93
 TProofPerfAnalysis.cxx:94
 TProofPerfAnalysis.cxx:95
 TProofPerfAnalysis.cxx:96
 TProofPerfAnalysis.cxx:97
 TProofPerfAnalysis.cxx:98
 TProofPerfAnalysis.cxx:99
 TProofPerfAnalysis.cxx:100
 TProofPerfAnalysis.cxx:101
 TProofPerfAnalysis.cxx:102
 TProofPerfAnalysis.cxx:103
 TProofPerfAnalysis.cxx:104
 TProofPerfAnalysis.cxx:105
 TProofPerfAnalysis.cxx:106
 TProofPerfAnalysis.cxx:107
 TProofPerfAnalysis.cxx:108
 TProofPerfAnalysis.cxx:109
 TProofPerfAnalysis.cxx:110
 TProofPerfAnalysis.cxx:111
 TProofPerfAnalysis.cxx:112
 TProofPerfAnalysis.cxx:113
 TProofPerfAnalysis.cxx:114
 TProofPerfAnalysis.cxx:115
 TProofPerfAnalysis.cxx:116
 TProofPerfAnalysis.cxx:117
 TProofPerfAnalysis.cxx:118
 TProofPerfAnalysis.cxx:119
 TProofPerfAnalysis.cxx:120
 TProofPerfAnalysis.cxx:121
 TProofPerfAnalysis.cxx:122
 TProofPerfAnalysis.cxx:123
 TProofPerfAnalysis.cxx:124
 TProofPerfAnalysis.cxx:125
 TProofPerfAnalysis.cxx:126
 TProofPerfAnalysis.cxx:127
 TProofPerfAnalysis.cxx:128
 TProofPerfAnalysis.cxx:129
 TProofPerfAnalysis.cxx:130
 TProofPerfAnalysis.cxx:131
 TProofPerfAnalysis.cxx:132
 TProofPerfAnalysis.cxx:133
 TProofPerfAnalysis.cxx:134
 TProofPerfAnalysis.cxx:135
 TProofPerfAnalysis.cxx:136
 TProofPerfAnalysis.cxx:137
 TProofPerfAnalysis.cxx:138
 TProofPerfAnalysis.cxx:139
 TProofPerfAnalysis.cxx:140
 TProofPerfAnalysis.cxx:141
 TProofPerfAnalysis.cxx:142
 TProofPerfAnalysis.cxx:143
 TProofPerfAnalysis.cxx:144
 TProofPerfAnalysis.cxx:145
 TProofPerfAnalysis.cxx:146
 TProofPerfAnalysis.cxx:147
 TProofPerfAnalysis.cxx:148
 TProofPerfAnalysis.cxx:149
 TProofPerfAnalysis.cxx:150
 TProofPerfAnalysis.cxx:151
 TProofPerfAnalysis.cxx:152
 TProofPerfAnalysis.cxx:153
 TProofPerfAnalysis.cxx:154
 TProofPerfAnalysis.cxx:155
 TProofPerfAnalysis.cxx:156
 TProofPerfAnalysis.cxx:157
 TProofPerfAnalysis.cxx:158
 TProofPerfAnalysis.cxx:159
 TProofPerfAnalysis.cxx:160
 TProofPerfAnalysis.cxx:161
 TProofPerfAnalysis.cxx:162
 TProofPerfAnalysis.cxx:163
 TProofPerfAnalysis.cxx:164
 TProofPerfAnalysis.cxx:165
 TProofPerfAnalysis.cxx:166
 TProofPerfAnalysis.cxx:167
 TProofPerfAnalysis.cxx:168
 TProofPerfAnalysis.cxx:169
 TProofPerfAnalysis.cxx:170
 TProofPerfAnalysis.cxx:171
 TProofPerfAnalysis.cxx:172
 TProofPerfAnalysis.cxx:173
 TProofPerfAnalysis.cxx:174
 TProofPerfAnalysis.cxx:175
 TProofPerfAnalysis.cxx:176
 TProofPerfAnalysis.cxx:177
 TProofPerfAnalysis.cxx:178
 TProofPerfAnalysis.cxx:179
 TProofPerfAnalysis.cxx:180
 TProofPerfAnalysis.cxx:181
 TProofPerfAnalysis.cxx:182
 TProofPerfAnalysis.cxx:183
 TProofPerfAnalysis.cxx:184
 TProofPerfAnalysis.cxx:185
 TProofPerfAnalysis.cxx:186
 TProofPerfAnalysis.cxx:187
 TProofPerfAnalysis.cxx:188
 TProofPerfAnalysis.cxx:189
 TProofPerfAnalysis.cxx:190
 TProofPerfAnalysis.cxx:191
 TProofPerfAnalysis.cxx:192
 TProofPerfAnalysis.cxx:193
 TProofPerfAnalysis.cxx:194
 TProofPerfAnalysis.cxx:195
 TProofPerfAnalysis.cxx:196
 TProofPerfAnalysis.cxx:197
 TProofPerfAnalysis.cxx:198
 TProofPerfAnalysis.cxx:199
 TProofPerfAnalysis.cxx:200
 TProofPerfAnalysis.cxx:201
 TProofPerfAnalysis.cxx:202
 TProofPerfAnalysis.cxx:203
 TProofPerfAnalysis.cxx:204
 TProofPerfAnalysis.cxx:205
 TProofPerfAnalysis.cxx:206
 TProofPerfAnalysis.cxx:207
 TProofPerfAnalysis.cxx:208
 TProofPerfAnalysis.cxx:209
 TProofPerfAnalysis.cxx:210
 TProofPerfAnalysis.cxx:211
 TProofPerfAnalysis.cxx:212
 TProofPerfAnalysis.cxx:213
 TProofPerfAnalysis.cxx:214
 TProofPerfAnalysis.cxx:215
 TProofPerfAnalysis.cxx:216
 TProofPerfAnalysis.cxx:217
 TProofPerfAnalysis.cxx:218
 TProofPerfAnalysis.cxx:219
 TProofPerfAnalysis.cxx:220
 TProofPerfAnalysis.cxx:221
 TProofPerfAnalysis.cxx:222
 TProofPerfAnalysis.cxx:223
 TProofPerfAnalysis.cxx:224
 TProofPerfAnalysis.cxx:225
 TProofPerfAnalysis.cxx:226
 TProofPerfAnalysis.cxx:227
 TProofPerfAnalysis.cxx:228
 TProofPerfAnalysis.cxx:229
 TProofPerfAnalysis.cxx:230
 TProofPerfAnalysis.cxx:231
 TProofPerfAnalysis.cxx:232
 TProofPerfAnalysis.cxx:233
 TProofPerfAnalysis.cxx:234
 TProofPerfAnalysis.cxx:235
 TProofPerfAnalysis.cxx:236
 TProofPerfAnalysis.cxx:237
 TProofPerfAnalysis.cxx:238
 TProofPerfAnalysis.cxx:239
 TProofPerfAnalysis.cxx:240
 TProofPerfAnalysis.cxx:241
 TProofPerfAnalysis.cxx:242
 TProofPerfAnalysis.cxx:243
 TProofPerfAnalysis.cxx:244
 TProofPerfAnalysis.cxx:245
 TProofPerfAnalysis.cxx:246
 TProofPerfAnalysis.cxx:247
 TProofPerfAnalysis.cxx:248
 TProofPerfAnalysis.cxx:249
 TProofPerfAnalysis.cxx:250
 TProofPerfAnalysis.cxx:251
 TProofPerfAnalysis.cxx:252
 TProofPerfAnalysis.cxx:253
 TProofPerfAnalysis.cxx:254
 TProofPerfAnalysis.cxx:255
 TProofPerfAnalysis.cxx:256
 TProofPerfAnalysis.cxx:257
 TProofPerfAnalysis.cxx:258
 TProofPerfAnalysis.cxx:259
 TProofPerfAnalysis.cxx:260
 TProofPerfAnalysis.cxx:261
 TProofPerfAnalysis.cxx:262
 TProofPerfAnalysis.cxx:263
 TProofPerfAnalysis.cxx:264
 TProofPerfAnalysis.cxx:265
 TProofPerfAnalysis.cxx:266
 TProofPerfAnalysis.cxx:267
 TProofPerfAnalysis.cxx:268
 TProofPerfAnalysis.cxx:269
 TProofPerfAnalysis.cxx:270
 TProofPerfAnalysis.cxx:271
 TProofPerfAnalysis.cxx:272
 TProofPerfAnalysis.cxx:273
 TProofPerfAnalysis.cxx:274
 TProofPerfAnalysis.cxx:275
 TProofPerfAnalysis.cxx:276
 TProofPerfAnalysis.cxx:277
 TProofPerfAnalysis.cxx:278
 TProofPerfAnalysis.cxx:279
 TProofPerfAnalysis.cxx:280
 TProofPerfAnalysis.cxx:281
 TProofPerfAnalysis.cxx:282
 TProofPerfAnalysis.cxx:283
 TProofPerfAnalysis.cxx:284
 TProofPerfAnalysis.cxx:285
 TProofPerfAnalysis.cxx:286
 TProofPerfAnalysis.cxx:287
 TProofPerfAnalysis.cxx:288
 TProofPerfAnalysis.cxx:289
 TProofPerfAnalysis.cxx:290
 TProofPerfAnalysis.cxx:291
 TProofPerfAnalysis.cxx:292
 TProofPerfAnalysis.cxx:293
 TProofPerfAnalysis.cxx:294
 TProofPerfAnalysis.cxx:295
 TProofPerfAnalysis.cxx:296
 TProofPerfAnalysis.cxx:297
 TProofPerfAnalysis.cxx:298
 TProofPerfAnalysis.cxx:299
 TProofPerfAnalysis.cxx:300
 TProofPerfAnalysis.cxx:301
 TProofPerfAnalysis.cxx:302
 TProofPerfAnalysis.cxx:303
 TProofPerfAnalysis.cxx:304
 TProofPerfAnalysis.cxx:305
 TProofPerfAnalysis.cxx:306
 TProofPerfAnalysis.cxx:307
 TProofPerfAnalysis.cxx:308
 TProofPerfAnalysis.cxx:309
 TProofPerfAnalysis.cxx:310
 TProofPerfAnalysis.cxx:311
 TProofPerfAnalysis.cxx:312
 TProofPerfAnalysis.cxx:313
 TProofPerfAnalysis.cxx:314
 TProofPerfAnalysis.cxx:315
 TProofPerfAnalysis.cxx:316
 TProofPerfAnalysis.cxx:317
 TProofPerfAnalysis.cxx:318
 TProofPerfAnalysis.cxx:319
 TProofPerfAnalysis.cxx:320
 TProofPerfAnalysis.cxx:321
 TProofPerfAnalysis.cxx:322
 TProofPerfAnalysis.cxx:323
 TProofPerfAnalysis.cxx:324
 TProofPerfAnalysis.cxx:325
 TProofPerfAnalysis.cxx:326
 TProofPerfAnalysis.cxx:327
 TProofPerfAnalysis.cxx:328
 TProofPerfAnalysis.cxx:329
 TProofPerfAnalysis.cxx:330
 TProofPerfAnalysis.cxx:331
 TProofPerfAnalysis.cxx:332
 TProofPerfAnalysis.cxx:333
 TProofPerfAnalysis.cxx:334
 TProofPerfAnalysis.cxx:335
 TProofPerfAnalysis.cxx:336
 TProofPerfAnalysis.cxx:337
 TProofPerfAnalysis.cxx:338
 TProofPerfAnalysis.cxx:339
 TProofPerfAnalysis.cxx:340
 TProofPerfAnalysis.cxx:341
 TProofPerfAnalysis.cxx:342
 TProofPerfAnalysis.cxx:343
 TProofPerfAnalysis.cxx:344
 TProofPerfAnalysis.cxx:345
 TProofPerfAnalysis.cxx:346
 TProofPerfAnalysis.cxx:347
 TProofPerfAnalysis.cxx:348
 TProofPerfAnalysis.cxx:349
 TProofPerfAnalysis.cxx:350
 TProofPerfAnalysis.cxx:351
 TProofPerfAnalysis.cxx:352
 TProofPerfAnalysis.cxx:353
 TProofPerfAnalysis.cxx:354
 TProofPerfAnalysis.cxx:355
 TProofPerfAnalysis.cxx:356
 TProofPerfAnalysis.cxx:357
 TProofPerfAnalysis.cxx:358
 TProofPerfAnalysis.cxx:359
 TProofPerfAnalysis.cxx:360
 TProofPerfAnalysis.cxx:361
 TProofPerfAnalysis.cxx:362
 TProofPerfAnalysis.cxx:363
 TProofPerfAnalysis.cxx:364
 TProofPerfAnalysis.cxx:365
 TProofPerfAnalysis.cxx:366
 TProofPerfAnalysis.cxx:367
 TProofPerfAnalysis.cxx:368
 TProofPerfAnalysis.cxx:369
 TProofPerfAnalysis.cxx:370
 TProofPerfAnalysis.cxx:371
 TProofPerfAnalysis.cxx:372
 TProofPerfAnalysis.cxx:373
 TProofPerfAnalysis.cxx:374
 TProofPerfAnalysis.cxx:375
 TProofPerfAnalysis.cxx:376
 TProofPerfAnalysis.cxx:377
 TProofPerfAnalysis.cxx:378
 TProofPerfAnalysis.cxx:379
 TProofPerfAnalysis.cxx:380
 TProofPerfAnalysis.cxx:381
 TProofPerfAnalysis.cxx:382
 TProofPerfAnalysis.cxx:383
 TProofPerfAnalysis.cxx:384
 TProofPerfAnalysis.cxx:385
 TProofPerfAnalysis.cxx:386
 TProofPerfAnalysis.cxx:387
 TProofPerfAnalysis.cxx:388
 TProofPerfAnalysis.cxx:389
 TProofPerfAnalysis.cxx:390
 TProofPerfAnalysis.cxx:391
 TProofPerfAnalysis.cxx:392
 TProofPerfAnalysis.cxx:393
 TProofPerfAnalysis.cxx:394
 TProofPerfAnalysis.cxx:395
 TProofPerfAnalysis.cxx:396
 TProofPerfAnalysis.cxx:397
 TProofPerfAnalysis.cxx:398
 TProofPerfAnalysis.cxx:399
 TProofPerfAnalysis.cxx:400
 TProofPerfAnalysis.cxx:401
 TProofPerfAnalysis.cxx:402
 TProofPerfAnalysis.cxx:403
 TProofPerfAnalysis.cxx:404
 TProofPerfAnalysis.cxx:405
 TProofPerfAnalysis.cxx:406
 TProofPerfAnalysis.cxx:407
 TProofPerfAnalysis.cxx:408
 TProofPerfAnalysis.cxx:409
 TProofPerfAnalysis.cxx:410
 TProofPerfAnalysis.cxx:411
 TProofPerfAnalysis.cxx:412
 TProofPerfAnalysis.cxx:413
 TProofPerfAnalysis.cxx:414
 TProofPerfAnalysis.cxx:415
 TProofPerfAnalysis.cxx:416
 TProofPerfAnalysis.cxx:417
 TProofPerfAnalysis.cxx:418
 TProofPerfAnalysis.cxx:419
 TProofPerfAnalysis.cxx:420
 TProofPerfAnalysis.cxx:421
 TProofPerfAnalysis.cxx:422
 TProofPerfAnalysis.cxx:423
 TProofPerfAnalysis.cxx:424
 TProofPerfAnalysis.cxx:425
 TProofPerfAnalysis.cxx:426
 TProofPerfAnalysis.cxx:427
 TProofPerfAnalysis.cxx:428
 TProofPerfAnalysis.cxx:429
 TProofPerfAnalysis.cxx:430
 TProofPerfAnalysis.cxx:431
 TProofPerfAnalysis.cxx:432
 TProofPerfAnalysis.cxx:433
 TProofPerfAnalysis.cxx:434
 TProofPerfAnalysis.cxx:435
 TProofPerfAnalysis.cxx:436
 TProofPerfAnalysis.cxx:437
 TProofPerfAnalysis.cxx:438
 TProofPerfAnalysis.cxx:439
 TProofPerfAnalysis.cxx:440
 TProofPerfAnalysis.cxx:441
 TProofPerfAnalysis.cxx:442
 TProofPerfAnalysis.cxx:443
 TProofPerfAnalysis.cxx:444
 TProofPerfAnalysis.cxx:445
 TProofPerfAnalysis.cxx:446
 TProofPerfAnalysis.cxx:447
 TProofPerfAnalysis.cxx:448
 TProofPerfAnalysis.cxx:449
 TProofPerfAnalysis.cxx:450
 TProofPerfAnalysis.cxx:451
 TProofPerfAnalysis.cxx:452
 TProofPerfAnalysis.cxx:453
 TProofPerfAnalysis.cxx:454
 TProofPerfAnalysis.cxx:455
 TProofPerfAnalysis.cxx:456
 TProofPerfAnalysis.cxx:457
 TProofPerfAnalysis.cxx:458
 TProofPerfAnalysis.cxx:459
 TProofPerfAnalysis.cxx:460
 TProofPerfAnalysis.cxx:461
 TProofPerfAnalysis.cxx:462
 TProofPerfAnalysis.cxx:463
 TProofPerfAnalysis.cxx:464
 TProofPerfAnalysis.cxx:465
 TProofPerfAnalysis.cxx:466
 TProofPerfAnalysis.cxx:467
 TProofPerfAnalysis.cxx:468
 TProofPerfAnalysis.cxx:469
 TProofPerfAnalysis.cxx:470
 TProofPerfAnalysis.cxx:471
 TProofPerfAnalysis.cxx:472
 TProofPerfAnalysis.cxx:473
 TProofPerfAnalysis.cxx:474
 TProofPerfAnalysis.cxx:475
 TProofPerfAnalysis.cxx:476
 TProofPerfAnalysis.cxx:477
 TProofPerfAnalysis.cxx:478
 TProofPerfAnalysis.cxx:479
 TProofPerfAnalysis.cxx:480
 TProofPerfAnalysis.cxx:481
 TProofPerfAnalysis.cxx:482
 TProofPerfAnalysis.cxx:483
 TProofPerfAnalysis.cxx:484
 TProofPerfAnalysis.cxx:485
 TProofPerfAnalysis.cxx:486
 TProofPerfAnalysis.cxx:487
 TProofPerfAnalysis.cxx:488
 TProofPerfAnalysis.cxx:489
 TProofPerfAnalysis.cxx:490
 TProofPerfAnalysis.cxx:491
 TProofPerfAnalysis.cxx:492
 TProofPerfAnalysis.cxx:493
 TProofPerfAnalysis.cxx:494
 TProofPerfAnalysis.cxx:495
 TProofPerfAnalysis.cxx:496
 TProofPerfAnalysis.cxx:497
 TProofPerfAnalysis.cxx:498
 TProofPerfAnalysis.cxx:499
 TProofPerfAnalysis.cxx:500
 TProofPerfAnalysis.cxx:501
 TProofPerfAnalysis.cxx:502
 TProofPerfAnalysis.cxx:503
 TProofPerfAnalysis.cxx:504
 TProofPerfAnalysis.cxx:505
 TProofPerfAnalysis.cxx:506
 TProofPerfAnalysis.cxx:507
 TProofPerfAnalysis.cxx:508
 TProofPerfAnalysis.cxx:509
 TProofPerfAnalysis.cxx:510
 TProofPerfAnalysis.cxx:511
 TProofPerfAnalysis.cxx:512
 TProofPerfAnalysis.cxx:513
 TProofPerfAnalysis.cxx:514
 TProofPerfAnalysis.cxx:515
 TProofPerfAnalysis.cxx:516
 TProofPerfAnalysis.cxx:517
 TProofPerfAnalysis.cxx:518
 TProofPerfAnalysis.cxx:519
 TProofPerfAnalysis.cxx:520
 TProofPerfAnalysis.cxx:521
 TProofPerfAnalysis.cxx:522
 TProofPerfAnalysis.cxx:523
 TProofPerfAnalysis.cxx:524
 TProofPerfAnalysis.cxx:525
 TProofPerfAnalysis.cxx:526
 TProofPerfAnalysis.cxx:527
 TProofPerfAnalysis.cxx:528
 TProofPerfAnalysis.cxx:529
 TProofPerfAnalysis.cxx:530
 TProofPerfAnalysis.cxx:531
 TProofPerfAnalysis.cxx:532
 TProofPerfAnalysis.cxx:533
 TProofPerfAnalysis.cxx:534
 TProofPerfAnalysis.cxx:535
 TProofPerfAnalysis.cxx:536
 TProofPerfAnalysis.cxx:537
 TProofPerfAnalysis.cxx:538
 TProofPerfAnalysis.cxx:539
 TProofPerfAnalysis.cxx:540
 TProofPerfAnalysis.cxx:541
 TProofPerfAnalysis.cxx:542
 TProofPerfAnalysis.cxx:543
 TProofPerfAnalysis.cxx:544
 TProofPerfAnalysis.cxx:545
 TProofPerfAnalysis.cxx:546
 TProofPerfAnalysis.cxx:547
 TProofPerfAnalysis.cxx:548
 TProofPerfAnalysis.cxx:549
 TProofPerfAnalysis.cxx:550
 TProofPerfAnalysis.cxx:551
 TProofPerfAnalysis.cxx:552
 TProofPerfAnalysis.cxx:553
 TProofPerfAnalysis.cxx:554
 TProofPerfAnalysis.cxx:555
 TProofPerfAnalysis.cxx:556
 TProofPerfAnalysis.cxx:557
 TProofPerfAnalysis.cxx:558
 TProofPerfAnalysis.cxx:559
 TProofPerfAnalysis.cxx:560
 TProofPerfAnalysis.cxx:561
 TProofPerfAnalysis.cxx:562
 TProofPerfAnalysis.cxx:563
 TProofPerfAnalysis.cxx:564
 TProofPerfAnalysis.cxx:565
 TProofPerfAnalysis.cxx:566
 TProofPerfAnalysis.cxx:567
 TProofPerfAnalysis.cxx:568
 TProofPerfAnalysis.cxx:569
 TProofPerfAnalysis.cxx:570
 TProofPerfAnalysis.cxx:571
 TProofPerfAnalysis.cxx:572
 TProofPerfAnalysis.cxx:573
 TProofPerfAnalysis.cxx:574
 TProofPerfAnalysis.cxx:575
 TProofPerfAnalysis.cxx:576
 TProofPerfAnalysis.cxx:577
 TProofPerfAnalysis.cxx:578
 TProofPerfAnalysis.cxx:579
 TProofPerfAnalysis.cxx:580
 TProofPerfAnalysis.cxx:581
 TProofPerfAnalysis.cxx:582
 TProofPerfAnalysis.cxx:583
 TProofPerfAnalysis.cxx:584
 TProofPerfAnalysis.cxx:585
 TProofPerfAnalysis.cxx:586
 TProofPerfAnalysis.cxx:587
 TProofPerfAnalysis.cxx:588
 TProofPerfAnalysis.cxx:589
 TProofPerfAnalysis.cxx:590
 TProofPerfAnalysis.cxx:591
 TProofPerfAnalysis.cxx:592
 TProofPerfAnalysis.cxx:593
 TProofPerfAnalysis.cxx:594
 TProofPerfAnalysis.cxx:595
 TProofPerfAnalysis.cxx:596
 TProofPerfAnalysis.cxx:597
 TProofPerfAnalysis.cxx:598
 TProofPerfAnalysis.cxx:599
 TProofPerfAnalysis.cxx:600
 TProofPerfAnalysis.cxx:601
 TProofPerfAnalysis.cxx:602
 TProofPerfAnalysis.cxx:603
 TProofPerfAnalysis.cxx:604
 TProofPerfAnalysis.cxx:605
 TProofPerfAnalysis.cxx:606
 TProofPerfAnalysis.cxx:607
 TProofPerfAnalysis.cxx:608
 TProofPerfAnalysis.cxx:609
 TProofPerfAnalysis.cxx:610
 TProofPerfAnalysis.cxx:611
 TProofPerfAnalysis.cxx:612
 TProofPerfAnalysis.cxx:613
 TProofPerfAnalysis.cxx:614
 TProofPerfAnalysis.cxx:615
 TProofPerfAnalysis.cxx:616
 TProofPerfAnalysis.cxx:617
 TProofPerfAnalysis.cxx:618
 TProofPerfAnalysis.cxx:619
 TProofPerfAnalysis.cxx:620
 TProofPerfAnalysis.cxx:621
 TProofPerfAnalysis.cxx:622
 TProofPerfAnalysis.cxx:623
 TProofPerfAnalysis.cxx:624
 TProofPerfAnalysis.cxx:625
 TProofPerfAnalysis.cxx:626
 TProofPerfAnalysis.cxx:627
 TProofPerfAnalysis.cxx:628
 TProofPerfAnalysis.cxx:629
 TProofPerfAnalysis.cxx:630
 TProofPerfAnalysis.cxx:631
 TProofPerfAnalysis.cxx:632
 TProofPerfAnalysis.cxx:633
 TProofPerfAnalysis.cxx:634
 TProofPerfAnalysis.cxx:635
 TProofPerfAnalysis.cxx:636
 TProofPerfAnalysis.cxx:637
 TProofPerfAnalysis.cxx:638
 TProofPerfAnalysis.cxx:639
 TProofPerfAnalysis.cxx:640
 TProofPerfAnalysis.cxx:641
 TProofPerfAnalysis.cxx:642
 TProofPerfAnalysis.cxx:643
 TProofPerfAnalysis.cxx:644
 TProofPerfAnalysis.cxx:645
 TProofPerfAnalysis.cxx:646
 TProofPerfAnalysis.cxx:647
 TProofPerfAnalysis.cxx:648
 TProofPerfAnalysis.cxx:649
 TProofPerfAnalysis.cxx:650
 TProofPerfAnalysis.cxx:651
 TProofPerfAnalysis.cxx:652
 TProofPerfAnalysis.cxx:653
 TProofPerfAnalysis.cxx:654
 TProofPerfAnalysis.cxx:655
 TProofPerfAnalysis.cxx:656
 TProofPerfAnalysis.cxx:657
 TProofPerfAnalysis.cxx:658
 TProofPerfAnalysis.cxx:659
 TProofPerfAnalysis.cxx:660
 TProofPerfAnalysis.cxx:661
 TProofPerfAnalysis.cxx:662
 TProofPerfAnalysis.cxx:663
 TProofPerfAnalysis.cxx:664
 TProofPerfAnalysis.cxx:665
 TProofPerfAnalysis.cxx:666
 TProofPerfAnalysis.cxx:667
 TProofPerfAnalysis.cxx:668
 TProofPerfAnalysis.cxx:669
 TProofPerfAnalysis.cxx:670
 TProofPerfAnalysis.cxx:671
 TProofPerfAnalysis.cxx:672
 TProofPerfAnalysis.cxx:673
 TProofPerfAnalysis.cxx:674
 TProofPerfAnalysis.cxx:675
 TProofPerfAnalysis.cxx:676
 TProofPerfAnalysis.cxx:677
 TProofPerfAnalysis.cxx:678
 TProofPerfAnalysis.cxx:679
 TProofPerfAnalysis.cxx:680
 TProofPerfAnalysis.cxx:681
 TProofPerfAnalysis.cxx:682
 TProofPerfAnalysis.cxx:683
 TProofPerfAnalysis.cxx:684
 TProofPerfAnalysis.cxx:685
 TProofPerfAnalysis.cxx:686
 TProofPerfAnalysis.cxx:687
 TProofPerfAnalysis.cxx:688
 TProofPerfAnalysis.cxx:689
 TProofPerfAnalysis.cxx:690
 TProofPerfAnalysis.cxx:691
 TProofPerfAnalysis.cxx:692
 TProofPerfAnalysis.cxx:693
 TProofPerfAnalysis.cxx:694
 TProofPerfAnalysis.cxx:695
 TProofPerfAnalysis.cxx:696
 TProofPerfAnalysis.cxx:697
 TProofPerfAnalysis.cxx:698
 TProofPerfAnalysis.cxx:699
 TProofPerfAnalysis.cxx:700
 TProofPerfAnalysis.cxx:701
 TProofPerfAnalysis.cxx:702
 TProofPerfAnalysis.cxx:703
 TProofPerfAnalysis.cxx:704
 TProofPerfAnalysis.cxx:705
 TProofPerfAnalysis.cxx:706
 TProofPerfAnalysis.cxx:707
 TProofPerfAnalysis.cxx:708
 TProofPerfAnalysis.cxx:709
 TProofPerfAnalysis.cxx:710
 TProofPerfAnalysis.cxx:711
 TProofPerfAnalysis.cxx:712
 TProofPerfAnalysis.cxx:713
 TProofPerfAnalysis.cxx:714
 TProofPerfAnalysis.cxx:715
 TProofPerfAnalysis.cxx:716
 TProofPerfAnalysis.cxx:717
 TProofPerfAnalysis.cxx:718
 TProofPerfAnalysis.cxx:719
 TProofPerfAnalysis.cxx:720
 TProofPerfAnalysis.cxx:721
 TProofPerfAnalysis.cxx:722
 TProofPerfAnalysis.cxx:723
 TProofPerfAnalysis.cxx:724
 TProofPerfAnalysis.cxx:725
 TProofPerfAnalysis.cxx:726
 TProofPerfAnalysis.cxx:727
 TProofPerfAnalysis.cxx:728
 TProofPerfAnalysis.cxx:729
 TProofPerfAnalysis.cxx:730
 TProofPerfAnalysis.cxx:731
 TProofPerfAnalysis.cxx:732
 TProofPerfAnalysis.cxx:733
 TProofPerfAnalysis.cxx:734
 TProofPerfAnalysis.cxx:735
 TProofPerfAnalysis.cxx:736
 TProofPerfAnalysis.cxx:737
 TProofPerfAnalysis.cxx:738
 TProofPerfAnalysis.cxx:739
 TProofPerfAnalysis.cxx:740
 TProofPerfAnalysis.cxx:741
 TProofPerfAnalysis.cxx:742
 TProofPerfAnalysis.cxx:743
 TProofPerfAnalysis.cxx:744
 TProofPerfAnalysis.cxx:745
 TProofPerfAnalysis.cxx:746
 TProofPerfAnalysis.cxx:747
 TProofPerfAnalysis.cxx:748
 TProofPerfAnalysis.cxx:749
 TProofPerfAnalysis.cxx:750
 TProofPerfAnalysis.cxx:751
 TProofPerfAnalysis.cxx:752
 TProofPerfAnalysis.cxx:753
 TProofPerfAnalysis.cxx:754
 TProofPerfAnalysis.cxx:755
 TProofPerfAnalysis.cxx:756
 TProofPerfAnalysis.cxx:757
 TProofPerfAnalysis.cxx:758
 TProofPerfAnalysis.cxx:759
 TProofPerfAnalysis.cxx:760
 TProofPerfAnalysis.cxx:761
 TProofPerfAnalysis.cxx:762
 TProofPerfAnalysis.cxx:763
 TProofPerfAnalysis.cxx:764
 TProofPerfAnalysis.cxx:765
 TProofPerfAnalysis.cxx:766
 TProofPerfAnalysis.cxx:767
 TProofPerfAnalysis.cxx:768
 TProofPerfAnalysis.cxx:769
 TProofPerfAnalysis.cxx:770
 TProofPerfAnalysis.cxx:771
 TProofPerfAnalysis.cxx:772
 TProofPerfAnalysis.cxx:773
 TProofPerfAnalysis.cxx:774
 TProofPerfAnalysis.cxx:775
 TProofPerfAnalysis.cxx:776
 TProofPerfAnalysis.cxx:777
 TProofPerfAnalysis.cxx:778
 TProofPerfAnalysis.cxx:779
 TProofPerfAnalysis.cxx:780
 TProofPerfAnalysis.cxx:781
 TProofPerfAnalysis.cxx:782
 TProofPerfAnalysis.cxx:783
 TProofPerfAnalysis.cxx:784
 TProofPerfAnalysis.cxx:785
 TProofPerfAnalysis.cxx:786
 TProofPerfAnalysis.cxx:787
 TProofPerfAnalysis.cxx:788
 TProofPerfAnalysis.cxx:789
 TProofPerfAnalysis.cxx:790
 TProofPerfAnalysis.cxx:791
 TProofPerfAnalysis.cxx:792
 TProofPerfAnalysis.cxx:793
 TProofPerfAnalysis.cxx:794
 TProofPerfAnalysis.cxx:795
 TProofPerfAnalysis.cxx:796
 TProofPerfAnalysis.cxx:797
 TProofPerfAnalysis.cxx:798
 TProofPerfAnalysis.cxx:799
 TProofPerfAnalysis.cxx:800
 TProofPerfAnalysis.cxx:801
 TProofPerfAnalysis.cxx:802
 TProofPerfAnalysis.cxx:803
 TProofPerfAnalysis.cxx:804
 TProofPerfAnalysis.cxx:805
 TProofPerfAnalysis.cxx:806
 TProofPerfAnalysis.cxx:807
 TProofPerfAnalysis.cxx:808
 TProofPerfAnalysis.cxx:809
 TProofPerfAnalysis.cxx:810
 TProofPerfAnalysis.cxx:811
 TProofPerfAnalysis.cxx:812
 TProofPerfAnalysis.cxx:813
 TProofPerfAnalysis.cxx:814
 TProofPerfAnalysis.cxx:815
 TProofPerfAnalysis.cxx:816
 TProofPerfAnalysis.cxx:817
 TProofPerfAnalysis.cxx:818
 TProofPerfAnalysis.cxx:819
 TProofPerfAnalysis.cxx:820
 TProofPerfAnalysis.cxx:821
 TProofPerfAnalysis.cxx:822
 TProofPerfAnalysis.cxx:823
 TProofPerfAnalysis.cxx:824
 TProofPerfAnalysis.cxx:825
 TProofPerfAnalysis.cxx:826
 TProofPerfAnalysis.cxx:827
 TProofPerfAnalysis.cxx:828
 TProofPerfAnalysis.cxx:829
 TProofPerfAnalysis.cxx:830
 TProofPerfAnalysis.cxx:831
 TProofPerfAnalysis.cxx:832
 TProofPerfAnalysis.cxx:833
 TProofPerfAnalysis.cxx:834
 TProofPerfAnalysis.cxx:835
 TProofPerfAnalysis.cxx:836
 TProofPerfAnalysis.cxx:837
 TProofPerfAnalysis.cxx:838
 TProofPerfAnalysis.cxx:839
 TProofPerfAnalysis.cxx:840
 TProofPerfAnalysis.cxx:841
 TProofPerfAnalysis.cxx:842
 TProofPerfAnalysis.cxx:843
 TProofPerfAnalysis.cxx:844
 TProofPerfAnalysis.cxx:845
 TProofPerfAnalysis.cxx:846
 TProofPerfAnalysis.cxx:847
 TProofPerfAnalysis.cxx:848
 TProofPerfAnalysis.cxx:849
 TProofPerfAnalysis.cxx:850
 TProofPerfAnalysis.cxx:851
 TProofPerfAnalysis.cxx:852
 TProofPerfAnalysis.cxx:853
 TProofPerfAnalysis.cxx:854
 TProofPerfAnalysis.cxx:855
 TProofPerfAnalysis.cxx:856
 TProofPerfAnalysis.cxx:857
 TProofPerfAnalysis.cxx:858
 TProofPerfAnalysis.cxx:859
 TProofPerfAnalysis.cxx:860
 TProofPerfAnalysis.cxx:861
 TProofPerfAnalysis.cxx:862
 TProofPerfAnalysis.cxx:863
 TProofPerfAnalysis.cxx:864
 TProofPerfAnalysis.cxx:865
 TProofPerfAnalysis.cxx:866
 TProofPerfAnalysis.cxx:867
 TProofPerfAnalysis.cxx:868
 TProofPerfAnalysis.cxx:869
 TProofPerfAnalysis.cxx:870
 TProofPerfAnalysis.cxx:871
 TProofPerfAnalysis.cxx:872
 TProofPerfAnalysis.cxx:873
 TProofPerfAnalysis.cxx:874
 TProofPerfAnalysis.cxx:875
 TProofPerfAnalysis.cxx:876
 TProofPerfAnalysis.cxx:877
 TProofPerfAnalysis.cxx:878
 TProofPerfAnalysis.cxx:879
 TProofPerfAnalysis.cxx:880
 TProofPerfAnalysis.cxx:881
 TProofPerfAnalysis.cxx:882
 TProofPerfAnalysis.cxx:883
 TProofPerfAnalysis.cxx:884
 TProofPerfAnalysis.cxx:885
 TProofPerfAnalysis.cxx:886
 TProofPerfAnalysis.cxx:887
 TProofPerfAnalysis.cxx:888
 TProofPerfAnalysis.cxx:889
 TProofPerfAnalysis.cxx:890
 TProofPerfAnalysis.cxx:891
 TProofPerfAnalysis.cxx:892
 TProofPerfAnalysis.cxx:893
 TProofPerfAnalysis.cxx:894
 TProofPerfAnalysis.cxx:895
 TProofPerfAnalysis.cxx:896
 TProofPerfAnalysis.cxx:897
 TProofPerfAnalysis.cxx:898
 TProofPerfAnalysis.cxx:899
 TProofPerfAnalysis.cxx:900
 TProofPerfAnalysis.cxx:901
 TProofPerfAnalysis.cxx:902
 TProofPerfAnalysis.cxx:903
 TProofPerfAnalysis.cxx:904
 TProofPerfAnalysis.cxx:905
 TProofPerfAnalysis.cxx:906
 TProofPerfAnalysis.cxx:907
 TProofPerfAnalysis.cxx:908
 TProofPerfAnalysis.cxx:909
 TProofPerfAnalysis.cxx:910
 TProofPerfAnalysis.cxx:911
 TProofPerfAnalysis.cxx:912
 TProofPerfAnalysis.cxx:913
 TProofPerfAnalysis.cxx:914
 TProofPerfAnalysis.cxx:915
 TProofPerfAnalysis.cxx:916
 TProofPerfAnalysis.cxx:917
 TProofPerfAnalysis.cxx:918
 TProofPerfAnalysis.cxx:919
 TProofPerfAnalysis.cxx:920
 TProofPerfAnalysis.cxx:921
 TProofPerfAnalysis.cxx:922
 TProofPerfAnalysis.cxx:923
 TProofPerfAnalysis.cxx:924
 TProofPerfAnalysis.cxx:925
 TProofPerfAnalysis.cxx:926
 TProofPerfAnalysis.cxx:927
 TProofPerfAnalysis.cxx:928
 TProofPerfAnalysis.cxx:929
 TProofPerfAnalysis.cxx:930
 TProofPerfAnalysis.cxx:931
 TProofPerfAnalysis.cxx:932
 TProofPerfAnalysis.cxx:933
 TProofPerfAnalysis.cxx:934
 TProofPerfAnalysis.cxx:935
 TProofPerfAnalysis.cxx:936
 TProofPerfAnalysis.cxx:937
 TProofPerfAnalysis.cxx:938
 TProofPerfAnalysis.cxx:939
 TProofPerfAnalysis.cxx:940
 TProofPerfAnalysis.cxx:941
 TProofPerfAnalysis.cxx:942
 TProofPerfAnalysis.cxx:943
 TProofPerfAnalysis.cxx:944
 TProofPerfAnalysis.cxx:945
 TProofPerfAnalysis.cxx:946
 TProofPerfAnalysis.cxx:947
 TProofPerfAnalysis.cxx:948
 TProofPerfAnalysis.cxx:949
 TProofPerfAnalysis.cxx:950
 TProofPerfAnalysis.cxx:951
 TProofPerfAnalysis.cxx:952
 TProofPerfAnalysis.cxx:953
 TProofPerfAnalysis.cxx:954
 TProofPerfAnalysis.cxx:955
 TProofPerfAnalysis.cxx:956
 TProofPerfAnalysis.cxx:957
 TProofPerfAnalysis.cxx:958
 TProofPerfAnalysis.cxx:959
 TProofPerfAnalysis.cxx:960
 TProofPerfAnalysis.cxx:961
 TProofPerfAnalysis.cxx:962
 TProofPerfAnalysis.cxx:963
 TProofPerfAnalysis.cxx:964
 TProofPerfAnalysis.cxx:965
 TProofPerfAnalysis.cxx:966
 TProofPerfAnalysis.cxx:967
 TProofPerfAnalysis.cxx:968
 TProofPerfAnalysis.cxx:969
 TProofPerfAnalysis.cxx:970
 TProofPerfAnalysis.cxx:971
 TProofPerfAnalysis.cxx:972
 TProofPerfAnalysis.cxx:973
 TProofPerfAnalysis.cxx:974
 TProofPerfAnalysis.cxx:975
 TProofPerfAnalysis.cxx:976
 TProofPerfAnalysis.cxx:977
 TProofPerfAnalysis.cxx:978
 TProofPerfAnalysis.cxx:979
 TProofPerfAnalysis.cxx:980
 TProofPerfAnalysis.cxx:981
 TProofPerfAnalysis.cxx:982
 TProofPerfAnalysis.cxx:983
 TProofPerfAnalysis.cxx:984
 TProofPerfAnalysis.cxx:985
 TProofPerfAnalysis.cxx:986
 TProofPerfAnalysis.cxx:987
 TProofPerfAnalysis.cxx:988
 TProofPerfAnalysis.cxx:989
 TProofPerfAnalysis.cxx:990
 TProofPerfAnalysis.cxx:991
 TProofPerfAnalysis.cxx:992
 TProofPerfAnalysis.cxx:993
 TProofPerfAnalysis.cxx:994
 TProofPerfAnalysis.cxx:995
 TProofPerfAnalysis.cxx:996
 TProofPerfAnalysis.cxx:997
 TProofPerfAnalysis.cxx:998
 TProofPerfAnalysis.cxx:999
 TProofPerfAnalysis.cxx:1000
 TProofPerfAnalysis.cxx:1001
 TProofPerfAnalysis.cxx:1002
 TProofPerfAnalysis.cxx:1003
 TProofPerfAnalysis.cxx:1004
 TProofPerfAnalysis.cxx:1005
 TProofPerfAnalysis.cxx:1006
 TProofPerfAnalysis.cxx:1007
 TProofPerfAnalysis.cxx:1008
 TProofPerfAnalysis.cxx:1009
 TProofPerfAnalysis.cxx:1010
 TProofPerfAnalysis.cxx:1011
 TProofPerfAnalysis.cxx:1012
 TProofPerfAnalysis.cxx:1013
 TProofPerfAnalysis.cxx:1014
 TProofPerfAnalysis.cxx:1015
 TProofPerfAnalysis.cxx:1016
 TProofPerfAnalysis.cxx:1017
 TProofPerfAnalysis.cxx:1018
 TProofPerfAnalysis.cxx:1019
 TProofPerfAnalysis.cxx:1020
 TProofPerfAnalysis.cxx:1021
 TProofPerfAnalysis.cxx:1022
 TProofPerfAnalysis.cxx:1023
 TProofPerfAnalysis.cxx:1024
 TProofPerfAnalysis.cxx:1025
 TProofPerfAnalysis.cxx:1026
 TProofPerfAnalysis.cxx:1027
 TProofPerfAnalysis.cxx:1028
 TProofPerfAnalysis.cxx:1029
 TProofPerfAnalysis.cxx:1030
 TProofPerfAnalysis.cxx:1031
 TProofPerfAnalysis.cxx:1032
 TProofPerfAnalysis.cxx:1033
 TProofPerfAnalysis.cxx:1034
 TProofPerfAnalysis.cxx:1035
 TProofPerfAnalysis.cxx:1036
 TProofPerfAnalysis.cxx:1037
 TProofPerfAnalysis.cxx:1038
 TProofPerfAnalysis.cxx:1039
 TProofPerfAnalysis.cxx:1040
 TProofPerfAnalysis.cxx:1041
 TProofPerfAnalysis.cxx:1042
 TProofPerfAnalysis.cxx:1043
 TProofPerfAnalysis.cxx:1044
 TProofPerfAnalysis.cxx:1045
 TProofPerfAnalysis.cxx:1046
 TProofPerfAnalysis.cxx:1047
 TProofPerfAnalysis.cxx:1048
 TProofPerfAnalysis.cxx:1049
 TProofPerfAnalysis.cxx:1050
 TProofPerfAnalysis.cxx:1051
 TProofPerfAnalysis.cxx:1052
 TProofPerfAnalysis.cxx:1053
 TProofPerfAnalysis.cxx:1054
 TProofPerfAnalysis.cxx:1055
 TProofPerfAnalysis.cxx:1056
 TProofPerfAnalysis.cxx:1057
 TProofPerfAnalysis.cxx:1058
 TProofPerfAnalysis.cxx:1059
 TProofPerfAnalysis.cxx:1060
 TProofPerfAnalysis.cxx:1061
 TProofPerfAnalysis.cxx:1062
 TProofPerfAnalysis.cxx:1063
 TProofPerfAnalysis.cxx:1064
 TProofPerfAnalysis.cxx:1065
 TProofPerfAnalysis.cxx:1066
 TProofPerfAnalysis.cxx:1067
 TProofPerfAnalysis.cxx:1068
 TProofPerfAnalysis.cxx:1069
 TProofPerfAnalysis.cxx:1070
 TProofPerfAnalysis.cxx:1071
 TProofPerfAnalysis.cxx:1072
 TProofPerfAnalysis.cxx:1073
 TProofPerfAnalysis.cxx:1074
 TProofPerfAnalysis.cxx:1075
 TProofPerfAnalysis.cxx:1076
 TProofPerfAnalysis.cxx:1077
 TProofPerfAnalysis.cxx:1078
 TProofPerfAnalysis.cxx:1079
 TProofPerfAnalysis.cxx:1080
 TProofPerfAnalysis.cxx:1081
 TProofPerfAnalysis.cxx:1082
 TProofPerfAnalysis.cxx:1083
 TProofPerfAnalysis.cxx:1084
 TProofPerfAnalysis.cxx:1085
 TProofPerfAnalysis.cxx:1086
 TProofPerfAnalysis.cxx:1087
 TProofPerfAnalysis.cxx:1088
 TProofPerfAnalysis.cxx:1089
 TProofPerfAnalysis.cxx:1090
 TProofPerfAnalysis.cxx:1091
 TProofPerfAnalysis.cxx:1092
 TProofPerfAnalysis.cxx:1093
 TProofPerfAnalysis.cxx:1094
 TProofPerfAnalysis.cxx:1095
 TProofPerfAnalysis.cxx:1096
 TProofPerfAnalysis.cxx:1097
 TProofPerfAnalysis.cxx:1098
 TProofPerfAnalysis.cxx:1099
 TProofPerfAnalysis.cxx:1100
 TProofPerfAnalysis.cxx:1101
 TProofPerfAnalysis.cxx:1102
 TProofPerfAnalysis.cxx:1103
 TProofPerfAnalysis.cxx:1104
 TProofPerfAnalysis.cxx:1105
 TProofPerfAnalysis.cxx:1106
 TProofPerfAnalysis.cxx:1107
 TProofPerfAnalysis.cxx:1108
 TProofPerfAnalysis.cxx:1109
 TProofPerfAnalysis.cxx:1110
 TProofPerfAnalysis.cxx:1111
 TProofPerfAnalysis.cxx:1112
 TProofPerfAnalysis.cxx:1113
 TProofPerfAnalysis.cxx:1114
 TProofPerfAnalysis.cxx:1115
 TProofPerfAnalysis.cxx:1116
 TProofPerfAnalysis.cxx:1117
 TProofPerfAnalysis.cxx:1118
 TProofPerfAnalysis.cxx:1119
 TProofPerfAnalysis.cxx:1120
 TProofPerfAnalysis.cxx:1121
 TProofPerfAnalysis.cxx:1122
 TProofPerfAnalysis.cxx:1123
 TProofPerfAnalysis.cxx:1124
 TProofPerfAnalysis.cxx:1125
 TProofPerfAnalysis.cxx:1126
 TProofPerfAnalysis.cxx:1127
 TProofPerfAnalysis.cxx:1128
 TProofPerfAnalysis.cxx:1129
 TProofPerfAnalysis.cxx:1130
 TProofPerfAnalysis.cxx:1131
 TProofPerfAnalysis.cxx:1132
 TProofPerfAnalysis.cxx:1133
 TProofPerfAnalysis.cxx:1134
 TProofPerfAnalysis.cxx:1135
 TProofPerfAnalysis.cxx:1136
 TProofPerfAnalysis.cxx:1137
 TProofPerfAnalysis.cxx:1138
 TProofPerfAnalysis.cxx:1139
 TProofPerfAnalysis.cxx:1140
 TProofPerfAnalysis.cxx:1141
 TProofPerfAnalysis.cxx:1142
 TProofPerfAnalysis.cxx:1143
 TProofPerfAnalysis.cxx:1144
 TProofPerfAnalysis.cxx:1145
 TProofPerfAnalysis.cxx:1146
 TProofPerfAnalysis.cxx:1147
 TProofPerfAnalysis.cxx:1148
 TProofPerfAnalysis.cxx:1149
 TProofPerfAnalysis.cxx:1150
 TProofPerfAnalysis.cxx:1151
 TProofPerfAnalysis.cxx:1152
 TProofPerfAnalysis.cxx:1153
 TProofPerfAnalysis.cxx:1154
 TProofPerfAnalysis.cxx:1155
 TProofPerfAnalysis.cxx:1156
 TProofPerfAnalysis.cxx:1157
 TProofPerfAnalysis.cxx:1158
 TProofPerfAnalysis.cxx:1159
 TProofPerfAnalysis.cxx:1160
 TProofPerfAnalysis.cxx:1161
 TProofPerfAnalysis.cxx:1162
 TProofPerfAnalysis.cxx:1163
 TProofPerfAnalysis.cxx:1164
 TProofPerfAnalysis.cxx:1165
 TProofPerfAnalysis.cxx:1166
 TProofPerfAnalysis.cxx:1167
 TProofPerfAnalysis.cxx:1168
 TProofPerfAnalysis.cxx:1169
 TProofPerfAnalysis.cxx:1170
 TProofPerfAnalysis.cxx:1171
 TProofPerfAnalysis.cxx:1172
 TProofPerfAnalysis.cxx:1173
 TProofPerfAnalysis.cxx:1174
 TProofPerfAnalysis.cxx:1175
 TProofPerfAnalysis.cxx:1176
 TProofPerfAnalysis.cxx:1177
 TProofPerfAnalysis.cxx:1178
 TProofPerfAnalysis.cxx:1179
 TProofPerfAnalysis.cxx:1180
 TProofPerfAnalysis.cxx:1181
 TProofPerfAnalysis.cxx:1182
 TProofPerfAnalysis.cxx:1183
 TProofPerfAnalysis.cxx:1184
 TProofPerfAnalysis.cxx:1185
 TProofPerfAnalysis.cxx:1186
 TProofPerfAnalysis.cxx:1187
 TProofPerfAnalysis.cxx:1188
 TProofPerfAnalysis.cxx:1189
 TProofPerfAnalysis.cxx:1190
 TProofPerfAnalysis.cxx:1191
 TProofPerfAnalysis.cxx:1192
 TProofPerfAnalysis.cxx:1193
 TProofPerfAnalysis.cxx:1194
 TProofPerfAnalysis.cxx:1195
 TProofPerfAnalysis.cxx:1196
 TProofPerfAnalysis.cxx:1197
 TProofPerfAnalysis.cxx:1198
 TProofPerfAnalysis.cxx:1199
 TProofPerfAnalysis.cxx:1200
 TProofPerfAnalysis.cxx:1201
 TProofPerfAnalysis.cxx:1202
 TProofPerfAnalysis.cxx:1203
 TProofPerfAnalysis.cxx:1204
 TProofPerfAnalysis.cxx:1205
 TProofPerfAnalysis.cxx:1206
 TProofPerfAnalysis.cxx:1207
 TProofPerfAnalysis.cxx:1208
 TProofPerfAnalysis.cxx:1209
 TProofPerfAnalysis.cxx:1210
 TProofPerfAnalysis.cxx:1211
 TProofPerfAnalysis.cxx:1212
 TProofPerfAnalysis.cxx:1213
 TProofPerfAnalysis.cxx:1214
 TProofPerfAnalysis.cxx:1215
 TProofPerfAnalysis.cxx:1216
 TProofPerfAnalysis.cxx:1217
 TProofPerfAnalysis.cxx:1218
 TProofPerfAnalysis.cxx:1219
 TProofPerfAnalysis.cxx:1220
 TProofPerfAnalysis.cxx:1221
 TProofPerfAnalysis.cxx:1222
 TProofPerfAnalysis.cxx:1223
 TProofPerfAnalysis.cxx:1224
 TProofPerfAnalysis.cxx:1225
 TProofPerfAnalysis.cxx:1226
 TProofPerfAnalysis.cxx:1227
 TProofPerfAnalysis.cxx:1228
 TProofPerfAnalysis.cxx:1229
 TProofPerfAnalysis.cxx:1230
 TProofPerfAnalysis.cxx:1231
 TProofPerfAnalysis.cxx:1232
 TProofPerfAnalysis.cxx:1233
 TProofPerfAnalysis.cxx:1234
 TProofPerfAnalysis.cxx:1235
 TProofPerfAnalysis.cxx:1236
 TProofPerfAnalysis.cxx:1237
 TProofPerfAnalysis.cxx:1238
 TProofPerfAnalysis.cxx:1239
 TProofPerfAnalysis.cxx:1240
 TProofPerfAnalysis.cxx:1241
 TProofPerfAnalysis.cxx:1242
 TProofPerfAnalysis.cxx:1243
 TProofPerfAnalysis.cxx:1244
 TProofPerfAnalysis.cxx:1245
 TProofPerfAnalysis.cxx:1246
 TProofPerfAnalysis.cxx:1247
 TProofPerfAnalysis.cxx:1248
 TProofPerfAnalysis.cxx:1249
 TProofPerfAnalysis.cxx:1250
 TProofPerfAnalysis.cxx:1251
 TProofPerfAnalysis.cxx:1252
 TProofPerfAnalysis.cxx:1253
 TProofPerfAnalysis.cxx:1254
 TProofPerfAnalysis.cxx:1255
 TProofPerfAnalysis.cxx:1256
 TProofPerfAnalysis.cxx:1257
 TProofPerfAnalysis.cxx:1258
 TProofPerfAnalysis.cxx:1259
 TProofPerfAnalysis.cxx:1260
 TProofPerfAnalysis.cxx:1261
 TProofPerfAnalysis.cxx:1262
 TProofPerfAnalysis.cxx:1263
 TProofPerfAnalysis.cxx:1264
 TProofPerfAnalysis.cxx:1265
 TProofPerfAnalysis.cxx:1266
 TProofPerfAnalysis.cxx:1267
 TProofPerfAnalysis.cxx:1268
 TProofPerfAnalysis.cxx:1269
 TProofPerfAnalysis.cxx:1270
 TProofPerfAnalysis.cxx:1271
 TProofPerfAnalysis.cxx:1272
 TProofPerfAnalysis.cxx:1273
 TProofPerfAnalysis.cxx:1274
 TProofPerfAnalysis.cxx:1275
 TProofPerfAnalysis.cxx:1276
 TProofPerfAnalysis.cxx:1277
 TProofPerfAnalysis.cxx:1278
 TProofPerfAnalysis.cxx:1279
 TProofPerfAnalysis.cxx:1280
 TProofPerfAnalysis.cxx:1281
 TProofPerfAnalysis.cxx:1282
 TProofPerfAnalysis.cxx:1283
 TProofPerfAnalysis.cxx:1284
 TProofPerfAnalysis.cxx:1285
 TProofPerfAnalysis.cxx:1286
 TProofPerfAnalysis.cxx:1287
 TProofPerfAnalysis.cxx:1288
 TProofPerfAnalysis.cxx:1289
 TProofPerfAnalysis.cxx:1290
 TProofPerfAnalysis.cxx:1291
 TProofPerfAnalysis.cxx:1292
 TProofPerfAnalysis.cxx:1293
 TProofPerfAnalysis.cxx:1294
 TProofPerfAnalysis.cxx:1295
 TProofPerfAnalysis.cxx:1296
 TProofPerfAnalysis.cxx:1297
 TProofPerfAnalysis.cxx:1298
 TProofPerfAnalysis.cxx:1299
 TProofPerfAnalysis.cxx:1300
 TProofPerfAnalysis.cxx:1301
 TProofPerfAnalysis.cxx:1302
 TProofPerfAnalysis.cxx:1303
 TProofPerfAnalysis.cxx:1304
 TProofPerfAnalysis.cxx:1305
 TProofPerfAnalysis.cxx:1306
 TProofPerfAnalysis.cxx:1307
 TProofPerfAnalysis.cxx:1308
 TProofPerfAnalysis.cxx:1309
 TProofPerfAnalysis.cxx:1310
 TProofPerfAnalysis.cxx:1311
 TProofPerfAnalysis.cxx:1312
 TProofPerfAnalysis.cxx:1313
 TProofPerfAnalysis.cxx:1314
 TProofPerfAnalysis.cxx:1315
 TProofPerfAnalysis.cxx:1316
 TProofPerfAnalysis.cxx:1317
 TProofPerfAnalysis.cxx:1318
 TProofPerfAnalysis.cxx:1319
 TProofPerfAnalysis.cxx:1320
 TProofPerfAnalysis.cxx:1321
 TProofPerfAnalysis.cxx:1322
 TProofPerfAnalysis.cxx:1323
 TProofPerfAnalysis.cxx:1324
 TProofPerfAnalysis.cxx:1325
 TProofPerfAnalysis.cxx:1326
 TProofPerfAnalysis.cxx:1327
 TProofPerfAnalysis.cxx:1328
 TProofPerfAnalysis.cxx:1329
 TProofPerfAnalysis.cxx:1330
 TProofPerfAnalysis.cxx:1331
 TProofPerfAnalysis.cxx:1332
 TProofPerfAnalysis.cxx:1333
 TProofPerfAnalysis.cxx:1334
 TProofPerfAnalysis.cxx:1335
 TProofPerfAnalysis.cxx:1336
 TProofPerfAnalysis.cxx:1337
 TProofPerfAnalysis.cxx:1338
 TProofPerfAnalysis.cxx:1339
 TProofPerfAnalysis.cxx:1340
 TProofPerfAnalysis.cxx:1341
 TProofPerfAnalysis.cxx:1342
 TProofPerfAnalysis.cxx:1343
 TProofPerfAnalysis.cxx:1344
 TProofPerfAnalysis.cxx:1345
 TProofPerfAnalysis.cxx:1346
 TProofPerfAnalysis.cxx:1347
 TProofPerfAnalysis.cxx:1348
 TProofPerfAnalysis.cxx:1349
 TProofPerfAnalysis.cxx:1350
 TProofPerfAnalysis.cxx:1351
 TProofPerfAnalysis.cxx:1352
 TProofPerfAnalysis.cxx:1353
 TProofPerfAnalysis.cxx:1354
 TProofPerfAnalysis.cxx:1355
 TProofPerfAnalysis.cxx:1356
 TProofPerfAnalysis.cxx:1357
 TProofPerfAnalysis.cxx:1358
 TProofPerfAnalysis.cxx:1359
 TProofPerfAnalysis.cxx:1360
 TProofPerfAnalysis.cxx:1361
 TProofPerfAnalysis.cxx:1362
 TProofPerfAnalysis.cxx:1363
 TProofPerfAnalysis.cxx:1364
 TProofPerfAnalysis.cxx:1365
 TProofPerfAnalysis.cxx:1366
 TProofPerfAnalysis.cxx:1367
 TProofPerfAnalysis.cxx:1368
 TProofPerfAnalysis.cxx:1369
 TProofPerfAnalysis.cxx:1370
 TProofPerfAnalysis.cxx:1371
 TProofPerfAnalysis.cxx:1372
 TProofPerfAnalysis.cxx:1373
 TProofPerfAnalysis.cxx:1374
 TProofPerfAnalysis.cxx:1375
 TProofPerfAnalysis.cxx:1376
 TProofPerfAnalysis.cxx:1377
 TProofPerfAnalysis.cxx:1378
 TProofPerfAnalysis.cxx:1379
 TProofPerfAnalysis.cxx:1380
 TProofPerfAnalysis.cxx:1381
 TProofPerfAnalysis.cxx:1382
 TProofPerfAnalysis.cxx:1383
 TProofPerfAnalysis.cxx:1384
 TProofPerfAnalysis.cxx:1385
 TProofPerfAnalysis.cxx:1386
 TProofPerfAnalysis.cxx:1387
 TProofPerfAnalysis.cxx:1388
 TProofPerfAnalysis.cxx:1389
 TProofPerfAnalysis.cxx:1390
 TProofPerfAnalysis.cxx:1391
 TProofPerfAnalysis.cxx:1392
 TProofPerfAnalysis.cxx:1393
 TProofPerfAnalysis.cxx:1394
 TProofPerfAnalysis.cxx:1395
 TProofPerfAnalysis.cxx:1396
 TProofPerfAnalysis.cxx:1397
 TProofPerfAnalysis.cxx:1398
 TProofPerfAnalysis.cxx:1399
 TProofPerfAnalysis.cxx:1400
 TProofPerfAnalysis.cxx:1401
 TProofPerfAnalysis.cxx:1402
 TProofPerfAnalysis.cxx:1403
 TProofPerfAnalysis.cxx:1404
 TProofPerfAnalysis.cxx:1405
 TProofPerfAnalysis.cxx:1406
 TProofPerfAnalysis.cxx:1407
 TProofPerfAnalysis.cxx:1408
 TProofPerfAnalysis.cxx:1409
 TProofPerfAnalysis.cxx:1410
 TProofPerfAnalysis.cxx:1411
 TProofPerfAnalysis.cxx:1412
 TProofPerfAnalysis.cxx:1413
 TProofPerfAnalysis.cxx:1414
 TProofPerfAnalysis.cxx:1415
 TProofPerfAnalysis.cxx:1416
 TProofPerfAnalysis.cxx:1417
 TProofPerfAnalysis.cxx:1418
 TProofPerfAnalysis.cxx:1419
 TProofPerfAnalysis.cxx:1420
 TProofPerfAnalysis.cxx:1421
 TProofPerfAnalysis.cxx:1422
 TProofPerfAnalysis.cxx:1423
 TProofPerfAnalysis.cxx:1424
 TProofPerfAnalysis.cxx:1425
 TProofPerfAnalysis.cxx:1426
 TProofPerfAnalysis.cxx:1427
 TProofPerfAnalysis.cxx:1428
 TProofPerfAnalysis.cxx:1429
 TProofPerfAnalysis.cxx:1430
 TProofPerfAnalysis.cxx:1431
 TProofPerfAnalysis.cxx:1432
 TProofPerfAnalysis.cxx:1433
 TProofPerfAnalysis.cxx:1434
 TProofPerfAnalysis.cxx:1435
 TProofPerfAnalysis.cxx:1436
 TProofPerfAnalysis.cxx:1437
 TProofPerfAnalysis.cxx:1438
 TProofPerfAnalysis.cxx:1439
 TProofPerfAnalysis.cxx:1440
 TProofPerfAnalysis.cxx:1441
 TProofPerfAnalysis.cxx:1442
 TProofPerfAnalysis.cxx:1443
 TProofPerfAnalysis.cxx:1444
 TProofPerfAnalysis.cxx:1445
 TProofPerfAnalysis.cxx:1446
 TProofPerfAnalysis.cxx:1447
 TProofPerfAnalysis.cxx:1448
 TProofPerfAnalysis.cxx:1449
 TProofPerfAnalysis.cxx:1450
 TProofPerfAnalysis.cxx:1451
 TProofPerfAnalysis.cxx:1452
 TProofPerfAnalysis.cxx:1453
 TProofPerfAnalysis.cxx:1454
 TProofPerfAnalysis.cxx:1455
 TProofPerfAnalysis.cxx:1456
 TProofPerfAnalysis.cxx:1457
 TProofPerfAnalysis.cxx:1458
 TProofPerfAnalysis.cxx:1459
 TProofPerfAnalysis.cxx:1460
 TProofPerfAnalysis.cxx:1461
 TProofPerfAnalysis.cxx:1462
 TProofPerfAnalysis.cxx:1463
 TProofPerfAnalysis.cxx:1464
 TProofPerfAnalysis.cxx:1465
 TProofPerfAnalysis.cxx:1466
 TProofPerfAnalysis.cxx:1467
 TProofPerfAnalysis.cxx:1468
 TProofPerfAnalysis.cxx:1469
 TProofPerfAnalysis.cxx:1470
 TProofPerfAnalysis.cxx:1471
 TProofPerfAnalysis.cxx:1472
 TProofPerfAnalysis.cxx:1473
 TProofPerfAnalysis.cxx:1474
 TProofPerfAnalysis.cxx:1475
 TProofPerfAnalysis.cxx:1476
 TProofPerfAnalysis.cxx:1477
 TProofPerfAnalysis.cxx:1478
 TProofPerfAnalysis.cxx:1479
 TProofPerfAnalysis.cxx:1480
 TProofPerfAnalysis.cxx:1481
 TProofPerfAnalysis.cxx:1482
 TProofPerfAnalysis.cxx:1483
 TProofPerfAnalysis.cxx:1484
 TProofPerfAnalysis.cxx:1485
 TProofPerfAnalysis.cxx:1486
 TProofPerfAnalysis.cxx:1487
 TProofPerfAnalysis.cxx:1488
 TProofPerfAnalysis.cxx:1489
 TProofPerfAnalysis.cxx:1490
 TProofPerfAnalysis.cxx:1491
 TProofPerfAnalysis.cxx:1492
 TProofPerfAnalysis.cxx:1493
 TProofPerfAnalysis.cxx:1494
 TProofPerfAnalysis.cxx:1495
 TProofPerfAnalysis.cxx:1496
 TProofPerfAnalysis.cxx:1497
 TProofPerfAnalysis.cxx:1498
 TProofPerfAnalysis.cxx:1499
 TProofPerfAnalysis.cxx:1500
 TProofPerfAnalysis.cxx:1501
 TProofPerfAnalysis.cxx:1502
 TProofPerfAnalysis.cxx:1503
 TProofPerfAnalysis.cxx:1504
 TProofPerfAnalysis.cxx:1505
 TProofPerfAnalysis.cxx:1506
 TProofPerfAnalysis.cxx:1507
 TProofPerfAnalysis.cxx:1508
 TProofPerfAnalysis.cxx:1509
 TProofPerfAnalysis.cxx:1510
 TProofPerfAnalysis.cxx:1511
 TProofPerfAnalysis.cxx:1512
 TProofPerfAnalysis.cxx:1513
 TProofPerfAnalysis.cxx:1514
 TProofPerfAnalysis.cxx:1515
 TProofPerfAnalysis.cxx:1516
 TProofPerfAnalysis.cxx:1517
 TProofPerfAnalysis.cxx:1518
 TProofPerfAnalysis.cxx:1519
 TProofPerfAnalysis.cxx:1520
 TProofPerfAnalysis.cxx:1521
 TProofPerfAnalysis.cxx:1522
 TProofPerfAnalysis.cxx:1523
 TProofPerfAnalysis.cxx:1524
 TProofPerfAnalysis.cxx:1525
 TProofPerfAnalysis.cxx:1526
 TProofPerfAnalysis.cxx:1527
 TProofPerfAnalysis.cxx:1528
 TProofPerfAnalysis.cxx:1529
 TProofPerfAnalysis.cxx:1530
 TProofPerfAnalysis.cxx:1531
 TProofPerfAnalysis.cxx:1532
 TProofPerfAnalysis.cxx:1533
 TProofPerfAnalysis.cxx:1534
 TProofPerfAnalysis.cxx:1535
 TProofPerfAnalysis.cxx:1536
 TProofPerfAnalysis.cxx:1537
 TProofPerfAnalysis.cxx:1538
 TProofPerfAnalysis.cxx:1539
 TProofPerfAnalysis.cxx:1540
 TProofPerfAnalysis.cxx:1541
 TProofPerfAnalysis.cxx:1542
 TProofPerfAnalysis.cxx:1543
 TProofPerfAnalysis.cxx:1544
 TProofPerfAnalysis.cxx:1545
 TProofPerfAnalysis.cxx:1546
 TProofPerfAnalysis.cxx:1547
 TProofPerfAnalysis.cxx:1548
 TProofPerfAnalysis.cxx:1549
 TProofPerfAnalysis.cxx:1550
 TProofPerfAnalysis.cxx:1551
 TProofPerfAnalysis.cxx:1552
 TProofPerfAnalysis.cxx:1553
 TProofPerfAnalysis.cxx:1554
 TProofPerfAnalysis.cxx:1555
 TProofPerfAnalysis.cxx:1556
 TProofPerfAnalysis.cxx:1557
 TProofPerfAnalysis.cxx:1558
 TProofPerfAnalysis.cxx:1559
 TProofPerfAnalysis.cxx:1560
 TProofPerfAnalysis.cxx:1561
 TProofPerfAnalysis.cxx:1562
 TProofPerfAnalysis.cxx:1563
 TProofPerfAnalysis.cxx:1564
 TProofPerfAnalysis.cxx:1565
 TProofPerfAnalysis.cxx:1566
 TProofPerfAnalysis.cxx:1567
 TProofPerfAnalysis.cxx:1568
 TProofPerfAnalysis.cxx:1569
 TProofPerfAnalysis.cxx:1570
 TProofPerfAnalysis.cxx:1571
 TProofPerfAnalysis.cxx:1572
 TProofPerfAnalysis.cxx:1573
 TProofPerfAnalysis.cxx:1574
 TProofPerfAnalysis.cxx:1575
 TProofPerfAnalysis.cxx:1576
 TProofPerfAnalysis.cxx:1577
 TProofPerfAnalysis.cxx:1578
 TProofPerfAnalysis.cxx:1579
 TProofPerfAnalysis.cxx:1580
 TProofPerfAnalysis.cxx:1581
 TProofPerfAnalysis.cxx:1582
 TProofPerfAnalysis.cxx:1583
 TProofPerfAnalysis.cxx:1584
 TProofPerfAnalysis.cxx:1585
 TProofPerfAnalysis.cxx:1586
 TProofPerfAnalysis.cxx:1587
 TProofPerfAnalysis.cxx:1588
 TProofPerfAnalysis.cxx:1589
 TProofPerfAnalysis.cxx:1590
 TProofPerfAnalysis.cxx:1591
 TProofPerfAnalysis.cxx:1592
 TProofPerfAnalysis.cxx:1593
 TProofPerfAnalysis.cxx:1594
 TProofPerfAnalysis.cxx:1595
 TProofPerfAnalysis.cxx:1596
 TProofPerfAnalysis.cxx:1597
 TProofPerfAnalysis.cxx:1598
 TProofPerfAnalysis.cxx:1599
 TProofPerfAnalysis.cxx:1600
 TProofPerfAnalysis.cxx:1601
 TProofPerfAnalysis.cxx:1602
 TProofPerfAnalysis.cxx:1603
 TProofPerfAnalysis.cxx:1604
 TProofPerfAnalysis.cxx:1605
 TProofPerfAnalysis.cxx:1606
 TProofPerfAnalysis.cxx:1607
 TProofPerfAnalysis.cxx:1608
 TProofPerfAnalysis.cxx:1609
 TProofPerfAnalysis.cxx:1610
 TProofPerfAnalysis.cxx:1611
 TProofPerfAnalysis.cxx:1612
 TProofPerfAnalysis.cxx:1613
 TProofPerfAnalysis.cxx:1614
 TProofPerfAnalysis.cxx:1615
 TProofPerfAnalysis.cxx:1616
 TProofPerfAnalysis.cxx:1617
 TProofPerfAnalysis.cxx:1618
 TProofPerfAnalysis.cxx:1619
 TProofPerfAnalysis.cxx:1620
 TProofPerfAnalysis.cxx:1621
 TProofPerfAnalysis.cxx:1622
 TProofPerfAnalysis.cxx:1623
 TProofPerfAnalysis.cxx:1624
 TProofPerfAnalysis.cxx:1625
 TProofPerfAnalysis.cxx:1626
 TProofPerfAnalysis.cxx:1627
 TProofPerfAnalysis.cxx:1628
 TProofPerfAnalysis.cxx:1629
 TProofPerfAnalysis.cxx:1630
 TProofPerfAnalysis.cxx:1631
 TProofPerfAnalysis.cxx:1632
 TProofPerfAnalysis.cxx:1633
 TProofPerfAnalysis.cxx:1634
 TProofPerfAnalysis.cxx:1635
 TProofPerfAnalysis.cxx:1636
 TProofPerfAnalysis.cxx:1637
 TProofPerfAnalysis.cxx:1638
 TProofPerfAnalysis.cxx:1639
 TProofPerfAnalysis.cxx:1640
 TProofPerfAnalysis.cxx:1641
 TProofPerfAnalysis.cxx:1642
 TProofPerfAnalysis.cxx:1643
 TProofPerfAnalysis.cxx:1644
 TProofPerfAnalysis.cxx:1645
 TProofPerfAnalysis.cxx:1646
 TProofPerfAnalysis.cxx:1647
 TProofPerfAnalysis.cxx:1648
 TProofPerfAnalysis.cxx:1649
 TProofPerfAnalysis.cxx:1650
 TProofPerfAnalysis.cxx:1651
 TProofPerfAnalysis.cxx:1652
 TProofPerfAnalysis.cxx:1653
 TProofPerfAnalysis.cxx:1654
 TProofPerfAnalysis.cxx:1655
 TProofPerfAnalysis.cxx:1656
 TProofPerfAnalysis.cxx:1657
 TProofPerfAnalysis.cxx:1658
 TProofPerfAnalysis.cxx:1659
 TProofPerfAnalysis.cxx:1660
 TProofPerfAnalysis.cxx:1661
 TProofPerfAnalysis.cxx:1662
 TProofPerfAnalysis.cxx:1663
 TProofPerfAnalysis.cxx:1664
 TProofPerfAnalysis.cxx:1665
 TProofPerfAnalysis.cxx:1666
 TProofPerfAnalysis.cxx:1667
 TProofPerfAnalysis.cxx:1668
 TProofPerfAnalysis.cxx:1669
 TProofPerfAnalysis.cxx:1670
 TProofPerfAnalysis.cxx:1671
 TProofPerfAnalysis.cxx:1672
 TProofPerfAnalysis.cxx:1673
 TProofPerfAnalysis.cxx:1674
 TProofPerfAnalysis.cxx:1675
 TProofPerfAnalysis.cxx:1676
 TProofPerfAnalysis.cxx:1677
 TProofPerfAnalysis.cxx:1678
 TProofPerfAnalysis.cxx:1679
 TProofPerfAnalysis.cxx:1680
 TProofPerfAnalysis.cxx:1681
 TProofPerfAnalysis.cxx:1682
 TProofPerfAnalysis.cxx:1683
 TProofPerfAnalysis.cxx:1684
 TProofPerfAnalysis.cxx:1685
 TProofPerfAnalysis.cxx:1686
 TProofPerfAnalysis.cxx:1687
 TProofPerfAnalysis.cxx:1688
 TProofPerfAnalysis.cxx:1689
 TProofPerfAnalysis.cxx:1690
 TProofPerfAnalysis.cxx:1691
 TProofPerfAnalysis.cxx:1692
 TProofPerfAnalysis.cxx:1693
 TProofPerfAnalysis.cxx:1694
 TProofPerfAnalysis.cxx:1695
 TProofPerfAnalysis.cxx:1696
 TProofPerfAnalysis.cxx:1697
 TProofPerfAnalysis.cxx:1698
 TProofPerfAnalysis.cxx:1699
 TProofPerfAnalysis.cxx:1700
 TProofPerfAnalysis.cxx:1701
 TProofPerfAnalysis.cxx:1702
 TProofPerfAnalysis.cxx:1703
 TProofPerfAnalysis.cxx:1704
 TProofPerfAnalysis.cxx:1705
 TProofPerfAnalysis.cxx:1706
 TProofPerfAnalysis.cxx:1707
 TProofPerfAnalysis.cxx:1708
 TProofPerfAnalysis.cxx:1709
 TProofPerfAnalysis.cxx:1710
 TProofPerfAnalysis.cxx:1711
 TProofPerfAnalysis.cxx:1712
 TProofPerfAnalysis.cxx:1713
 TProofPerfAnalysis.cxx:1714
 TProofPerfAnalysis.cxx:1715
 TProofPerfAnalysis.cxx:1716
 TProofPerfAnalysis.cxx:1717
 TProofPerfAnalysis.cxx:1718
 TProofPerfAnalysis.cxx:1719
 TProofPerfAnalysis.cxx:1720
 TProofPerfAnalysis.cxx:1721
 TProofPerfAnalysis.cxx:1722
 TProofPerfAnalysis.cxx:1723
 TProofPerfAnalysis.cxx:1724
 TProofPerfAnalysis.cxx:1725
 TProofPerfAnalysis.cxx:1726
 TProofPerfAnalysis.cxx:1727
 TProofPerfAnalysis.cxx:1728
 TProofPerfAnalysis.cxx:1729
 TProofPerfAnalysis.cxx:1730
 TProofPerfAnalysis.cxx:1731
 TProofPerfAnalysis.cxx:1732
 TProofPerfAnalysis.cxx:1733
 TProofPerfAnalysis.cxx:1734
 TProofPerfAnalysis.cxx:1735
 TProofPerfAnalysis.cxx:1736
 TProofPerfAnalysis.cxx:1737
 TProofPerfAnalysis.cxx:1738
 TProofPerfAnalysis.cxx:1739
 TProofPerfAnalysis.cxx:1740
 TProofPerfAnalysis.cxx:1741
 TProofPerfAnalysis.cxx:1742
 TProofPerfAnalysis.cxx:1743
 TProofPerfAnalysis.cxx:1744
 TProofPerfAnalysis.cxx:1745
 TProofPerfAnalysis.cxx:1746
 TProofPerfAnalysis.cxx:1747
 TProofPerfAnalysis.cxx:1748
 TProofPerfAnalysis.cxx:1749
 TProofPerfAnalysis.cxx:1750
 TProofPerfAnalysis.cxx:1751
 TProofPerfAnalysis.cxx:1752
 TProofPerfAnalysis.cxx:1753
 TProofPerfAnalysis.cxx:1754
 TProofPerfAnalysis.cxx:1755
 TProofPerfAnalysis.cxx:1756
 TProofPerfAnalysis.cxx:1757
 TProofPerfAnalysis.cxx:1758
 TProofPerfAnalysis.cxx:1759
 TProofPerfAnalysis.cxx:1760
 TProofPerfAnalysis.cxx:1761
 TProofPerfAnalysis.cxx:1762
 TProofPerfAnalysis.cxx:1763
 TProofPerfAnalysis.cxx:1764
 TProofPerfAnalysis.cxx:1765
 TProofPerfAnalysis.cxx:1766
 TProofPerfAnalysis.cxx:1767
 TProofPerfAnalysis.cxx:1768
 TProofPerfAnalysis.cxx:1769
 TProofPerfAnalysis.cxx:1770
 TProofPerfAnalysis.cxx:1771
 TProofPerfAnalysis.cxx:1772
 TProofPerfAnalysis.cxx:1773
 TProofPerfAnalysis.cxx:1774
 TProofPerfAnalysis.cxx:1775
 TProofPerfAnalysis.cxx:1776
 TProofPerfAnalysis.cxx:1777
 TProofPerfAnalysis.cxx:1778
 TProofPerfAnalysis.cxx:1779
 TProofPerfAnalysis.cxx:1780
 TProofPerfAnalysis.cxx:1781
 TProofPerfAnalysis.cxx:1782
 TProofPerfAnalysis.cxx:1783
 TProofPerfAnalysis.cxx:1784
 TProofPerfAnalysis.cxx:1785
 TProofPerfAnalysis.cxx:1786
 TProofPerfAnalysis.cxx:1787
 TProofPerfAnalysis.cxx:1788
 TProofPerfAnalysis.cxx:1789
 TProofPerfAnalysis.cxx:1790
 TProofPerfAnalysis.cxx:1791
 TProofPerfAnalysis.cxx:1792
 TProofPerfAnalysis.cxx:1793
 TProofPerfAnalysis.cxx:1794
 TProofPerfAnalysis.cxx:1795
 TProofPerfAnalysis.cxx:1796
 TProofPerfAnalysis.cxx:1797
 TProofPerfAnalysis.cxx:1798
 TProofPerfAnalysis.cxx:1799
 TProofPerfAnalysis.cxx:1800
 TProofPerfAnalysis.cxx:1801
 TProofPerfAnalysis.cxx:1802
 TProofPerfAnalysis.cxx:1803
 TProofPerfAnalysis.cxx:1804
 TProofPerfAnalysis.cxx:1805
 TProofPerfAnalysis.cxx:1806
 TProofPerfAnalysis.cxx:1807
 TProofPerfAnalysis.cxx:1808
 TProofPerfAnalysis.cxx:1809
 TProofPerfAnalysis.cxx:1810
 TProofPerfAnalysis.cxx:1811
 TProofPerfAnalysis.cxx:1812
 TProofPerfAnalysis.cxx:1813
 TProofPerfAnalysis.cxx:1814
 TProofPerfAnalysis.cxx:1815
 TProofPerfAnalysis.cxx:1816
 TProofPerfAnalysis.cxx:1817
 TProofPerfAnalysis.cxx:1818
 TProofPerfAnalysis.cxx:1819
 TProofPerfAnalysis.cxx:1820
 TProofPerfAnalysis.cxx:1821
 TProofPerfAnalysis.cxx:1822
 TProofPerfAnalysis.cxx:1823
 TProofPerfAnalysis.cxx:1824
 TProofPerfAnalysis.cxx:1825
 TProofPerfAnalysis.cxx:1826
 TProofPerfAnalysis.cxx:1827
 TProofPerfAnalysis.cxx:1828
 TProofPerfAnalysis.cxx:1829
 TProofPerfAnalysis.cxx:1830
 TProofPerfAnalysis.cxx:1831
 TProofPerfAnalysis.cxx:1832
 TProofPerfAnalysis.cxx:1833
 TProofPerfAnalysis.cxx:1834
 TProofPerfAnalysis.cxx:1835
 TProofPerfAnalysis.cxx:1836
 TProofPerfAnalysis.cxx:1837
 TProofPerfAnalysis.cxx:1838
 TProofPerfAnalysis.cxx:1839
 TProofPerfAnalysis.cxx:1840
 TProofPerfAnalysis.cxx:1841
 TProofPerfAnalysis.cxx:1842
 TProofPerfAnalysis.cxx:1843
 TProofPerfAnalysis.cxx:1844
 TProofPerfAnalysis.cxx:1845
 TProofPerfAnalysis.cxx:1846
 TProofPerfAnalysis.cxx:1847
 TProofPerfAnalysis.cxx:1848
 TProofPerfAnalysis.cxx:1849
 TProofPerfAnalysis.cxx:1850
 TProofPerfAnalysis.cxx:1851
 TProofPerfAnalysis.cxx:1852
 TProofPerfAnalysis.cxx:1853
 TProofPerfAnalysis.cxx:1854
 TProofPerfAnalysis.cxx:1855
 TProofPerfAnalysis.cxx:1856
 TProofPerfAnalysis.cxx:1857
 TProofPerfAnalysis.cxx:1858
 TProofPerfAnalysis.cxx:1859
 TProofPerfAnalysis.cxx:1860
 TProofPerfAnalysis.cxx:1861