ROOT logo
// @(#)root/treeplayer:$Id: TTreePlayer.cxx 41643 2011-10-28 18:24:36Z pcanal $
// Author: Rene Brun   12/01/96

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

//////////////////////////////////////////////////////////////////////////
// 
// TTreePlayer
//
// Implement some of the functionality of the class TTree requiring access to 
// extra libraries (Histogram, display, etc).
// 

#include <string.h>
#include <stdio.h>

#include "Riostream.h"
#include "TTreePlayer.h"
#include "TROOT.h"
#include "TSystem.h"
#include "TFile.h"
#include "TEventList.h"
#include "TEntryList.h"
#include "TBranchObject.h"
#include "TBranchElement.h"
#include "TStreamerInfo.h"
#include "TStreamerElement.h"
#include "TLeafObject.h"
#include "TLeafF.h"
#include "TLeafD.h"
#include "TLeafC.h"
#include "TLeafB.h"
#include "TLeafI.h"
#include "TLeafS.h"
#include "TMath.h"
#include "TH2.h"
#include "TH3.h"
#include "TPolyMarker.h"
#include "TPolyMarker3D.h"
#include "TDirectory.h"
#include "TClonesArray.h"
#include "TClass.h"
#include "TVirtualPad.h"
#include "TProfile.h"
#include "TProfile2D.h"
#include "TTreeFormula.h"
#include "TTreeFormulaManager.h"
#include "TStyle.h"
#include "Foption.h"
#include "TTreeResult.h"
#include "TTreeRow.h"
#include "TPrincipal.h"
#include "TChain.h"
#include "TChainElement.h"
#include "TF1.h"
#include "TH1.h"
#include "TVirtualFitter.h"
#include "TEnv.h"
#include "THLimitsFinder.h"
#include "TSelectorDraw.h"
#include "TSelectorEntries.h"
#include "TPluginManager.h"
#include "TObjString.h"
#include "TTreeProxyGenerator.h"
#include "TTreeIndex.h"
#include "TChainIndex.h"
#include "TRefProxy.h"
#include "TRefArrayProxy.h"
#include "TVirtualMonitoring.h"
#include "TTreeCache.h"
#include "TStyle.h"

#include "HFitInterface.h"
#include "Foption.h"
#include "Fit/UnBinData.h"
#include "Math/MinimizerOptions.h"

R__EXTERN Foption_t Foption;
R__EXTERN  TTree *gTree;

TVirtualFitter *tFitter=0;

extern void TreeUnbinnedFitLikelihood(Int_t &npar, Double_t *gin, Double_t &f, Double_t *u, Int_t flag);

ClassImp(TTreePlayer)

//______________________________________________________________________________
TTreePlayer::TTreePlayer()
{
//*-*-*-*-*-*-*-*-*-*-*Default Tree constructor*-*-*-*-*-*-*-*-*-*-*-*-*-*
//*-*                  ========================
   fTree           = 0;
   fScanFileName   = 0;
   fScanRedirect   = kFALSE;
   fSelectedRows   = 0;
   fDimension      = 0;
   fHistogram      = 0;
   fFormulaList    = new TList();
   fFormulaList->SetOwner(kTRUE);
   fSelector         = new TSelectorDraw();
   fSelectorFromFile = 0;
   fSelectorClass    = 0;
   fSelectorUpdate   = 0;
   fInput            = new TList();
   fInput->Add(new TNamed("varexp",""));
   fInput->Add(new TNamed("selection",""));
   fSelector->SetInputList(fInput);
   gROOT->GetListOfCleanups()->Add(this);
   TClass::GetClass("TRef")->AdoptReferenceProxy(new TRefProxy());
   TClass::GetClass("TRefArray")->AdoptReferenceProxy(new TRefArrayProxy());
}

//______________________________________________________________________________
TTreePlayer::~TTreePlayer()
{
//*-*-*-*-*-*-*-*-*-*-*Tree destructor*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
//*-*                  =================

   delete fFormulaList;
   delete fSelector;
   DeleteSelectorFromFile();
   fInput->Delete();
   delete fInput;
   gROOT->GetListOfCleanups()->Remove(this);
}

//______________________________________________________________________________
TVirtualIndex *TTreePlayer::BuildIndex(const TTree *T, const char *majorname, const char *minorname)
{
   // Build the index for the tree (see TTree::BuildIndex)

   TVirtualIndex *index;
   if (dynamic_cast<const TChain*>(T)) {
      index = new TChainIndex(T, majorname, minorname);
      if (index->IsZombie()) {
         delete index;
         Error("BuildIndex", "Creating a TChainIndex unsuccessfull - switching to TTreeIndex");
      }
      else
         return index;
   }
   return new TTreeIndex(T,majorname,minorname);
}

//______________________________________________________________________________
TTree *TTreePlayer::CopyTree(const char *selection, Option_t *, Long64_t nentries,
                             Long64_t firstentry)
{
   // copy a Tree with selection
   // make a clone of this Tree header.
   // then copy the selected entries
   //
   // selection is a standard selection expression (see TTreePlayer::Draw)
   // option is reserved for possible future use
   // nentries is the number of entries to process (default is all)
   // first is the first entry to process (default is 0)
   //
   // IMPORTANT: The copied tree stays connected with this tree until this tree
   //            is deleted.  In particular, any changes in branch addresses
   //            in this tree are forwarded to the clone trees.  Any changes
   //            made to the branch addresses of the copied trees are over-ridden
   //            anytime this tree changes its branch addresses.
   //            Once this tree is deleted, all the addresses of the copied tree
   //            are reset to their default values.
   //
   // The following example illustrates how to copy some events from the Tree
   // generated in $ROOTSYS/test/Event
   //
   //   gSystem->Load("libEvent");
   //   TFile f("Event.root");
   //   TTree *T = (TTree*)f.Get("T");
   //   Event *event = new Event();
   //   T->SetBranchAddress("event",&event);
   //   TFile f2("Event2.root","recreate");
   //   TTree *T2 = T->CopyTree("fNtrack<595");
   //   T2->Write();


   // we make a copy of the tree header
   TTree *tree = fTree->CloneTree(0);
   if (tree == 0) return 0;

   // The clone should not delete any shared i/o buffers.
   TObjArray* branches = tree->GetListOfBranches();
   Int_t nb = branches->GetEntriesFast();
   for (Int_t i = 0; i < nb; ++i) {
      TBranch* br = (TBranch*) branches->UncheckedAt(i);
      if (br->InheritsFrom(TBranchElement::Class())) {
         ((TBranchElement*) br)->ResetDeleteObject();
      }
   }

   Long64_t entry,entryNumber;
   nentries = GetEntriesToProcess(firstentry, nentries);

   // Compile selection expression if there is one
   TTreeFormula *select = 0; // no need to interfere with fSelect since we
                             // handle the loop explicitly below and can call
                             // UpdateFormulaLeaves ourselves.
   if (strlen(selection)) {
      select = new TTreeFormula("Selection",selection,fTree);
      if (!select || !select->GetNdim()) {
         delete select;
         delete tree;
         return 0;
      }
      fFormulaList->Add(select);
   }

   //loop on the specified entries
   Int_t tnumber = -1;
   for (entry=firstentry;entry<firstentry+nentries;entry++) {
      entryNumber = fTree->GetEntryNumber(entry);
      if (entryNumber < 0) break;
      Long64_t localEntry = fTree->LoadTree(entryNumber);
      if (localEntry < 0) break;
      if (tnumber != fTree->GetTreeNumber()) {
         tnumber = fTree->GetTreeNumber();
         if (select) select->UpdateFormulaLeaves();
      }
      if (select) {
         Int_t ndata = select->GetNdata();
         Bool_t keep = kFALSE;
         for(Int_t current = 0; current<ndata && !keep; current++) {
            keep |= (select->EvalInstance(current) != 0);
         }
         if (!keep) continue;
      }
      fTree->GetEntry(entryNumber);
      tree->Fill();
   }
   fFormulaList->Clear();
   return tree;
}

//______________________________________________________________________________
void TTreePlayer::DeleteSelectorFromFile()
{
// Delete any selector created by this object.
// The selector has been created using TSelector::GetSelector(file)

   if (fSelectorFromFile && fSelectorClass) {
      if (fSelectorClass->IsLoaded()) {
         delete fSelectorFromFile;
      }
   }
   fSelectorFromFile = 0;
   fSelectorClass = 0;
}

//______________________________________________________________________________
Long64_t TTreePlayer::DrawScript(const char* wrapperPrefix,
                                 const char *macrofilename, const char *cutfilename,
                                 Option_t *option, Long64_t nentries, Long64_t firstentry)
{
   // Draw the result of a C++ script.
   //
   // The macrofilename and optionally cutfilename are assumed to contain
   // at least a method with the same name as the file.  The method
   // should return a value that can be automatically cast to
   // respectively a double and a boolean.
   //
   // Both methods will be executed in a context such that the
   // branch names can be used as C++ variables. This is
   // accomplished by generating a TTreeProxy (see MakeProxy)
   // and including the files in the proper location.
   //
   // If the branch name can not be used a proper C++ symbol name,
   // it will be modified as follow:
   //    - white spaces are removed
   //    - if the leading character is not a letter, an underscore is inserted
   //    - < and > are replace by underscores
   //    - * is replaced by st
   //    - & is replaced by rf
   //
   // If a cutfilename is specified, for each entry, we execute
   //   if (cutfilename()) htemp->Fill(macrofilename());
   // If no cutfilename is specified, for each entry we execute
   //   htemp(macrofilename());
   //
   // The default for the histogram are the same as for
   // TTreePlayer::DrawSelect

   if (!macrofilename || strlen(macrofilename)==0) return 0;

   TString aclicMode;
   TString arguments;
   TString io;
   TString realcutname;
   if (cutfilename && strlen(cutfilename))
      realcutname =  gSystem->SplitAclicMode(cutfilename, aclicMode, arguments, io);

   // we ignore the aclicMode for the cutfilename!
   TString realname = gSystem->SplitAclicMode(macrofilename, aclicMode, arguments, io);

   TString selname = wrapperPrefix;

   TTreeProxyGenerator gp(fTree,realname,realcutname,selname,option,3);

   selname = gp.GetFileName();
   if (aclicMode.Length()==0) {
      Warning("DrawScript","TTreeProxy does not work in interpreted mode yet. The script will be compiled.");
      aclicMode = "+";
   }
   selname.Append(aclicMode);

   Info("DrawScript","%s",Form("Will process tree/chain using %s",selname.Data()));
   Long64_t result = fTree->Process(selname,option,nentries,firstentry);
   fTree->SetNotify(0);

   // could delete the file selname+".h"
   // However this would remove the optimization of avoiding a useless
   // recompilation if the user ask for the same thing twice!

   return result;
}

//______________________________________________________________________________
Long64_t TTreePlayer::DrawSelect(const char *varexp0, const char *selection, Option_t *option,Long64_t nentries, Long64_t firstentry)
{
   // Draw expression varexp for specified entries that matches the selection.
   // Returns -1 in case of error or number of selected events in case of succss.
   //
   // See the documentation of TTree::Draw for the complete details.
   
   if (fTree->GetEntriesFriend() == 0) return 0;

   // Let's see if we have a filename as arguments instead of
   // a TTreeFormula expression.

   TString possibleFilename = varexp0;
   Ssiz_t dot_pos = possibleFilename.Last('.');
   if ( dot_pos != kNPOS
       && possibleFilename.Index("Alt$")<0 && possibleFilename.Index("Entries$")<0
       && possibleFilename.Index("Length$")<0  && possibleFilename.Index("Entry$")<0
       && possibleFilename.Index("LocalEntry$")<0
       && possibleFilename.Index("Min$")<0 && possibleFilename.Index("Max$")<0
       && possibleFilename.Index("MinIf$")<0 && possibleFilename.Index("MaxIf$")<0
       && possibleFilename.Index("Iteration$")<0 && possibleFilename.Index("Sum$")<0
       && possibleFilename.Index(">")<0 && possibleFilename.Index("<")<0
       && gSystem->IsFileInIncludePath(possibleFilename.Data())) {

      if (selection && strlen(selection) && !gSystem->IsFileInIncludePath(selection)) {
         Error("DrawSelect",
               "Drawing using a C++ file currently requires that both the expression and the selection are files\n\t\"%s\" is not a file",
               selection);
         return 0;
      }
      return DrawScript("generatedSel",varexp0,selection,option,nentries,firstentry);

   } else {
      possibleFilename = selection;
      if (possibleFilename.Index("Alt$")<0 && possibleFilename.Index("Entries$")<0
          && possibleFilename.Index("Length$")<0  && possibleFilename.Index("Entry$")<0
          && possibleFilename.Index("LocalEntry$")<0
          && possibleFilename.Index("Min$")<0 && possibleFilename.Index("Max$")<0
          && possibleFilename.Index("MinIf$")<0 && possibleFilename.Index("MaxIf$")<0
          && possibleFilename.Index("Iteration$")<0 && possibleFilename.Index("Sum$")<0
          && possibleFilename.Index(">")<0 && possibleFilename.Index("<")<0
          && gSystem->IsFileInIncludePath(possibleFilename.Data())) {

         Error("DrawSelect",
               "Drawing using a C++ file currently requires that both the expression and the selection are files\n\t\"%s\" is not a file",
               varexp0);
         return 0;
      }
   }

   Long64_t oldEstimate  = fTree->GetEstimate();
   TEventList *evlist  = fTree->GetEventList();
   TEntryList *elist = fTree->GetEntryList();
   if (evlist && elist){
      elist->SetBit(kCanDelete, kTRUE);
   }
   TNamed *cvarexp    = (TNamed*)fInput->FindObject("varexp");
   TNamed *cselection = (TNamed*)fInput->FindObject("selection");
   if (cvarexp) cvarexp->SetTitle(varexp0);
   if (cselection) cselection->SetTitle(selection);

   TString opt = option;
   opt.ToLower();
   Bool_t optpara   = kFALSE;
   Bool_t optcandle = kFALSE;
   Bool_t optgl5d   = kFALSE;
   Bool_t optnorm   = kFALSE;
   if (opt.Contains("norm")) {optnorm = kTRUE; opt.ReplaceAll("norm",""); opt.ReplaceAll(" ","");}
   if (opt.Contains("para")) optpara = kTRUE;
   if (opt.Contains("candle")) optcandle = kTRUE;
   if (opt.Contains("gl5d")) optgl5d = kTRUE;
   Bool_t pgl = gStyle->GetCanvasPreferGL();
   if (optgl5d) {
      fTree->SetEstimate(fTree->GetEntries());
      if (!gPad) {
         if (pgl == kFALSE) gStyle->SetCanvasPreferGL(kTRUE);
         gROOT->ProcessLineFast("new TCanvas();");
      }
   }


   // Do not process more than fMaxEntryLoop entries
   if (nentries > fTree->GetMaxEntryLoop()) nentries = fTree->GetMaxEntryLoop();

   // invoke the selector
   Long64_t nrows = Process(fSelector,option,nentries,firstentry);
   fSelectedRows = nrows;
   fDimension = fSelector->GetDimension();

   //*-* an Event List
   if (fDimension <= 0) {
      fTree->SetEstimate(oldEstimate);
      if (fSelector->GetCleanElist()) {
         // We are in the case where the input list was reset!
         fTree->SetEntryList(elist);
         delete fSelector->GetObject();
      }
      return nrows;
   }

   // Draw generated histogram
   Long64_t drawflag = fSelector->GetDrawFlag();
   Int_t action   = fSelector->GetAction();
   Bool_t draw = kFALSE;
   if (!drawflag && !opt.Contains("goff")) draw = kTRUE;
   if (!optcandle && !optpara) fHistogram = (TH1*)fSelector->GetObject();
   if (optnorm) {
      Double_t sumh= fHistogram->GetSumOfWeights();
      if (sumh != 0) fHistogram->Scale(1./sumh);
   }
   
   //if (!nrows && draw && drawflag && !opt.Contains("same")) {
   //   if (gPad) gPad->Clear();
   //   return 0;
   //}

   //*-*- 1-D distribution
   if (fDimension == 1) {
      if (fSelector->GetVar1()->IsInteger()) fHistogram->LabelsDeflate("X");
      if (draw) fHistogram->Draw(opt.Data());

   //*-*- 2-D distribution
   } else if (fDimension == 2 && !(optpara||optcandle)) {
      if (fSelector->GetVar1()->IsInteger()) fHistogram->LabelsDeflate("Y");
      if (fSelector->GetVar2()->IsInteger()) fHistogram->LabelsDeflate("X");
      if (action == 4) {
         if (draw) fHistogram->Draw(opt.Data());
      } else {
         Bool_t graph = kFALSE;
         Int_t l = opt.Length();
         if (l == 0 || opt == "same") graph = kTRUE;
         if (opt.Contains("p")     || opt.Contains("*")    || opt.Contains("l"))    graph = kTRUE;
         if (opt.Contains("surf")  || opt.Contains("lego") || opt.Contains("cont")) graph = kFALSE;
         if (opt.Contains("col")   || opt.Contains("hist") || opt.Contains("scat")) graph = kFALSE;
         if (!graph) {
            if (draw) fHistogram->Draw(opt.Data());
         } else {
            if (fSelector->GetOldHistogram() && draw) fHistogram->Draw(opt.Data());
         }
      }
   //*-*- 3-D distribution
   } else if (fDimension == 3 && !(optpara||optcandle)) {
      if (fSelector->GetVar1()->IsInteger()) fHistogram->LabelsDeflate("Z");
      if (fSelector->GetVar2()->IsInteger()) fHistogram->LabelsDeflate("Y");
      if (fSelector->GetVar3()->IsInteger()) fHistogram->LabelsDeflate("X");
      if (action == 23) {
         if (draw) fHistogram->Draw(opt.Data());
      } else {
         Int_t noscat = opt.Length();
         if (opt.Contains("same")) noscat -= 4;
         if (noscat) {
            if (draw) fHistogram->Draw(opt.Data());
         } else {
            if (fSelector->GetOldHistogram() && draw) fHistogram->Draw(opt.Data());
         }
      }
   //*-*- 4-D distribution
   } else if (fDimension == 4 && !(optpara||optcandle)) {
      if (fSelector->GetVar1()->IsInteger()) fHistogram->LabelsDeflate("Z");
      if (fSelector->GetVar2()->IsInteger()) fHistogram->LabelsDeflate("Y");
      if (fSelector->GetVar3()->IsInteger()) fHistogram->LabelsDeflate("X");
      if (draw) fHistogram->Draw(opt.Data());
      Int_t ncolors  = gStyle->GetNumberOfColors();
      TObjArray *pms = (TObjArray*)fHistogram->GetListOfFunctions()->FindObject("polymarkers");
      for (Int_t col=0;col<ncolors;col++) {
         if (!pms) continue;
         TPolyMarker3D *pm3d = (TPolyMarker3D*)pms->UncheckedAt(col);
         if (draw) pm3d->Draw();
      }
   //*-*- Parallel Coordinates or Candle chart.
   } else if (optpara || optcandle) {
      if (draw) {
         TObject* para = fSelector->GetObject();
         TObject *enlist = gDirectory->FindObject("enlist");
         fTree->Draw(">>enlist",selection,"entrylist",nentries,firstentry);
         gROOT->ProcessLineFast(Form("TParallelCoord::SetEntryList((TParallelCoord*)0x%lx,(TEntryList*)0x%lx)",
                                     (ULong_t)para, (ULong_t)enlist));
      }
   //*-*- 5d with gl
   } else if (optgl5d) {
      gROOT->ProcessLineFast(Form("(new TGL5DDataSet((TTree *)0x%lx))->Draw(\"%s\");", (ULong_t)fTree, opt.Data()));
      gStyle->SetCanvasPreferGL(pgl);
   }

   if (fHistogram) fHistogram->ResetBit(TH1::kCanRebin);
   return fSelectedRows;
}

//______________________________________________________________________________
Int_t TTreePlayer::Fit(const char *formula ,const char *varexp, const char *selection,Option_t *option ,Option_t *goption,Long64_t nentries, Long64_t firstentry)
{
// Fit  a projected item(s) from a Tree.
// Returns -1 in case of error or number of selected events in case of success.
//
//  The formula is a TF1 expression.
//
//  See TTree::Draw for explanations of the other parameters.
//
//  By default the temporary histogram created is called htemp.
//  If varexp contains >>hnew , the new histogram created is called hnew
//  and it is kept in the current directory.
//  Example:
//    tree.Fit("pol4","sqrt(x)>>hsqrt","y>0")
//    will fit sqrt(x) and save the histogram as "hsqrt" in the current
//    directory.
//
//   Return status
//   =============
// The function returns the status of the histogram fit (see TH1::Fit)
// If no entries were selected, the function returns -1;
//   (i.e. fitResult is null if the fit is OK)

   Int_t nch = option ? strlen(option) + 10 : 10;
   char *opt = new char[nch];
   if (option) strlcpy(opt,option,nch-1);
   else        strlcpy(opt,"goff",5);
   
   Long64_t nsel = DrawSelect(varexp,selection,opt,nentries,firstentry);

   delete [] opt;
   Int_t fitResult = -1;

   if (fHistogram && nsel > 0) {
      fitResult = fHistogram->Fit(formula,option,goption);
   }
   return fitResult;
}

//______________________________________________________________________________
Long64_t TTreePlayer::GetEntries(const char *selection)
{
   // Return the number of entries matching the selection.
   // Return -1 in case of errors.
   //
   // If the selection uses any arrays or containers, we return the number
   // of entries where at least one element match the selection.
   // GetEntries is implemented using the selector class TSelectorEntries,
   // which can be used directly (see code in TTreePlayer::GetEntries) for
   // additional option.
   // If SetEventList was used on the TTree or TChain, only that subset
   // of entries will be considered.

   TSelectorEntries s(selection);
   fTree->Process(&s);
   fTree->SetNotify(0);
   return s.GetSelectedRows();
}

//______________________________________________________________________________
Long64_t TTreePlayer::GetEntriesToProcess(Long64_t firstentry, Long64_t nentries) const
{
   // return the number of entries to be processed
   // this function checks that nentries is not bigger than the number
   // of entries in the Tree or in the associated TEventlist

   Long64_t lastentry = firstentry + nentries - 1;
   if (lastentry > fTree->GetEntriesFriend()-1) {
      lastentry  = fTree->GetEntriesFriend() - 1;
      nentries   = lastentry - firstentry + 1;
   }
   //TEventList *elist = fTree->GetEventList();
   //if (elist && elist->GetN() < nentries) nentries = elist->GetN();
   TEntryList *elist = fTree->GetEntryList();
   if (elist && elist->GetN() < nentries) nentries = elist->GetN();
   return nentries;
}

//______________________________________________________________________________
const char *TTreePlayer::GetNameByIndex(TString &varexp, Int_t *index,Int_t colindex)
{
//*-*-*-*-*-*-*-*-*Return name corresponding to colindex in varexp*-*-*-*-*-*
//*-*              ===============================================
//
//   varexp is a string of names separated by :
//   index is an array with pointers to the start of name[i] in varexp
//

   Int_t i1,n;
   static TString column;
   if (colindex<0 ) return "";
   i1 = index[colindex] + 1;
   n  = index[colindex+1] - i1;
   column = varexp(i1,n);
   //  return (const char*)Form((const char*)column);
   return column.Data();
}

//______________________________________________________________________________
static TString R__GetBranchPointerName(TLeaf *leaf, Bool_t replace = kTRUE)
{
   // Return the name of the branch pointer needed by MakeClass/MakeSelector

   TLeaf *leafcount = leaf->GetLeafCount();
   TBranch *branch = leaf->GetBranch();

   TString branchname( branch->GetName() );

   if ( branch->GetNleaves() <= 1 ) {
       if (branch->IsA() != TBranchObject::Class()) {
         if (!leafcount) {
            TBranch *mother = branch->GetMother();
            const char* ltitle = leaf->GetTitle();
            if (mother && mother!=branch) {
               branchname = mother->GetName();
               if (branchname[branchname.Length()-1]!='.') {
                  branchname += ".";
               }
               if (strncmp(branchname.Data(),ltitle,branchname.Length())==0) {
                  branchname = "";
               }
            } else {
               branchname = "";
            }
            branchname += ltitle;
         }
      }
   }
   if (replace) {
      char *bname = (char*)branchname.Data();
      char *twodim = (char*)strstr(bname,"[");
      if (twodim) *twodim = 0;
      while (*bname) {
         if (*bname == '.') *bname='_';
         if (*bname == ',') *bname='_';
         if (*bname == ':') *bname='_';
         if (*bname == '<') *bname='_';
         if (*bname == '>') *bname='_';
         bname++;
      }
   }
   return branchname;
}

//______________________________________________________________________________
Int_t TTreePlayer::MakeClass(const char *classname, const char *option)
{
// Generate skeleton analysis class for this Tree.
//
// The following files are produced: classname.h and classname.C
// If classname is 0, classname will be called "nameoftree.
//
// The generated code in classname.h includes the following:
//    - Identification of the original Tree and Input file name
//    - Definition of analysis class (data and functions)
//    - the following class functions:
//       - constructor (connecting by default the Tree file)
//       - GetEntry(Long64_t entry)
//       - Init(TTree *tree) to initialize a new TTree
//       - Show(Long64_t entry) to read and Dump entry
//
// The generated code in classname.C includes only the main
// analysis function Loop.
//
// To use this function:
//    - connect your Tree file (eg: TFile f("myfile.root");)
//    - T->MakeClass("MyClass");
// where T is the name of the Tree in file myfile.root
// and MyClass.h, MyClass.C the name of the files created by this function.
// In a ROOT session, you can do:
//    root > .L MyClass.C
//    root > MyClass t
//    root > t.GetEntry(12); // Fill t data members with entry number 12
//    root > t.Show();       // Show values of entry 12
//    root > t.Show(16);     // Read and show values of entry 16
//    root > t.Loop();       // Loop on all entries
//
//  NOTE: Do not use the code generated for one Tree in case of a TChain.
//        Maximum dimensions calculated on the basis of one TTree only
//        might be too small when processing all the TTrees in one TChain.
//        Instead of myTree.MakeClass(..,  use myChain.MakeClass(..

   TString opt = option;
   opt.ToLower();

   // Connect output files
   if (!classname) classname = fTree->GetName();

   TString thead;
   thead.Form("%s.h", classname);
   FILE *fp = fopen(thead, "w");
   if (!fp) {
      Error("MakeClass","cannot open output file %s", thead.Data());
      return 3;
   }
   TString tcimp;
   tcimp.Form("%s.C", classname);
   FILE *fpc = fopen(tcimp, "w");
   if (!fpc) {
      Error("MakeClass","cannot open output file %s", tcimp.Data());
      fclose(fp);
      return 3;
   }
   TString treefile;
   if (fTree->GetDirectory() && fTree->GetDirectory()->GetFile()) {
      treefile = fTree->GetDirectory()->GetFile()->GetName();
   } else {
      treefile = "Memory Directory";
   }
   // In the case of a chain, the GetDirectory information usually does
   // pertain to the Chain itself but to the currently loaded tree.
   // So we can not rely on it.
   Bool_t ischain = fTree->InheritsFrom(TChain::Class());
   Bool_t isHbook = fTree->InheritsFrom("THbookTree");
   if (isHbook)
      treefile = fTree->GetTitle();

//======================Generate classname.h=====================
   // Print header
   TObjArray *leaves = fTree->GetListOfLeaves();
   Int_t nleaves = leaves ? leaves->GetEntriesFast() : 0;
   TDatime td;
   fprintf(fp,"//////////////////////////////////////////////////////////\n");
   fprintf(fp,"// This class has been automatically generated on\n");
   fprintf(fp,"// %s by ROOT version %s\n",td.AsString(),gROOT->GetVersion());
   if (!ischain) {
      fprintf(fp,"// from TTree %s/%s\n",fTree->GetName(),fTree->GetTitle());
      fprintf(fp,"// found on file: %s\n",treefile.Data());
   } else {
      fprintf(fp,"// from TChain %s/%s\n",fTree->GetName(),fTree->GetTitle());
   }
   fprintf(fp,"//////////////////////////////////////////////////////////\n");
   fprintf(fp,"\n");
   fprintf(fp,"#ifndef %s_h\n",classname);
   fprintf(fp,"#define %s_h\n",classname);
   fprintf(fp,"\n");
   fprintf(fp,"#include <TROOT.h>\n");
   fprintf(fp,"#include <TChain.h>\n");
   fprintf(fp,"#include <TFile.h>\n");
   if (isHbook) fprintf(fp,"#include <THbookFile.h>\n");
   if (opt.Contains("selector")) fprintf(fp,"#include <TSelector.h>\n");

   // See if we can add any #include about the user data.
   Int_t l;
   fprintf(fp,"\n// Header file for the classes stored in the TTree if any.\n");
   TList listOfHeaders;
   listOfHeaders.SetOwner();
   for (l=0;l<nleaves;l++) {
      TLeaf *leaf = (TLeaf*)leaves->UncheckedAt(l);
      TBranch *branch = leaf->GetBranch();
      TClass *cl = TClass::GetClass(branch->GetClassName());
      if (cl && cl->IsLoaded() && !listOfHeaders.FindObject(cl->GetName())) {
         const char *declfile = cl->GetDeclFileName();
         if (declfile && declfile[0]) {
            static const char *precstl = "prec_stl/";
            static const unsigned int precstl_len = strlen(precstl);
            static const char *rootinclude = "include/";
            static const unsigned int rootinclude_len = strlen(rootinclude);
            if (strncmp(declfile,precstl,precstl_len) == 0) {
               fprintf(fp,"#include <%s>\n",declfile+precstl_len);
               listOfHeaders.Add(new TNamed(cl->GetName(),declfile+precstl_len));
            } else if (strncmp(declfile,rootinclude,rootinclude_len) == 0) {
               fprintf(fp,"#include <%s>\n",declfile+rootinclude_len);              
               listOfHeaders.Add(new TNamed(cl->GetName(),declfile+rootinclude_len));
            } else {
               fprintf(fp,"#include \"%s\"\n",declfile);
               listOfHeaders.Add(new TNamed(cl->GetName(),declfile));
            }
         }
      }
   }

   // First loop on all leaves to generate dimension declarations
   Int_t len, lenb;
   char blen[1024];
   char *bname;
   Int_t *leaflen = new Int_t[nleaves];
   TObjArray *leafs = new TObjArray(nleaves);
   for (l=0;l<nleaves;l++) {
      TLeaf *leaf = (TLeaf*)leaves->UncheckedAt(l);
      leafs->AddAt(new TObjString(leaf->GetName()),l);
      leaflen[l] = leaf->GetMaximum();
   }
   if (ischain) {
      // In case of a chain, one must find the maximum dimension of each leaf
      // One must be careful and not assume that all Trees in the chain
      // have the same leaves and in the same order!
      TChain *chain = (TChain*)fTree;
      Int_t ntrees = chain->GetNtrees();
      for (Int_t file=0;file<ntrees;file++) {
         Long64_t first = chain->GetTreeOffset()[file];
         chain->LoadTree(first);
         for (l=0;l<nleaves;l++) {
            TObjString *obj = (TObjString*)leafs->At(l);
            TLeaf *leaf = chain->GetLeaf(obj->GetName());
            if (leaf) {
               leaflen[l] = TMath::Max(leaflen[l],leaf->GetMaximum());
            }
         }
      }
      chain->LoadTree(0);
   }

   fprintf(fp,"\n// Fixed size dimensions of array or collections stored in the TTree if any.\n");   
   leaves = fTree->GetListOfLeaves();
   for (l=0;l<nleaves;l++) {
      TLeaf *leaf = (TLeaf*)leaves->UncheckedAt(l);
      strlcpy(blen,leaf->GetName(),sizeof(blen)); 
      bname = &blen[0];
      while (*bname) {
         if (*bname == '.') *bname='_';
         if (*bname == ',') *bname='_';
         if (*bname == ':') *bname='_';
         if (*bname == '<') *bname='_';
         if (*bname == '>') *bname='_';
         bname++;
      }
      lenb = strlen(blen);
      if (blen[lenb-1] == '_') {
         blen[lenb-1] = 0;
         len = leaflen[l];
         if (len <= 0) len = 1;
         fprintf(fp,"const Int_t kMax%s = %d;\n",blen,len);
      }
   }
   delete [] leaflen;
   leafs->Delete();
   delete leafs;

// second loop on all leaves to generate type declarations
   fprintf(fp,"\n");
   if (opt.Contains("selector")) {
      fprintf(fp,"class %s : public TSelector {\n",classname);
      fprintf(fp,"public :\n");
      fprintf(fp,"   TTree          *fChain;   //!pointer to the analyzed TTree or TChain\n");
   } else {
      fprintf(fp,"class %s {\n",classname);
      fprintf(fp,"public :\n");
      fprintf(fp,"   TTree          *fChain;   //!pointer to the analyzed TTree or TChain\n");
      fprintf(fp,"   Int_t           fCurrent; //!current Tree number in a TChain\n");
   }
   fprintf(fp,"\n   // Declaration of leaf types\n");
   TLeaf *leafcount;
   TLeafObject *leafobj;
   TBranchElement *bre=0;
   const char *headOK  = "   ";
   const char *headcom = " //";
   const char *head;
   char branchname[1024];
   char aprefix[1024];
   TObjArray branches(100);
   TObjArray mustInit(100);
   TObjArray mustInitArr(100);
   mustInitArr.SetOwner(kFALSE);
   Int_t *leafStatus = new Int_t[nleaves];
   for (l=0;l<nleaves;l++) {
      Int_t kmax = 0;
      head = headOK;
      leafStatus[l] = 0;
      TLeaf *leaf = (TLeaf*)leaves->UncheckedAt(l);
      len = leaf->GetLen(); if (len<=0) len = 1;
      leafcount =leaf->GetLeafCount();
      TBranch *branch = leaf->GetBranch();
      branchname[0] = 0;
      strlcpy(branchname,branch->GetName(),sizeof(branchname)); 
      strlcpy(aprefix,branch->GetName(),sizeof(aprefix)); 
      if (!branches.FindObject(branch)) branches.Add(branch);
      else leafStatus[l] = 1;
      if ( branch->GetNleaves() > 1) {
         // More than one leaf for the branch we need to distinguish them
         strlcat(branchname,".",sizeof(branchname));
         strlcat(branchname,leaf->GetTitle(),sizeof(branchname));
         if (leafcount) {
            // remove any dimension in title
            char *dim =  (char*)strstr(branchname,"["); if (dim) dim[0] = 0;
         }
      } else {
         strlcpy(branchname,branch->GetName(),sizeof(branchname)); 
      }
      char *twodim = (char*)strstr(leaf->GetTitle(),"][");
      bname = branchname;
      while (*bname) {
         if (*bname == '.') *bname='_';
         if (*bname == ',') *bname='_';
         if (*bname == ':') *bname='_';
         if (*bname == '<') *bname='_';
         if (*bname == '>') *bname='_';
         bname++;
      }
      if (branch->IsA() == TBranchObject::Class()) {
         if (branch->GetListOfBranches()->GetEntriesFast()) {leafStatus[l] = 1; continue;}
         leafobj = (TLeafObject*)leaf;
         if (!leafobj->GetClass()) {leafStatus[l] = 1; head = headcom;}
         fprintf(fp,"%s%-15s *%s;\n",head,leafobj->GetTypeName(), leafobj->GetName());
         if (leafStatus[l] == 0) mustInit.Add(leafobj);
         continue;
      }
      if (leafcount) {
         len = leafcount->GetMaximum();
         if (len<=0) len = 1;
         strlcpy(blen,leafcount->GetName(),sizeof(blen)); 
         bname = &blen[0];
         while (*bname) {
            if (*bname == '.') *bname='_';
            if (*bname == ',') *bname='_';
            if (*bname == ':') *bname='_';
            if (*bname == '<') *bname='_';
            if (*bname == '>') *bname='_';
            bname++;
         }
         lenb = strlen(blen);
         if (blen[lenb-1] == '_') {blen[lenb-1] = 0; kmax = 1;}
         else                     snprintf(blen,sizeof(blen),"%d",len);
      }
      if (branch->IsA() == TBranchElement::Class()) {
         bre = (TBranchElement*)branch;
         if (bre->GetType() != 3 && bre->GetType() != 4
             && bre->GetStreamerType() <= 0 && bre->GetListOfBranches()->GetEntriesFast()) {
            leafStatus[l] = 0;
         }
         if (bre->GetType() == 3 || bre->GetType() == 4) {
            fprintf(fp,"   %-15s %s_;\n","Int_t", branchname);
            continue;
         }
         if (bre->IsBranchFolder()) {
            fprintf(fp,"   %-15s *%s;\n",bre->GetClassName(), branchname);
            mustInit.Add(bre);
            continue;
         } else {
            if (branch->GetListOfBranches()->GetEntriesFast()) {leafStatus[l] = 1;}
         }
         if (bre->GetStreamerType() < 0) {
            if (branch->GetListOfBranches()->GetEntriesFast()) {
               fprintf(fp,"%s%-15s *%s;\n",headcom,bre->GetClassName(), branchname);
            } else {
               fprintf(fp,"%s%-15s *%s;\n",head,bre->GetClassName(), branchname);
               mustInit.Add(bre);
            }
            continue;
         }
         if (bre->GetStreamerType() == 0) {
            if (!TClass::GetClass(bre->GetClassName())->GetClassInfo()) {leafStatus[l] = 1; head = headcom;}
            fprintf(fp,"%s%-15s *%s;\n",head,bre->GetClassName(), branchname);
            if (leafStatus[l] == 0) mustInit.Add(bre);
            continue;
         }
         if (bre->GetStreamerType() > 60) {
            TClass *cle = TClass::GetClass(bre->GetClassName());
            if (!cle) {leafStatus[l] = 1; continue;}
            if (bre->GetStreamerType() == 66) leafStatus[l] = 0;
            char brename[256];
            strlcpy(brename,bre->GetName(),255); 
            char *bren = brename;
            char *adot = strrchr(bren,'.');
            if (adot) bren = adot+1;
            char *brack = strchr(bren,'[');
            if (brack) *brack = 0;
            TStreamerElement *elem = (TStreamerElement*)cle->GetStreamerInfo()->GetElements()->FindObject(bren);
            if (elem) {
               if (elem->IsA() == TStreamerBase::Class()) {leafStatus[l] = 1; continue;}
               if (!TClass::GetClass(elem->GetTypeName())) {leafStatus[l] = 1; continue;}
               if (!TClass::GetClass(elem->GetTypeName())->GetClassInfo()) {leafStatus[l] = 1; head = headcom;}
               if (leafcount) fprintf(fp,"%s%-15s %s[kMax%s];\n",head,elem->GetTypeName(), branchname,blen);
               else           fprintf(fp,"%s%-15s %s;\n",head,elem->GetTypeName(), branchname);
            } else {
               if (!TClass::GetClass(bre->GetClassName())->GetClassInfo()) {leafStatus[l] = 1; head = headcom;}
               fprintf(fp,"%s%-15s %s;\n",head,bre->GetClassName(), branchname);
            }
            continue;
         }
      }
      if (strlen(leaf->GetTypeName()) == 0) {leafStatus[l] = 1; continue;}
      if (leafcount) {
         //len = leafcount->GetMaximum();
         //strlcpy(blen,leafcount->GetName(),sizeof(blen));
         //bname = &blen[0];
         //while (*bname) {if (*bname == '.') *bname='_'; bname++;}
         //lenb = strlen(blen);
         //Int_t kmax = 0;
         //if (blen[lenb-1] == '_') {blen[lenb-1] = 0; kmax = 1;}
         //else                     sprintf(blen,"%d",len);

         const char *stars = " ";
         if (bre && bre->GetBranchCount2()) {
            stars = "*";
         }
         // Dimensions can be in the branchname for a split Object with a fix length C array.
         // Theses dimensions HAVE TO be placed after the dimension explicited by leafcount
         TString dimensions;
         char *dimInName = (char*) strstr(branchname,"[");
         if ( twodim || dimInName ) {
            if (dimInName) {
               dimensions = dimInName; 
               dimInName[0] = 0; // terminate branchname before the array dimensions.
            }
            if (twodim) dimensions += (char*)(twodim+1);
         }
         const char* leafcountName = leafcount->GetName();
         char b2len[1024];
         if (bre && bre->GetBranchCount2()) {
            TLeaf * l2 = (TLeaf*)bre->GetBranchCount2()->GetListOfLeaves()->At(0);
            strlcpy(b2len,l2->GetName(),sizeof(b2len)); 
            bname = &b2len[0];
            while (*bname) {
               if (*bname == '.') *bname='_';
               if (*bname == ',') *bname='_';
               if (*bname == ':') *bname='_';
               if (*bname == '<') *bname='_';
               if (*bname == '>') *bname='_';
               bname++;
            }
            leafcountName = b2len;
         }
         if (dimensions.Length()) {
            if (kmax) fprintf(fp,"   %-14s %s%s[kMax%s]%s;   //[%s]\n",leaf->GetTypeName(), stars,
                              branchname,blen,dimensions.Data(),leafcountName);
            else      fprintf(fp,"   %-14s %s%s[%d]%s;   //[%s]\n",leaf->GetTypeName(), stars,
                              branchname,len,dimensions.Data(),leafcountName);
         } else {
            if (kmax) fprintf(fp,"   %-14s %s%s[kMax%s];   //[%s]\n",leaf->GetTypeName(), stars, branchname,blen,leafcountName);
            else      fprintf(fp,"   %-14s %s%s[%d];   //[%s]\n",leaf->GetTypeName(), stars, branchname,len,leafcountName);
         }
         if (stars[0]=='*') {
            TNamed *n;
            if (kmax) n = new TNamed(branchname, Form("kMax%s",blen));
            else n = new TNamed(branchname, Form("%d",len));
            mustInitArr.Add(n);
         }
      } else {
         if (strstr(branchname,"[")) len = 1;
         if (len < 2) fprintf(fp,"   %-15s %s;\n",leaf->GetTypeName(), branchname);
         else {
            if (twodim) fprintf(fp,"   %-15s %s%s;\n",leaf->GetTypeName(), branchname,(char*)strstr(leaf->GetTitle(),"["));
            else        fprintf(fp,"   %-15s %s[%d];\n",leaf->GetTypeName(), branchname,len);
         }
      }
   }

// generate list of branches
   fprintf(fp,"\n");
   fprintf(fp,"   // List of branches\n");
   for (l=0;l<nleaves;l++) {
      if (leafStatus[l]) continue;
      TLeaf *leaf = (TLeaf*)leaves->UncheckedAt(l);
      fprintf(fp,"   TBranch        *b_%s;   //!\n",R__GetBranchPointerName(leaf).Data());
   }

// generate class member functions prototypes
   if (opt.Contains("selector")) {
      fprintf(fp,"\n");
      fprintf(fp,"   %s(TTree * /*tree*/ =0) : fChain(0) { }\n",classname) ;
      fprintf(fp,"   virtual ~%s() { }\n",classname);
      fprintf(fp,"   virtual Int_t   Version() const { return 2; }\n");
      fprintf(fp,"   virtual void    Begin(TTree *tree);\n");
      fprintf(fp,"   virtual void    SlaveBegin(TTree *tree);\n");
      fprintf(fp,"   virtual void    Init(TTree *tree);\n");
      fprintf(fp,"   virtual Bool_t  Notify();\n");
      fprintf(fp,"   virtual Bool_t  Process(Long64_t entry);\n");
      fprintf(fp,"   virtual Int_t   GetEntry(Long64_t entry, Int_t getall = 0) { return fChain ? fChain->GetTree()->GetEntry(entry, getall) : 0; }\n");
      fprintf(fp,"   virtual void    SetOption(const char *option) { fOption = option; }\n");
      fprintf(fp,"   virtual void    SetObject(TObject *obj) { fObject = obj; }\n");
      fprintf(fp,"   virtual void    SetInputList(TList *input) { fInput = input; }\n");
      fprintf(fp,"   virtual TList  *GetOutputList() const { return fOutput; }\n");
      fprintf(fp,"   virtual void    SlaveTerminate();\n");
      fprintf(fp,"   virtual void    Terminate();\n\n");
      fprintf(fp,"   ClassDef(%s,0);\n",classname);
      fprintf(fp,"};\n");
      fprintf(fp,"\n");
      fprintf(fp,"#endif\n");
      fprintf(fp,"\n");
   } else {
      fprintf(fp,"\n");
      fprintf(fp,"   %s(TTree *tree=0);\n",classname);
      fprintf(fp,"   virtual ~%s();\n",classname);
      fprintf(fp,"   virtual Int_t    Cut(Long64_t entry);\n");
      fprintf(fp,"   virtual Int_t    GetEntry(Long64_t entry);\n");
      fprintf(fp,"   virtual Long64_t LoadTree(Long64_t entry);\n");
      fprintf(fp,"   virtual void     Init(TTree *tree);\n");
      fprintf(fp,"   virtual void     Loop();\n");
      fprintf(fp,"   virtual Bool_t   Notify();\n");
      fprintf(fp,"   virtual void     Show(Long64_t entry = -1);\n");
      fprintf(fp,"};\n");
      fprintf(fp,"\n");
      fprintf(fp,"#endif\n");
      fprintf(fp,"\n");
   }
// generate code for class constructor
   fprintf(fp,"#ifdef %s_cxx\n",classname);
   if (!opt.Contains("selector")) {
      fprintf(fp,"%s::%s(TTree *tree) : fChain(0) \n",classname,classname);
      fprintf(fp,"{\n");
      fprintf(fp,"// if parameter tree is not specified (or zero), connect the file\n");
      fprintf(fp,"// used to generate this class and read the Tree.\n");
      fprintf(fp,"   if (tree == 0) {\n");
      if (ischain) {
         fprintf(fp,"\n#ifdef SINGLE_TREE\n");
         fprintf(fp,"      // The following code should be used if you want this class to access\n");
         fprintf(fp,"      // a single tree instead of a chain\n");
      }
      if (isHbook) {
         fprintf(fp,"      THbookFile *f = (THbookFile*)gROOT->GetListOfBrowsables()->FindObject(\"%s\");\n",
                    treefile.Data());
         fprintf(fp,"      if (!f) {\n");
         fprintf(fp,"         f = new THbookFile(\"%s\");\n",treefile.Data());
         fprintf(fp,"      }\n");
         Int_t hid;
         sscanf(fTree->GetName(),"h%d",&hid);
         fprintf(fp,"      tree = (TTree*)f->Get(%d);\n\n",hid);
      } else {
         fprintf(fp,"      TFile *f = (TFile*)gROOT->GetListOfFiles()->FindObject(\"%s\");\n",treefile.Data());
         fprintf(fp,"      if (!f || !f->IsOpen()) {\n");
         fprintf(fp,"         f = new TFile(\"%s\");\n",treefile.Data());
         fprintf(fp,"      }\n");
         if (fTree->GetDirectory() != fTree->GetCurrentFile()) {
            fprintf(fp,"      TDirectory * dir = (TDirectory*)f->Get(\"%s\");\n",fTree->GetDirectory()->GetPath());
            fprintf(fp,"      dir->GetObject(\"%s\",tree);\n\n",fTree->GetName());
         } else {
            fprintf(fp,"      f->GetObject(\"%s\",tree);\n\n",fTree->GetName());
         }
      }
      if (ischain) {
         fprintf(fp,"#else // SINGLE_TREE\n\n");
         fprintf(fp,"      // The following code should be used if you want this class to access a chain\n");
         fprintf(fp,"      // of trees.\n");
         fprintf(fp,"      TChain * chain = new TChain(\"%s\",\"%s\");\n",
                 fTree->GetName(),fTree->GetTitle());
         TIter next(((TChain*)fTree)->GetListOfFiles());
         TChainElement *element;
         while ((element = (TChainElement*)next())) {
            fprintf(fp,"      chain->Add(\"%s/%s\");\n",element->GetTitle(),element->GetName());
         }
         fprintf(fp,"      tree = chain;\n");
         fprintf(fp,"#endif // SINGLE_TREE\n\n");
      }
      fprintf(fp,"   }\n");
      fprintf(fp,"   Init(tree);\n");
      fprintf(fp,"}\n");
      fprintf(fp,"\n");
   }

// generate code for class destructor()
   if (!opt.Contains("selector")) {
      fprintf(fp,"%s::~%s()\n",classname,classname);
      fprintf(fp,"{\n");
      fprintf(fp,"   if (!fChain) return;\n");
      if (isHbook) {
         //fprintf(fp,"   delete fChain->GetCurrentFile();\n");
      } else {
         fprintf(fp,"   delete fChain->GetCurrentFile();\n");
      }
      fprintf(fp,"}\n");
      fprintf(fp,"\n");
   }
// generate code for class member function GetEntry()
   if (!opt.Contains("selector")) {
      fprintf(fp,"Int_t %s::GetEntry(Long64_t entry)\n",classname);
      fprintf(fp,"{\n");
      fprintf(fp,"// Read contents of entry.\n");

      fprintf(fp,"   if (!fChain) return 0;\n");
      fprintf(fp,"   return fChain->GetEntry(entry);\n");
      fprintf(fp,"}\n");
   }
// generate code for class member function LoadTree()
   if (!opt.Contains("selector")) {
      fprintf(fp,"Long64_t %s::LoadTree(Long64_t entry)\n",classname);
      fprintf(fp,"{\n");
      fprintf(fp,"// Set the environment to read one entry\n");
      fprintf(fp,"   if (!fChain) return -5;\n");
      fprintf(fp,"   Long64_t centry = fChain->LoadTree(entry);\n");
      fprintf(fp,"   if (centry < 0) return centry;\n");
      fprintf(fp,"   if (fChain->GetTreeNumber() != fCurrent) {\n");
      fprintf(fp,"      fCurrent = fChain->GetTreeNumber();\n");
      fprintf(fp,"      Notify();\n");
      fprintf(fp,"   }\n");
      fprintf(fp,"   return centry;\n");
      fprintf(fp,"}\n");
      fprintf(fp,"\n");
   }

// generate code for class member function Init(), first pass = get branch pointer
   fprintf(fp,"void %s::Init(TTree *tree)\n",classname);
   fprintf(fp,"{\n");
   fprintf(fp,"   // The Init() function is called when the selector needs to initialize\n"
              "   // a new tree or chain. Typically here the branch addresses and branch\n"
              "   // pointers of the tree will be set.\n"
              "   // It is normally not necessary to make changes to the generated\n"
              "   // code, but the routine can be extended by the user if needed.\n"
              "   // Init() will be called many times when running on PROOF\n"
              "   // (once per file to be processed).\n\n");
   if (mustInit.Last()) {
      TIter next(&mustInit);
      TObject *obj;
      fprintf(fp,"   // Set object pointer\n");
      while( (obj = next()) ) {
         if (obj->InheritsFrom(TBranch::Class())) {
            strlcpy(branchname,((TBranch*)obj)->GetName(),sizeof(branchname));
         } else if (obj->InheritsFrom(TLeaf::Class())) {
            strlcpy(branchname,((TLeaf*)obj)->GetName(),sizeof(branchname)); 
         }
         branchname[1023]=0;
         bname = branchname;
         while (*bname) {
            if (*bname == '.') *bname='_';
            if (*bname == ',') *bname='_';
            if (*bname == ':') *bname='_';
            if (*bname == '<') *bname='_';
            if (*bname == '>') *bname='_';
            bname++;
         }
         fprintf(fp,"   %s = 0;\n",branchname );
      }
   }
   if (mustInitArr.Last()) {
      TIter next(&mustInitArr);
      TNamed *info;
      fprintf(fp,"   // Set array pointer\n");
      while( (info = (TNamed*)next()) ) {
         fprintf(fp,"   for(int i=0; i<%s; ++i) %s[i] = 0;\n",info->GetTitle(),info->GetName());
      }
      fprintf(fp,"\n");
   }
   fprintf(fp,"   // Set branch addresses and branch pointers\n");
   fprintf(fp,"   if (!tree) return;\n");
   fprintf(fp,"   fChain = tree;\n");
   if (!opt.Contains("selector")) fprintf(fp,"   fCurrent = -1;\n");
   fprintf(fp,"   fChain->SetMakeClass(1);\n");
   fprintf(fp,"\n");
   for (l=0;l<nleaves;l++) {
      if (leafStatus[l]) continue;
      TLeaf *leaf = (TLeaf*)leaves->UncheckedAt(l);
      len = leaf->GetLen();
      leafcount =leaf->GetLeafCount();
      TBranch *branch = leaf->GetBranch();
      strlcpy(aprefix,branch->GetName(),sizeof(aprefix)); 

      if ( branch->GetNleaves() > 1) {
         // More than one leaf for the branch we need to distinguish them
         strlcpy(branchname,branch->GetName(),sizeof(branchname)); 
         strlcat(branchname,".",sizeof(branchname));
         strlcat(branchname,leaf->GetTitle(),sizeof(branchname));
         if (leafcount) {
            // remove any dimension in title
            char *dim =  (char*)strstr(branchname,"["); if (dim) dim[0] = 0;
         }
      } else {
         strlcpy(branchname,branch->GetName(),sizeof(branchname)); 
         if (branch->IsA() == TBranchElement::Class()) {
            bre = (TBranchElement*)branch;
            if (bre->GetType() == 3 || bre->GetType()==4) strlcat(branchname,"_",sizeof(branchname));
         }
      }
      bname = branchname;
      char *brak = strstr(branchname,"[");     if (brak) *brak = 0;
      char *twodim = (char*)strstr(bname,"["); if (twodim) *twodim = 0;
      while (*bname) {
         if (*bname == '.') *bname='_';
         if (*bname == ',') *bname='_';
         if (*bname == ':') *bname='_';
         if (*bname == '<') *bname='_';
         if (*bname == '>') *bname='_';
         bname++;
      }
      const char *maybedisable = "";
      if (branch != fTree->GetBranch(branch->GetName())) {
         Error("MakeClass","The branch named %s (full path name: %s) is hidden by another branch of the same name and its data will not be loaded.",branch->GetName(),R__GetBranchPointerName(leaf,kFALSE).Data());
         maybedisable = "// ";
      }
      if (branch->IsA() == TBranchObject::Class()) {
         if (branch->GetListOfBranches()->GetEntriesFast()) {
            fprintf(fp,"%s   fChain->SetBranchAddress(\"%s\",(void*)-1,&b_%s);\n",maybedisable,branch->GetName(),R__GetBranchPointerName(leaf).Data());
            continue;
         }
         strlcpy(branchname,branch->GetName(),sizeof(branchname)); 
      }
      if (branch->IsA() == TBranchElement::Class()) {
         if (((TBranchElement*)branch)->GetType() == 3) len =1;
         if (((TBranchElement*)branch)->GetType() == 4) len =1;
      }
      if (leafcount) len = leafcount->GetMaximum()+1;
      if (len > 1) fprintf(fp,"%s   fChain->SetBranchAddress(\"%s\", %s, &b_%s);\n",
                           maybedisable,branch->GetName(), branchname, R__GetBranchPointerName(leaf).Data());
      else         fprintf(fp,"%s   fChain->SetBranchAddress(\"%s\", &%s, &b_%s);\n",
                           maybedisable,branch->GetName(), branchname, R__GetBranchPointerName(leaf).Data());
   }
   //must call Notify in case of MakeClass
   if (!opt.Contains("selector")) {
      fprintf(fp,"   Notify();\n");
   }

   fprintf(fp,"}\n");
   fprintf(fp,"\n");

// generate code for class member function Notify()
   fprintf(fp,"Bool_t %s::Notify()\n",classname);
   fprintf(fp,"{\n");
   fprintf(fp,"   // The Notify() function is called when a new file is opened. This\n"
              "   // can be either for a new TTree in a TChain or when when a new TTree\n"
              "   // is started when using PROOF. It is normally not necessary to make changes\n"
              "   // to the generated code, but the routine can be extended by the\n"
              "   // user if needed. The return value is currently not used.\n\n");
   fprintf(fp,"   return kTRUE;\n");
   fprintf(fp,"}\n");
   fprintf(fp,"\n");

// generate code for class member function Show()
   if (!opt.Contains("selector")) {
      fprintf(fp,"void %s::Show(Long64_t entry)\n",classname);
      fprintf(fp,"{\n");
      fprintf(fp,"// Print contents of entry.\n");
      fprintf(fp,"// If entry is not specified, print current entry\n");

      fprintf(fp,"   if (!fChain) return;\n");
      fprintf(fp,"   fChain->Show(entry);\n");
      fprintf(fp,"}\n");
   }
// generate code for class member function Cut()
   if (!opt.Contains("selector")) {
      fprintf(fp,"Int_t %s::Cut(Long64_t entry)\n",classname);
      fprintf(fp,"{\n");
      fprintf(fp,"// This function may be called from Loop.\n");
      fprintf(fp,"// returns  1 if entry is accepted.\n");
      fprintf(fp,"// returns -1 otherwise.\n");

      fprintf(fp,"   return 1;\n");
      fprintf(fp,"}\n");
   }
   fprintf(fp,"#endif // #ifdef %s_cxx\n",classname);

//======================Generate classname.C=====================
   if (!opt.Contains("selector")) {
      // generate code for class member function Loop()
      fprintf(fpc,"#define %s_cxx\n",classname);
      fprintf(fpc,"#include \"%s\"\n",thead.Data());
      fprintf(fpc,"#include <TH2.h>\n");
      fprintf(fpc,"#include <TStyle.h>\n");
      fprintf(fpc,"#include <TCanvas.h>\n");
      fprintf(fpc,"\n");
      fprintf(fpc,"void %s::Loop()\n",classname);
      fprintf(fpc,"{\n");
      fprintf(fpc,"//   In a ROOT session, you can do:\n");
      fprintf(fpc,"//      Root > .L %s.C\n",classname);
      fprintf(fpc,"//      Root > %s t\n",classname);
      fprintf(fpc,"//      Root > t.GetEntry(12); // Fill t data members with entry number 12\n");
      fprintf(fpc,"//      Root > t.Show();       // Show values of entry 12\n");
      fprintf(fpc,"//      Root > t.Show(16);     // Read and show values of entry 16\n");
      fprintf(fpc,"//      Root > t.Loop();       // Loop on all entries\n");
      fprintf(fpc,"//\n");
      fprintf(fpc,"\n//     This is the loop skeleton where:\n");
      fprintf(fpc,"//    jentry is the global entry number in the chain\n");
      fprintf(fpc,"//    ientry is the entry number in the current Tree\n");
      fprintf(fpc,"//  Note that the argument to GetEntry must be:\n");
      fprintf(fpc,"//    jentry for TChain::GetEntry\n");
      fprintf(fpc,"//    ientry for TTree::GetEntry and TBranch::GetEntry\n");
      fprintf(fpc,"//\n");
      fprintf(fpc,"//       To read only selected branches, Insert statements like:\n");
      fprintf(fpc,"// METHOD1:\n");
      fprintf(fpc,"//    fChain->SetBranchStatus(\"*\",0);  // disable all branches\n");
      fprintf(fpc,"//    fChain->SetBranchStatus(\"branchname\",1);  // activate branchname\n");
      fprintf(fpc,"// METHOD2: replace line\n");
      fprintf(fpc,"//    fChain->GetEntry(jentry);       //read all branches\n");
      fprintf(fpc,"//by  b_branchname->GetEntry(ientry); //read only this branch\n");
      fprintf(fpc,"   if (fChain == 0) return;\n");
      fprintf(fpc,"\n   Long64_t nentries = fChain->GetEntriesFast();\n");
      fprintf(fpc,"\n   Long64_t nbytes = 0, nb = 0;\n");
      fprintf(fpc,"   for (Long64_t jentry=0; jentry<nentries;jentry++) {\n");
      fprintf(fpc,"      Long64_t ientry = LoadTree(jentry);\n");
      fprintf(fpc,"      if (ientry < 0) break;\n");
      fprintf(fpc,"      nb = fChain->GetEntry(jentry);   nbytes += nb;\n");
      fprintf(fpc,"      // if (Cut(ientry) < 0) continue;\n");
      fprintf(fpc,"   }\n");
      fprintf(fpc,"}\n");
   }
   if (opt.Contains("selector")) {
      // generate usage comments and list of includes
      fprintf(fpc,"#define %s_cxx\n",classname);
      fprintf(fpc,"// The class definition in %s.h has been generated automatically\n",classname);
      fprintf(fpc,"// by the ROOT utility TTree::MakeSelector(). This class is derived\n");
      fprintf(fpc,"// from the ROOT class TSelector. For more information on the TSelector\n"
                  "// framework see $ROOTSYS/README/README.SELECTOR or the ROOT User Manual.\n\n");
      fprintf(fpc,"// The following methods are defined in this file:\n");
      fprintf(fpc,"//    Begin():        called every time a loop on the tree starts,\n");
      fprintf(fpc,"//                    a convenient place to create your histograms.\n");
      fprintf(fpc,"//    SlaveBegin():   called after Begin(), when on PROOF called only on the\n"
                  "//                    slave servers.\n");
      fprintf(fpc,"//    Process():      called for each event, in this function you decide what\n");
      fprintf(fpc,"//                    to read and fill your histograms.\n");
      fprintf(fpc,"//    SlaveTerminate: called at the end of the loop on the tree, when on PROOF\n"
                  "//                    called only on the slave servers.\n");
      fprintf(fpc,"//    Terminate():    called at the end of the loop on the tree,\n");
      fprintf(fpc,"//                    a convenient place to draw/fit your histograms.\n");
      fprintf(fpc,"//\n");
      fprintf(fpc,"// To use this file, try the following session on your Tree T:\n");
      fprintf(fpc,"//\n");
      fprintf(fpc,"// Root > T->Process(\"%s.C\")\n",classname);
      fprintf(fpc,"// Root > T->Process(\"%s.C\",\"some options\")\n",classname);
      fprintf(fpc,"// Root > T->Process(\"%s.C+\")\n",classname);
      fprintf(fpc,"//\n\n");
      fprintf(fpc,"#include \"%s\"\n",thead.Data());
      fprintf(fpc,"#include <TH2.h>\n");
      fprintf(fpc,"#include <TStyle.h>\n");
      fprintf(fpc,"\n");
      // generate code for class member function Begin
      fprintf(fpc,"\n");
      fprintf(fpc,"void %s::Begin(TTree * /*tree*/)\n",classname);
      fprintf(fpc,"{\n");
      fprintf(fpc,"   // The Begin() function is called at the start of the query.\n");
      fprintf(fpc,"   // When running with PROOF Begin() is only called on the client.\n");
      fprintf(fpc,"   // The tree argument is deprecated (on PROOF 0 is passed).\n");
      fprintf(fpc,"\n");
      fprintf(fpc,"   TString option = GetOption();\n");
      fprintf(fpc,"\n");
      fprintf(fpc,"}\n");
      // generate code for class member function SlaveBegin
      fprintf(fpc,"\n");
      fprintf(fpc,"void %s::SlaveBegin(TTree * /*tree*/)\n",classname);
      fprintf(fpc,"{\n");
      fprintf(fpc,"   // The SlaveBegin() function is called after the Begin() function.\n");
      fprintf(fpc,"   // When running with PROOF SlaveBegin() is called on each slave server.\n");
      fprintf(fpc,"   // The tree argument is deprecated (on PROOF 0 is passed).\n");
      fprintf(fpc,"\n");
      fprintf(fpc,"   TString option = GetOption();\n");
      fprintf(fpc,"\n");
      fprintf(fpc,"}\n");
      // generate code for class member function Process
      fprintf(fpc,"\n");
      fprintf(fpc,"Bool_t %s::Process(Long64_t entry)\n",classname);
      fprintf(fpc,"{\n");
      fprintf(fpc,"   // The Process() function is called for each entry in the tree (or possibly\n"
                  "   // keyed object in the case of PROOF) to be processed. The entry argument\n"
                  "   // specifies which entry in the currently loaded tree is to be processed.\n"
                  "   // It can be passed to either %s::GetEntry() or TBranch::GetEntry()\n"
                  "   // to read either all or the required parts of the data. When processing\n"
                  "   // keyed objects with PROOF, the object is already loaded and is available\n"
                  "   // via the fObject pointer.\n"
                  "   //\n"
                  "   // This function should contain the \"body\" of the analysis. It can contain\n"
                  "   // simple or elaborate selection criteria, run algorithms on the data\n"
                  "   // of the event and typically fill histograms.\n"
                  "   //\n"
                  "   // The processing can be stopped by calling Abort().\n"
                  "   //\n"
                  "   // Use fStatus to set the return value of TTree::Process().\n"
                  "   //\n"
                  "   // The return value is currently not used.\n\n", classname);
      fprintf(fpc,"\n");
      fprintf(fpc,"   return kTRUE;\n");
      fprintf(fpc,"}\n");
      // generate code for class member function SlaveTerminate
      fprintf(fpc,"\n");
      fprintf(fpc,"void %s::SlaveTerminate()\n",classname);
      fprintf(fpc,"{\n");
      fprintf(fpc,"   // The SlaveTerminate() function is called after all entries or objects\n"
                  "   // have been processed. When running with PROOF SlaveTerminate() is called\n"
                  "   // on each slave server.");
      fprintf(fpc,"\n");
      fprintf(fpc,"\n");
      fprintf(fpc,"}\n");
      // generate code for class member function Terminate
      fprintf(fpc,"\n");
      fprintf(fpc,"void %s::Terminate()\n",classname);
      fprintf(fpc,"{\n");
      fprintf(fpc,"   // The Terminate() function is the last function to be called during\n"
                  "   // a query. It always runs on the client, it can be used to present\n"
                  "   // the results graphically or save the results to file.");
      fprintf(fpc,"\n");
      fprintf(fpc,"\n");
      fprintf(fpc,"}\n");
   }
   Info("MakeClass","Files: %s and %s generated from TTree: %s",thead.Data(),tcimp.Data(),fTree->GetName());
   delete [] leafStatus;
   fclose(fp);
   fclose(fpc);

   return 0;
}


//______________________________________________________________________________
Int_t TTreePlayer::MakeCode(const char *filename)
{
// Generate skeleton function for this Tree
//
// The function code is written on filename.
// If filename is 0, filename will be called nameoftree.C
//
// The generated code includes the following:
//    - Identification of the original Tree and Input file name
//    - Connection of the Tree file
//    - Declaration of Tree variables
//    - Setting of branches addresses
//    - A skeleton for the entry loop
//
// To use this function:
//    - connect your Tree file (eg: TFile f("myfile.root");)
//    - T->MakeCode("anal.C");
// where T is the name of the Tree in file myfile.root
// and anal.C the name of the file created by this function.
//
// NOTE: Since the implementation of this function, a new and better
//       function TTree::MakeClass() has been developed.

// Connect output file
   TString tfile;
   if (filename)
      tfile = filename;
   else
      tfile.Form("%s.C", fTree->GetName());
   FILE *fp = fopen(tfile, "w");
   if (!fp) {
      Error("MakeCode","cannot open output file %s", tfile.Data());
      return 3;
   }
   TString treefile;
   if (fTree->GetDirectory() && fTree->GetDirectory()->GetFile()) {
      treefile = fTree->GetDirectory()->GetFile()->GetName();
   } else {
      treefile = "Memory Directory";
   }
   // In the case of a chain, the GetDirectory information usually does
   // pertain to the Chain itself but to the currently loaded tree.
   // So we can not rely on it.
   Bool_t ischain = fTree->InheritsFrom(TChain::Class());

// Print header
   TObjArray *leaves = fTree->GetListOfLeaves();
   Int_t nleaves = leaves ? leaves->GetEntriesFast() : 0;
   TDatime td;
   fprintf(fp,"{\n");
   fprintf(fp,"//////////////////////////////////////////////////////////\n");
   fprintf(fp,"//   This file has been automatically generated \n");
   fprintf(fp,"//     (%s by ROOT version%s)\n",td.AsString(),gROOT->GetVersion());
   if (!ischain) {
      fprintf(fp,"//   from TTree %s/%s\n",fTree->GetName(),fTree->GetTitle());
      fprintf(fp,"//   found on file: %s\n",treefile.Data());
   } else {
      fprintf(fp,"//   from TChain %s/%s\n",fTree->GetName(),fTree->GetTitle());
   }
   fprintf(fp,"//////////////////////////////////////////////////////////\n");
   fprintf(fp,"\n");
   fprintf(fp,"\n");


// Reset and file connect
   fprintf(fp,"//Reset ROOT and connect tree file\n");
   fprintf(fp,"   gROOT->Reset();\n");
   if (ischain) {
      fprintf(fp,"\n#ifdef SINGLE_TREE\n");
      fprintf(fp,"   // The following code should be used if you want this code to access\n");
      fprintf(fp,"   // a single tree instead of a chain\n");
   }
   fprintf(fp,"   TFile *f = (TFile*)gROOT->GetListOfFiles()->FindObject(\"%s\");\n",treefile.Data());
   fprintf(fp,"   if (!f) {\n");
   fprintf(fp,"      f = new TFile(\"%s\");\n",treefile.Data());
   fprintf(fp,"   }\n");
   if (fTree->GetDirectory() != fTree->GetCurrentFile()) {
      fprintf(fp,"    TDirectory * dir = (TDirectory*)f->Get(\"%s\");\n",fTree->GetDirectory()->GetPath());
      fprintf(fp,"    dir->GetObject(\"%s\",tree);\n\n",fTree->GetName());
   } else {
      fprintf(fp,"    f->GetObject(\"%s\",tree);\n\n",fTree->GetName());
   }
   if (ischain) {
      fprintf(fp,"#else // SINGLE_TREE\n\n");
      fprintf(fp,"   // The following code should be used if you want this code to access a chain\n");
      fprintf(fp,"   // of trees.\n");
      fprintf(fp,"   TChain *%s = new TChain(\"%s\",\"%s\");\n",
                 fTree->GetName(),fTree->GetName(),fTree->GetTitle());
      TIter next(((TChain*)fTree)->GetListOfFiles());
      TChainElement *element;
      while ((element = (TChainElement*)next())) {
         fprintf(fp,"   %s->Add(\"%s/%s\");\n",fTree->GetName(),element->GetTitle(),element->GetName());
      }
      fprintf(fp,"#endif // SINGLE_TREE\n\n");
   }

// First loop on all leaves to generate type declarations
   fprintf(fp,"//Declaration of leaves types\n");
   Int_t len, l;
   TLeaf *leafcount;
   TLeafObject *leafobj;
   char *bname;
   const char *headOK  = "   ";
   const char *headcom = " //";
   const char *head;
   char branchname[1024];
   for (l=0;l<nleaves;l++) {
      TLeaf *leaf = (TLeaf*)leaves->UncheckedAt(l);
      len = leaf->GetLen();
      leafcount =leaf->GetLeafCount();
      TBranch *branch = leaf->GetBranch();
      if (branch->GetListOfBranches()->GetEntriesFast() > 0) continue;

      if ( branch->GetNleaves() > 1) {
         // More than one leaf for the branch we need to distinguish them
         strlcpy(branchname,branch->GetName(),sizeof(branchname)); 
         strlcat(branchname,".",sizeof(branchname));
         strlcat(branchname,leaf->GetTitle(),sizeof(branchname));
         if (leafcount) {
            // remove any dimension in title
            char *dim =  (char*)strstr(branchname,"[");
            if (dim) dim[0] = 0;
         }
      } else {
         if (leafcount) strlcpy(branchname,branch->GetName(),sizeof(branchname));
         else           strlcpy(branchname,leaf->GetTitle(),sizeof(branchname));
      }
      char *twodim = (char*)strstr(leaf->GetTitle(),"][");
      bname = branchname;
      while (*bname) {
         if (*bname == '.') *bname='_';
         if (*bname == ',') *bname='_';
         if (*bname == ':') *bname='_';
         if (*bname == '<') *bname='_';
         if (*bname == '>') *bname='_';
         bname++;
      }
      if (branch->IsA() == TBranchObject::Class()) {
         leafobj = (TLeafObject*)leaf;
         if (leafobj->GetClass()) head = headOK;
         else                     head = headcom;
         fprintf(fp,"%s%-15s *%s = 0;\n",head,leafobj->GetTypeName(), leafobj->GetName());
         continue;
      }
      if (leafcount) {
         len = leafcount->GetMaximum();
         // Dimensions can be in the branchname for a split Object with a fix length C array.
         // Theses dimensions HAVE TO be placed after the dimension explicited by leafcount
         char *dimInName = (char*) strstr(branchname,"[");
         TString dimensions;
         if ( twodim || dimInName ) {
            if (dimInName) {
               dimensions = dimInName; 
               dimInName[0] = 0; // terminate branchname before the array dimensions.
            }
            if (twodim) dimensions += (char*)(twodim+1);
         }
         if (dimensions.Length()) {
            fprintf(fp,"   %-15s %s[%d]%s;\n",leaf->GetTypeName(), branchname,len,dimensions.Data());
         } else {
            fprintf(fp,"   %-15s %s[%d];\n",leaf->GetTypeName(), branchname,len);
         }
      } else {
         if (strstr(branchname,"[")) len = 1;
         if (len < 2) fprintf(fp,"   %-15s %s;\n",leaf->GetTypeName(), branchname);
         else         fprintf(fp,"   %-15s %s[%d];\n",leaf->GetTypeName(), branchname,len);
      }
   }

// Second loop on all leaves to set the corresponding branch address
   fprintf(fp,"\n   // Set branch addresses.\n");
   for (l=0;l<nleaves;l++) {
      TLeaf *leaf = (TLeaf*)leaves->UncheckedAt(l);
      len = leaf->GetLen();
      leafcount =leaf->GetLeafCount();
      TBranch *branch = leaf->GetBranch();

      if ( branch->GetNleaves() > 1) {
         // More than one leaf for the branch we need to distinguish them
         strlcpy(branchname,branch->GetName(),sizeof(branchname)); 
         strlcat(branchname,".",sizeof(branchname));
         strlcat(branchname,leaf->GetTitle(),sizeof(branchname));
         if (leafcount) {
            // remove any dimension in title
            char *dim =  (char*)strstr(branchname,"[");
            if (dim) dim[0] = 0;
         }
      } else {
         if (leafcount) strlcpy(branchname,branch->GetName(),sizeof(branchname));
         else           strlcpy(branchname,leaf->GetTitle(),sizeof(branchname));
      }
      bname = branchname;
      while (*bname) {
         if (*bname == '.') *bname='_';
         if (*bname == ',') *bname='_';
         if (*bname == ':') *bname='_';
         if (*bname == '<') *bname='_';
         if (*bname == '>') *bname='_';
         bname++;
      }
      char *brak = strstr(branchname,"[");
      if (brak) *brak = 0;
      head = headOK;
      if (branch->IsA() == TBranchObject::Class()) {
         strlcpy(branchname,branch->GetName(),sizeof(branchname));
         leafobj = (TLeafObject*)leaf;
         if (!leafobj->GetClass()) head = headcom;
      }
      if (leafcount) len = leafcount->GetMaximum()+1;
      if (len > 1 || brak) fprintf(fp,"%s%s->SetBranchAddress(\"%s\",%s);\n",head,fTree->GetName(),branch->GetName(),branchname);
      else                 fprintf(fp,"%s%s->SetBranchAddress(\"%s\",&%s);\n",head,fTree->GetName(),branch->GetName(),branchname);
   }

//Generate instructions to make the loop on entries
   fprintf(fp,"\n//     This is the loop skeleton\n");
   fprintf(fp,"//       To read only selected branches, Insert statements like:\n");
   fprintf(fp,"// %s->SetBranchStatus(\"*\",0);  // disable all branches\n",fTree->GetName());
   fprintf(fp,"// %s->SetBranchStatus(\"branchname\",1);  // activate branchname\n",GetName());
   fprintf(fp,"\n   Long64_t nentries = %s->GetEntries();\n",fTree->GetName());
   fprintf(fp,"\n   Long64_t nbytes = 0;\n");
   fprintf(fp,"//   for (Long64_t i=0; i<nentries;i++) {\n");
   fprintf(fp,"//      nbytes += %s->GetEntry(i);\n",fTree->GetName());
   fprintf(fp,"//   }\n");
   fprintf(fp,"}\n");

   printf("Macro: %s generated from Tree: %s\n",tfile.Data(), fTree->GetName());
   fclose(fp);

   return 0;
}

//______________________________________________________________________________
Int_t TTreePlayer::MakeProxy(const char *proxyClassname,
                             const char *macrofilename, const char *cutfilename,
                             const char *option, Int_t maxUnrolling)
{
   // Generate a skeleton analysis class for this Tree using TBranchProxy.
   // TBranchProxy is the base of a class hierarchy implementing an
   // indirect access to the content of the branches of a TTree.
   //
   // "proxyClassname" is expected to be of the form:
   //    [path/]fileprefix
   // The skeleton will then be generated in the file:
   //    fileprefix.h
   // located in the current directory or in 'path/' if it is specified.
   // The class generated will be named 'fileprefix'.
   // If the fileprefix contains a period, the right side of the period
   // will be used as the extension (instead of 'h') and the left side
   // will be used as the classname.
   //
   // "macrofilename" and optionally "cutfilename" are expected to point
   // to source file which will be included in by the generated skeletong.
   // Method of the same name as the file(minus the extension and path)
   // will be called by the generated skeleton's Process method as follow:
   //    [if (cutfilename())] htemp->Fill(macrofilename());
   //
   // "option" can be used select some of the optional features during
   // the code generation.  The possible options are:
   //    nohist : indicates that the generated ProcessFill should not
   //             fill the histogram.
   //
   // 'maxUnrolling' controls how deep in the class hierarchy does the
   // system 'unroll' class that are not split.  'unrolling' a class
   // will allow direct access to its data members a class (this
   // emulates the behavior of TTreeFormula).
   //
   // The main features of this skeleton are:
   //
   //    * on-demand loading of branches
   //    * ability to use the 'branchname' as if it was a data member
   //    * protection against array out-of-bound
   //    * ability to use the branch data as object (when the user code is available)
   //
   // For example with Event.root, if
   //    Double_t somepx = fTracks.fPx[2];
   // is executed by one of the method of the skeleton,
   // somepx will be updated with the current value of fPx of the 3rd track.
   //
   // Both macrofilename and the optional cutfilename are expected to be
   // the name of source files which contain at least a free standing
   // function with the signature:
   //     x_t macrofilename(); // i.e function with the same name as the file
   // and
   //     y_t cutfilename();   // i.e function with the same name as the file
   //
   // x_t and y_t needs to be types that can convert respectively to a double
   // and a bool (because the skeleton uses:
   //     if (cutfilename()) htemp->Fill(macrofilename());
   //
   // This 2 functions are run in a context such that the branch names are
   // available as local variables of the correct (read-only) type.
   //
   // Note that if you use the same 'variable' twice, it is more efficient
   // to 'cache' the value. For example
   //   Int_t n = fEventNumber; // Read fEventNumber
   //   if (n<10 || n>10) { ... }
   // is more efficient than
   //   if (fEventNumber<10 || fEventNumber>10)
   //
   // Access to TClonesArray.
   //
   // If a branch (or member) is a TClonesArray (let's say fTracks), you
   // can access the TClonesArray itself by using ->:
   //    fTracks->GetLast();
   // However this will load the full TClonesArray object and its content.
   // To quickly read the size of the TClonesArray use (note the dot):
   //    fTracks.GetEntries();
   // This will read only the size from disk if the TClonesArray has been
   // split.
   // To access the content of the TClonesArray, use the [] operator:
   //    float px = fTracks[i].fPx; // fPx of the i-th track
   //
   // Warning:
   //    The variable actually use for access are 'wrapper' around the
   // real data type (to add autoload for example) and hence getting to
   // the data involves the implicit call to a C++ conversion operator.
   // This conversion is automatic in most case.  However it is not invoked
   // in a few cases, in particular in variadic function (like printf).
   // So when using printf you should either explicitly cast the value or
   // use any intermediary variable:
   //      fprintf(stdout,"trs[%d].a = %d\n",i,(int)trs.a[i]);
   //
   // Also, optionally, the generated selector will also call methods named
   // macrofilename_methodname in each of 6 main selector methods if the method
   // macrofilename_methodname exist (Where macrofilename is stripped of its
   // extension).
   //
   // Concretely, with the script named h1analysisProxy.C,
   //
   // The method         calls the method (if it exist)
   // Begin           -> void h1analysisProxy_Begin(TTree*);
   // SlaveBegin      -> void h1analysisProxy_SlaveBegin(TTree*);
   // Notify          -> Bool_t h1analysisProxy_Notify();
   // Process         -> Bool_t h1analysisProxy_Process(Long64_t);
   // SlaveTerminate  -> void h1analysisProxy_SlaveTerminate();
   // Terminate       -> void h1analysisProxy_Terminate();
   //
   // If a file name macrofilename.h (or .hh, .hpp, .hxx, .hPP, .hXX) exist
   // it is included before the declaration of the proxy class.  This can
   // be used in particular to insure that the include files needed by
   // the macro file are properly loaded.
   //
   // The default histogram is accessible via the variable named 'htemp'.
   //
   // If the library of the classes describing the data in the branch is
   // loaded, the skeleton will add the needed #include statements and
   // give the ability to access the object stored in the branches.
   //
   // To draw px using the file hsimple.root (generated by the
   // hsimple.C tutorial), we need a file named hsimple.cxx:
   //
   //     double hsimple() {
   //        return px;
   //     }
   //
   // MakeProxy can then be used indirectly via the TTree::Draw interface
   // as follow:
   //     new TFile("hsimple.root")
   //     ntuple->Draw("hsimple.cxx");
   //
   // A more complete example is available in the tutorials directory:
   //   h1analysisProxy.cxx , h1analysProxy.h and h1analysisProxyCut.C
   // which reimplement the selector found in h1analysis.C

   if (macrofilename==0 || strlen(macrofilename)==0 ) {
      // We currently require a file name for the script
      Error("MakeProxy","A file name for the user script is required");
      return 0;
   }

   TTreeProxyGenerator gp(fTree,macrofilename,cutfilename,proxyClassname,option,maxUnrolling);

   return 0;
}

//______________________________________________________________________________
TPrincipal *TTreePlayer::Principal(const char *varexp, const char *selection, Option_t *option, Long64_t nentries, Long64_t firstentry)
{
// Interface to the Principal Components Analysis class.
//
//   Create an instance of TPrincipal
//   Fill it with the selected variables
//   if option "n" is specified, the TPrincipal object is filled with
//                 normalized variables.
//   If option "p" is specified, compute the principal components
//   If option "p" and "d" print results of analysis
//   If option "p" and "h" generate standard histograms
//   If option "p" and "c" generate code of conversion functions
//   return a pointer to the TPrincipal object. It is the user responsibility
//   to delete this object.
//   The option default value is "np"
//
//   See TTreePlayer::DrawSelect for explanation of the other parameters.

   TTreeFormula **var;
   std::vector<TString> cnames;
   TString opt = option;
   opt.ToLower();
   TPrincipal *principal = 0;
   Long64_t entry,entryNumber;
   Int_t i,nch;
   Int_t ncols = 8;   // by default first 8 columns are printed only
   TObjArray *leaves = fTree->GetListOfLeaves();
   Int_t nleaves = leaves->GetEntriesFast();
   if (nleaves < ncols) ncols = nleaves;
   nch = varexp ? strlen(varexp) : 0;

   nentries = GetEntriesToProcess(firstentry, nentries);

//*-*- Compile selection expression if there is one
   TTreeFormula *select = 0;
   if (strlen(selection)) {
      select = new TTreeFormula("Selection",selection,fTree);
      if (!select) return principal;
      if (!select->GetNdim()) { delete select; return principal; }
      fFormulaList->Add(select);
   }
//*-*- if varexp is empty, take first 8 columns by default
   int allvar = 0;
   if (varexp && !strcmp(varexp, "*")) { ncols = nleaves; allvar = 1; }
   if (nch == 0 || allvar) {
      for (i=0;i<ncols;i++) {
         cnames.push_back( ((TLeaf*)leaves->At(i))->GetName() );
      }
//*-*- otherwise select only the specified columns
   } else {
      ncols = fSelector->SplitNames(varexp,cnames);
   }
   var = new TTreeFormula* [ncols];
   Double_t *xvars = new Double_t[ncols];

//*-*- Create the TreeFormula objects corresponding to each column
   for (i=0;i<ncols;i++) {
      var[i] = new TTreeFormula("Var1",cnames[i].Data(),fTree);
      fFormulaList->Add(var[i]);
   }

//*-*- Create a TreeFormulaManager to coordinate the formulas
   TTreeFormulaManager *manager=0;
   if (fFormulaList->LastIndex()>=0) {
      manager = new TTreeFormulaManager;
      for(i=0;i<=fFormulaList->LastIndex();i++) {
         manager->Add((TTreeFormula*)fFormulaList->At(i));
      }
      manager->Sync();
   }

//*-* Build the TPrincipal object
   if (opt.Contains("n")) principal = new TPrincipal(ncols, "n");
   else                   principal = new TPrincipal(ncols);

//*-*- loop on all selected entries
   fSelectedRows = 0;
   Int_t tnumber = -1;
   for (entry=firstentry;entry<firstentry+nentries;entry++) {
      entryNumber = fTree->GetEntryNumber(entry);
      if (entryNumber < 0) break;
      Long64_t localEntry = fTree->LoadTree(entryNumber);
      if (localEntry < 0) break;
      if (tnumber != fTree->GetTreeNumber()) {
         tnumber = fTree->GetTreeNumber();
         if (manager) manager->UpdateFormulaLeaves();
      }
      int ndata = 1;
      if (manager && manager->GetMultiplicity()) {
         ndata = manager->GetNdata();
      }

      for(int inst=0;inst<ndata;inst++) {
         Bool_t loaded = kFALSE;
         if (select) {
            if (select->EvalInstance(inst) == 0) {
               continue;
            }
         }

         if (inst==0) loaded = kTRUE;
         else if (!loaded) {
            // EvalInstance(0) always needs to be called so that
            // the proper branches are loaded.
            for (i=0;i<ncols;i++) {
               var[i]->EvalInstance(0);
            }
            loaded = kTRUE;
         }

         for (i=0;i<ncols;i++) {
            xvars[i] = var[i]->EvalInstance(inst);
         }
         principal->AddRow(xvars);
      }
   }

   //*-* some actions with principal ?
   if (opt.Contains("p")) {
      principal->MakePrincipals(); // Do the actual analysis
      if (opt.Contains("d")) principal->Print();
      if (opt.Contains("h")) principal->MakeHistograms();
      if (opt.Contains("c")) principal->MakeCode();
   }

//*-*- delete temporary objects
   fFormulaList->Clear();
   delete [] var;
   delete [] xvars;

   return principal;
}

//______________________________________________________________________________
Long64_t TTreePlayer::Process(const char *filename,Option_t *option, Long64_t nentries, Long64_t firstentry)
{
   // Process this tree executing the TSelector code in the specified filename.
   // The return value is -1 in case of error and TSelector::GetStatus() in
   // in case of success.
   //
   // The code in filename is loaded (interpreted or compiled, see below),
   // filename must contain a valid class implementation derived from TSelector,
   // where TSelector has the following member functions:
   //
   //    Begin():        called every time a loop on the tree starts,
   //                    a convenient place to create your histograms.
   //    SlaveBegin():   called after Begin(), when on PROOF called only on the
   //                    slave servers.
   //    Process():      called for each event, in this function you decide what
   //                    to read and fill your histograms.
   //    SlaveTerminate: called at the end of the loop on the tree, when on PROOF
   //                    called only on the slave servers.
   //    Terminate():    called at the end of the loop on the tree,
   //                    a convenient place to draw/fit your histograms.
   //
   // If filename is of the form file.C, the file will be interpreted.
   // If filename is of the form file.C++, the file file.C will be compiled
   // and dynamically loaded.
   // If filename is of the form file.C+, the file file.C will be compiled
   // and dynamically loaded. At next call, if file.C is older than file.o
   // and file.so, the file.C is not compiled, only file.so is loaded.
   //
   //  NOTE1
   //  It may be more interesting to invoke directly the other Process function
   //  accepting a TSelector* as argument.eg
   //     MySelector *selector = (MySelector*)TSelector::GetSelector(filename);
   //     selector->CallSomeFunction(..);
   //     mytree.Process(selector,..);
   //
   //  NOTE2
   //  One should not call this function twice with the same selector file
   //  in the same script. If this is required, proceed as indicated in NOTE1,
   //  by getting a pointer to the corresponding TSelector,eg
   //    workaround 1
   //    ------------
   //void stubs1() {
   //   TSelector *selector = TSelector::GetSelector("h1test.C");
   //   TFile *f1 = new TFile("stubs_nood_le1.root");
   //   TTree *h1 = (TTree*)f1->Get("h1");
   //   h1->Process(selector);
   //   TFile *f2 = new TFile("stubs_nood_le1_coarse.root");
   //   TTree *h2 = (TTree*)f2->Get("h1");
   //   h2->Process(selector);
   //}
   //  or use ACLIC to compile the selector
   //   workaround 2
   //   ------------
   //void stubs2() {
   //   TFile *f1 = new TFile("stubs_nood_le1.root");
   //   TTree *h1 = (TTree*)f1->Get("h1");
   //   h1->Process("h1test.C+");
   //   TFile *f2 = new TFile("stubs_nood_le1_coarse.root");
   //   TTree *h2 = (TTree*)f2->Get("h1");
   //   h2->Process("h1test.C+");
   //}

   DeleteSelectorFromFile(); //delete previous selector if any

   // This might reloads the script and delete your option
   // string! so let copy it first:
   TString opt(option);
   TString file(filename);
   TSelector *selector = TSelector::GetSelector(file);
   if (!selector) return -1;

   fSelectorFromFile = selector;
   fSelectorClass    = selector->IsA();

   Long64_t nsel = Process(selector,opt,nentries,firstentry);
   return nsel;
}

//______________________________________________________________________________
Long64_t TTreePlayer::Process(TSelector *selector,Option_t *option, Long64_t nentries, Long64_t firstentry)
{
   // Process this tree executing the code in the specified selector.
   // The return value is -1 in case of error and TSelector::GetStatus() in
   // in case of success.
   //
   //   The TSelector class has the following member functions:
   //
   //    Begin():        called every time a loop on the tree starts,
   //                    a convenient place to create your histograms.
   //    SlaveBegin():   called after Begin(), when on PROOF called only on the
   //                    slave servers.
   //    Process():      called for each event, in this function you decide what
   //                    to read and fill your histograms.
   //    SlaveTerminate: called at the end of the loop on the tree, when on PROOF
   //                    called only on the slave servers.
   //    Terminate():    called at the end of the loop on the tree,
   //                    a convenient place to draw/fit your histograms.
   //
   //  If the Tree (Chain) has an associated EventList, the loop is on the nentries
   //  of the EventList, starting at firstentry, otherwise the loop is on the
   //  specified Tree entries.

   nentries = GetEntriesToProcess(firstentry, nentries);

   TDirectory::TContext ctxt(0);

   fTree->SetNotify(selector);

   selector->SetOption(option);

   selector->Begin(fTree);       //<===call user initialization function
   selector->SlaveBegin(fTree);  //<===call user initialization function
   if (selector->Version() >= 2)
      selector->Init(fTree);
   selector->Notify();

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

   if (selector->GetAbort() != TSelector::kAbortProcess
       && (selector->Version() != 0 || selector->GetStatus() != -1)) {

      Long64_t readbytesatstart = 0;
      readbytesatstart = TFile::GetFileBytesRead();

      //set the file cache
      TTreeCache *tpf = 0;
      TFile *curfile = fTree->GetCurrentFile();
      if (curfile && fTree->GetCacheSize() > 0) {
         tpf = (TTreeCache*)curfile->GetCacheRead();
         if (tpf)
            tpf->SetEntryRange(firstentry,firstentry+nentries);
         else {
            fTree->SetCacheSize(fTree->GetCacheSize());
            tpf = (TTreeCache*)curfile->GetCacheRead();
            if (tpf) tpf->SetEntryRange(firstentry,firstentry+nentries);
         }
      }

      //Create a timer to get control in the entry loop(s)
      TProcessEventTimer *timer = 0;
      Int_t interval = fTree->GetTimerInterval();
      if (!gROOT->IsBatch() && interval)
         timer = new TProcessEventTimer(interval);

      //loop on entries (elist or all entries)
      Long64_t entry, entryNumber, localEntry;

      Bool_t useCutFill = selector->Version() == 0;

      // force the first monitoring info
      if (gMonitoringWriter)
         gMonitoringWriter->SendProcessingProgress(0,0,kTRUE);

      //trying to set the first tree, because in the Draw function
      //the tree corresponding to firstentry has already been loaded,
      //so it is not set in the entry list
      fSelectorUpdate = selector;
      UpdateFormulaLeaves();

      for (entry=firstentry;entry<firstentry+nentries;entry++) {
         entryNumber = fTree->GetEntryNumber(entry);
         if (entryNumber < 0) break;
         if (timer && timer->ProcessEvents()) break;
         if (gROOT->IsInterrupted()) break;
         localEntry = fTree->LoadTree(entryNumber);
         if (localEntry < 0) break;
         if(useCutFill) {
            if (selector->ProcessCut(localEntry))
               selector->ProcessFill(localEntry); //<==call user analysis function
         } else {
            selector->Process(localEntry);        //<==call user analysis function
         }
         if (gMonitoringWriter)
            gMonitoringWriter->SendProcessingProgress((entry-firstentry),TFile::GetFileBytesRead()-readbytesatstart,kTRUE);
         if (selector->GetAbort() == TSelector::kAbortProcess) break;
         if (selector->GetAbort() == TSelector::kAbortFile) {
            // Skip to the next file.
            entry += fTree->GetTree()->GetEntries() - localEntry;
            // Reset the abort status.
            selector->ResetAbort();
         }
      }
      delete timer;
      //we must reset the cache
      {
         TFile *curfile2 = fTree->GetCurrentFile();
         if (curfile2 && fTree->GetCacheSize() > 0) {
            tpf = (TTreeCache*)curfile2->GetCacheRead();
            if (tpf) tpf->SetEntryRange(0,0);
         }
      }
   }

   if (selector->Version() != 0 || selector->GetStatus() != -1) {
      selector->SlaveTerminate();   //<==call user termination function
      selector->Terminate();        //<==call user termination function
   }
   fSelectorUpdate = 0;
   if (gMonitoringWriter)
      gMonitoringWriter->SendProcessingStatus("DONE");

   return selector->GetStatus();
}

//______________________________________________________________________________
void TTreePlayer::RecursiveRemove(TObject *obj)
{
// cleanup pointers in the player pointing to obj

   if (fHistogram == obj) fHistogram = 0;
}

//______________________________________________________________________________
Long64_t TTreePlayer::Scan(const char *varexp, const char *selection,
                           Option_t * option,
                           Long64_t nentries, Long64_t firstentry)
{
   // Loop on Tree and print entries passing selection. If varexp is 0 (or "")
   // then print only first 8 columns. If varexp = "*" print all columns.
   // Otherwise a columns selection can be made using "var1:var2:var3".
   // The function returns the number of entries passing the selection.
   //
   // By default 50 rows are shown and you are asked for <CR>
   // to see the next 50 rows.
   // You can change the default number of rows to be shown before <CR>
   // via  mytree->SetScanField(maxrows) where maxrows is 50 by default.
   // if maxrows is set to 0 all rows of the Tree are shown.
   // This option is interesting when dumping the contents of a Tree to
   // an ascii file, eg from the command line
   //   tree->SetScanField(0);
   //   tree->Scan("*"); >tree.log
   //  will create a file tree.log
   //
   // Arrays (within an entry) are printed in their linear forms.
   // If several arrays with multiple dimensions are printed together,
   // they will NOT be synchronized.  For example print
   //   arr1[4][2] and arr2[2][3] will results in a printing similar to:
   // ***********************************************
   // *    Row   * Instance *      arr1 *      arr2 *
   // ***********************************************
   // *        x *        0 * arr1[0][0]* arr2[0][0]*
   // *        x *        1 * arr1[0][1]* arr2[0][1]*
   // *        x *        2 * arr1[1][0]* arr2[0][2]*
   // *        x *        3 * arr1[1][1]* arr2[1][0]*
   // *        x *        4 * arr1[2][0]* arr2[1][1]*
   // *        x *        5 * arr1[2][1]* arr2[1][2]*
   // *        x *        6 * arr1[3][0]*           *
   // *        x *        7 * arr1[3][1]*           *
   //
   // However, if there is a selection criterion which is an array, then
   // all the formulas will be synchronized with the selection criterion
   // (see TTreePlayer::DrawSelect for more information).
   //
   // The options string can contains the following parameters:
   //    lenmax=dd
   //       Where 'dd' is the maximum number of elements per array that should
   //       be printed.  If 'dd' is 0, all elements are printed (this is the
   //       default)
   //    colsize=ss
   //       Where 'ss' will be used as the default size for all the column
   //       If this options is not specified, the default column size is 9
   //    precision=pp
   //       Where 'pp' will be used as the default 'precision' for the
   //       printing format.
   //    col=xxx
   //       Where 'xxx' is colon (:) delimited list of printing format for
   //       each column. The format string should follow the printf format
   //       specification.  The value given will be prefixed by % and, if no
   //       conversion specifier is given, will be suffixed by the letter g.
   //       before being passed to fprintf.  If no format is specified for a
   //       column, the default is used  (aka ${colsize}.${precision}g )
   // For example:
   //   tree->Scan("a:b:c","","colsize=30 precision=3 col=::20.10:#x:5ld");
   // Will print 3 columns, the first 2 columns will be 30 characters long,
   // the third columns will be 20 characters long.  The printing format used
   // for the columns (assuming they are numbers) will be respectively:
   //   %30.3g %30.3g %20.10g %#x %5ld


   TString opt = option;
   opt.ToLower();
   UInt_t ui;
   UInt_t lenmax = 0;
   UInt_t colDefaultSize = 9;
   UInt_t colPrecision = 9;
   vector<TString> colFormats;
   vector<Int_t> colSizes;

   if (opt.Contains("lenmax=")) {
      int start = opt.Index("lenmax=");
      int numpos = start + strlen("lenmax=");
      int numlen = 0;
      int len = opt.Length();
      while( (numpos+numlen<len) && isdigit(opt[numpos+numlen]) ) numlen++;
      TString num = opt(numpos,numlen);
      opt.Remove(start,strlen("lenmax")+numlen);

      lenmax = atoi(num.Data());
   }
   if (opt.Contains("colsize=")) {
      int start = opt.Index("colsize=");
      int numpos = start + strlen("colsize=");
      int numlen = 0;
      int len = opt.Length();
      while( (numpos+numlen<len) && isdigit(opt[numpos+numlen]) ) numlen++;
      TString num = opt(numpos,numlen);
      opt.Remove(start,strlen("size")+numlen);

      colDefaultSize = atoi(num.Data());
      colPrecision = colDefaultSize;
      if (colPrecision>18) colPrecision = 18;
   }
   if (opt.Contains("precision=")) {
      int start = opt.Index("precision=");
      int numpos = start + strlen("precision=");
      int numlen = 0;
      int len = opt.Length();
      while( (numpos+numlen<len) && isdigit(opt[numpos+numlen]) ) numlen++;
      TString num = opt(numpos,numlen);
      opt.Remove(start,strlen("precision")+numlen);

      colPrecision = atoi(num.Data());
   }
   TString defFormat = Form("%d.%d",colDefaultSize,colPrecision);
   if (opt.Contains("col=")) {
      int start = opt.Index("col=");
      int numpos = start + strlen("col=");
      int numlen = 0;
      int len = opt.Length();
      while( (numpos+numlen<len) &&
             (isdigit(opt[numpos+numlen])
              || opt[numpos+numlen] == 'c'
              || opt[numpos+numlen] == 'd'
              || opt[numpos+numlen] == 'i'
              || opt[numpos+numlen] == 'o'
              || opt[numpos+numlen] == 'x'
              || opt[numpos+numlen] == 'X'
              || opt[numpos+numlen] == 'u'
              || opt[numpos+numlen] == 'f'
              || opt[numpos+numlen] == 'e'
              || opt[numpos+numlen] == 'E'
              || opt[numpos+numlen] == 'g'
              || opt[numpos+numlen] == 'G'
              || opt[numpos+numlen] == 'l'
              || opt[numpos+numlen] == 'L'
              || opt[numpos+numlen] == 'h'
              || opt[numpos+numlen] == '#'
              || opt[numpos+numlen]=='.'
              || opt[numpos+numlen]==':')) numlen++;
      TString flist = opt(numpos,numlen);
      opt.Remove(start,strlen("col")+numlen);

      int i = 0;
      while(i<flist.Length() && flist[i]==':') {
         colFormats.push_back(defFormat);
         colSizes.push_back(colDefaultSize);
         ++i;
      }
      for(; i<flist.Length(); ++i) {
         int next = flist.Index(":",i);
         if (next==i) {
            colFormats.push_back(defFormat);
         } else if (next==kNPOS) {
            colFormats.push_back(flist(i,flist.Length()-i));
            i = flist.Length();
         } else {
            colFormats.push_back(flist(i,next-i));
            i = next;
         }
         UInt_t siz = atoi(colFormats[colFormats.size()-1].Data());
         colSizes.push_back( siz ? siz : colDefaultSize );
      }
   }

   TTreeFormula **var;
   std::vector<TString> cnames;
   TString onerow;
   Long64_t entry,entryNumber;
   Int_t i,nch;
   UInt_t ncols = 8;   // by default first 8 columns are printed only
   ofstream out;
   Int_t lenfile = 0;
   char * fname = 0;
   if (fScanRedirect) {
      fTree->SetScanField(0);  // no page break if Scan is redirected
      fname = (char *) fScanFileName;
      if (!fname) fname = (char*)"";
      lenfile = strlen(fname);
      if (!lenfile) {
         Int_t nch2 = strlen(fTree->GetName());
         fname = new char[nch2+10];
         strlcpy(fname, fTree->GetName(),nch2+10);
         strlcat(fname, "-scan.dat",nch2+10);
      }
      out.open(fname, ios::out);
      if (!out.good ()) {
         if (!lenfile) delete [] fname;
         Error("Scan","Can not open file for redirection");
         return 0;
      }
   }
   TObjArray *leaves = fTree->GetListOfLeaves();
   if (leaves==0) return 0;
   UInt_t nleaves = leaves->GetEntriesFast();
   if (nleaves < ncols) ncols = nleaves;
   nch = varexp ? strlen(varexp) : 0;

   nentries = GetEntriesToProcess(firstentry, nentries);

//*-*- Compile selection expression if there is one
   TTreeFormula        *select  = 0;
   if (selection && strlen(selection)) {
      select = new TTreeFormula("Selection",selection,fTree);
      if (!select) return -1;
      if (!select->GetNdim()) { delete select; return -1; }
      fFormulaList->Add(select);
   }
//*-*- if varexp is empty, take first 8 columns by default
   int allvar = 0;
   if (varexp && !strcmp(varexp, "*")) { ncols = nleaves; allvar = 1; }
   if (nch == 0 || allvar) {
      UInt_t ncs = ncols;
      ncols = 0;
      for (ui=0;ui<ncs;++ui) {
         TLeaf *lf = (TLeaf*)leaves->At(ui);
         if (lf->GetBranch()->GetListOfBranches()->GetEntries() > 0) continue;
         cnames.push_back( lf->GetBranch()->GetMother()->GetName() );
         if (cnames[ncols] == lf->GetName() ) {
            // Already complete, let move on.
         } else if (cnames[ncols][cnames[ncols].Length()-1]=='.') {
            cnames[ncols] = lf->GetBranch()->GetName(); // name of branch already include mother's name
         } else {
            if (lf->GetBranch()->GetMother()->IsA()->InheritsFrom(TBranchElement::Class())) {
               TBranchElement *mother = (TBranchElement*)lf->GetBranch()->GetMother();
               if (mother->GetType() == 3 || mother->GetType() == 4) {
                  // The name of the mother branch is embedded in the sub-branch names.
                  cnames[ncols] = lf->GetBranch()->GetName();
                  ++ncols;
                  continue;
               }
            }
            if (!strchr(lf->GetBranch()->GetName() ,'[') ) {
               cnames[ncols].Append('.');
               cnames[ncols].Append( lf->GetBranch()->GetName() );
            }
         }
         if (strcmp( lf->GetBranch()->GetName(), lf->GetName() ) != 0 ) {
            cnames[ncols].Append('.');
            cnames[ncols].Append( lf->GetName() );
         }
         ++ncols;
      }
//*-*- otherwise select only the specified columns
   } else {

      ncols = fSelector->SplitNames(varexp, cnames);

   }
   var = new TTreeFormula* [ncols];

   for(ui=colFormats.size();ui<ncols;++ui) {
      colFormats.push_back(defFormat);
      colSizes.push_back(colDefaultSize);
   }

//*-*- Create the TreeFormula objects corresponding to each column
   for (ui=0;ui<ncols;ui++) {
      var[ui] = new TTreeFormula("Var1",cnames[ui].Data(),fTree);
      fFormulaList->Add(var[ui]);
   }

//*-*- Create a TreeFormulaManager to coordinate the formulas
   TTreeFormulaManager *manager=0;
   Bool_t hasArray = kFALSE;
   Bool_t forceDim = kFALSE;
   if (fFormulaList->LastIndex()>=0) {
      if (select) {
         if (select->GetManager()->GetMultiplicity() > 0 ) {
            manager = new TTreeFormulaManager;
            for(i=0;i<=fFormulaList->LastIndex();i++) {
               manager->Add((TTreeFormula*)fFormulaList->At(i));
            }
            manager->Sync();
         }
      }
      for(i=0;i<=fFormulaList->LastIndex();i++) {
         TTreeFormula *form = ((TTreeFormula*)fFormulaList->At(i));
         switch( form->GetManager()->GetMultiplicity() ) {
            case  1:
            case  2:
               hasArray = kTRUE;
               forceDim = kTRUE;
               break;
            case -1:
               forceDim = kTRUE;
               break;
            case  0:
               break;
         }

      }
   }

//*-*- Print header
   onerow = "***********";
   if (hasArray) onerow += "***********";

   for (ui=0;ui<ncols;ui++) {
      TString starFormat = Form("*%%%d.%ds",colSizes[ui]+2,colSizes[ui]+2);
      onerow += Form(starFormat.Data(),var[ui]->PrintValue(-2));
   }
   if (fScanRedirect)
      out<<onerow.Data()<<"*"<<endl;
   else
      printf("%s*\n",onerow.Data());
   onerow = "*    Row   ";
   if (hasArray) onerow += "* Instance ";
   for (ui=0;ui<ncols;ui++) {
      TString numbFormat = Form("* %%%d.%ds ",colSizes[ui],colSizes[ui]);
      onerow += Form(numbFormat.Data(),var[ui]->PrintValue(-1));
   }
   if (fScanRedirect)
      out<<onerow.Data()<<"*"<<endl;
   else
      printf("%s*\n",onerow.Data());
   onerow = "***********";
   if (hasArray) onerow += "***********";
   for (ui=0;ui<ncols;ui++) {
      TString starFormat = Form("*%%%d.%ds",colSizes[ui]+2,colSizes[ui]+2);
      onerow += Form(starFormat.Data(),var[ui]->PrintValue(-2));
   }
   if (fScanRedirect)
      out<<onerow.Data()<<"*"<<endl;
   else
      printf("%s*\n",onerow.Data());
//*-*- loop on all selected entries
   fSelectedRows = 0;
   Int_t tnumber = -1;
   Bool_t exitloop = kFALSE;
   for (entry=firstentry;
        entry<(firstentry+nentries) && !exitloop;
        entry++) {
      entryNumber = fTree->GetEntryNumber(entry);
      if (entryNumber < 0) break;
      Long64_t localEntry = fTree->LoadTree(entryNumber);
      if (localEntry < 0) break;
      if (tnumber != fTree->GetTreeNumber()) {
         tnumber = fTree->GetTreeNumber();
         if (manager) manager->UpdateFormulaLeaves();
         else {
            for(i=0;i<=fFormulaList->LastIndex();i++) {
               ((TTreeFormula*)fFormulaList->At(i))->UpdateFormulaLeaves();
            }
         }
      }

      int ndata = 1;
      if (forceDim) {

         if (manager) {

            ndata = manager->GetNdata(kTRUE);

         } else {

            // let's print the max number of column
            for (ui=0;ui<ncols;ui++) {
               if (ndata < var[ui]->GetNdata() ) {
                  ndata = var[ui]->GetNdata();
               }
            }
            if (select && select->GetNdata()==0) ndata = 0;
         }

      }

      if (lenmax && ndata>(int)lenmax) ndata = lenmax;
      Bool_t loaded = kFALSE;
      for(int inst=0;inst<ndata;inst++) {
         if (select) {
            if (select->EvalInstance(inst) == 0) {
               continue;
            }
         }
         if (inst==0) loaded = kTRUE;
         else if (!loaded) {
            // EvalInstance(0) always needs to be called so that
            // the proper branches are loaded.
            for (ui=0;ui<ncols;ui++) {
               var[ui]->EvalInstance(0);
            }
            loaded = kTRUE;
         }
         onerow = Form("* %8lld ",entryNumber);
         if (hasArray) {
            onerow += Form("* %8d ",inst);
         }
         for (ui=0;ui<ncols;++ui) {
            TString numbFormat = Form("* %%%d.%ds ",colSizes[ui],colSizes[ui]);
            if (var[ui]->GetNdim()) onerow += Form(numbFormat.Data(),var[ui]->PrintValue(0,inst,colFormats[ui].Data()));
            else {
               TString emptyForm = Form("* %%%dc ",colSizes[ui]);
               onerow += Form(emptyForm.Data(),' ');
            }
         }
         fSelectedRows++;
         if (fScanRedirect)
            out<<onerow.Data()<<"*"<<endl;
         else
            printf("%s*\n",onerow.Data());
         if (fTree->GetScanField() > 0 && fSelectedRows > 0) {
            if (fSelectedRows%fTree->GetScanField() == 0) {
               fprintf(stderr,"Type <CR> to continue or q to quit ==> ");
               int answer, readch;
               readch = getchar();
               answer = readch;
               while (readch != '\n' && readch != EOF) readch = getchar();
               if (answer == 'q' || answer == 'Q') {
                  exitloop = kTRUE;
                  break;
               }
            }
         }
      }
   }
   onerow = "***********";
   if (hasArray) onerow += "***********";
   for (ui=0;ui<ncols;ui++) {
      TString starFormat = Form("*%%%d.%ds",colSizes[ui]+2,colSizes[ui]+2);
      onerow += Form(starFormat.Data(),var[ui]->PrintValue(-2));
   }
   if (fScanRedirect)
      out<<onerow.Data()<<"*"<<endl;
   else
      printf("%s*\n",onerow.Data());
   if (select) Printf("==> %lld selected %s", fSelectedRows,
                      fSelectedRows == 1 ? "entry" : "entries");
   if (fScanRedirect) printf("File <%s> created\n", fname);

//*-*- delete temporary objects
   fFormulaList->Clear();
   // The TTreeFormulaManager is deleted by the last TTreeFormula.
   delete [] var;
   return fSelectedRows;
}

//______________________________________________________________________________
TSQLResult *TTreePlayer::Query(const char *varexp, const char *selection,
                               Option_t *, Long64_t nentries, Long64_t firstentry)
{
   // Loop on Tree and return TSQLResult object containing entries passing
   // selection. If varexp is 0 (or "") then print only first 8 columns.
   // If varexp = "*" print all columns. Otherwise a columns selection can
   // be made using "var1:var2:var3". In case of error 0 is returned otherwise
   // a TSQLResult object which must be deleted by the user.

   TTreeFormula **var;
   std::vector<TString> cnames;
   TString onerow;
   Long64_t entry,entryNumber;
   Int_t i,nch;
   Int_t ncols = 8;   // by default first 8 columns are printed only
   TObjArray *leaves = fTree->GetListOfLeaves();
   Int_t nleaves = leaves->GetEntriesFast();
   if (nleaves < ncols) ncols = nleaves;
   nch = varexp ? strlen(varexp) : 0;

   nentries = GetEntriesToProcess(firstentry, nentries);

   // compile selection expression if there is one
   TTreeFormula *select = 0;
   if (strlen(selection)) {
      select = new TTreeFormula("Selection",selection,fTree);
      if (!select) return 0;
      if (!select->GetNdim()) { delete select; return 0; }
      fFormulaList->Add(select);
   }

   // if varexp is empty, take first 8 columns by default
   int allvar = 0;
   if (varexp && !strcmp(varexp, "*")) { ncols = nleaves; allvar = 1; }
   if (nch == 0 || allvar) {
      for (i=0;i<ncols;i++) {
         cnames.push_back( ((TLeaf*)leaves->At(i))->GetName() );
      }
   } else {
      // otherwise select only the specified columns
      ncols = fSelector->SplitNames(varexp,cnames);
   }
   var = new TTreeFormula* [ncols];

   // create the TreeFormula objects corresponding to each column
   for (i=0;i<ncols;i++) {
      var[i] = new TTreeFormula("Var1",cnames[i].Data(),fTree);
      fFormulaList->Add(var[i]);
   }

   // fill header info into result object
   TTreeResult *res = new TTreeResult(ncols);
   for (i = 0; i < ncols; i++) {
      res->AddField(i, var[i]->PrintValue(-1));
   }

   //*-*- Create a TreeFormulaManager to coordinate the formulas
   TTreeFormulaManager *manager=0;
   if (fFormulaList->LastIndex()>=0) {
      manager = new TTreeFormulaManager;
      for(i=0;i<=fFormulaList->LastIndex();i++) {
         manager->Add((TTreeFormula*)fFormulaList->At(i));
      }
      manager->Sync();
   }

   // loop on all selected entries
   const char *aresult;
   Int_t len;
   char *arow = new char[ncols*50];
   fSelectedRows = 0;
   Int_t tnumber = -1;
   Int_t *fields = new Int_t[ncols];
   for (entry=firstentry;entry<firstentry+nentries;entry++) {
      entryNumber = fTree->GetEntryNumber(entry);
      if (entryNumber < 0) break;
      Long64_t localEntry = fTree->LoadTree(entryNumber);
      if (localEntry < 0) break;
      if (tnumber != fTree->GetTreeNumber()) {
         tnumber = fTree->GetTreeNumber();
         for (i=0;i<ncols;i++) var[i]->UpdateFormulaLeaves();
      }

      Int_t ndata = 1;
      if (manager && manager->GetMultiplicity()) {
         ndata = manager->GetNdata();
      }

      if (select) {
         select->GetNdata();
         if (select->EvalInstance(0) == 0) continue;
      }

      Bool_t loaded = kFALSE;
      for(int inst=0;inst<ndata;inst++) {
         if (select) {
            if (select->EvalInstance(inst) == 0) {
               continue;
            }
         }

         if (inst==0) loaded = kTRUE;
         else if (!loaded) {
            // EvalInstance(0) always needs to be called so that
            // the proper branches are loaded.
            for (i=0;i<ncols;i++) {
               var[i]->EvalInstance(0);
            }
            loaded = kTRUE;
         }
         for (i=0;i<ncols;i++) {
            aresult = var[i]->PrintValue(0,inst);
            len = strlen(aresult)+1;
            if (i == 0) {
               memcpy(arow,aresult,len);
               fields[i] = len;
            } else {
               memcpy(arow+fields[i-1],aresult,len);
               fields[i] = fields[i-1] + len;
            }
         }
         res->AddRow(new TTreeRow(ncols,fields,arow));
         fSelectedRows++;
      }
   }

   // delete temporary objects
   fFormulaList->Clear();
   // The TTreeFormulaManager is deleted by the last TTreeFormula.
   delete [] fields;
   delete [] arow;
   delete [] var;

   return res;
}

//_______________________________________________________________________
void TTreePlayer::SetEstimate(Long64_t n)
{
//*-*-*-*-*-*-*-*-*Set number of entries to estimate variable limits*-*-*-*
//*-*              ================================================
//
   fSelector->SetEstimate(n);
}

//_______________________________________________________________________
void TTreePlayer::StartViewer(Int_t ww, Int_t wh)
{
//*-*-*-*-*-*-*-*-*Start the TTreeViewer on this TTree*-*-*-*-*-*-*-*-*-*
//*-*              ===================================
//
//  ww is the width of the canvas in pixels
//  wh is the height of the canvas in pixels

   if (gROOT->IsBatch()) {
      Warning("StartViewer", "viewer cannot run in batch mode");
      return;
   }

   if (ww || wh) { }   // use unused variables
   TPluginHandler *h;
   if ((h = gROOT->GetPluginManager()->FindHandler("TVirtualTreeViewer"))) {
      if (h->LoadPlugin() == -1)
         return;
      h->ExecPlugin(1,fTree);
   }
}

//______________________________________________________________________________
void TreeUnbinnedFitLikelihood(Int_t & /*npar*/, Double_t * /*gin*/,
                               Double_t &r, Double_t *par, Int_t /*flag*/)
{
   // The fit function used by the unbinned likelihood fit.

   Double_t x[3];
   TF1 *fitfunc = (TF1*)tFitter->GetObjectFit();
   fitfunc->InitArgs(x,par);

   Long64_t n = gTree->GetSelectedRows();
   Double_t  *data1 = gTree->GetV1();
   Double_t  *data2 = gTree->GetV2();
   Double_t  *data3 = gTree->GetV3();
   Double_t *weight = gTree->GetW();
   Double_t logEpsilon = -230;   // protect against negative probabilities
   Double_t logL = 0.0, prob;
   //printf("n=%lld, data1=%x, weight=%x\n",n,data1,weight);

   for(Long64_t i = 0; i < n; i++) {
      if (weight[i] <= 0) continue;
      x[0] = data1[i];
      if (data2) x[1] = data2[i];
      if (data3) x[2] = data3[i];
      prob = fitfunc->EvalPar(x,par);
      //printf("i=%lld, x=%g, w=%g, prob=%g, logL=%g\n",i,x[0],weight[i],prob,logL);
      if(prob > 0) logL += TMath::Log(prob) * weight[i];
      else         logL += logEpsilon * weight[i];
   }

   r = -2*logL;
}


//______________________________________________________________________________
Int_t TTreePlayer::UnbinnedFit(const char *funcname ,const char *varexp, const char *selection,Option_t *option ,Long64_t nentries, Long64_t firstentry)
{
//*-*-*-*-*-*Unbinned fit of one or more variable(s) from a Tree*-*-*-*-*-*
//*-*        ===================================================
//
//  funcname is a TF1 function.
//
//  See TTree::Draw for explanations of the other parameters.
//
//   Fit the variable varexp using the function funcname using the
//   selection cuts given by selection.
//
//   The list of fit options is given in parameter option.
//      option = "Q" Quiet mode (minimum printing)
//             = "V" Verbose mode (default is between Q and V)
//             = "E" Perform better Errors estimation using Minos technique
//             = "M" More. Improve fit results
//             = "D" Draw the projected histogram with the fitted function
//                   normalized to the number of selected rows
//                   and multiplied by the bin width
//
//   You can specify boundary limits for some or all parameters via
//        func->SetParLimits(p_number, parmin, parmax);
//   if parmin>=parmax, the parameter is fixed
//   Note that you are not forced to fix the limits for all parameters.
//   For example, if you fit a function with 6 parameters, you can do:
//     func->SetParameters(0,3.1,1.e-6,0.1,-8,100);
//     func->SetParLimits(4,-10,-4);
//     func->SetParLimits(5, 1,1);
//   With this setup, parameters 0->3 can vary freely
//   Parameter 4 has boundaries [-10,-4] with initial value -8
//   Parameter 5 is fixed to 100.
//
//   For the fit to be meaningful, the function must be self-normalized.
//
//   i.e. It must have the same integral regardless of the parameter
//   settings.  Otherwise the fit will effectively just maximize the
//   area.
//
//   It is mandatory to have a normalization variable
//   which is fixed for the fit.  e.g.
//
//     TF1* f1 = new TF1("f1", "gaus(0)/sqrt(2*3.14159)/[2]", 0, 5);
//     f1->SetParameters(1, 3.1, 0.01);
//     f1->SetParLimits(0, 1, 1); // fix the normalization parameter to 1
//     data->UnbinnedFit("f1", "jpsimass", "jpsipt>3.0");
//   //
//
//   1, 2 and 3 Dimensional fits are supported.
//   See also TTree::Fit
//
//    Return status
//    =============
//   The function return the status of the fit in the following form
//     fitResult = migradResult + 10*minosResult + 100*hesseResult + 1000*improveResult
//   The fitResult is 0 is the fit is OK.
//   The fitResult is negative in case of an error not connected with the fit.
//   The number of entries used in the fit can be obtained via
//     mytree.GetSelectedRows();
//   If the number of selected entries is null the function returns -1


// new implementation using new Fitter classes

   gTree = fTree; // not sure if this is still needed

   // function is given by name, find it in gROOT
   TF1* fitfunc = (TF1*)gROOT->GetFunction(funcname);
   if (!fitfunc) { Error("UnbinnedFit", "Unknown function: %s",funcname); return 0; }

   Int_t npar = fitfunc->GetNpar();
   if (npar <=0) { Error("UnbinnedFit", "Illegal number of parameters = %d",npar); return 0; }

   // Spin through the data to select out the events of interest
   // Make sure that the arrays V1,etc are created large enough to accommodate
   // all entries
   Long64_t oldEstimate = fTree->GetEstimate();
   Long64_t nent = fTree->GetEntriesFriend();
   fTree->SetEstimate(TMath::Min(nent,nentries));

   // build FitOptions
   TString opt = option;
   opt.ToUpper();
   Foption_t fitOption;
   if (opt.Contains("Q")) fitOption.Quiet   = 1;
   if (opt.Contains("V")){fitOption.Verbose = 1; fitOption.Quiet   = 0;}
   if (opt.Contains("E")) fitOption.Errors  = 1;
   if (opt.Contains("M")) fitOption.More    = 1;
   if (!opt.Contains("D")) fitOption.Nograph    = 1;  // what about 0
   // could add range and automatic normalization of functions and gradient

   TString drawOpt = "goff para";
   if (!fitOption.Nograph) drawOpt = "";
   Long64_t nsel = DrawSelect(varexp, selection,drawOpt, nentries, firstentry);

   if (!fitOption.Nograph  && GetSelectedRows() <= 0 && GetDimension() > 4) {
      Info("UnbinnedFit","Ignore option D with more than 4 variables");
      nsel = DrawSelect(varexp, selection,"goff para", nentries, firstentry);
   }

   //if no selected entries return
   Long64_t nrows = GetSelectedRows();

   if (nrows <= 0) {
      Error("UnbinnedFit", "Cannot fit: no entries selected");
      return -1;
   }

   // Check that function has same dimension as number of variables
   Int_t ndim = GetDimension();
   // do not check with TF1::GetNdim() since it returns 1 for TF1 classes created with
   // a C function with larger dimension


   // use pointer stored in the tree (not copy the data in)
   std::vector<double *> vlist(ndim);
   for (int i = 0; i < ndim; ++i)
      vlist[i] = fSelector->GetVal(i);

   // fill the data
   ROOT::Fit::UnBinData * fitdata = new ROOT::Fit::UnBinData(nrows, ndim, vlist.begin());



   ROOT::Math::MinimizerOptions minOption;
   TFitResultPtr ret = ROOT::Fit::UnBinFit(fitdata,fitfunc, fitOption, minOption);

   //reset estimate
   fTree->SetEstimate(oldEstimate);

   //if option "D" is specified, draw the projected histogram
   //with the fitted function normalized to the number of selected rows
   //and multiplied by the bin width
   if (!fitOption.Nograph && fHistogram) {
      if (fHistogram->GetDimension() < 2) {
         TH1 *hf = (TH1*)fHistogram->Clone("unbinnedFit");
         hf->SetLineWidth(3);
         hf->Reset();
         Int_t nbins = fHistogram->GetXaxis()->GetNbins();
         Double_t norm = ((Double_t)nsel)*fHistogram->GetXaxis()->GetBinWidth(1);
         for (Int_t bin=1;bin<=nbins;bin++) {
            Double_t func = norm*fitfunc->Eval(hf->GetBinCenter(bin));
            hf->SetBinContent(bin,func);
         }
         fHistogram->GetListOfFunctions()->Add(hf,"lsame");
      }
      fHistogram->Draw();
   }


   return int(ret);

}

//______________________________________________________________________________
void TTreePlayer::UpdateFormulaLeaves()
{
   // this function is called by TChain::LoadTree when a new Tree is loaded.
   // Because Trees in a TChain may have a different list of leaves, one
   // must update the leaves numbers in the TTreeFormula used by the TreePlayer.

   if (fSelector)  fSelector->Notify();
   if (fSelectorUpdate){
      //If the selector is writing into a TEntryList, the entry list's
      //sublists need to be changed according to the loaded tree
      if (fSelector==fSelectorUpdate) {
         //FIXME: should be more consistent with selector from file
         TObject *obj = fSelector->GetObject();
         if (obj){
            if (fSelector->GetObject()->InheritsFrom(TEntryList::Class())){
               ((TEntryList*)fSelector->GetObject())->SetTree(fTree->GetTree());
            }
         }
      }
      if (fSelectorFromFile==fSelectorUpdate) {
         TIter next(fSelectorFromFile->GetOutputList());
         TEntryList *elist=0;
         while ((elist=(TEntryList*)next())){
            if (elist->InheritsFrom(TEntryList::Class())){
               elist->SetTree(fTree->GetTree());
            }
         }
      }
   }

   if (fFormulaList->GetSize()) {
      TObjLink *lnk = fFormulaList->FirstLink();
      while (lnk) {
         lnk->GetObject()->Notify();
         lnk = lnk->Next();
      }
   }
}
 TTreePlayer.cxx:1
 TTreePlayer.cxx:2
 TTreePlayer.cxx:3
 TTreePlayer.cxx:4
 TTreePlayer.cxx:5
 TTreePlayer.cxx:6
 TTreePlayer.cxx:7
 TTreePlayer.cxx:8
 TTreePlayer.cxx:9
 TTreePlayer.cxx:10
 TTreePlayer.cxx:11
 TTreePlayer.cxx:12
 TTreePlayer.cxx:13
 TTreePlayer.cxx:14
 TTreePlayer.cxx:15
 TTreePlayer.cxx:16
 TTreePlayer.cxx:17
 TTreePlayer.cxx:18
 TTreePlayer.cxx:19
 TTreePlayer.cxx:20
 TTreePlayer.cxx:21
 TTreePlayer.cxx:22
 TTreePlayer.cxx:23
 TTreePlayer.cxx:24
 TTreePlayer.cxx:25
 TTreePlayer.cxx:26
 TTreePlayer.cxx:27
 TTreePlayer.cxx:28
 TTreePlayer.cxx:29
 TTreePlayer.cxx:30
 TTreePlayer.cxx:31
 TTreePlayer.cxx:32
 TTreePlayer.cxx:33
 TTreePlayer.cxx:34
 TTreePlayer.cxx:35
 TTreePlayer.cxx:36
 TTreePlayer.cxx:37
 TTreePlayer.cxx:38
 TTreePlayer.cxx:39
 TTreePlayer.cxx:40
 TTreePlayer.cxx:41
 TTreePlayer.cxx:42
 TTreePlayer.cxx:43
 TTreePlayer.cxx:44
 TTreePlayer.cxx:45
 TTreePlayer.cxx:46
 TTreePlayer.cxx:47
 TTreePlayer.cxx:48
 TTreePlayer.cxx:49
 TTreePlayer.cxx:50
 TTreePlayer.cxx:51
 TTreePlayer.cxx:52
 TTreePlayer.cxx:53
 TTreePlayer.cxx:54
 TTreePlayer.cxx:55
 TTreePlayer.cxx:56
 TTreePlayer.cxx:57
 TTreePlayer.cxx:58
 TTreePlayer.cxx:59
 TTreePlayer.cxx:60
 TTreePlayer.cxx:61
 TTreePlayer.cxx:62
 TTreePlayer.cxx:63
 TTreePlayer.cxx:64
 TTreePlayer.cxx:65
 TTreePlayer.cxx:66
 TTreePlayer.cxx:67
 TTreePlayer.cxx:68
 TTreePlayer.cxx:69
 TTreePlayer.cxx:70
 TTreePlayer.cxx:71
 TTreePlayer.cxx:72
 TTreePlayer.cxx:73
 TTreePlayer.cxx:74
 TTreePlayer.cxx:75
 TTreePlayer.cxx:76
 TTreePlayer.cxx:77
 TTreePlayer.cxx:78
 TTreePlayer.cxx:79
 TTreePlayer.cxx:80
 TTreePlayer.cxx:81
 TTreePlayer.cxx:82
 TTreePlayer.cxx:83
 TTreePlayer.cxx:84
 TTreePlayer.cxx:85
 TTreePlayer.cxx:86
 TTreePlayer.cxx:87
 TTreePlayer.cxx:88
 TTreePlayer.cxx:89
 TTreePlayer.cxx:90
 TTreePlayer.cxx:91
 TTreePlayer.cxx:92
 TTreePlayer.cxx:93
 TTreePlayer.cxx:94
 TTreePlayer.cxx:95
 TTreePlayer.cxx:96
 TTreePlayer.cxx:97
 TTreePlayer.cxx:98
 TTreePlayer.cxx:99
 TTreePlayer.cxx:100
 TTreePlayer.cxx:101
 TTreePlayer.cxx:102
 TTreePlayer.cxx:103
 TTreePlayer.cxx:104
 TTreePlayer.cxx:105
 TTreePlayer.cxx:106
 TTreePlayer.cxx:107
 TTreePlayer.cxx:108
 TTreePlayer.cxx:109
 TTreePlayer.cxx:110
 TTreePlayer.cxx:111
 TTreePlayer.cxx:112
 TTreePlayer.cxx:113
 TTreePlayer.cxx:114
 TTreePlayer.cxx:115
 TTreePlayer.cxx:116
 TTreePlayer.cxx:117
 TTreePlayer.cxx:118
 TTreePlayer.cxx:119
 TTreePlayer.cxx:120
 TTreePlayer.cxx:121
 TTreePlayer.cxx:122
 TTreePlayer.cxx:123
 TTreePlayer.cxx:124
 TTreePlayer.cxx:125
 TTreePlayer.cxx:126
 TTreePlayer.cxx:127
 TTreePlayer.cxx:128
 TTreePlayer.cxx:129
 TTreePlayer.cxx:130
 TTreePlayer.cxx:131
 TTreePlayer.cxx:132
 TTreePlayer.cxx:133
 TTreePlayer.cxx:134
 TTreePlayer.cxx:135
 TTreePlayer.cxx:136
 TTreePlayer.cxx:137
 TTreePlayer.cxx:138
 TTreePlayer.cxx:139
 TTreePlayer.cxx:140
 TTreePlayer.cxx:141
 TTreePlayer.cxx:142
 TTreePlayer.cxx:143
 TTreePlayer.cxx:144
 TTreePlayer.cxx:145
 TTreePlayer.cxx:146
 TTreePlayer.cxx:147
 TTreePlayer.cxx:148
 TTreePlayer.cxx:149
 TTreePlayer.cxx:150
 TTreePlayer.cxx:151
 TTreePlayer.cxx:152
 TTreePlayer.cxx:153
 TTreePlayer.cxx:154
 TTreePlayer.cxx:155
 TTreePlayer.cxx:156
 TTreePlayer.cxx:157
 TTreePlayer.cxx:158
 TTreePlayer.cxx:159
 TTreePlayer.cxx:160
 TTreePlayer.cxx:161
 TTreePlayer.cxx:162
 TTreePlayer.cxx:163
 TTreePlayer.cxx:164
 TTreePlayer.cxx:165
 TTreePlayer.cxx:166
 TTreePlayer.cxx:167
 TTreePlayer.cxx:168
 TTreePlayer.cxx:169
 TTreePlayer.cxx:170
 TTreePlayer.cxx:171
 TTreePlayer.cxx:172
 TTreePlayer.cxx:173
 TTreePlayer.cxx:174
 TTreePlayer.cxx:175
 TTreePlayer.cxx:176
 TTreePlayer.cxx:177
 TTreePlayer.cxx:178
 TTreePlayer.cxx:179
 TTreePlayer.cxx:180
 TTreePlayer.cxx:181
 TTreePlayer.cxx:182
 TTreePlayer.cxx:183
 TTreePlayer.cxx:184
 TTreePlayer.cxx:185
 TTreePlayer.cxx:186
 TTreePlayer.cxx:187
 TTreePlayer.cxx:188
 TTreePlayer.cxx:189
 TTreePlayer.cxx:190
 TTreePlayer.cxx:191
 TTreePlayer.cxx:192
 TTreePlayer.cxx:193
 TTreePlayer.cxx:194
 TTreePlayer.cxx:195
 TTreePlayer.cxx:196
 TTreePlayer.cxx:197
 TTreePlayer.cxx:198
 TTreePlayer.cxx:199
 TTreePlayer.cxx:200
 TTreePlayer.cxx:201
 TTreePlayer.cxx:202
 TTreePlayer.cxx:203
 TTreePlayer.cxx:204
 TTreePlayer.cxx:205
 TTreePlayer.cxx:206
 TTreePlayer.cxx:207
 TTreePlayer.cxx:208
 TTreePlayer.cxx:209
 TTreePlayer.cxx:210
 TTreePlayer.cxx:211
 TTreePlayer.cxx:212
 TTreePlayer.cxx:213
 TTreePlayer.cxx:214
 TTreePlayer.cxx:215
 TTreePlayer.cxx:216
 TTreePlayer.cxx:217
 TTreePlayer.cxx:218
 TTreePlayer.cxx:219
 TTreePlayer.cxx:220
 TTreePlayer.cxx:221
 TTreePlayer.cxx:222
 TTreePlayer.cxx:223
 TTreePlayer.cxx:224
 TTreePlayer.cxx:225
 TTreePlayer.cxx:226
 TTreePlayer.cxx:227
 TTreePlayer.cxx:228
 TTreePlayer.cxx:229
 TTreePlayer.cxx:230
 TTreePlayer.cxx:231
 TTreePlayer.cxx:232
 TTreePlayer.cxx:233
 TTreePlayer.cxx:234
 TTreePlayer.cxx:235
 TTreePlayer.cxx:236
 TTreePlayer.cxx:237
 TTreePlayer.cxx:238
 TTreePlayer.cxx:239
 TTreePlayer.cxx:240
 TTreePlayer.cxx:241
 TTreePlayer.cxx:242
 TTreePlayer.cxx:243
 TTreePlayer.cxx:244
 TTreePlayer.cxx:245
 TTreePlayer.cxx:246
 TTreePlayer.cxx:247
 TTreePlayer.cxx:248
 TTreePlayer.cxx:249
 TTreePlayer.cxx:250
 TTreePlayer.cxx:251
 TTreePlayer.cxx:252
 TTreePlayer.cxx:253
 TTreePlayer.cxx:254
 TTreePlayer.cxx:255
 TTreePlayer.cxx:256
 TTreePlayer.cxx:257
 TTreePlayer.cxx:258
 TTreePlayer.cxx:259
 TTreePlayer.cxx:260
 TTreePlayer.cxx:261
 TTreePlayer.cxx:262
 TTreePlayer.cxx:263
 TTreePlayer.cxx:264
 TTreePlayer.cxx:265
 TTreePlayer.cxx:266
 TTreePlayer.cxx:267
 TTreePlayer.cxx:268
 TTreePlayer.cxx:269
 TTreePlayer.cxx:270
 TTreePlayer.cxx:271
 TTreePlayer.cxx:272
 TTreePlayer.cxx:273
 TTreePlayer.cxx:274
 TTreePlayer.cxx:275
 TTreePlayer.cxx:276
 TTreePlayer.cxx:277
 TTreePlayer.cxx:278
 TTreePlayer.cxx:279
 TTreePlayer.cxx:280
 TTreePlayer.cxx:281
 TTreePlayer.cxx:282
 TTreePlayer.cxx:283
 TTreePlayer.cxx:284
 TTreePlayer.cxx:285
 TTreePlayer.cxx:286
 TTreePlayer.cxx:287
 TTreePlayer.cxx:288
 TTreePlayer.cxx:289
 TTreePlayer.cxx:290
 TTreePlayer.cxx:291
 TTreePlayer.cxx:292
 TTreePlayer.cxx:293
 TTreePlayer.cxx:294
 TTreePlayer.cxx:295
 TTreePlayer.cxx:296
 TTreePlayer.cxx:297
 TTreePlayer.cxx:298
 TTreePlayer.cxx:299
 TTreePlayer.cxx:300
 TTreePlayer.cxx:301
 TTreePlayer.cxx:302
 TTreePlayer.cxx:303
 TTreePlayer.cxx:304
 TTreePlayer.cxx:305
 TTreePlayer.cxx:306
 TTreePlayer.cxx:307
 TTreePlayer.cxx:308
 TTreePlayer.cxx:309
 TTreePlayer.cxx:310
 TTreePlayer.cxx:311
 TTreePlayer.cxx:312
 TTreePlayer.cxx:313
 TTreePlayer.cxx:314
 TTreePlayer.cxx:315
 TTreePlayer.cxx:316
 TTreePlayer.cxx:317
 TTreePlayer.cxx:318
 TTreePlayer.cxx:319
 TTreePlayer.cxx:320
 TTreePlayer.cxx:321
 TTreePlayer.cxx:322
 TTreePlayer.cxx:323
 TTreePlayer.cxx:324
 TTreePlayer.cxx:325
 TTreePlayer.cxx:326
 TTreePlayer.cxx:327
 TTreePlayer.cxx:328
 TTreePlayer.cxx:329
 TTreePlayer.cxx:330
 TTreePlayer.cxx:331
 TTreePlayer.cxx:332
 TTreePlayer.cxx:333
 TTreePlayer.cxx:334
 TTreePlayer.cxx:335
 TTreePlayer.cxx:336
 TTreePlayer.cxx:337
 TTreePlayer.cxx:338
 TTreePlayer.cxx:339
 TTreePlayer.cxx:340
 TTreePlayer.cxx:341
 TTreePlayer.cxx:342
 TTreePlayer.cxx:343
 TTreePlayer.cxx:344
 TTreePlayer.cxx:345
 TTreePlayer.cxx:346
 TTreePlayer.cxx:347
 TTreePlayer.cxx:348
 TTreePlayer.cxx:349
 TTreePlayer.cxx:350
 TTreePlayer.cxx:351
 TTreePlayer.cxx:352
 TTreePlayer.cxx:353
 TTreePlayer.cxx:354
 TTreePlayer.cxx:355
 TTreePlayer.cxx:356
 TTreePlayer.cxx:357
 TTreePlayer.cxx:358
 TTreePlayer.cxx:359
 TTreePlayer.cxx:360
 TTreePlayer.cxx:361
 TTreePlayer.cxx:362
 TTreePlayer.cxx:363
 TTreePlayer.cxx:364
 TTreePlayer.cxx:365
 TTreePlayer.cxx:366
 TTreePlayer.cxx:367
 TTreePlayer.cxx:368
 TTreePlayer.cxx:369
 TTreePlayer.cxx:370
 TTreePlayer.cxx:371
 TTreePlayer.cxx:372
 TTreePlayer.cxx:373
 TTreePlayer.cxx:374
 TTreePlayer.cxx:375
 TTreePlayer.cxx:376
 TTreePlayer.cxx:377
 TTreePlayer.cxx:378
 TTreePlayer.cxx:379
 TTreePlayer.cxx:380
 TTreePlayer.cxx:381
 TTreePlayer.cxx:382
 TTreePlayer.cxx:383
 TTreePlayer.cxx:384
 TTreePlayer.cxx:385
 TTreePlayer.cxx:386
 TTreePlayer.cxx:387
 TTreePlayer.cxx:388
 TTreePlayer.cxx:389
 TTreePlayer.cxx:390
 TTreePlayer.cxx:391
 TTreePlayer.cxx:392
 TTreePlayer.cxx:393
 TTreePlayer.cxx:394
 TTreePlayer.cxx:395
 TTreePlayer.cxx:396
 TTreePlayer.cxx:397
 TTreePlayer.cxx:398
 TTreePlayer.cxx:399
 TTreePlayer.cxx:400
 TTreePlayer.cxx:401
 TTreePlayer.cxx:402
 TTreePlayer.cxx:403
 TTreePlayer.cxx:404
 TTreePlayer.cxx:405
 TTreePlayer.cxx:406
 TTreePlayer.cxx:407
 TTreePlayer.cxx:408
 TTreePlayer.cxx:409
 TTreePlayer.cxx:410
 TTreePlayer.cxx:411
 TTreePlayer.cxx:412
 TTreePlayer.cxx:413
 TTreePlayer.cxx:414
 TTreePlayer.cxx:415
 TTreePlayer.cxx:416
 TTreePlayer.cxx:417
 TTreePlayer.cxx:418
 TTreePlayer.cxx:419
 TTreePlayer.cxx:420
 TTreePlayer.cxx:421
 TTreePlayer.cxx:422
 TTreePlayer.cxx:423
 TTreePlayer.cxx:424
 TTreePlayer.cxx:425
 TTreePlayer.cxx:426
 TTreePlayer.cxx:427
 TTreePlayer.cxx:428
 TTreePlayer.cxx:429
 TTreePlayer.cxx:430
 TTreePlayer.cxx:431
 TTreePlayer.cxx:432
 TTreePlayer.cxx:433
 TTreePlayer.cxx:434
 TTreePlayer.cxx:435
 TTreePlayer.cxx:436
 TTreePlayer.cxx:437
 TTreePlayer.cxx:438
 TTreePlayer.cxx:439
 TTreePlayer.cxx:440
 TTreePlayer.cxx:441
 TTreePlayer.cxx:442
 TTreePlayer.cxx:443
 TTreePlayer.cxx:444
 TTreePlayer.cxx:445
 TTreePlayer.cxx:446
 TTreePlayer.cxx:447
 TTreePlayer.cxx:448
 TTreePlayer.cxx:449
 TTreePlayer.cxx:450
 TTreePlayer.cxx:451
 TTreePlayer.cxx:452
 TTreePlayer.cxx:453
 TTreePlayer.cxx:454
 TTreePlayer.cxx:455
 TTreePlayer.cxx:456
 TTreePlayer.cxx:457
 TTreePlayer.cxx:458
 TTreePlayer.cxx:459
 TTreePlayer.cxx:460
 TTreePlayer.cxx:461
 TTreePlayer.cxx:462
 TTreePlayer.cxx:463
 TTreePlayer.cxx:464
 TTreePlayer.cxx:465
 TTreePlayer.cxx:466
 TTreePlayer.cxx:467
 TTreePlayer.cxx:468
 TTreePlayer.cxx:469
 TTreePlayer.cxx:470
 TTreePlayer.cxx:471
 TTreePlayer.cxx:472
 TTreePlayer.cxx:473
 TTreePlayer.cxx:474
 TTreePlayer.cxx:475
 TTreePlayer.cxx:476
 TTreePlayer.cxx:477
 TTreePlayer.cxx:478
 TTreePlayer.cxx:479
 TTreePlayer.cxx:480
 TTreePlayer.cxx:481
 TTreePlayer.cxx:482
 TTreePlayer.cxx:483
 TTreePlayer.cxx:484
 TTreePlayer.cxx:485
 TTreePlayer.cxx:486
 TTreePlayer.cxx:487
 TTreePlayer.cxx:488
 TTreePlayer.cxx:489
 TTreePlayer.cxx:490
 TTreePlayer.cxx:491
 TTreePlayer.cxx:492
 TTreePlayer.cxx:493
 TTreePlayer.cxx:494
 TTreePlayer.cxx:495
 TTreePlayer.cxx:496
 TTreePlayer.cxx:497
 TTreePlayer.cxx:498
 TTreePlayer.cxx:499
 TTreePlayer.cxx:500
 TTreePlayer.cxx:501
 TTreePlayer.cxx:502
 TTreePlayer.cxx:503
 TTreePlayer.cxx:504
 TTreePlayer.cxx:505
 TTreePlayer.cxx:506
 TTreePlayer.cxx:507
 TTreePlayer.cxx:508
 TTreePlayer.cxx:509
 TTreePlayer.cxx:510
 TTreePlayer.cxx:511
 TTreePlayer.cxx:512
 TTreePlayer.cxx:513
 TTreePlayer.cxx:514
 TTreePlayer.cxx:515
 TTreePlayer.cxx:516
 TTreePlayer.cxx:517
 TTreePlayer.cxx:518
 TTreePlayer.cxx:519
 TTreePlayer.cxx:520
 TTreePlayer.cxx:521
 TTreePlayer.cxx:522
 TTreePlayer.cxx:523
 TTreePlayer.cxx:524
 TTreePlayer.cxx:525
 TTreePlayer.cxx:526
 TTreePlayer.cxx:527
 TTreePlayer.cxx:528
 TTreePlayer.cxx:529
 TTreePlayer.cxx:530
 TTreePlayer.cxx:531
 TTreePlayer.cxx:532
 TTreePlayer.cxx:533
 TTreePlayer.cxx:534
 TTreePlayer.cxx:535
 TTreePlayer.cxx:536
 TTreePlayer.cxx:537
 TTreePlayer.cxx:538
 TTreePlayer.cxx:539
 TTreePlayer.cxx:540
 TTreePlayer.cxx:541
 TTreePlayer.cxx:542
 TTreePlayer.cxx:543
 TTreePlayer.cxx:544
 TTreePlayer.cxx:545
 TTreePlayer.cxx:546
 TTreePlayer.cxx:547
 TTreePlayer.cxx:548
 TTreePlayer.cxx:549
 TTreePlayer.cxx:550
 TTreePlayer.cxx:551
 TTreePlayer.cxx:552
 TTreePlayer.cxx:553
 TTreePlayer.cxx:554
 TTreePlayer.cxx:555
 TTreePlayer.cxx:556
 TTreePlayer.cxx:557
 TTreePlayer.cxx:558
 TTreePlayer.cxx:559
 TTreePlayer.cxx:560
 TTreePlayer.cxx:561
 TTreePlayer.cxx:562
 TTreePlayer.cxx:563
 TTreePlayer.cxx:564
 TTreePlayer.cxx:565
 TTreePlayer.cxx:566
 TTreePlayer.cxx:567
 TTreePlayer.cxx:568
 TTreePlayer.cxx:569
 TTreePlayer.cxx:570
 TTreePlayer.cxx:571
 TTreePlayer.cxx:572
 TTreePlayer.cxx:573
 TTreePlayer.cxx:574
 TTreePlayer.cxx:575
 TTreePlayer.cxx:576
 TTreePlayer.cxx:577
 TTreePlayer.cxx:578
 TTreePlayer.cxx:579
 TTreePlayer.cxx:580
 TTreePlayer.cxx:581
 TTreePlayer.cxx:582
 TTreePlayer.cxx:583
 TTreePlayer.cxx:584
 TTreePlayer.cxx:585
 TTreePlayer.cxx:586
 TTreePlayer.cxx:587
 TTreePlayer.cxx:588
 TTreePlayer.cxx:589
 TTreePlayer.cxx:590
 TTreePlayer.cxx:591
 TTreePlayer.cxx:592
 TTreePlayer.cxx:593
 TTreePlayer.cxx:594
 TTreePlayer.cxx:595
 TTreePlayer.cxx:596
 TTreePlayer.cxx:597
 TTreePlayer.cxx:598
 TTreePlayer.cxx:599
 TTreePlayer.cxx:600
 TTreePlayer.cxx:601
 TTreePlayer.cxx:602
 TTreePlayer.cxx:603
 TTreePlayer.cxx:604
 TTreePlayer.cxx:605
 TTreePlayer.cxx:606
 TTreePlayer.cxx:607
 TTreePlayer.cxx:608
 TTreePlayer.cxx:609
 TTreePlayer.cxx:610
 TTreePlayer.cxx:611
 TTreePlayer.cxx:612
 TTreePlayer.cxx:613
 TTreePlayer.cxx:614
 TTreePlayer.cxx:615
 TTreePlayer.cxx:616
 TTreePlayer.cxx:617
 TTreePlayer.cxx:618
 TTreePlayer.cxx:619
 TTreePlayer.cxx:620
 TTreePlayer.cxx:621
 TTreePlayer.cxx:622
 TTreePlayer.cxx:623
 TTreePlayer.cxx:624
 TTreePlayer.cxx:625
 TTreePlayer.cxx:626
 TTreePlayer.cxx:627
 TTreePlayer.cxx:628
 TTreePlayer.cxx:629
 TTreePlayer.cxx:630
 TTreePlayer.cxx:631
 TTreePlayer.cxx:632
 TTreePlayer.cxx:633
 TTreePlayer.cxx:634
 TTreePlayer.cxx:635
 TTreePlayer.cxx:636
 TTreePlayer.cxx:637
 TTreePlayer.cxx:638
 TTreePlayer.cxx:639
 TTreePlayer.cxx:640
 TTreePlayer.cxx:641
 TTreePlayer.cxx:642
 TTreePlayer.cxx:643
 TTreePlayer.cxx:644
 TTreePlayer.cxx:645
 TTreePlayer.cxx:646
 TTreePlayer.cxx:647
 TTreePlayer.cxx:648
 TTreePlayer.cxx:649
 TTreePlayer.cxx:650
 TTreePlayer.cxx:651
 TTreePlayer.cxx:652
 TTreePlayer.cxx:653
 TTreePlayer.cxx:654
 TTreePlayer.cxx:655
 TTreePlayer.cxx:656
 TTreePlayer.cxx:657
 TTreePlayer.cxx:658
 TTreePlayer.cxx:659
 TTreePlayer.cxx:660
 TTreePlayer.cxx:661
 TTreePlayer.cxx:662
 TTreePlayer.cxx:663
 TTreePlayer.cxx:664
 TTreePlayer.cxx:665
 TTreePlayer.cxx:666
 TTreePlayer.cxx:667
 TTreePlayer.cxx:668
 TTreePlayer.cxx:669
 TTreePlayer.cxx:670
 TTreePlayer.cxx:671
 TTreePlayer.cxx:672
 TTreePlayer.cxx:673
 TTreePlayer.cxx:674
 TTreePlayer.cxx:675
 TTreePlayer.cxx:676
 TTreePlayer.cxx:677
 TTreePlayer.cxx:678
 TTreePlayer.cxx:679
 TTreePlayer.cxx:680
 TTreePlayer.cxx:681
 TTreePlayer.cxx:682
 TTreePlayer.cxx:683
 TTreePlayer.cxx:684
 TTreePlayer.cxx:685
 TTreePlayer.cxx:686
 TTreePlayer.cxx:687
 TTreePlayer.cxx:688
 TTreePlayer.cxx:689
 TTreePlayer.cxx:690
 TTreePlayer.cxx:691
 TTreePlayer.cxx:692
 TTreePlayer.cxx:693
 TTreePlayer.cxx:694
 TTreePlayer.cxx:695
 TTreePlayer.cxx:696
 TTreePlayer.cxx:697
 TTreePlayer.cxx:698
 TTreePlayer.cxx:699
 TTreePlayer.cxx:700
 TTreePlayer.cxx:701
 TTreePlayer.cxx:702
 TTreePlayer.cxx:703
 TTreePlayer.cxx:704
 TTreePlayer.cxx:705
 TTreePlayer.cxx:706
 TTreePlayer.cxx:707
 TTreePlayer.cxx:708
 TTreePlayer.cxx:709
 TTreePlayer.cxx:710
 TTreePlayer.cxx:711
 TTreePlayer.cxx:712
 TTreePlayer.cxx:713
 TTreePlayer.cxx:714
 TTreePlayer.cxx:715
 TTreePlayer.cxx:716
 TTreePlayer.cxx:717
 TTreePlayer.cxx:718
 TTreePlayer.cxx:719
 TTreePlayer.cxx:720
 TTreePlayer.cxx:721
 TTreePlayer.cxx:722
 TTreePlayer.cxx:723
 TTreePlayer.cxx:724
 TTreePlayer.cxx:725
 TTreePlayer.cxx:726
 TTreePlayer.cxx:727
 TTreePlayer.cxx:728
 TTreePlayer.cxx:729
 TTreePlayer.cxx:730
 TTreePlayer.cxx:731
 TTreePlayer.cxx:732
 TTreePlayer.cxx:733
 TTreePlayer.cxx:734
 TTreePlayer.cxx:735
 TTreePlayer.cxx:736
 TTreePlayer.cxx:737
 TTreePlayer.cxx:738
 TTreePlayer.cxx:739
 TTreePlayer.cxx:740
 TTreePlayer.cxx:741
 TTreePlayer.cxx:742
 TTreePlayer.cxx:743
 TTreePlayer.cxx:744
 TTreePlayer.cxx:745
 TTreePlayer.cxx:746
 TTreePlayer.cxx:747
 TTreePlayer.cxx:748
 TTreePlayer.cxx:749
 TTreePlayer.cxx:750
 TTreePlayer.cxx:751
 TTreePlayer.cxx:752
 TTreePlayer.cxx:753
 TTreePlayer.cxx:754
 TTreePlayer.cxx:755
 TTreePlayer.cxx:756
 TTreePlayer.cxx:757
 TTreePlayer.cxx:758
 TTreePlayer.cxx:759
 TTreePlayer.cxx:760
 TTreePlayer.cxx:761
 TTreePlayer.cxx:762
 TTreePlayer.cxx:763
 TTreePlayer.cxx:764
 TTreePlayer.cxx:765
 TTreePlayer.cxx:766
 TTreePlayer.cxx:767
 TTreePlayer.cxx:768
 TTreePlayer.cxx:769
 TTreePlayer.cxx:770
 TTreePlayer.cxx:771
 TTreePlayer.cxx:772
 TTreePlayer.cxx:773
 TTreePlayer.cxx:774
 TTreePlayer.cxx:775
 TTreePlayer.cxx:776
 TTreePlayer.cxx:777
 TTreePlayer.cxx:778
 TTreePlayer.cxx:779
 TTreePlayer.cxx:780
 TTreePlayer.cxx:781
 TTreePlayer.cxx:782
 TTreePlayer.cxx:783
 TTreePlayer.cxx:784
 TTreePlayer.cxx:785
 TTreePlayer.cxx:786
 TTreePlayer.cxx:787
 TTreePlayer.cxx:788
 TTreePlayer.cxx:789
 TTreePlayer.cxx:790
 TTreePlayer.cxx:791
 TTreePlayer.cxx:792
 TTreePlayer.cxx:793
 TTreePlayer.cxx:794
 TTreePlayer.cxx:795
 TTreePlayer.cxx:796
 TTreePlayer.cxx:797
 TTreePlayer.cxx:798
 TTreePlayer.cxx:799
 TTreePlayer.cxx:800
 TTreePlayer.cxx:801
 TTreePlayer.cxx:802
 TTreePlayer.cxx:803
 TTreePlayer.cxx:804
 TTreePlayer.cxx:805
 TTreePlayer.cxx:806
 TTreePlayer.cxx:807
 TTreePlayer.cxx:808
 TTreePlayer.cxx:809
 TTreePlayer.cxx:810
 TTreePlayer.cxx:811
 TTreePlayer.cxx:812
 TTreePlayer.cxx:813
 TTreePlayer.cxx:814
 TTreePlayer.cxx:815
 TTreePlayer.cxx:816
 TTreePlayer.cxx:817
 TTreePlayer.cxx:818
 TTreePlayer.cxx:819
 TTreePlayer.cxx:820
 TTreePlayer.cxx:821
 TTreePlayer.cxx:822
 TTreePlayer.cxx:823
 TTreePlayer.cxx:824
 TTreePlayer.cxx:825
 TTreePlayer.cxx:826
 TTreePlayer.cxx:827
 TTreePlayer.cxx:828
 TTreePlayer.cxx:829
 TTreePlayer.cxx:830
 TTreePlayer.cxx:831
 TTreePlayer.cxx:832
 TTreePlayer.cxx:833
 TTreePlayer.cxx:834
 TTreePlayer.cxx:835
 TTreePlayer.cxx:836
 TTreePlayer.cxx:837
 TTreePlayer.cxx:838
 TTreePlayer.cxx:839
 TTreePlayer.cxx:840
 TTreePlayer.cxx:841
 TTreePlayer.cxx:842
 TTreePlayer.cxx:843
 TTreePlayer.cxx:844
 TTreePlayer.cxx:845
 TTreePlayer.cxx:846
 TTreePlayer.cxx:847
 TTreePlayer.cxx:848
 TTreePlayer.cxx:849
 TTreePlayer.cxx:850
 TTreePlayer.cxx:851
 TTreePlayer.cxx:852
 TTreePlayer.cxx:853
 TTreePlayer.cxx:854
 TTreePlayer.cxx:855
 TTreePlayer.cxx:856
 TTreePlayer.cxx:857
 TTreePlayer.cxx:858
 TTreePlayer.cxx:859
 TTreePlayer.cxx:860
 TTreePlayer.cxx:861
 TTreePlayer.cxx:862
 TTreePlayer.cxx:863
 TTreePlayer.cxx:864
 TTreePlayer.cxx:865
 TTreePlayer.cxx:866
 TTreePlayer.cxx:867
 TTreePlayer.cxx:868
 TTreePlayer.cxx:869
 TTreePlayer.cxx:870
 TTreePlayer.cxx:871
 TTreePlayer.cxx:872
 TTreePlayer.cxx:873
 TTreePlayer.cxx:874
 TTreePlayer.cxx:875
 TTreePlayer.cxx:876
 TTreePlayer.cxx:877
 TTreePlayer.cxx:878
 TTreePlayer.cxx:879
 TTreePlayer.cxx:880
 TTreePlayer.cxx:881
 TTreePlayer.cxx:882
 TTreePlayer.cxx:883
 TTreePlayer.cxx:884
 TTreePlayer.cxx:885
 TTreePlayer.cxx:886
 TTreePlayer.cxx:887
 TTreePlayer.cxx:888
 TTreePlayer.cxx:889
 TTreePlayer.cxx:890
 TTreePlayer.cxx:891
 TTreePlayer.cxx:892
 TTreePlayer.cxx:893
 TTreePlayer.cxx:894
 TTreePlayer.cxx:895
 TTreePlayer.cxx:896
 TTreePlayer.cxx:897
 TTreePlayer.cxx:898
 TTreePlayer.cxx:899
 TTreePlayer.cxx:900
 TTreePlayer.cxx:901
 TTreePlayer.cxx:902
 TTreePlayer.cxx:903
 TTreePlayer.cxx:904
 TTreePlayer.cxx:905
 TTreePlayer.cxx:906
 TTreePlayer.cxx:907
 TTreePlayer.cxx:908
 TTreePlayer.cxx:909
 TTreePlayer.cxx:910
 TTreePlayer.cxx:911
 TTreePlayer.cxx:912
 TTreePlayer.cxx:913
 TTreePlayer.cxx:914
 TTreePlayer.cxx:915
 TTreePlayer.cxx:916
 TTreePlayer.cxx:917
 TTreePlayer.cxx:918
 TTreePlayer.cxx:919
 TTreePlayer.cxx:920
 TTreePlayer.cxx:921
 TTreePlayer.cxx:922
 TTreePlayer.cxx:923
 TTreePlayer.cxx:924
 TTreePlayer.cxx:925
 TTreePlayer.cxx:926
 TTreePlayer.cxx:927
 TTreePlayer.cxx:928
 TTreePlayer.cxx:929
 TTreePlayer.cxx:930
 TTreePlayer.cxx:931
 TTreePlayer.cxx:932
 TTreePlayer.cxx:933
 TTreePlayer.cxx:934
 TTreePlayer.cxx:935
 TTreePlayer.cxx:936
 TTreePlayer.cxx:937
 TTreePlayer.cxx:938
 TTreePlayer.cxx:939
 TTreePlayer.cxx:940
 TTreePlayer.cxx:941
 TTreePlayer.cxx:942
 TTreePlayer.cxx:943
 TTreePlayer.cxx:944
 TTreePlayer.cxx:945
 TTreePlayer.cxx:946
 TTreePlayer.cxx:947
 TTreePlayer.cxx:948
 TTreePlayer.cxx:949
 TTreePlayer.cxx:950
 TTreePlayer.cxx:951
 TTreePlayer.cxx:952
 TTreePlayer.cxx:953
 TTreePlayer.cxx:954
 TTreePlayer.cxx:955
 TTreePlayer.cxx:956
 TTreePlayer.cxx:957
 TTreePlayer.cxx:958
 TTreePlayer.cxx:959
 TTreePlayer.cxx:960
 TTreePlayer.cxx:961
 TTreePlayer.cxx:962
 TTreePlayer.cxx:963
 TTreePlayer.cxx:964
 TTreePlayer.cxx:965
 TTreePlayer.cxx:966
 TTreePlayer.cxx:967
 TTreePlayer.cxx:968
 TTreePlayer.cxx:969
 TTreePlayer.cxx:970
 TTreePlayer.cxx:971
 TTreePlayer.cxx:972
 TTreePlayer.cxx:973
 TTreePlayer.cxx:974
 TTreePlayer.cxx:975
 TTreePlayer.cxx:976
 TTreePlayer.cxx:977
 TTreePlayer.cxx:978
 TTreePlayer.cxx:979
 TTreePlayer.cxx:980
 TTreePlayer.cxx:981
 TTreePlayer.cxx:982
 TTreePlayer.cxx:983
 TTreePlayer.cxx:984
 TTreePlayer.cxx:985
 TTreePlayer.cxx:986
 TTreePlayer.cxx:987
 TTreePlayer.cxx:988
 TTreePlayer.cxx:989
 TTreePlayer.cxx:990
 TTreePlayer.cxx:991
 TTreePlayer.cxx:992
 TTreePlayer.cxx:993
 TTreePlayer.cxx:994
 TTreePlayer.cxx:995
 TTreePlayer.cxx:996
 TTreePlayer.cxx:997
 TTreePlayer.cxx:998
 TTreePlayer.cxx:999
 TTreePlayer.cxx:1000
 TTreePlayer.cxx:1001
 TTreePlayer.cxx:1002
 TTreePlayer.cxx:1003
 TTreePlayer.cxx:1004
 TTreePlayer.cxx:1005
 TTreePlayer.cxx:1006
 TTreePlayer.cxx:1007
 TTreePlayer.cxx:1008
 TTreePlayer.cxx:1009
 TTreePlayer.cxx:1010
 TTreePlayer.cxx:1011
 TTreePlayer.cxx:1012
 TTreePlayer.cxx:1013
 TTreePlayer.cxx:1014
 TTreePlayer.cxx:1015
 TTreePlayer.cxx:1016
 TTreePlayer.cxx:1017
 TTreePlayer.cxx:1018
 TTreePlayer.cxx:1019
 TTreePlayer.cxx:1020
 TTreePlayer.cxx:1021
 TTreePlayer.cxx:1022
 TTreePlayer.cxx:1023
 TTreePlayer.cxx:1024
 TTreePlayer.cxx:1025
 TTreePlayer.cxx:1026
 TTreePlayer.cxx:1027
 TTreePlayer.cxx:1028
 TTreePlayer.cxx:1029
 TTreePlayer.cxx:1030
 TTreePlayer.cxx:1031
 TTreePlayer.cxx:1032
 TTreePlayer.cxx:1033
 TTreePlayer.cxx:1034
 TTreePlayer.cxx:1035
 TTreePlayer.cxx:1036
 TTreePlayer.cxx:1037
 TTreePlayer.cxx:1038
 TTreePlayer.cxx:1039
 TTreePlayer.cxx:1040
 TTreePlayer.cxx:1041
 TTreePlayer.cxx:1042
 TTreePlayer.cxx:1043
 TTreePlayer.cxx:1044
 TTreePlayer.cxx:1045
 TTreePlayer.cxx:1046
 TTreePlayer.cxx:1047
 TTreePlayer.cxx:1048
 TTreePlayer.cxx:1049
 TTreePlayer.cxx:1050
 TTreePlayer.cxx:1051
 TTreePlayer.cxx:1052
 TTreePlayer.cxx:1053
 TTreePlayer.cxx:1054
 TTreePlayer.cxx:1055
 TTreePlayer.cxx:1056
 TTreePlayer.cxx:1057
 TTreePlayer.cxx:1058
 TTreePlayer.cxx:1059
 TTreePlayer.cxx:1060
 TTreePlayer.cxx:1061
 TTreePlayer.cxx:1062
 TTreePlayer.cxx:1063
 TTreePlayer.cxx:1064
 TTreePlayer.cxx:1065
 TTreePlayer.cxx:1066
 TTreePlayer.cxx:1067
 TTreePlayer.cxx:1068
 TTreePlayer.cxx:1069
 TTreePlayer.cxx:1070
 TTreePlayer.cxx:1071
 TTreePlayer.cxx:1072
 TTreePlayer.cxx:1073
 TTreePlayer.cxx:1074
 TTreePlayer.cxx:1075
 TTreePlayer.cxx:1076
 TTreePlayer.cxx:1077
 TTreePlayer.cxx:1078
 TTreePlayer.cxx:1079
 TTreePlayer.cxx:1080
 TTreePlayer.cxx:1081
 TTreePlayer.cxx:1082
 TTreePlayer.cxx:1083
 TTreePlayer.cxx:1084
 TTreePlayer.cxx:1085
 TTreePlayer.cxx:1086
 TTreePlayer.cxx:1087
 TTreePlayer.cxx:1088
 TTreePlayer.cxx:1089
 TTreePlayer.cxx:1090
 TTreePlayer.cxx:1091
 TTreePlayer.cxx:1092
 TTreePlayer.cxx:1093
 TTreePlayer.cxx:1094
 TTreePlayer.cxx:1095
 TTreePlayer.cxx:1096
 TTreePlayer.cxx:1097
 TTreePlayer.cxx:1098
 TTreePlayer.cxx:1099
 TTreePlayer.cxx:1100
 TTreePlayer.cxx:1101
 TTreePlayer.cxx:1102
 TTreePlayer.cxx:1103
 TTreePlayer.cxx:1104
 TTreePlayer.cxx:1105
 TTreePlayer.cxx:1106
 TTreePlayer.cxx:1107
 TTreePlayer.cxx:1108
 TTreePlayer.cxx:1109
 TTreePlayer.cxx:1110
 TTreePlayer.cxx:1111
 TTreePlayer.cxx:1112
 TTreePlayer.cxx:1113
 TTreePlayer.cxx:1114
 TTreePlayer.cxx:1115
 TTreePlayer.cxx:1116
 TTreePlayer.cxx:1117
 TTreePlayer.cxx:1118
 TTreePlayer.cxx:1119
 TTreePlayer.cxx:1120
 TTreePlayer.cxx:1121
 TTreePlayer.cxx:1122
 TTreePlayer.cxx:1123
 TTreePlayer.cxx:1124
 TTreePlayer.cxx:1125
 TTreePlayer.cxx:1126
 TTreePlayer.cxx:1127
 TTreePlayer.cxx:1128
 TTreePlayer.cxx:1129
 TTreePlayer.cxx:1130
 TTreePlayer.cxx:1131
 TTreePlayer.cxx:1132
 TTreePlayer.cxx:1133
 TTreePlayer.cxx:1134
 TTreePlayer.cxx:1135
 TTreePlayer.cxx:1136
 TTreePlayer.cxx:1137
 TTreePlayer.cxx:1138
 TTreePlayer.cxx:1139
 TTreePlayer.cxx:1140
 TTreePlayer.cxx:1141
 TTreePlayer.cxx:1142
 TTreePlayer.cxx:1143
 TTreePlayer.cxx:1144
 TTreePlayer.cxx:1145
 TTreePlayer.cxx:1146
 TTreePlayer.cxx:1147
 TTreePlayer.cxx:1148
 TTreePlayer.cxx:1149
 TTreePlayer.cxx:1150
 TTreePlayer.cxx:1151
 TTreePlayer.cxx:1152
 TTreePlayer.cxx:1153
 TTreePlayer.cxx:1154
 TTreePlayer.cxx:1155
 TTreePlayer.cxx:1156
 TTreePlayer.cxx:1157
 TTreePlayer.cxx:1158
 TTreePlayer.cxx:1159
 TTreePlayer.cxx:1160
 TTreePlayer.cxx:1161
 TTreePlayer.cxx:1162
 TTreePlayer.cxx:1163
 TTreePlayer.cxx:1164
 TTreePlayer.cxx:1165
 TTreePlayer.cxx:1166
 TTreePlayer.cxx:1167
 TTreePlayer.cxx:1168
 TTreePlayer.cxx:1169
 TTreePlayer.cxx:1170
 TTreePlayer.cxx:1171
 TTreePlayer.cxx:1172
 TTreePlayer.cxx:1173
 TTreePlayer.cxx:1174
 TTreePlayer.cxx:1175
 TTreePlayer.cxx:1176
 TTreePlayer.cxx:1177
 TTreePlayer.cxx:1178
 TTreePlayer.cxx:1179
 TTreePlayer.cxx:1180
 TTreePlayer.cxx:1181
 TTreePlayer.cxx:1182
 TTreePlayer.cxx:1183
 TTreePlayer.cxx:1184
 TTreePlayer.cxx:1185
 TTreePlayer.cxx:1186
 TTreePlayer.cxx:1187
 TTreePlayer.cxx:1188
 TTreePlayer.cxx:1189
 TTreePlayer.cxx:1190
 TTreePlayer.cxx:1191
 TTreePlayer.cxx:1192
 TTreePlayer.cxx:1193
 TTreePlayer.cxx:1194
 TTreePlayer.cxx:1195
 TTreePlayer.cxx:1196
 TTreePlayer.cxx:1197
 TTreePlayer.cxx:1198
 TTreePlayer.cxx:1199
 TTreePlayer.cxx:1200
 TTreePlayer.cxx:1201
 TTreePlayer.cxx:1202
 TTreePlayer.cxx:1203
 TTreePlayer.cxx:1204
 TTreePlayer.cxx:1205
 TTreePlayer.cxx:1206
 TTreePlayer.cxx:1207
 TTreePlayer.cxx:1208
 TTreePlayer.cxx:1209
 TTreePlayer.cxx:1210
 TTreePlayer.cxx:1211
 TTreePlayer.cxx:1212
 TTreePlayer.cxx:1213
 TTreePlayer.cxx:1214
 TTreePlayer.cxx:1215
 TTreePlayer.cxx:1216
 TTreePlayer.cxx:1217
 TTreePlayer.cxx:1218
 TTreePlayer.cxx:1219
 TTreePlayer.cxx:1220
 TTreePlayer.cxx:1221
 TTreePlayer.cxx:1222
 TTreePlayer.cxx:1223
 TTreePlayer.cxx:1224
 TTreePlayer.cxx:1225
 TTreePlayer.cxx:1226
 TTreePlayer.cxx:1227
 TTreePlayer.cxx:1228
 TTreePlayer.cxx:1229
 TTreePlayer.cxx:1230
 TTreePlayer.cxx:1231
 TTreePlayer.cxx:1232
 TTreePlayer.cxx:1233
 TTreePlayer.cxx:1234
 TTreePlayer.cxx:1235
 TTreePlayer.cxx:1236
 TTreePlayer.cxx:1237
 TTreePlayer.cxx:1238
 TTreePlayer.cxx:1239
 TTreePlayer.cxx:1240
 TTreePlayer.cxx:1241
 TTreePlayer.cxx:1242
 TTreePlayer.cxx:1243
 TTreePlayer.cxx:1244
 TTreePlayer.cxx:1245
 TTreePlayer.cxx:1246
 TTreePlayer.cxx:1247
 TTreePlayer.cxx:1248
 TTreePlayer.cxx:1249
 TTreePlayer.cxx:1250
 TTreePlayer.cxx:1251
 TTreePlayer.cxx:1252
 TTreePlayer.cxx:1253
 TTreePlayer.cxx:1254
 TTreePlayer.cxx:1255
 TTreePlayer.cxx:1256
 TTreePlayer.cxx:1257
 TTreePlayer.cxx:1258
 TTreePlayer.cxx:1259
 TTreePlayer.cxx:1260
 TTreePlayer.cxx:1261
 TTreePlayer.cxx:1262
 TTreePlayer.cxx:1263
 TTreePlayer.cxx:1264
 TTreePlayer.cxx:1265
 TTreePlayer.cxx:1266
 TTreePlayer.cxx:1267
 TTreePlayer.cxx:1268
 TTreePlayer.cxx:1269
 TTreePlayer.cxx:1270
 TTreePlayer.cxx:1271
 TTreePlayer.cxx:1272
 TTreePlayer.cxx:1273
 TTreePlayer.cxx:1274
 TTreePlayer.cxx:1275
 TTreePlayer.cxx:1276
 TTreePlayer.cxx:1277
 TTreePlayer.cxx:1278
 TTreePlayer.cxx:1279
 TTreePlayer.cxx:1280
 TTreePlayer.cxx:1281
 TTreePlayer.cxx:1282
 TTreePlayer.cxx:1283
 TTreePlayer.cxx:1284
 TTreePlayer.cxx:1285
 TTreePlayer.cxx:1286
 TTreePlayer.cxx:1287
 TTreePlayer.cxx:1288
 TTreePlayer.cxx:1289
 TTreePlayer.cxx:1290
 TTreePlayer.cxx:1291
 TTreePlayer.cxx:1292
 TTreePlayer.cxx:1293
 TTreePlayer.cxx:1294
 TTreePlayer.cxx:1295
 TTreePlayer.cxx:1296
 TTreePlayer.cxx:1297
 TTreePlayer.cxx:1298
 TTreePlayer.cxx:1299
 TTreePlayer.cxx:1300
 TTreePlayer.cxx:1301
 TTreePlayer.cxx:1302
 TTreePlayer.cxx:1303
 TTreePlayer.cxx:1304
 TTreePlayer.cxx:1305
 TTreePlayer.cxx:1306
 TTreePlayer.cxx:1307
 TTreePlayer.cxx:1308
 TTreePlayer.cxx:1309
 TTreePlayer.cxx:1310
 TTreePlayer.cxx:1311
 TTreePlayer.cxx:1312
 TTreePlayer.cxx:1313
 TTreePlayer.cxx:1314
 TTreePlayer.cxx:1315
 TTreePlayer.cxx:1316
 TTreePlayer.cxx:1317
 TTreePlayer.cxx:1318
 TTreePlayer.cxx:1319
 TTreePlayer.cxx:1320
 TTreePlayer.cxx:1321
 TTreePlayer.cxx:1322
 TTreePlayer.cxx:1323
 TTreePlayer.cxx:1324
 TTreePlayer.cxx:1325
 TTreePlayer.cxx:1326
 TTreePlayer.cxx:1327
 TTreePlayer.cxx:1328
 TTreePlayer.cxx:1329
 TTreePlayer.cxx:1330
 TTreePlayer.cxx:1331
 TTreePlayer.cxx:1332
 TTreePlayer.cxx:1333
 TTreePlayer.cxx:1334
 TTreePlayer.cxx:1335
 TTreePlayer.cxx:1336
 TTreePlayer.cxx:1337
 TTreePlayer.cxx:1338
 TTreePlayer.cxx:1339
 TTreePlayer.cxx:1340
 TTreePlayer.cxx:1341
 TTreePlayer.cxx:1342
 TTreePlayer.cxx:1343
 TTreePlayer.cxx:1344
 TTreePlayer.cxx:1345
 TTreePlayer.cxx:1346
 TTreePlayer.cxx:1347
 TTreePlayer.cxx:1348
 TTreePlayer.cxx:1349
 TTreePlayer.cxx:1350
 TTreePlayer.cxx:1351
 TTreePlayer.cxx:1352
 TTreePlayer.cxx:1353
 TTreePlayer.cxx:1354
 TTreePlayer.cxx:1355
 TTreePlayer.cxx:1356
 TTreePlayer.cxx:1357
 TTreePlayer.cxx:1358
 TTreePlayer.cxx:1359
 TTreePlayer.cxx:1360
 TTreePlayer.cxx:1361
 TTreePlayer.cxx:1362
 TTreePlayer.cxx:1363
 TTreePlayer.cxx:1364
 TTreePlayer.cxx:1365
 TTreePlayer.cxx:1366
 TTreePlayer.cxx:1367
 TTreePlayer.cxx:1368
 TTreePlayer.cxx:1369
 TTreePlayer.cxx:1370
 TTreePlayer.cxx:1371
 TTreePlayer.cxx:1372
 TTreePlayer.cxx:1373
 TTreePlayer.cxx:1374
 TTreePlayer.cxx:1375
 TTreePlayer.cxx:1376
 TTreePlayer.cxx:1377
 TTreePlayer.cxx:1378
 TTreePlayer.cxx:1379
 TTreePlayer.cxx:1380
 TTreePlayer.cxx:1381
 TTreePlayer.cxx:1382
 TTreePlayer.cxx:1383
 TTreePlayer.cxx:1384
 TTreePlayer.cxx:1385
 TTreePlayer.cxx:1386
 TTreePlayer.cxx:1387
 TTreePlayer.cxx:1388
 TTreePlayer.cxx:1389
 TTreePlayer.cxx:1390
 TTreePlayer.cxx:1391
 TTreePlayer.cxx:1392
 TTreePlayer.cxx:1393
 TTreePlayer.cxx:1394
 TTreePlayer.cxx:1395
 TTreePlayer.cxx:1396
 TTreePlayer.cxx:1397
 TTreePlayer.cxx:1398
 TTreePlayer.cxx:1399
 TTreePlayer.cxx:1400
 TTreePlayer.cxx:1401
 TTreePlayer.cxx:1402
 TTreePlayer.cxx:1403
 TTreePlayer.cxx:1404
 TTreePlayer.cxx:1405
 TTreePlayer.cxx:1406
 TTreePlayer.cxx:1407
 TTreePlayer.cxx:1408
 TTreePlayer.cxx:1409
 TTreePlayer.cxx:1410
 TTreePlayer.cxx:1411
 TTreePlayer.cxx:1412
 TTreePlayer.cxx:1413
 TTreePlayer.cxx:1414
 TTreePlayer.cxx:1415
 TTreePlayer.cxx:1416
 TTreePlayer.cxx:1417
 TTreePlayer.cxx:1418
 TTreePlayer.cxx:1419
 TTreePlayer.cxx:1420
 TTreePlayer.cxx:1421
 TTreePlayer.cxx:1422
 TTreePlayer.cxx:1423
 TTreePlayer.cxx:1424
 TTreePlayer.cxx:1425
 TTreePlayer.cxx:1426
 TTreePlayer.cxx:1427
 TTreePlayer.cxx:1428
 TTreePlayer.cxx:1429
 TTreePlayer.cxx:1430
 TTreePlayer.cxx:1431
 TTreePlayer.cxx:1432
 TTreePlayer.cxx:1433
 TTreePlayer.cxx:1434
 TTreePlayer.cxx:1435
 TTreePlayer.cxx:1436
 TTreePlayer.cxx:1437
 TTreePlayer.cxx:1438
 TTreePlayer.cxx:1439
 TTreePlayer.cxx:1440
 TTreePlayer.cxx:1441
 TTreePlayer.cxx:1442
 TTreePlayer.cxx:1443
 TTreePlayer.cxx:1444
 TTreePlayer.cxx:1445
 TTreePlayer.cxx:1446
 TTreePlayer.cxx:1447
 TTreePlayer.cxx:1448
 TTreePlayer.cxx:1449
 TTreePlayer.cxx:1450
 TTreePlayer.cxx:1451
 TTreePlayer.cxx:1452
 TTreePlayer.cxx:1453
 TTreePlayer.cxx:1454
 TTreePlayer.cxx:1455
 TTreePlayer.cxx:1456
 TTreePlayer.cxx:1457
 TTreePlayer.cxx:1458
 TTreePlayer.cxx:1459
 TTreePlayer.cxx:1460
 TTreePlayer.cxx:1461
 TTreePlayer.cxx:1462
 TTreePlayer.cxx:1463
 TTreePlayer.cxx:1464
 TTreePlayer.cxx:1465
 TTreePlayer.cxx:1466
 TTreePlayer.cxx:1467
 TTreePlayer.cxx:1468
 TTreePlayer.cxx:1469
 TTreePlayer.cxx:1470
 TTreePlayer.cxx:1471
 TTreePlayer.cxx:1472
 TTreePlayer.cxx:1473
 TTreePlayer.cxx:1474
 TTreePlayer.cxx:1475
 TTreePlayer.cxx:1476
 TTreePlayer.cxx:1477
 TTreePlayer.cxx:1478
 TTreePlayer.cxx:1479
 TTreePlayer.cxx:1480
 TTreePlayer.cxx:1481
 TTreePlayer.cxx:1482
 TTreePlayer.cxx:1483
 TTreePlayer.cxx:1484
 TTreePlayer.cxx:1485
 TTreePlayer.cxx:1486
 TTreePlayer.cxx:1487
 TTreePlayer.cxx:1488
 TTreePlayer.cxx:1489
 TTreePlayer.cxx:1490
 TTreePlayer.cxx:1491
 TTreePlayer.cxx:1492
 TTreePlayer.cxx:1493
 TTreePlayer.cxx:1494
 TTreePlayer.cxx:1495
 TTreePlayer.cxx:1496
 TTreePlayer.cxx:1497
 TTreePlayer.cxx:1498
 TTreePlayer.cxx:1499
 TTreePlayer.cxx:1500
 TTreePlayer.cxx:1501
 TTreePlayer.cxx:1502
 TTreePlayer.cxx:1503
 TTreePlayer.cxx:1504
 TTreePlayer.cxx:1505
 TTreePlayer.cxx:1506
 TTreePlayer.cxx:1507
 TTreePlayer.cxx:1508
 TTreePlayer.cxx:1509
 TTreePlayer.cxx:1510
 TTreePlayer.cxx:1511
 TTreePlayer.cxx:1512
 TTreePlayer.cxx:1513
 TTreePlayer.cxx:1514
 TTreePlayer.cxx:1515
 TTreePlayer.cxx:1516
 TTreePlayer.cxx:1517
 TTreePlayer.cxx:1518
 TTreePlayer.cxx:1519
 TTreePlayer.cxx:1520
 TTreePlayer.cxx:1521
 TTreePlayer.cxx:1522
 TTreePlayer.cxx:1523
 TTreePlayer.cxx:1524
 TTreePlayer.cxx:1525
 TTreePlayer.cxx:1526
 TTreePlayer.cxx:1527
 TTreePlayer.cxx:1528
 TTreePlayer.cxx:1529
 TTreePlayer.cxx:1530
 TTreePlayer.cxx:1531
 TTreePlayer.cxx:1532
 TTreePlayer.cxx:1533
 TTreePlayer.cxx:1534
 TTreePlayer.cxx:1535
 TTreePlayer.cxx:1536
 TTreePlayer.cxx:1537
 TTreePlayer.cxx:1538
 TTreePlayer.cxx:1539
 TTreePlayer.cxx:1540
 TTreePlayer.cxx:1541
 TTreePlayer.cxx:1542
 TTreePlayer.cxx:1543
 TTreePlayer.cxx:1544
 TTreePlayer.cxx:1545
 TTreePlayer.cxx:1546
 TTreePlayer.cxx:1547
 TTreePlayer.cxx:1548
 TTreePlayer.cxx:1549
 TTreePlayer.cxx:1550
 TTreePlayer.cxx:1551
 TTreePlayer.cxx:1552
 TTreePlayer.cxx:1553
 TTreePlayer.cxx:1554
 TTreePlayer.cxx:1555
 TTreePlayer.cxx:1556
 TTreePlayer.cxx:1557
 TTreePlayer.cxx:1558
 TTreePlayer.cxx:1559
 TTreePlayer.cxx:1560
 TTreePlayer.cxx:1561
 TTreePlayer.cxx:1562
 TTreePlayer.cxx:1563
 TTreePlayer.cxx:1564
 TTreePlayer.cxx:1565
 TTreePlayer.cxx:1566
 TTreePlayer.cxx:1567
 TTreePlayer.cxx:1568
 TTreePlayer.cxx:1569
 TTreePlayer.cxx:1570
 TTreePlayer.cxx:1571
 TTreePlayer.cxx:1572
 TTreePlayer.cxx:1573
 TTreePlayer.cxx:1574
 TTreePlayer.cxx:1575
 TTreePlayer.cxx:1576
 TTreePlayer.cxx:1577
 TTreePlayer.cxx:1578
 TTreePlayer.cxx:1579
 TTreePlayer.cxx:1580
 TTreePlayer.cxx:1581
 TTreePlayer.cxx:1582
 TTreePlayer.cxx:1583
 TTreePlayer.cxx:1584
 TTreePlayer.cxx:1585
 TTreePlayer.cxx:1586
 TTreePlayer.cxx:1587
 TTreePlayer.cxx:1588
 TTreePlayer.cxx:1589
 TTreePlayer.cxx:1590
 TTreePlayer.cxx:1591
 TTreePlayer.cxx:1592
 TTreePlayer.cxx:1593
 TTreePlayer.cxx:1594
 TTreePlayer.cxx:1595
 TTreePlayer.cxx:1596
 TTreePlayer.cxx:1597
 TTreePlayer.cxx:1598
 TTreePlayer.cxx:1599
 TTreePlayer.cxx:1600
 TTreePlayer.cxx:1601
 TTreePlayer.cxx:1602
 TTreePlayer.cxx:1603
 TTreePlayer.cxx:1604
 TTreePlayer.cxx:1605
 TTreePlayer.cxx:1606
 TTreePlayer.cxx:1607
 TTreePlayer.cxx:1608
 TTreePlayer.cxx:1609
 TTreePlayer.cxx:1610
 TTreePlayer.cxx:1611
 TTreePlayer.cxx:1612
 TTreePlayer.cxx:1613
 TTreePlayer.cxx:1614
 TTreePlayer.cxx:1615
 TTreePlayer.cxx:1616
 TTreePlayer.cxx:1617
 TTreePlayer.cxx:1618
 TTreePlayer.cxx:1619
 TTreePlayer.cxx:1620
 TTreePlayer.cxx:1621
 TTreePlayer.cxx:1622
 TTreePlayer.cxx:1623
 TTreePlayer.cxx:1624
 TTreePlayer.cxx:1625
 TTreePlayer.cxx:1626
 TTreePlayer.cxx:1627
 TTreePlayer.cxx:1628
 TTreePlayer.cxx:1629
 TTreePlayer.cxx:1630
 TTreePlayer.cxx:1631
 TTreePlayer.cxx:1632
 TTreePlayer.cxx:1633
 TTreePlayer.cxx:1634
 TTreePlayer.cxx:1635
 TTreePlayer.cxx:1636
 TTreePlayer.cxx:1637
 TTreePlayer.cxx:1638
 TTreePlayer.cxx:1639
 TTreePlayer.cxx:1640
 TTreePlayer.cxx:1641
 TTreePlayer.cxx:1642
 TTreePlayer.cxx:1643
 TTreePlayer.cxx:1644
 TTreePlayer.cxx:1645
 TTreePlayer.cxx:1646
 TTreePlayer.cxx:1647
 TTreePlayer.cxx:1648
 TTreePlayer.cxx:1649
 TTreePlayer.cxx:1650
 TTreePlayer.cxx:1651
 TTreePlayer.cxx:1652
 TTreePlayer.cxx:1653
 TTreePlayer.cxx:1654
 TTreePlayer.cxx:1655
 TTreePlayer.cxx:1656
 TTreePlayer.cxx:1657
 TTreePlayer.cxx:1658
 TTreePlayer.cxx:1659
 TTreePlayer.cxx:1660
 TTreePlayer.cxx:1661
 TTreePlayer.cxx:1662
 TTreePlayer.cxx:1663
 TTreePlayer.cxx:1664
 TTreePlayer.cxx:1665
 TTreePlayer.cxx:1666
 TTreePlayer.cxx:1667
 TTreePlayer.cxx:1668
 TTreePlayer.cxx:1669
 TTreePlayer.cxx:1670
 TTreePlayer.cxx:1671
 TTreePlayer.cxx:1672
 TTreePlayer.cxx:1673
 TTreePlayer.cxx:1674
 TTreePlayer.cxx:1675
 TTreePlayer.cxx:1676
 TTreePlayer.cxx:1677
 TTreePlayer.cxx:1678
 TTreePlayer.cxx:1679
 TTreePlayer.cxx:1680
 TTreePlayer.cxx:1681
 TTreePlayer.cxx:1682
 TTreePlayer.cxx:1683
 TTreePlayer.cxx:1684
 TTreePlayer.cxx:1685
 TTreePlayer.cxx:1686
 TTreePlayer.cxx:1687
 TTreePlayer.cxx:1688
 TTreePlayer.cxx:1689
 TTreePlayer.cxx:1690
 TTreePlayer.cxx:1691
 TTreePlayer.cxx:1692
 TTreePlayer.cxx:1693
 TTreePlayer.cxx:1694
 TTreePlayer.cxx:1695
 TTreePlayer.cxx:1696
 TTreePlayer.cxx:1697
 TTreePlayer.cxx:1698
 TTreePlayer.cxx:1699
 TTreePlayer.cxx:1700
 TTreePlayer.cxx:1701
 TTreePlayer.cxx:1702
 TTreePlayer.cxx:1703
 TTreePlayer.cxx:1704
 TTreePlayer.cxx:1705
 TTreePlayer.cxx:1706
 TTreePlayer.cxx:1707
 TTreePlayer.cxx:1708
 TTreePlayer.cxx:1709
 TTreePlayer.cxx:1710
 TTreePlayer.cxx:1711
 TTreePlayer.cxx:1712
 TTreePlayer.cxx:1713
 TTreePlayer.cxx:1714
 TTreePlayer.cxx:1715
 TTreePlayer.cxx:1716
 TTreePlayer.cxx:1717
 TTreePlayer.cxx:1718
 TTreePlayer.cxx:1719
 TTreePlayer.cxx:1720
 TTreePlayer.cxx:1721
 TTreePlayer.cxx:1722
 TTreePlayer.cxx:1723
 TTreePlayer.cxx:1724
 TTreePlayer.cxx:1725
 TTreePlayer.cxx:1726
 TTreePlayer.cxx:1727
 TTreePlayer.cxx:1728
 TTreePlayer.cxx:1729
 TTreePlayer.cxx:1730
 TTreePlayer.cxx:1731
 TTreePlayer.cxx:1732
 TTreePlayer.cxx:1733
 TTreePlayer.cxx:1734
 TTreePlayer.cxx:1735
 TTreePlayer.cxx:1736
 TTreePlayer.cxx:1737
 TTreePlayer.cxx:1738
 TTreePlayer.cxx:1739
 TTreePlayer.cxx:1740
 TTreePlayer.cxx:1741
 TTreePlayer.cxx:1742
 TTreePlayer.cxx:1743
 TTreePlayer.cxx:1744
 TTreePlayer.cxx:1745
 TTreePlayer.cxx:1746
 TTreePlayer.cxx:1747
 TTreePlayer.cxx:1748
 TTreePlayer.cxx:1749
 TTreePlayer.cxx:1750
 TTreePlayer.cxx:1751
 TTreePlayer.cxx:1752
 TTreePlayer.cxx:1753
 TTreePlayer.cxx:1754
 TTreePlayer.cxx:1755
 TTreePlayer.cxx:1756
 TTreePlayer.cxx:1757
 TTreePlayer.cxx:1758
 TTreePlayer.cxx:1759
 TTreePlayer.cxx:1760
 TTreePlayer.cxx:1761
 TTreePlayer.cxx:1762
 TTreePlayer.cxx:1763
 TTreePlayer.cxx:1764
 TTreePlayer.cxx:1765
 TTreePlayer.cxx:1766
 TTreePlayer.cxx:1767
 TTreePlayer.cxx:1768
 TTreePlayer.cxx:1769
 TTreePlayer.cxx:1770
 TTreePlayer.cxx:1771
 TTreePlayer.cxx:1772
 TTreePlayer.cxx:1773
 TTreePlayer.cxx:1774
 TTreePlayer.cxx:1775
 TTreePlayer.cxx:1776
 TTreePlayer.cxx:1777
 TTreePlayer.cxx:1778
 TTreePlayer.cxx:1779
 TTreePlayer.cxx:1780
 TTreePlayer.cxx:1781
 TTreePlayer.cxx:1782
 TTreePlayer.cxx:1783
 TTreePlayer.cxx:1784
 TTreePlayer.cxx:1785
 TTreePlayer.cxx:1786
 TTreePlayer.cxx:1787
 TTreePlayer.cxx:1788
 TTreePlayer.cxx:1789
 TTreePlayer.cxx:1790
 TTreePlayer.cxx:1791
 TTreePlayer.cxx:1792
 TTreePlayer.cxx:1793
 TTreePlayer.cxx:1794
 TTreePlayer.cxx:1795
 TTreePlayer.cxx:1796
 TTreePlayer.cxx:1797
 TTreePlayer.cxx:1798
 TTreePlayer.cxx:1799
 TTreePlayer.cxx:1800
 TTreePlayer.cxx:1801
 TTreePlayer.cxx:1802
 TTreePlayer.cxx:1803
 TTreePlayer.cxx:1804
 TTreePlayer.cxx:1805
 TTreePlayer.cxx:1806
 TTreePlayer.cxx:1807
 TTreePlayer.cxx:1808
 TTreePlayer.cxx:1809
 TTreePlayer.cxx:1810
 TTreePlayer.cxx:1811
 TTreePlayer.cxx:1812
 TTreePlayer.cxx:1813
 TTreePlayer.cxx:1814
 TTreePlayer.cxx:1815
 TTreePlayer.cxx:1816
 TTreePlayer.cxx:1817
 TTreePlayer.cxx:1818
 TTreePlayer.cxx:1819
 TTreePlayer.cxx:1820
 TTreePlayer.cxx:1821
 TTreePlayer.cxx:1822
 TTreePlayer.cxx:1823
 TTreePlayer.cxx:1824
 TTreePlayer.cxx:1825
 TTreePlayer.cxx:1826
 TTreePlayer.cxx:1827
 TTreePlayer.cxx:1828
 TTreePlayer.cxx:1829
 TTreePlayer.cxx:1830
 TTreePlayer.cxx:1831
 TTreePlayer.cxx:1832
 TTreePlayer.cxx:1833
 TTreePlayer.cxx:1834
 TTreePlayer.cxx:1835
 TTreePlayer.cxx:1836
 TTreePlayer.cxx:1837
 TTreePlayer.cxx:1838
 TTreePlayer.cxx:1839
 TTreePlayer.cxx:1840
 TTreePlayer.cxx:1841
 TTreePlayer.cxx:1842
 TTreePlayer.cxx:1843
 TTreePlayer.cxx:1844
 TTreePlayer.cxx:1845
 TTreePlayer.cxx:1846
 TTreePlayer.cxx:1847
 TTreePlayer.cxx:1848
 TTreePlayer.cxx:1849
 TTreePlayer.cxx:1850
 TTreePlayer.cxx:1851
 TTreePlayer.cxx:1852
 TTreePlayer.cxx:1853
 TTreePlayer.cxx:1854
 TTreePlayer.cxx:1855
 TTreePlayer.cxx:1856
 TTreePlayer.cxx:1857
 TTreePlayer.cxx:1858
 TTreePlayer.cxx:1859
 TTreePlayer.cxx:1860
 TTreePlayer.cxx:1861
 TTreePlayer.cxx:1862
 TTreePlayer.cxx:1863
 TTreePlayer.cxx:1864
 TTreePlayer.cxx:1865
 TTreePlayer.cxx:1866
 TTreePlayer.cxx:1867
 TTreePlayer.cxx:1868
 TTreePlayer.cxx:1869
 TTreePlayer.cxx:1870
 TTreePlayer.cxx:1871
 TTreePlayer.cxx:1872
 TTreePlayer.cxx:1873
 TTreePlayer.cxx:1874
 TTreePlayer.cxx:1875
 TTreePlayer.cxx:1876
 TTreePlayer.cxx:1877
 TTreePlayer.cxx:1878
 TTreePlayer.cxx:1879
 TTreePlayer.cxx:1880
 TTreePlayer.cxx:1881
 TTreePlayer.cxx:1882
 TTreePlayer.cxx:1883
 TTreePlayer.cxx:1884
 TTreePlayer.cxx:1885
 TTreePlayer.cxx:1886
 TTreePlayer.cxx:1887
 TTreePlayer.cxx:1888
 TTreePlayer.cxx:1889
 TTreePlayer.cxx:1890
 TTreePlayer.cxx:1891
 TTreePlayer.cxx:1892
 TTreePlayer.cxx:1893
 TTreePlayer.cxx:1894
 TTreePlayer.cxx:1895
 TTreePlayer.cxx:1896
 TTreePlayer.cxx:1897
 TTreePlayer.cxx:1898
 TTreePlayer.cxx:1899
 TTreePlayer.cxx:1900
 TTreePlayer.cxx:1901
 TTreePlayer.cxx:1902
 TTreePlayer.cxx:1903
 TTreePlayer.cxx:1904
 TTreePlayer.cxx:1905
 TTreePlayer.cxx:1906
 TTreePlayer.cxx:1907
 TTreePlayer.cxx:1908
 TTreePlayer.cxx:1909
 TTreePlayer.cxx:1910
 TTreePlayer.cxx:1911
 TTreePlayer.cxx:1912
 TTreePlayer.cxx:1913
 TTreePlayer.cxx:1914
 TTreePlayer.cxx:1915
 TTreePlayer.cxx:1916
 TTreePlayer.cxx:1917
 TTreePlayer.cxx:1918
 TTreePlayer.cxx:1919
 TTreePlayer.cxx:1920
 TTreePlayer.cxx:1921
 TTreePlayer.cxx:1922
 TTreePlayer.cxx:1923
 TTreePlayer.cxx:1924
 TTreePlayer.cxx:1925
 TTreePlayer.cxx:1926
 TTreePlayer.cxx:1927
 TTreePlayer.cxx:1928
 TTreePlayer.cxx:1929
 TTreePlayer.cxx:1930
 TTreePlayer.cxx:1931
 TTreePlayer.cxx:1932
 TTreePlayer.cxx:1933
 TTreePlayer.cxx:1934
 TTreePlayer.cxx:1935
 TTreePlayer.cxx:1936
 TTreePlayer.cxx:1937
 TTreePlayer.cxx:1938
 TTreePlayer.cxx:1939
 TTreePlayer.cxx:1940
 TTreePlayer.cxx:1941
 TTreePlayer.cxx:1942
 TTreePlayer.cxx:1943
 TTreePlayer.cxx:1944
 TTreePlayer.cxx:1945
 TTreePlayer.cxx:1946
 TTreePlayer.cxx:1947
 TTreePlayer.cxx:1948
 TTreePlayer.cxx:1949
 TTreePlayer.cxx:1950
 TTreePlayer.cxx:1951
 TTreePlayer.cxx:1952
 TTreePlayer.cxx:1953
 TTreePlayer.cxx:1954
 TTreePlayer.cxx:1955
 TTreePlayer.cxx:1956
 TTreePlayer.cxx:1957
 TTreePlayer.cxx:1958
 TTreePlayer.cxx:1959
 TTreePlayer.cxx:1960
 TTreePlayer.cxx:1961
 TTreePlayer.cxx:1962
 TTreePlayer.cxx:1963
 TTreePlayer.cxx:1964
 TTreePlayer.cxx:1965
 TTreePlayer.cxx:1966
 TTreePlayer.cxx:1967
 TTreePlayer.cxx:1968
 TTreePlayer.cxx:1969
 TTreePlayer.cxx:1970
 TTreePlayer.cxx:1971
 TTreePlayer.cxx:1972
 TTreePlayer.cxx:1973
 TTreePlayer.cxx:1974
 TTreePlayer.cxx:1975
 TTreePlayer.cxx:1976
 TTreePlayer.cxx:1977
 TTreePlayer.cxx:1978
 TTreePlayer.cxx:1979
 TTreePlayer.cxx:1980
 TTreePlayer.cxx:1981
 TTreePlayer.cxx:1982
 TTreePlayer.cxx:1983
 TTreePlayer.cxx:1984
 TTreePlayer.cxx:1985
 TTreePlayer.cxx:1986
 TTreePlayer.cxx:1987
 TTreePlayer.cxx:1988
 TTreePlayer.cxx:1989
 TTreePlayer.cxx:1990
 TTreePlayer.cxx:1991
 TTreePlayer.cxx:1992
 TTreePlayer.cxx:1993
 TTreePlayer.cxx:1994
 TTreePlayer.cxx:1995
 TTreePlayer.cxx:1996
 TTreePlayer.cxx:1997
 TTreePlayer.cxx:1998
 TTreePlayer.cxx:1999
 TTreePlayer.cxx:2000
 TTreePlayer.cxx:2001
 TTreePlayer.cxx:2002
 TTreePlayer.cxx:2003
 TTreePlayer.cxx:2004
 TTreePlayer.cxx:2005
 TTreePlayer.cxx:2006
 TTreePlayer.cxx:2007
 TTreePlayer.cxx:2008
 TTreePlayer.cxx:2009
 TTreePlayer.cxx:2010
 TTreePlayer.cxx:2011
 TTreePlayer.cxx:2012
 TTreePlayer.cxx:2013
 TTreePlayer.cxx:2014
 TTreePlayer.cxx:2015
 TTreePlayer.cxx:2016
 TTreePlayer.cxx:2017
 TTreePlayer.cxx:2018
 TTreePlayer.cxx:2019
 TTreePlayer.cxx:2020
 TTreePlayer.cxx:2021
 TTreePlayer.cxx:2022
 TTreePlayer.cxx:2023
 TTreePlayer.cxx:2024
 TTreePlayer.cxx:2025
 TTreePlayer.cxx:2026
 TTreePlayer.cxx:2027
 TTreePlayer.cxx:2028
 TTreePlayer.cxx:2029
 TTreePlayer.cxx:2030
 TTreePlayer.cxx:2031
 TTreePlayer.cxx:2032
 TTreePlayer.cxx:2033
 TTreePlayer.cxx:2034
 TTreePlayer.cxx:2035
 TTreePlayer.cxx:2036
 TTreePlayer.cxx:2037
 TTreePlayer.cxx:2038
 TTreePlayer.cxx:2039
 TTreePlayer.cxx:2040
 TTreePlayer.cxx:2041
 TTreePlayer.cxx:2042
 TTreePlayer.cxx:2043
 TTreePlayer.cxx:2044
 TTreePlayer.cxx:2045
 TTreePlayer.cxx:2046
 TTreePlayer.cxx:2047
 TTreePlayer.cxx:2048
 TTreePlayer.cxx:2049
 TTreePlayer.cxx:2050
 TTreePlayer.cxx:2051
 TTreePlayer.cxx:2052
 TTreePlayer.cxx:2053
 TTreePlayer.cxx:2054
 TTreePlayer.cxx:2055
 TTreePlayer.cxx:2056
 TTreePlayer.cxx:2057
 TTreePlayer.cxx:2058
 TTreePlayer.cxx:2059
 TTreePlayer.cxx:2060
 TTreePlayer.cxx:2061
 TTreePlayer.cxx:2062
 TTreePlayer.cxx:2063
 TTreePlayer.cxx:2064
 TTreePlayer.cxx:2065
 TTreePlayer.cxx:2066
 TTreePlayer.cxx:2067
 TTreePlayer.cxx:2068
 TTreePlayer.cxx:2069
 TTreePlayer.cxx:2070
 TTreePlayer.cxx:2071
 TTreePlayer.cxx:2072
 TTreePlayer.cxx:2073
 TTreePlayer.cxx:2074
 TTreePlayer.cxx:2075
 TTreePlayer.cxx:2076
 TTreePlayer.cxx:2077
 TTreePlayer.cxx:2078
 TTreePlayer.cxx:2079
 TTreePlayer.cxx:2080
 TTreePlayer.cxx:2081
 TTreePlayer.cxx:2082
 TTreePlayer.cxx:2083
 TTreePlayer.cxx:2084
 TTreePlayer.cxx:2085
 TTreePlayer.cxx:2086
 TTreePlayer.cxx:2087
 TTreePlayer.cxx:2088
 TTreePlayer.cxx:2089
 TTreePlayer.cxx:2090
 TTreePlayer.cxx:2091
 TTreePlayer.cxx:2092
 TTreePlayer.cxx:2093
 TTreePlayer.cxx:2094
 TTreePlayer.cxx:2095
 TTreePlayer.cxx:2096
 TTreePlayer.cxx:2097
 TTreePlayer.cxx:2098
 TTreePlayer.cxx:2099
 TTreePlayer.cxx:2100
 TTreePlayer.cxx:2101
 TTreePlayer.cxx:2102
 TTreePlayer.cxx:2103
 TTreePlayer.cxx:2104
 TTreePlayer.cxx:2105
 TTreePlayer.cxx:2106
 TTreePlayer.cxx:2107
 TTreePlayer.cxx:2108
 TTreePlayer.cxx:2109
 TTreePlayer.cxx:2110
 TTreePlayer.cxx:2111
 TTreePlayer.cxx:2112
 TTreePlayer.cxx:2113
 TTreePlayer.cxx:2114
 TTreePlayer.cxx:2115
 TTreePlayer.cxx:2116
 TTreePlayer.cxx:2117
 TTreePlayer.cxx:2118
 TTreePlayer.cxx:2119
 TTreePlayer.cxx:2120
 TTreePlayer.cxx:2121
 TTreePlayer.cxx:2122
 TTreePlayer.cxx:2123
 TTreePlayer.cxx:2124
 TTreePlayer.cxx:2125
 TTreePlayer.cxx:2126
 TTreePlayer.cxx:2127
 TTreePlayer.cxx:2128
 TTreePlayer.cxx:2129
 TTreePlayer.cxx:2130
 TTreePlayer.cxx:2131
 TTreePlayer.cxx:2132
 TTreePlayer.cxx:2133
 TTreePlayer.cxx:2134
 TTreePlayer.cxx:2135
 TTreePlayer.cxx:2136
 TTreePlayer.cxx:2137
 TTreePlayer.cxx:2138
 TTreePlayer.cxx:2139
 TTreePlayer.cxx:2140
 TTreePlayer.cxx:2141
 TTreePlayer.cxx:2142
 TTreePlayer.cxx:2143
 TTreePlayer.cxx:2144
 TTreePlayer.cxx:2145
 TTreePlayer.cxx:2146
 TTreePlayer.cxx:2147
 TTreePlayer.cxx:2148
 TTreePlayer.cxx:2149
 TTreePlayer.cxx:2150
 TTreePlayer.cxx:2151
 TTreePlayer.cxx:2152
 TTreePlayer.cxx:2153
 TTreePlayer.cxx:2154
 TTreePlayer.cxx:2155
 TTreePlayer.cxx:2156
 TTreePlayer.cxx:2157
 TTreePlayer.cxx:2158
 TTreePlayer.cxx:2159
 TTreePlayer.cxx:2160
 TTreePlayer.cxx:2161
 TTreePlayer.cxx:2162
 TTreePlayer.cxx:2163
 TTreePlayer.cxx:2164
 TTreePlayer.cxx:2165
 TTreePlayer.cxx:2166
 TTreePlayer.cxx:2167
 TTreePlayer.cxx:2168
 TTreePlayer.cxx:2169
 TTreePlayer.cxx:2170
 TTreePlayer.cxx:2171
 TTreePlayer.cxx:2172
 TTreePlayer.cxx:2173
 TTreePlayer.cxx:2174
 TTreePlayer.cxx:2175
 TTreePlayer.cxx:2176
 TTreePlayer.cxx:2177
 TTreePlayer.cxx:2178
 TTreePlayer.cxx:2179
 TTreePlayer.cxx:2180
 TTreePlayer.cxx:2181
 TTreePlayer.cxx:2182
 TTreePlayer.cxx:2183
 TTreePlayer.cxx:2184
 TTreePlayer.cxx:2185
 TTreePlayer.cxx:2186
 TTreePlayer.cxx:2187
 TTreePlayer.cxx:2188
 TTreePlayer.cxx:2189
 TTreePlayer.cxx:2190
 TTreePlayer.cxx:2191
 TTreePlayer.cxx:2192
 TTreePlayer.cxx:2193
 TTreePlayer.cxx:2194
 TTreePlayer.cxx:2195
 TTreePlayer.cxx:2196
 TTreePlayer.cxx:2197
 TTreePlayer.cxx:2198
 TTreePlayer.cxx:2199
 TTreePlayer.cxx:2200
 TTreePlayer.cxx:2201
 TTreePlayer.cxx:2202
 TTreePlayer.cxx:2203
 TTreePlayer.cxx:2204
 TTreePlayer.cxx:2205
 TTreePlayer.cxx:2206
 TTreePlayer.cxx:2207
 TTreePlayer.cxx:2208
 TTreePlayer.cxx:2209
 TTreePlayer.cxx:2210
 TTreePlayer.cxx:2211
 TTreePlayer.cxx:2212
 TTreePlayer.cxx:2213
 TTreePlayer.cxx:2214
 TTreePlayer.cxx:2215
 TTreePlayer.cxx:2216
 TTreePlayer.cxx:2217
 TTreePlayer.cxx:2218
 TTreePlayer.cxx:2219
 TTreePlayer.cxx:2220
 TTreePlayer.cxx:2221
 TTreePlayer.cxx:2222
 TTreePlayer.cxx:2223
 TTreePlayer.cxx:2224
 TTreePlayer.cxx:2225
 TTreePlayer.cxx:2226
 TTreePlayer.cxx:2227
 TTreePlayer.cxx:2228
 TTreePlayer.cxx:2229
 TTreePlayer.cxx:2230
 TTreePlayer.cxx:2231
 TTreePlayer.cxx:2232
 TTreePlayer.cxx:2233
 TTreePlayer.cxx:2234
 TTreePlayer.cxx:2235
 TTreePlayer.cxx:2236
 TTreePlayer.cxx:2237
 TTreePlayer.cxx:2238
 TTreePlayer.cxx:2239
 TTreePlayer.cxx:2240
 TTreePlayer.cxx:2241
 TTreePlayer.cxx:2242
 TTreePlayer.cxx:2243
 TTreePlayer.cxx:2244
 TTreePlayer.cxx:2245
 TTreePlayer.cxx:2246
 TTreePlayer.cxx:2247
 TTreePlayer.cxx:2248
 TTreePlayer.cxx:2249
 TTreePlayer.cxx:2250
 TTreePlayer.cxx:2251
 TTreePlayer.cxx:2252
 TTreePlayer.cxx:2253
 TTreePlayer.cxx:2254
 TTreePlayer.cxx:2255
 TTreePlayer.cxx:2256
 TTreePlayer.cxx:2257
 TTreePlayer.cxx:2258
 TTreePlayer.cxx:2259
 TTreePlayer.cxx:2260
 TTreePlayer.cxx:2261
 TTreePlayer.cxx:2262
 TTreePlayer.cxx:2263
 TTreePlayer.cxx:2264
 TTreePlayer.cxx:2265
 TTreePlayer.cxx:2266
 TTreePlayer.cxx:2267
 TTreePlayer.cxx:2268
 TTreePlayer.cxx:2269
 TTreePlayer.cxx:2270
 TTreePlayer.cxx:2271
 TTreePlayer.cxx:2272
 TTreePlayer.cxx:2273
 TTreePlayer.cxx:2274
 TTreePlayer.cxx:2275
 TTreePlayer.cxx:2276
 TTreePlayer.cxx:2277
 TTreePlayer.cxx:2278
 TTreePlayer.cxx:2279
 TTreePlayer.cxx:2280
 TTreePlayer.cxx:2281
 TTreePlayer.cxx:2282
 TTreePlayer.cxx:2283
 TTreePlayer.cxx:2284
 TTreePlayer.cxx:2285
 TTreePlayer.cxx:2286
 TTreePlayer.cxx:2287
 TTreePlayer.cxx:2288
 TTreePlayer.cxx:2289
 TTreePlayer.cxx:2290
 TTreePlayer.cxx:2291
 TTreePlayer.cxx:2292
 TTreePlayer.cxx:2293
 TTreePlayer.cxx:2294
 TTreePlayer.cxx:2295
 TTreePlayer.cxx:2296
 TTreePlayer.cxx:2297
 TTreePlayer.cxx:2298
 TTreePlayer.cxx:2299
 TTreePlayer.cxx:2300
 TTreePlayer.cxx:2301
 TTreePlayer.cxx:2302
 TTreePlayer.cxx:2303
 TTreePlayer.cxx:2304
 TTreePlayer.cxx:2305
 TTreePlayer.cxx:2306
 TTreePlayer.cxx:2307
 TTreePlayer.cxx:2308
 TTreePlayer.cxx:2309
 TTreePlayer.cxx:2310
 TTreePlayer.cxx:2311
 TTreePlayer.cxx:2312
 TTreePlayer.cxx:2313
 TTreePlayer.cxx:2314
 TTreePlayer.cxx:2315
 TTreePlayer.cxx:2316
 TTreePlayer.cxx:2317
 TTreePlayer.cxx:2318
 TTreePlayer.cxx:2319
 TTreePlayer.cxx:2320
 TTreePlayer.cxx:2321
 TTreePlayer.cxx:2322
 TTreePlayer.cxx:2323
 TTreePlayer.cxx:2324
 TTreePlayer.cxx:2325
 TTreePlayer.cxx:2326
 TTreePlayer.cxx:2327
 TTreePlayer.cxx:2328
 TTreePlayer.cxx:2329
 TTreePlayer.cxx:2330
 TTreePlayer.cxx:2331
 TTreePlayer.cxx:2332
 TTreePlayer.cxx:2333
 TTreePlayer.cxx:2334
 TTreePlayer.cxx:2335
 TTreePlayer.cxx:2336
 TTreePlayer.cxx:2337
 TTreePlayer.cxx:2338
 TTreePlayer.cxx:2339
 TTreePlayer.cxx:2340
 TTreePlayer.cxx:2341
 TTreePlayer.cxx:2342
 TTreePlayer.cxx:2343
 TTreePlayer.cxx:2344
 TTreePlayer.cxx:2345
 TTreePlayer.cxx:2346
 TTreePlayer.cxx:2347
 TTreePlayer.cxx:2348
 TTreePlayer.cxx:2349
 TTreePlayer.cxx:2350
 TTreePlayer.cxx:2351
 TTreePlayer.cxx:2352
 TTreePlayer.cxx:2353
 TTreePlayer.cxx:2354
 TTreePlayer.cxx:2355
 TTreePlayer.cxx:2356
 TTreePlayer.cxx:2357
 TTreePlayer.cxx:2358
 TTreePlayer.cxx:2359
 TTreePlayer.cxx:2360
 TTreePlayer.cxx:2361
 TTreePlayer.cxx:2362
 TTreePlayer.cxx:2363
 TTreePlayer.cxx:2364
 TTreePlayer.cxx:2365
 TTreePlayer.cxx:2366
 TTreePlayer.cxx:2367
 TTreePlayer.cxx:2368
 TTreePlayer.cxx:2369
 TTreePlayer.cxx:2370
 TTreePlayer.cxx:2371
 TTreePlayer.cxx:2372
 TTreePlayer.cxx:2373
 TTreePlayer.cxx:2374
 TTreePlayer.cxx:2375
 TTreePlayer.cxx:2376
 TTreePlayer.cxx:2377
 TTreePlayer.cxx:2378
 TTreePlayer.cxx:2379
 TTreePlayer.cxx:2380
 TTreePlayer.cxx:2381
 TTreePlayer.cxx:2382
 TTreePlayer.cxx:2383
 TTreePlayer.cxx:2384
 TTreePlayer.cxx:2385
 TTreePlayer.cxx:2386
 TTreePlayer.cxx:2387
 TTreePlayer.cxx:2388
 TTreePlayer.cxx:2389
 TTreePlayer.cxx:2390
 TTreePlayer.cxx:2391
 TTreePlayer.cxx:2392
 TTreePlayer.cxx:2393
 TTreePlayer.cxx:2394
 TTreePlayer.cxx:2395
 TTreePlayer.cxx:2396
 TTreePlayer.cxx:2397
 TTreePlayer.cxx:2398
 TTreePlayer.cxx:2399
 TTreePlayer.cxx:2400
 TTreePlayer.cxx:2401
 TTreePlayer.cxx:2402
 TTreePlayer.cxx:2403
 TTreePlayer.cxx:2404
 TTreePlayer.cxx:2405
 TTreePlayer.cxx:2406
 TTreePlayer.cxx:2407
 TTreePlayer.cxx:2408
 TTreePlayer.cxx:2409
 TTreePlayer.cxx:2410
 TTreePlayer.cxx:2411
 TTreePlayer.cxx:2412
 TTreePlayer.cxx:2413
 TTreePlayer.cxx:2414
 TTreePlayer.cxx:2415
 TTreePlayer.cxx:2416
 TTreePlayer.cxx:2417
 TTreePlayer.cxx:2418
 TTreePlayer.cxx:2419
 TTreePlayer.cxx:2420
 TTreePlayer.cxx:2421
 TTreePlayer.cxx:2422
 TTreePlayer.cxx:2423
 TTreePlayer.cxx:2424
 TTreePlayer.cxx:2425
 TTreePlayer.cxx:2426
 TTreePlayer.cxx:2427
 TTreePlayer.cxx:2428
 TTreePlayer.cxx:2429
 TTreePlayer.cxx:2430
 TTreePlayer.cxx:2431
 TTreePlayer.cxx:2432
 TTreePlayer.cxx:2433
 TTreePlayer.cxx:2434
 TTreePlayer.cxx:2435
 TTreePlayer.cxx:2436
 TTreePlayer.cxx:2437
 TTreePlayer.cxx:2438
 TTreePlayer.cxx:2439
 TTreePlayer.cxx:2440
 TTreePlayer.cxx:2441
 TTreePlayer.cxx:2442
 TTreePlayer.cxx:2443
 TTreePlayer.cxx:2444
 TTreePlayer.cxx:2445
 TTreePlayer.cxx:2446
 TTreePlayer.cxx:2447
 TTreePlayer.cxx:2448
 TTreePlayer.cxx:2449
 TTreePlayer.cxx:2450
 TTreePlayer.cxx:2451
 TTreePlayer.cxx:2452
 TTreePlayer.cxx:2453
 TTreePlayer.cxx:2454
 TTreePlayer.cxx:2455
 TTreePlayer.cxx:2456
 TTreePlayer.cxx:2457
 TTreePlayer.cxx:2458
 TTreePlayer.cxx:2459
 TTreePlayer.cxx:2460
 TTreePlayer.cxx:2461
 TTreePlayer.cxx:2462
 TTreePlayer.cxx:2463
 TTreePlayer.cxx:2464
 TTreePlayer.cxx:2465
 TTreePlayer.cxx:2466
 TTreePlayer.cxx:2467
 TTreePlayer.cxx:2468
 TTreePlayer.cxx:2469
 TTreePlayer.cxx:2470
 TTreePlayer.cxx:2471
 TTreePlayer.cxx:2472
 TTreePlayer.cxx:2473
 TTreePlayer.cxx:2474
 TTreePlayer.cxx:2475
 TTreePlayer.cxx:2476
 TTreePlayer.cxx:2477
 TTreePlayer.cxx:2478
 TTreePlayer.cxx:2479
 TTreePlayer.cxx:2480
 TTreePlayer.cxx:2481
 TTreePlayer.cxx:2482
 TTreePlayer.cxx:2483
 TTreePlayer.cxx:2484
 TTreePlayer.cxx:2485
 TTreePlayer.cxx:2486
 TTreePlayer.cxx:2487
 TTreePlayer.cxx:2488
 TTreePlayer.cxx:2489
 TTreePlayer.cxx:2490
 TTreePlayer.cxx:2491
 TTreePlayer.cxx:2492
 TTreePlayer.cxx:2493
 TTreePlayer.cxx:2494
 TTreePlayer.cxx:2495
 TTreePlayer.cxx:2496
 TTreePlayer.cxx:2497
 TTreePlayer.cxx:2498
 TTreePlayer.cxx:2499
 TTreePlayer.cxx:2500
 TTreePlayer.cxx:2501
 TTreePlayer.cxx:2502
 TTreePlayer.cxx:2503
 TTreePlayer.cxx:2504
 TTreePlayer.cxx:2505
 TTreePlayer.cxx:2506
 TTreePlayer.cxx:2507
 TTreePlayer.cxx:2508
 TTreePlayer.cxx:2509
 TTreePlayer.cxx:2510
 TTreePlayer.cxx:2511
 TTreePlayer.cxx:2512
 TTreePlayer.cxx:2513
 TTreePlayer.cxx:2514
 TTreePlayer.cxx:2515
 TTreePlayer.cxx:2516
 TTreePlayer.cxx:2517
 TTreePlayer.cxx:2518
 TTreePlayer.cxx:2519
 TTreePlayer.cxx:2520
 TTreePlayer.cxx:2521
 TTreePlayer.cxx:2522
 TTreePlayer.cxx:2523
 TTreePlayer.cxx:2524
 TTreePlayer.cxx:2525
 TTreePlayer.cxx:2526
 TTreePlayer.cxx:2527
 TTreePlayer.cxx:2528
 TTreePlayer.cxx:2529
 TTreePlayer.cxx:2530
 TTreePlayer.cxx:2531
 TTreePlayer.cxx:2532
 TTreePlayer.cxx:2533
 TTreePlayer.cxx:2534
 TTreePlayer.cxx:2535
 TTreePlayer.cxx:2536
 TTreePlayer.cxx:2537
 TTreePlayer.cxx:2538
 TTreePlayer.cxx:2539
 TTreePlayer.cxx:2540
 TTreePlayer.cxx:2541
 TTreePlayer.cxx:2542
 TTreePlayer.cxx:2543
 TTreePlayer.cxx:2544
 TTreePlayer.cxx:2545
 TTreePlayer.cxx:2546
 TTreePlayer.cxx:2547
 TTreePlayer.cxx:2548
 TTreePlayer.cxx:2549
 TTreePlayer.cxx:2550
 TTreePlayer.cxx:2551
 TTreePlayer.cxx:2552
 TTreePlayer.cxx:2553
 TTreePlayer.cxx:2554
 TTreePlayer.cxx:2555
 TTreePlayer.cxx:2556
 TTreePlayer.cxx:2557
 TTreePlayer.cxx:2558
 TTreePlayer.cxx:2559
 TTreePlayer.cxx:2560
 TTreePlayer.cxx:2561
 TTreePlayer.cxx:2562
 TTreePlayer.cxx:2563
 TTreePlayer.cxx:2564
 TTreePlayer.cxx:2565
 TTreePlayer.cxx:2566
 TTreePlayer.cxx:2567
 TTreePlayer.cxx:2568
 TTreePlayer.cxx:2569
 TTreePlayer.cxx:2570
 TTreePlayer.cxx:2571
 TTreePlayer.cxx:2572
 TTreePlayer.cxx:2573
 TTreePlayer.cxx:2574
 TTreePlayer.cxx:2575
 TTreePlayer.cxx:2576
 TTreePlayer.cxx:2577
 TTreePlayer.cxx:2578
 TTreePlayer.cxx:2579
 TTreePlayer.cxx:2580
 TTreePlayer.cxx:2581
 TTreePlayer.cxx:2582
 TTreePlayer.cxx:2583
 TTreePlayer.cxx:2584
 TTreePlayer.cxx:2585
 TTreePlayer.cxx:2586
 TTreePlayer.cxx:2587
 TTreePlayer.cxx:2588
 TTreePlayer.cxx:2589
 TTreePlayer.cxx:2590
 TTreePlayer.cxx:2591
 TTreePlayer.cxx:2592
 TTreePlayer.cxx:2593
 TTreePlayer.cxx:2594
 TTreePlayer.cxx:2595
 TTreePlayer.cxx:2596
 TTreePlayer.cxx:2597
 TTreePlayer.cxx:2598
 TTreePlayer.cxx:2599
 TTreePlayer.cxx:2600
 TTreePlayer.cxx:2601
 TTreePlayer.cxx:2602
 TTreePlayer.cxx:2603
 TTreePlayer.cxx:2604
 TTreePlayer.cxx:2605
 TTreePlayer.cxx:2606
 TTreePlayer.cxx:2607
 TTreePlayer.cxx:2608
 TTreePlayer.cxx:2609
 TTreePlayer.cxx:2610
 TTreePlayer.cxx:2611
 TTreePlayer.cxx:2612
 TTreePlayer.cxx:2613
 TTreePlayer.cxx:2614
 TTreePlayer.cxx:2615
 TTreePlayer.cxx:2616
 TTreePlayer.cxx:2617
 TTreePlayer.cxx:2618
 TTreePlayer.cxx:2619
 TTreePlayer.cxx:2620
 TTreePlayer.cxx:2621
 TTreePlayer.cxx:2622
 TTreePlayer.cxx:2623
 TTreePlayer.cxx:2624
 TTreePlayer.cxx:2625
 TTreePlayer.cxx:2626
 TTreePlayer.cxx:2627
 TTreePlayer.cxx:2628
 TTreePlayer.cxx:2629
 TTreePlayer.cxx:2630
 TTreePlayer.cxx:2631
 TTreePlayer.cxx:2632
 TTreePlayer.cxx:2633
 TTreePlayer.cxx:2634
 TTreePlayer.cxx:2635
 TTreePlayer.cxx:2636
 TTreePlayer.cxx:2637
 TTreePlayer.cxx:2638
 TTreePlayer.cxx:2639
 TTreePlayer.cxx:2640
 TTreePlayer.cxx:2641
 TTreePlayer.cxx:2642
 TTreePlayer.cxx:2643
 TTreePlayer.cxx:2644
 TTreePlayer.cxx:2645
 TTreePlayer.cxx:2646
 TTreePlayer.cxx:2647
 TTreePlayer.cxx:2648
 TTreePlayer.cxx:2649
 TTreePlayer.cxx:2650
 TTreePlayer.cxx:2651
 TTreePlayer.cxx:2652
 TTreePlayer.cxx:2653
 TTreePlayer.cxx:2654
 TTreePlayer.cxx:2655
 TTreePlayer.cxx:2656
 TTreePlayer.cxx:2657
 TTreePlayer.cxx:2658
 TTreePlayer.cxx:2659
 TTreePlayer.cxx:2660
 TTreePlayer.cxx:2661
 TTreePlayer.cxx:2662
 TTreePlayer.cxx:2663
 TTreePlayer.cxx:2664
 TTreePlayer.cxx:2665
 TTreePlayer.cxx:2666
 TTreePlayer.cxx:2667
 TTreePlayer.cxx:2668
 TTreePlayer.cxx:2669
 TTreePlayer.cxx:2670
 TTreePlayer.cxx:2671
 TTreePlayer.cxx:2672
 TTreePlayer.cxx:2673
 TTreePlayer.cxx:2674
 TTreePlayer.cxx:2675
 TTreePlayer.cxx:2676
 TTreePlayer.cxx:2677
 TTreePlayer.cxx:2678
 TTreePlayer.cxx:2679
 TTreePlayer.cxx:2680
 TTreePlayer.cxx:2681
 TTreePlayer.cxx:2682
 TTreePlayer.cxx:2683
 TTreePlayer.cxx:2684
 TTreePlayer.cxx:2685
 TTreePlayer.cxx:2686
 TTreePlayer.cxx:2687
 TTreePlayer.cxx:2688
 TTreePlayer.cxx:2689
 TTreePlayer.cxx:2690
 TTreePlayer.cxx:2691
 TTreePlayer.cxx:2692
 TTreePlayer.cxx:2693
 TTreePlayer.cxx:2694
 TTreePlayer.cxx:2695
 TTreePlayer.cxx:2696
 TTreePlayer.cxx:2697
 TTreePlayer.cxx:2698
 TTreePlayer.cxx:2699
 TTreePlayer.cxx:2700
 TTreePlayer.cxx:2701
 TTreePlayer.cxx:2702
 TTreePlayer.cxx:2703
 TTreePlayer.cxx:2704
 TTreePlayer.cxx:2705
 TTreePlayer.cxx:2706
 TTreePlayer.cxx:2707
 TTreePlayer.cxx:2708
 TTreePlayer.cxx:2709
 TTreePlayer.cxx:2710
 TTreePlayer.cxx:2711
 TTreePlayer.cxx:2712
 TTreePlayer.cxx:2713
 TTreePlayer.cxx:2714
 TTreePlayer.cxx:2715
 TTreePlayer.cxx:2716
 TTreePlayer.cxx:2717
 TTreePlayer.cxx:2718
 TTreePlayer.cxx:2719
 TTreePlayer.cxx:2720
 TTreePlayer.cxx:2721
 TTreePlayer.cxx:2722
 TTreePlayer.cxx:2723
 TTreePlayer.cxx:2724
 TTreePlayer.cxx:2725
 TTreePlayer.cxx:2726
 TTreePlayer.cxx:2727
 TTreePlayer.cxx:2728
 TTreePlayer.cxx:2729
 TTreePlayer.cxx:2730
 TTreePlayer.cxx:2731
 TTreePlayer.cxx:2732
 TTreePlayer.cxx:2733
 TTreePlayer.cxx:2734
 TTreePlayer.cxx:2735
 TTreePlayer.cxx:2736
 TTreePlayer.cxx:2737
 TTreePlayer.cxx:2738
 TTreePlayer.cxx:2739
 TTreePlayer.cxx:2740
 TTreePlayer.cxx:2741
 TTreePlayer.cxx:2742
 TTreePlayer.cxx:2743
 TTreePlayer.cxx:2744
 TTreePlayer.cxx:2745
 TTreePlayer.cxx:2746
 TTreePlayer.cxx:2747
 TTreePlayer.cxx:2748
 TTreePlayer.cxx:2749
 TTreePlayer.cxx:2750
 TTreePlayer.cxx:2751
 TTreePlayer.cxx:2752
 TTreePlayer.cxx:2753
 TTreePlayer.cxx:2754
 TTreePlayer.cxx:2755
 TTreePlayer.cxx:2756
 TTreePlayer.cxx:2757
 TTreePlayer.cxx:2758
 TTreePlayer.cxx:2759
 TTreePlayer.cxx:2760
 TTreePlayer.cxx:2761
 TTreePlayer.cxx:2762
 TTreePlayer.cxx:2763
 TTreePlayer.cxx:2764
 TTreePlayer.cxx:2765
 TTreePlayer.cxx:2766
 TTreePlayer.cxx:2767
 TTreePlayer.cxx:2768
 TTreePlayer.cxx:2769
 TTreePlayer.cxx:2770
 TTreePlayer.cxx:2771
 TTreePlayer.cxx:2772
 TTreePlayer.cxx:2773
 TTreePlayer.cxx:2774
 TTreePlayer.cxx:2775
 TTreePlayer.cxx:2776
 TTreePlayer.cxx:2777
 TTreePlayer.cxx:2778
 TTreePlayer.cxx:2779
 TTreePlayer.cxx:2780
 TTreePlayer.cxx:2781
 TTreePlayer.cxx:2782
 TTreePlayer.cxx:2783
 TTreePlayer.cxx:2784
 TTreePlayer.cxx:2785
 TTreePlayer.cxx:2786
 TTreePlayer.cxx:2787
 TTreePlayer.cxx:2788
 TTreePlayer.cxx:2789
 TTreePlayer.cxx:2790
 TTreePlayer.cxx:2791
 TTreePlayer.cxx:2792
 TTreePlayer.cxx:2793
 TTreePlayer.cxx:2794
 TTreePlayer.cxx:2795
 TTreePlayer.cxx:2796
 TTreePlayer.cxx:2797
 TTreePlayer.cxx:2798
 TTreePlayer.cxx:2799
 TTreePlayer.cxx:2800
 TTreePlayer.cxx:2801
 TTreePlayer.cxx:2802
 TTreePlayer.cxx:2803
 TTreePlayer.cxx:2804
 TTreePlayer.cxx:2805
 TTreePlayer.cxx:2806
 TTreePlayer.cxx:2807
 TTreePlayer.cxx:2808
 TTreePlayer.cxx:2809
 TTreePlayer.cxx:2810
 TTreePlayer.cxx:2811
 TTreePlayer.cxx:2812
 TTreePlayer.cxx:2813
 TTreePlayer.cxx:2814
 TTreePlayer.cxx:2815
 TTreePlayer.cxx:2816
 TTreePlayer.cxx:2817
 TTreePlayer.cxx:2818
 TTreePlayer.cxx:2819
 TTreePlayer.cxx:2820
 TTreePlayer.cxx:2821
 TTreePlayer.cxx:2822
 TTreePlayer.cxx:2823
 TTreePlayer.cxx:2824
 TTreePlayer.cxx:2825
 TTreePlayer.cxx:2826
 TTreePlayer.cxx:2827
 TTreePlayer.cxx:2828
 TTreePlayer.cxx:2829
 TTreePlayer.cxx:2830
 TTreePlayer.cxx:2831
 TTreePlayer.cxx:2832
 TTreePlayer.cxx:2833
 TTreePlayer.cxx:2834
 TTreePlayer.cxx:2835
 TTreePlayer.cxx:2836
 TTreePlayer.cxx:2837
 TTreePlayer.cxx:2838
 TTreePlayer.cxx:2839
 TTreePlayer.cxx:2840
 TTreePlayer.cxx:2841
 TTreePlayer.cxx:2842
 TTreePlayer.cxx:2843
 TTreePlayer.cxx:2844
 TTreePlayer.cxx:2845
 TTreePlayer.cxx:2846
 TTreePlayer.cxx:2847
 TTreePlayer.cxx:2848
 TTreePlayer.cxx:2849
 TTreePlayer.cxx:2850
 TTreePlayer.cxx:2851
 TTreePlayer.cxx:2852
 TTreePlayer.cxx:2853
 TTreePlayer.cxx:2854
 TTreePlayer.cxx:2855
 TTreePlayer.cxx:2856
 TTreePlayer.cxx:2857
 TTreePlayer.cxx:2858
 TTreePlayer.cxx:2859
 TTreePlayer.cxx:2860
 TTreePlayer.cxx:2861
 TTreePlayer.cxx:2862
 TTreePlayer.cxx:2863
 TTreePlayer.cxx:2864
 TTreePlayer.cxx:2865
 TTreePlayer.cxx:2866
 TTreePlayer.cxx:2867
 TTreePlayer.cxx:2868
 TTreePlayer.cxx:2869
 TTreePlayer.cxx:2870
 TTreePlayer.cxx:2871
 TTreePlayer.cxx:2872
 TTreePlayer.cxx:2873
 TTreePlayer.cxx:2874
 TTreePlayer.cxx:2875
 TTreePlayer.cxx:2876
 TTreePlayer.cxx:2877
 TTreePlayer.cxx:2878
 TTreePlayer.cxx:2879
 TTreePlayer.cxx:2880
 TTreePlayer.cxx:2881
 TTreePlayer.cxx:2882
 TTreePlayer.cxx:2883
 TTreePlayer.cxx:2884
 TTreePlayer.cxx:2885
 TTreePlayer.cxx:2886
 TTreePlayer.cxx:2887
 TTreePlayer.cxx:2888
 TTreePlayer.cxx:2889
 TTreePlayer.cxx:2890
 TTreePlayer.cxx:2891
 TTreePlayer.cxx:2892
 TTreePlayer.cxx:2893
 TTreePlayer.cxx:2894
 TTreePlayer.cxx:2895
 TTreePlayer.cxx:2896
 TTreePlayer.cxx:2897
 TTreePlayer.cxx:2898
 TTreePlayer.cxx:2899
 TTreePlayer.cxx:2900
 TTreePlayer.cxx:2901
 TTreePlayer.cxx:2902
 TTreePlayer.cxx:2903
 TTreePlayer.cxx:2904
 TTreePlayer.cxx:2905
 TTreePlayer.cxx:2906
 TTreePlayer.cxx:2907
 TTreePlayer.cxx:2908
 TTreePlayer.cxx:2909
 TTreePlayer.cxx:2910
 TTreePlayer.cxx:2911
 TTreePlayer.cxx:2912
 TTreePlayer.cxx:2913
 TTreePlayer.cxx:2914
 TTreePlayer.cxx:2915
 TTreePlayer.cxx:2916
 TTreePlayer.cxx:2917
 TTreePlayer.cxx:2918
 TTreePlayer.cxx:2919
 TTreePlayer.cxx:2920
 TTreePlayer.cxx:2921
 TTreePlayer.cxx:2922
 TTreePlayer.cxx:2923
 TTreePlayer.cxx:2924
 TTreePlayer.cxx:2925
 TTreePlayer.cxx:2926
 TTreePlayer.cxx:2927
 TTreePlayer.cxx:2928
 TTreePlayer.cxx:2929
 TTreePlayer.cxx:2930
 TTreePlayer.cxx:2931
 TTreePlayer.cxx:2932
 TTreePlayer.cxx:2933
 TTreePlayer.cxx:2934
 TTreePlayer.cxx:2935
 TTreePlayer.cxx:2936
 TTreePlayer.cxx:2937
 TTreePlayer.cxx:2938
 TTreePlayer.cxx:2939
 TTreePlayer.cxx:2940
 TTreePlayer.cxx:2941
 TTreePlayer.cxx:2942
 TTreePlayer.cxx:2943
 TTreePlayer.cxx:2944
 TTreePlayer.cxx:2945
 TTreePlayer.cxx:2946
 TTreePlayer.cxx:2947
 TTreePlayer.cxx:2948
 TTreePlayer.cxx:2949
 TTreePlayer.cxx:2950
 TTreePlayer.cxx:2951
 TTreePlayer.cxx:2952
 TTreePlayer.cxx:2953
 TTreePlayer.cxx:2954
 TTreePlayer.cxx:2955
 TTreePlayer.cxx:2956
 TTreePlayer.cxx:2957
 TTreePlayer.cxx:2958
 TTreePlayer.cxx:2959
 TTreePlayer.cxx:2960
 TTreePlayer.cxx:2961
 TTreePlayer.cxx:2962
 TTreePlayer.cxx:2963
 TTreePlayer.cxx:2964
 TTreePlayer.cxx:2965
 TTreePlayer.cxx:2966
 TTreePlayer.cxx:2967
 TTreePlayer.cxx:2968
 TTreePlayer.cxx:2969
 TTreePlayer.cxx:2970
 TTreePlayer.cxx:2971
 TTreePlayer.cxx:2972
 TTreePlayer.cxx:2973
 TTreePlayer.cxx:2974
 TTreePlayer.cxx:2975
 TTreePlayer.cxx:2976
 TTreePlayer.cxx:2977
 TTreePlayer.cxx:2978
 TTreePlayer.cxx:2979
 TTreePlayer.cxx:2980
 TTreePlayer.cxx:2981
 TTreePlayer.cxx:2982
 TTreePlayer.cxx:2983
 TTreePlayer.cxx:2984
 TTreePlayer.cxx:2985
 TTreePlayer.cxx:2986
 TTreePlayer.cxx:2987
 TTreePlayer.cxx:2988
 TTreePlayer.cxx:2989
 TTreePlayer.cxx:2990
 TTreePlayer.cxx:2991
 TTreePlayer.cxx:2992
 TTreePlayer.cxx:2993
 TTreePlayer.cxx:2994
 TTreePlayer.cxx:2995
 TTreePlayer.cxx:2996
 TTreePlayer.cxx:2997
 TTreePlayer.cxx:2998
 TTreePlayer.cxx:2999
 TTreePlayer.cxx:3000
 TTreePlayer.cxx:3001
 TTreePlayer.cxx:3002
 TTreePlayer.cxx:3003
 TTreePlayer.cxx:3004
 TTreePlayer.cxx:3005
 TTreePlayer.cxx:3006
 TTreePlayer.cxx:3007
 TTreePlayer.cxx:3008
 TTreePlayer.cxx:3009
 TTreePlayer.cxx:3010
 TTreePlayer.cxx:3011
 TTreePlayer.cxx:3012
 TTreePlayer.cxx:3013
 TTreePlayer.cxx:3014
 TTreePlayer.cxx:3015
 TTreePlayer.cxx:3016
 TTreePlayer.cxx:3017
 TTreePlayer.cxx:3018
 TTreePlayer.cxx:3019
 TTreePlayer.cxx:3020
 TTreePlayer.cxx:3021
 TTreePlayer.cxx:3022
 TTreePlayer.cxx:3023
 TTreePlayer.cxx:3024
 TTreePlayer.cxx:3025
 TTreePlayer.cxx:3026
 TTreePlayer.cxx:3027
 TTreePlayer.cxx:3028
 TTreePlayer.cxx:3029
 TTreePlayer.cxx:3030
 TTreePlayer.cxx:3031
 TTreePlayer.cxx:3032
 TTreePlayer.cxx:3033
 TTreePlayer.cxx:3034
 TTreePlayer.cxx:3035
 TTreePlayer.cxx:3036
 TTreePlayer.cxx:3037
 TTreePlayer.cxx:3038
 TTreePlayer.cxx:3039
 TTreePlayer.cxx:3040
 TTreePlayer.cxx:3041
 TTreePlayer.cxx:3042
 TTreePlayer.cxx:3043
 TTreePlayer.cxx:3044
 TTreePlayer.cxx:3045
 TTreePlayer.cxx:3046