ROOT logo
// @(#)root/treeplayer:$Id: TTreeFormula.cxx 41326 2011-10-11 10:26:39Z pcanal $
// Author: Rene Brun   19/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.             *
 *************************************************************************/

#include "TROOT.h"
#include "TTreeFormula.h"
#include "TTree.h"
#include "TBranch.h"
#include "TBranchObject.h"
#include "TFunction.h"
#include "TClonesArray.h"
#include "TLeafB.h"
#include "TLeafC.h"
#include "TLeafObject.h"
#include "TDataMember.h"
#include "TMethodCall.h"
#include "TCutG.h"
#include "TRandom.h"
#include "TInterpreter.h"
#include "TDataType.h"
#include "TStreamerInfo.h"
#include "TStreamerElement.h"
#include "TBranchElement.h"
#include "TLeafElement.h"
#include "TArrayI.h"
#include "TAxis.h"
#include "TError.h"
#include "TVirtualCollectionProxy.h"
#include "TString.h"
#include "TTimeStamp.h"
#include "TMath.h"

#include "TVirtualRefProxy.h"
#include "TTreeFormulaManager.h"
#include "TFormLeafInfo.h"
#include "TMethod.h"
#include "TBaseClass.h"
#include "TFormLeafInfoReference.h"

#include "TEntryList.h"

#include <ctype.h>
#include <stdio.h>
#include <math.h>
#include <stdlib.h>
#include <typeinfo>
#include <algorithm>

const Int_t kMaxLen     = 1024;
R__EXTERN TTree *gTree;



ClassImp(TTreeFormula)

//______________________________________________________________________________
//
// TTreeFormula now relies on a variety of TFormLeafInfo classes to handle the
// reading of the information.  Here is the list of theses classes:
//   TFormLeafInfo
//   TFormLeafInfoDirect
//   TFormLeafInfoNumerical
//   TFormLeafInfoClones
//   TFormLeafInfoCollection
//   TFormLeafInfoPointer
//   TFormLeafInfoMethod
//   TFormLeafInfoMultiVarDim
//   TFormLeafInfoMultiVarDimDirect
//   TFormLeafInfoCast
//
// The following method are available from the TFormLeafInfo interface:
//
//  AddOffset(Int_t offset, TStreamerElement* element)
//  GetCounterValue(TLeaf* leaf) : return the size of the array pointed to.
//  GetObjectAddress(TLeafElement* leaf) : Returns the the location of the object pointed to.
//  GetMultiplicity() : Returns info on the variability of the number of elements
//  GetNdata(TLeaf* leaf) : Returns the number of elements
//  GetNdata() : Used by GetNdata(TLeaf* leaf)
//  GetValue(TLeaf *leaf, Int_t instance = 0) : Return the value
//  GetValuePointer(TLeaf *leaf, Int_t instance = 0) : Returns the address of the value
//  GetLocalValuePointer(TLeaf *leaf, Int_t instance = 0) : Returns the address of the value of 'this' LeafInfo
//  IsString()
//  ReadValue(char *where, Int_t instance = 0) : Internal function to interpret the location 'where'
//  Update() : react to the possible loading of a shared library.
//
//

//______________________________________________________________________________
inline static void R__LoadBranch(TBranch* br, Long64_t entry, Bool_t quickLoad)
{
   if (!quickLoad || (br->GetReadEntry() != entry)) {
      br->GetEntry(entry);
   }
}

//______________________________________________________________________________
//
// This class is a small helper class to help in keeping track of the array
// dimensions encountered in the analysis of the expression.
class TDimensionInfo : public TObject {
public:
   Int_t fCode;  // Location of the leaf in TTreeFormula::fCode
   Int_t fOper;  // Location of the Operation using the leaf in TTreeFormula::fOper
   Int_t fSize;
   TFormLeafInfoMultiVarDim* fMultiDim;
   TDimensionInfo(Int_t code, Int_t oper, Int_t size, TFormLeafInfoMultiVarDim* multiDim)
      : fCode(code), fOper(oper), fSize(size), fMultiDim(multiDim) {};
   ~TDimensionInfo() {};
};

//______________________________________________________________________________
//
//     A TreeFormula is used to pass a selection expression
//     to the Tree drawing routine. See TTree::Draw
//
//  A TreeFormula can contain any arithmetic expression including
//  standard operators and mathematical functions separated by operators.
//  Examples of valid expression:
//          "x<y && sqrt(z)>3.2"
//

//______________________________________________________________________________
TTreeFormula::TTreeFormula(): TFormula(), fQuickLoad(kFALSE), fNeedLoading(kTRUE),
   fDidBooleanOptimization(kFALSE), fDimensionSetup(0)

{
   // Tree Formula default constructor

   fTree         = 0;
   fLookupType   = 0;
   fNindex       = 0;
   fNcodes       = 0;
   fAxis         = 0;
   fHasCast      = 0;
   fManager      = 0;
   fMultiplicity = 0;

   Int_t j,k;
   for (j=0; j<kMAXCODES; j++) {
      fNdimensions[j] = 0;
      fCodes[j] = 0;
      fNdata[j] = 1;
      fHasMultipleVarDim[j] = kFALSE;
      for (k = 0; k<kMAXFORMDIM; k++) {
         fIndexes[j][k] = -1;
         fCumulSizes[j][k] = 1;
         fVarIndexes[j][k] = 0;
      }
   }
}

//______________________________________________________________________________
TTreeFormula::TTreeFormula(const char *name,const char *expression, TTree *tree)
   :TFormula(), fTree(tree), fQuickLoad(kFALSE), fNeedLoading(kTRUE),
    fDidBooleanOptimization(kFALSE), fDimensionSetup(0)
{
   // Normal TTree Formula Constuctor

   Init(name,expression);
}

//______________________________________________________________________________
TTreeFormula::TTreeFormula(const char *name,const char *expression, TTree *tree,
                           const std::vector<std::string>& aliases)
   :TFormula(), fTree(tree), fQuickLoad(kFALSE), fNeedLoading(kTRUE),
    fDidBooleanOptimization(kFALSE), fDimensionSetup(0), fAliasesUsed(aliases)
{
   // Constructor used during the expansion of an alias
   Init(name,expression);
}

//______________________________________________________________________________
void TTreeFormula::Init(const char*name, const char* expression)
{
   // Initialiation called from the constructors.

   TDirectory *const savedir=gDirectory;

   fNindex       = kMAXFOUND;
   fLookupType   = new Int_t[fNindex];
   fNcodes       = 0;
   fMultiplicity = 0;
   fAxis         = 0;
   fHasCast      = 0;
   Int_t i,j,k;
   fManager      = new TTreeFormulaManager;
   fManager->Add(this);

   for (j=0; j<kMAXCODES; j++) {
      fNdimensions[j] = 0;
      fLookupType[j] = kDirect;
      fCodes[j] = 0;
      fNdata[j] = 1;
      fHasMultipleVarDim[j] = kFALSE;
      for (k = 0; k<kMAXFORMDIM; k++) {
         fIndexes[j][k] = -1;
         fCumulSizes[j][k] = 1;
         fVarIndexes[j][k] = 0;
      }
   }

   fDimensionSetup = new TList;

   if (Compile(expression)) {
      fTree = 0; fNdim = 0; 
      if(savedir) savedir->cd();
      return; 
   }

   if (fNcodes >= kMAXFOUND) {
      Warning("TTreeFormula","Too many items in expression:%s",expression);
      fNcodes = kMAXFOUND;
   }
   SetName(name);

   for (i=0;i<fNoper;i++) {

      if (GetAction(i)==kDefinedString) {
         Int_t string_code = GetActionParam(i);
         TLeaf *leafc = (TLeaf*)fLeaves.UncheckedAt(string_code);
         if (!leafc) continue;

         // We have a string used as a string

         // This dormant portion of code would be used if (when?) we allow the histogramming
         // of the integral content (as opposed to the string content) of strings
         // held in a variable size container delimited by a null (as opposed to
         // a fixed size container or variable size container whose size is controlled
         // by a variable).  In GetNdata, we will then use strlen to grab the current length.
         //fCumulSizes[i][fNdimensions[i]-1] = 1;
         //fUsedSizes[fNdimensions[i]-1] = -TMath::Abs(fUsedSizes[fNdimensions[i]-1]);
         //fUsedSizes[0] = - TMath::Abs( fUsedSizes[0]);

         if (fNcodes == 1) {
            // If the string is by itself, then it can safely be histogrammed as
            // in a string based axis.  To histogram the number inside the string
            // just make it part of a useless expression (for example: mystring+0)
            SetBit(kIsCharacter);
         }
         continue;
      }
      if (GetAction(i)==kJump && GetActionParam(i)==(fNoper-1)) {
         // We have cond ? string1 : string2
         if (IsString(fNoper-1)) SetBit(kIsCharacter);
      }
   }
   if (fNoper==1 && GetAction(0)==kAliasString) {
      TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(0));
      R__ASSERT(subform);
      if (subform->TestBit(kIsCharacter)) SetBit(kIsCharacter);
   } else if (fNoper==2 && GetAction(0)==kAlternateString) {
      TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(0));
      R__ASSERT(subform);
      if (subform->TestBit(kIsCharacter)) SetBit(kIsCharacter);
   }

   fManager->Sync();

   // Let's verify the indexes and dies if we need to.
   Int_t k0,k1;
   for(k0 = 0; k0 < fNcodes; k0++) {
      for(k1 = 0; k1 < fNdimensions[k0]; k1++ ) {
         // fprintf(stderr,"Saw %d dim %d and index %d\n",k1, fFixedSizes[k0][k1], fIndexes[k0][k1]);
         if ( fIndexes[k0][k1]>=0 && fFixedSizes[k0][k1]>=0
              && fIndexes[k0][k1]>=fFixedSizes[k0][k1]) {
            Error("TTreeFormula",
                  "Index %d for dimension #%d in %s is too high (max is %d)",
                  fIndexes[k0][k1],k1+1, expression,fFixedSizes[k0][k1]-1);
            fTree = 0; fNdim = 0; 
            if(savedir) savedir->cd();
            return;
         }
      }
   }

   // Create a list of uniques branches to load.
   for(k=0; k<fNcodes; k++) {
      TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(k);
      TBranch *branch = 0;
      if (leaf) {
         branch = leaf->GetBranch();
         if (fBranches.FindObject(branch)) branch = 0;
      }
      fBranches.AddAtAndExpand(branch,k);
   }
   
   if (IsInteger(kFALSE)) SetBit(kIsInteger);

   if (TestBit(TTreeFormula::kNeedEntries)) { 
      // Call TTree::GetEntries() to insure that it is already calculated.
      // This will need to be done anyway at the first iteration and insure
      // that it will not mess up the branch reading (because TTree::GetEntries
      // opens all the file in the chain and 'stays' on the last file.
      
      Long64_t readentry = fTree->GetReadEntry();
      Int_t treenumber = fTree->GetTreeNumber();
      fTree->GetEntries();
      if (treenumber != fTree->GetTreeNumber()) {
         if (readentry >= 0) {
            fTree->LoadTree(readentry);
         }
         UpdateFormulaLeaves();
      } else {
         if (readentry >= 0) {
            fTree->LoadTree(readentry);
         }
      }

   }

   if(savedir) savedir->cd();
}

//______________________________________________________________________________
TTreeFormula::~TTreeFormula()
{
//*-*-*-*-*-*-*-*-*-*-*Tree Formula default destructor*-*-*-*-*-*-*-*-*-*-*
//*-*                  =================================
   if (fManager) {
      fManager->Remove(this);
      if (fManager->fFormulas.GetLast()<0) {
         delete fManager;
         fManager = 0;
      }
   }
   // Objects in fExternalCuts are not owned and should not be deleted
   // fExternalCuts.Clear();
   fLeafNames.Delete();
   fDataMembers.Delete();
   fMethods.Delete();
   fAliases.Delete();
   if (fLookupType) delete [] fLookupType;
   for (int j=0; j<fNcodes; j++) {
      for (int k = 0; k<fNdimensions[j]; k++) {
         if (fVarIndexes[j][k]) delete fVarIndexes[j][k];
         fVarIndexes[j][k] = 0;
      }
   }
   if (fDimensionSetup) {
      fDimensionSetup->Delete();
      delete fDimensionSetup;
   }
}

//______________________________________________________________________________
void TTreeFormula::DefineDimensions(Int_t code, Int_t size,
                                    TFormLeafInfoMultiVarDim * info,
                                    Int_t& virt_dim) {
   // This method is used internally to decode the dimensions of the variables

   if (info) {
      fManager->EnableMultiVarDims();
      //if (fIndexes[code][info->fDim]<0) { // removed because the index might be out of bounds!
         info->fVirtDim = virt_dim;
         fManager->AddVarDims(virt_dim); // if (!fVarDims[virt_dim]) fVarDims[virt_dim] = new TArrayI;
      //}
   }

   Int_t vsize = 0;

   if (fIndexes[code][fNdimensions[code]]==-2) {
      TTreeFormula *indexvar = fVarIndexes[code][fNdimensions[code]];
      // ASSERT(indexvar!=0);
      Int_t index_multiplicity = indexvar->GetMultiplicity();
      switch (index_multiplicity) {
         case -1:
         case  0:
         case  2:
            vsize = indexvar->GetNdata();
            break;
         case  1:
            vsize = -1;
            break;
      };
   } else vsize = size;

   fCumulSizes[code][fNdimensions[code]] = size;

   if ( fIndexes[code][fNdimensions[code]] < 0 ) {
      fManager->UpdateUsedSize(virt_dim, vsize);
   }

   fNdimensions[code] ++;

}

//______________________________________________________________________________
Int_t TTreeFormula::RegisterDimensions(const char *info, Int_t code)
{
   // This method is used internally to decode the dimensions of the variables

   // We assume that there are NO white spaces in the info string
   const char * current;
   Int_t size, scanindex, vardim;

   current = info;
   vardim = 0;
   // the next value could be before the string but
   // that's okay because the next operation is ++
   // (this is to avoid (?) a if statement at the end of the
   // loop)
   if (current[0] != '[') current--;
   while (current) {
      current++;
      scanindex = sscanf(current,"%d",&size);
      // if scanindex is 0 then we have a name index thus a variable
      // array (or TClonesArray!).

      if (scanindex==0) size = -1;

      vardim += RegisterDimensions(code, size);

      if (fNdimensions[code] >= kMAXFORMDIM) {
         // NOTE: test that fNdimensions[code] is NOT too big!!

         break;
      }
      current = (char*)strstr( current, "[" );
   }
   return vardim;
}


//______________________________________________________________________________
Int_t TTreeFormula::RegisterDimensions(Int_t code, Int_t size, TFormLeafInfoMultiVarDim * multidim) {
   // This method stores the dimension information for later usage.

   TDimensionInfo * info = new TDimensionInfo(code,fNoper,size,multidim);
   fDimensionSetup->Add(info);
   fCumulSizes[code][fNdimensions[code]] = size;
   fNdimensions[code] ++;
   return (size==-1) ? 1 : 0;
}

//______________________________________________________________________________
Int_t TTreeFormula::RegisterDimensions(Int_t code, TFormLeafInfo *leafinfo,
                                       TFormLeafInfo * /* maininfo */,
                                       Bool_t useCollectionObject) {
   // This method is used internally to decode the dimensions of the variables

   Int_t ndim, size, current, vardim;
   vardim = 0;

   const TStreamerElement * elem = leafinfo->fElement;
   TClass* c = elem ? elem->GetClassPointer() : 0;

   TFormLeafInfoMultiVarDim * multi = dynamic_cast<TFormLeafInfoMultiVarDim * >(leafinfo);
   if (multi) {
      // We have a second variable dimensions
      fManager->EnableMultiVarDims();
      multi->fDim = fNdimensions[code];
      return RegisterDimensions(code, -1, multi);
   }
   if (elem->IsA() == TStreamerBasicPointer::Class()) {

      if (elem->GetArrayDim()>0) {

         ndim = elem->GetArrayDim();
         size = elem->GetMaxIndex(0);
         vardim += RegisterDimensions(code, -1);
      } else {
         ndim = 1;
         size = -1;
      }

      TStreamerBasicPointer *array = (TStreamerBasicPointer*)elem;
      TClass *cl = leafinfo->fClass;
      Int_t offset;
      TStreamerElement* counter = ((TStreamerInfo*)cl->GetStreamerInfo())->GetStreamerElement(array->GetCountName(),offset);
#if 1
      leafinfo->fCounter = new TFormLeafInfo(cl,offset,counter);
#else /* Code is not ready yet see revision 14078 */
      if (maininfo==0 || maininfo==leafinfo || 1) {
         leafinfo->fCounter = new TFormLeafInfo(cl,offset,counter);
      } else {
         leafinfo->fCounter = maininfo->DeepCopy();
         TFormLeafInfo *currentinfo = leafinfo->fCounter;
         while(currentinfo->fNext && currentinfo->fNext->fNext) currentinfo=currentinfo->fNext;
         delete currentinfo->fNext;
         currentinfo->fNext = new TFormLeafInfo(cl,offset,counter);
      }
#endif
   } else if (!useCollectionObject && elem->GetClassPointer() == TClonesArray::Class() ) {

      ndim = 1;
      size = -1;

      TClass * clonesClass = TClonesArray::Class();
      Int_t c_offset;
      TStreamerElement *counter = ((TStreamerInfo*)clonesClass->GetStreamerInfo())->GetStreamerElement("fLast",c_offset);
      leafinfo->fCounter = new TFormLeafInfo(clonesClass,c_offset,counter);

   } else if (!useCollectionObject && elem->GetClassPointer() && elem->GetClassPointer()->GetCollectionProxy() ) {

      if ( typeid(*leafinfo) == typeid(TFormLeafInfoCollection) ) {
         ndim = 1;
         size = -1;
      } else {
         R__ASSERT( fHasMultipleVarDim[code] );
         ndim = 1;
         size = 1;
      }

   } else if ( c && c->GetReferenceProxy() && c->GetReferenceProxy()->HasCounter() ) {
      ndim = 1;
      size = -1;
   } else if (elem->GetArrayDim()>0) {

      ndim = elem->GetArrayDim();
      size = elem->GetMaxIndex(0);

   } else if ( elem->GetNewType()== TStreamerInfo::kCharStar) {

      // When we implement being able to read the length from
      // strlen, we will have:
      // ndim = 1;
      // size = -1;
      // until then we more or so die:
      ndim = 1;
      size = 1; //NOTE: changed from 0

   } else return 0;

   current = 0;
   do {
      vardim += RegisterDimensions(code, size);

      if (fNdimensions[code] >= kMAXFORMDIM) {
         // NOTE: test that fNdimensions[code] is NOT too big!!

         break;
      }
      current++;
      size = elem->GetMaxIndex(current);
   } while (current<ndim);

   return vardim;
}

//______________________________________________________________________________
Int_t TTreeFormula::RegisterDimensions(Int_t code, TBranchElement *branch) {
   // This method is used internally to decode the dimensions of the variables

   TBranchElement * leafcount2 = branch->GetBranchCount2();
   if (leafcount2) {
      // With have a second variable dimensions
      TBranchElement *leafcount = dynamic_cast<TBranchElement*>(branch->GetBranchCount());

      R__ASSERT(leafcount); // The function should only be called on a functional TBranchElement object

      fManager->EnableMultiVarDims();
      TFormLeafInfoMultiVarDim * info = new TFormLeafInfoMultiVarDimDirect();
      fDataMembers.AddAtAndExpand(info, code);
      fHasMultipleVarDim[code] = kTRUE;

      info->fCounter = new TFormLeafInfoDirect(leafcount);
      info->fCounter2 = new TFormLeafInfoDirect(leafcount2);
      info->fDim = fNdimensions[code];
      //if (fIndexes[code][info->fDim]<0) {
      //  info->fVirtDim = virt_dim;
      //  if (!fVarDims[virt_dim]) fVarDims[virt_dim] = new TArrayI;
      //}
      return RegisterDimensions(code, -1, info);
   }
   return 0;
}

//______________________________________________________________________________
Int_t TTreeFormula::RegisterDimensions(Int_t code, TLeaf *leaf) {
   // This method is used internally to decode the dimensions of the variables

   Int_t numberOfVarDim = 0;

   // Let see if we can understand the structure of this branch.
   // Usually we have: leafname[fixed_array] leaftitle[var_array]\type
   // (with fixed_array that can be a multi-dimension array.
   const char *tname = leaf->GetTitle();
   char *leaf_dim = (char*)strstr( tname, "[" );

   const char *bname = leaf->GetBranch()->GetName();
   char *branch_dim = (char*)strstr(bname,"[");
   if (branch_dim) branch_dim++; // skip the '['

   Bool_t isString  = kFALSE;
   if  (leaf->IsA() == TLeafElement::Class()) {
      Int_t type =((TBranchElement*)leaf->GetBranch())->GetStreamerType();
      isString =    (type == TStreamerInfo::kOffsetL+TStreamerInfo::kChar)
                 || (type == TStreamerInfo::kCharStar);
   } else {
      isString = (leaf->IsA() == TLeafC::Class());
   }
   if (leaf_dim) {
      leaf_dim++; // skip the '['
      if (!branch_dim || strncmp(branch_dim,leaf_dim,strlen(branch_dim))) {
         // then both are NOT the same so do the leaf title first:
         numberOfVarDim += RegisterDimensions( leaf_dim, code);
      } else if (branch_dim && strncmp(branch_dim,leaf_dim,strlen(branch_dim))==0
                 && strlen(leaf_dim)>strlen(branch_dim)
                 && (leaf_dim+strlen(branch_dim))[0]=='[') {
         // we have extra info in the leaf title
         numberOfVarDim += RegisterDimensions( leaf_dim+strlen(branch_dim)+1, code);
      }
   }
   if (branch_dim) {
      // then both are NOT same so do the branch name next:
      if (isString) {
         numberOfVarDim += RegisterDimensions( code, 1);            
      } else {
         numberOfVarDim += RegisterDimensions( branch_dim, code);
      }
   }
   if (leaf->IsA() == TLeafElement::Class()) {
      TBranchElement* branch = (TBranchElement*) leaf->GetBranch();
      if (branch->GetBranchCount2()) {

         if (!branch->GetBranchCount()) {
            Warning("DefinedVariable",
                    "Noticed an incorrect in-memory TBranchElement object (%s).\nIt has a BranchCount2 but no BranchCount!\nThe result might be incorrect!",
                    branch->GetName());
            return numberOfVarDim;
         }

         // Switch from old direct style to using a TLeafInfo
         if (fLookupType[code] == kDataMember)
            Warning("DefinedVariable",
                    "Already in kDataMember mode when handling multiple variable dimensions");
         fLookupType[code] = kDataMember;

         // Feed the information into the Dimensions system
         numberOfVarDim += RegisterDimensions( code, branch);

      }
   }
   return numberOfVarDim;
}

//______________________________________________________________________________
Int_t TTreeFormula::DefineAlternate(const char *expression)
{
   // This method check for treat the case where expression contains $Atl and load up
   // both fAliases and fExpr.
   // We return
   //   -1 in case of failure
   //   0 in case we did not find $Alt
   //   the action number in case of success.

   static const char *altfunc = "Alt$(";
   static const char *minfunc = "MinIf$(";
   static const char *maxfunc = "MaxIf$(";
   Int_t action = 0;
   Int_t start = 0;
   
   if (   strncmp(expression,altfunc,strlen(altfunc))==0
       && expression[strlen(expression)-1]==')' ) {
      action = kAlternate;
      start = strlen(altfunc);
   }
   if (   strncmp(expression,maxfunc,strlen(maxfunc))==0
       && expression[strlen(expression)-1]==')' ) {
      action = kMaxIf;
      start = strlen(maxfunc);
   }
   if (   strncmp(expression,minfunc,strlen(minfunc))==0
       && expression[strlen(expression)-1]==')' ) {
      action = kMinIf;
      start = strlen(minfunc);
   }
   
   if (action) {
      TString full = expression;
      TString part1;
      TString part2;
      int paran = 0;
      int instr = 0;
      int brack = 0;
      for(unsigned int i=start;i<strlen(expression);++i) {
         switch (expression[i]) {
            case '(': paran++; break;
            case ')': paran--; break;
            case '"': instr = instr ? 0 : 1; break;
            case '[': brack++; break;
            case ']': brack--; break;
         };
         if (expression[i]==',' && paran==0 && instr==0 && brack==0) {
            part1 = full( start, i-start );
            part2 = full( i+1, full.Length() -1 - (i+1) );
            break; // out of the for loop
         }
      }
      if (part1.Length() && part2.Length()) {
         TTreeFormula *primary = new TTreeFormula("primary",part1,fTree);
         TTreeFormula *alternate = new TTreeFormula("alternate",part2,fTree);

         short isstring = 0;

         if (action == kAlternate) {
            if (alternate->GetManager()->GetMultiplicity() != 0 ) {
               Error("DefinedVariable","The 2nd arguments in %s can not be an array (%s,%d)!",
                     expression,alternate->GetTitle(),
                     alternate->GetManager()->GetMultiplicity());
               return -1;
            }

            // Should check whether we have strings.
            if (primary->IsString()) {
               if (!alternate->IsString()) {
                  Error("DefinedVariable",
                        "The 2nd arguments in %s has to return the same type as the 1st argument (string)!",
                        expression);
                  return -1;
               }
               isstring = 1;
            } else if (alternate->IsString()) {
               Error("DefinedVariable",
                     "The 2nd arguments in %s has to return the same type as the 1st argument (numerical type)!",
                     expression);
               return -1;
            }
         } else {
            primary->GetManager()->Add( alternate );
            primary->GetManager()->Sync();
            if (primary->IsString() || alternate->IsString()) {
               if (!alternate->IsString()) {
                  Error("DefinedVariable",
                        "The arguments of %s can not be strings!",
                        expression);
                  return -1;
               }
            }
         }

         fAliases.AddAtAndExpand(primary,fNoper);
         fExpr[fNoper] = "";
         SetAction(fNoper, (Int_t)action + isstring, 0 );
         ++fNoper;

         fAliases.AddAtAndExpand(alternate,fNoper);
         return (Int_t)kAlias + isstring;
      }
   }
   return 0;
}

//______________________________________________________________________________
Int_t TTreeFormula::ParseWithLeaf(TLeaf* leaf, const char* subExpression, Bool_t final, UInt_t paran_level, TObjArray& castqueue, Bool_t useLeafCollectionObject, const char* fullExpression)
{
   // Decompose 'expression' as pointing to something inside the leaf
   // Returns:
   //   -2  Error: some information is missing (message already printed)
   //   -1  Error: Syntax is incorrect (message already printed)
   //    0
   //    >0 the value returns is the action code.

   Int_t action = 0;

   Int_t numberOfVarDim = 0;
   char *current;

   char  scratch[kMaxLen]; scratch[0] = '\0';
   char     work[kMaxLen];    work[0] = '\0';

   const char *right = subExpression;
   TString name = fullExpression;

   TBranch *branch = leaf ? leaf->GetBranch() : 0;
   Long64_t readentry = fTree->GetTree()->GetReadEntry();
   if (readentry < 0) readentry=0;

   Bool_t useLeafReferenceObject = false;
   Int_t code = fNcodes-1;

   // Make a check to prevent problem with some corrupted files (missing TStreamerInfo).
   if (leaf && leaf->IsA()==TLeafElement::Class()) {
      TBranchElement *br = 0;
      if( branch->IsA() ==  TBranchElement::Class() )
      {
         br = ((TBranchElement*)branch);

         if ( br->GetInfo() == 0 ) {
            Error("DefinedVariable","Missing StreamerInfo for %s.  We will be unable to read!",
                  name.Data());
            return -2;
         }
      }

      TBranch *bmom = branch->GetMother();
      if( bmom->IsA() == TBranchElement::Class() )
      {
         TBranchElement *mom = (TBranchElement*)br->GetMother();
         if (mom!=br) {
            if (mom->GetInfo()==0) {
               Error("DefinedVariable","Missing StreamerInfo for %s."
                     "  We will be unable to read!",
                     mom->GetName());
               return -2;
            }
            if ((mom->GetType()) < -1 && !mom->GetAddress()) {
               Error("DefinedVariable", "Address not set when the type of the branch is negative for for %s.  We will be unable to read!", mom->GetName());
               return -2;
            }
         }
      }
   }

   // We need to record the location in the list of leaves because
   // the tree might actually be a chain and in that case the leaf will
   // change from tree to tree!.

   // Let's reconstruct the name of the leaf, including the possible friend alias
   TTree *realtree = fTree->GetTree();
   const char* alias = 0;
   if (leaf) {
      if (realtree) alias = realtree->GetFriendAlias(leaf->GetBranch()->GetTree());
      if (!alias && realtree!=fTree) {
         // Let's try on the chain
         alias = fTree->GetFriendAlias(leaf->GetBranch()->GetTree());
      }
   }
   if (alias) snprintf(scratch,kMaxLen-1,"%s.%s",alias,leaf->GetName());
   else if (leaf) strlcpy(scratch,leaf->GetName(),kMaxLen);

   TTree *tleaf = realtree;
   if (leaf) {
      tleaf = leaf->GetBranch()->GetTree();
      fCodes[code] = tleaf->GetListOfLeaves()->IndexOf(leaf);
      const char *mother_name = leaf->GetBranch()->GetMother()->GetName();
      TString br_extended_name; // Could do ( strlen(mother_name)+strlen( leaf->GetBranch()->GetName() ) + 2 )
      if (leaf->GetBranch()!=leaf->GetBranch()->GetMother()) {
         if (mother_name[strlen(mother_name)-1]!='.') {
            br_extended_name = mother_name;
            br_extended_name.Append('.');
         }
      }
      br_extended_name.Append( leaf->GetBranch()->GetName() );
      Ssiz_t dim = br_extended_name.First('[');
      if (dim >= 0) br_extended_name.Remove(dim);

      TNamed *named = new TNamed(scratch,br_extended_name.Data());
      fLeafNames.AddAtAndExpand(named,code);
      fLeaves.AddAtAndExpand(leaf,code);
   }

   // If the leaf belongs to a friend tree which has an index, we might
   // be in the case where some entry do not exist.
   if (tleaf != realtree && tleaf->GetTreeIndex()) {
      // reset the multiplicity
      if (fMultiplicity >= 0) fMultiplicity = 1;
   }

   // Analyze the content of 'right'

   // Try to find out the class (if any) of the object in the leaf.
   TClass * cl = 0;
   TFormLeafInfo *maininfo = 0;
   TFormLeafInfo *previnfo = 0;
   Bool_t unwindCollection = kFALSE;
   static TClassRef stdStringClass = TClass::GetClass("string");

   if (leaf==0) {
      TNamed *names = (TNamed*)fLeafNames.UncheckedAt(code);
      fLeafNames.AddAt(0,code);
      TTree *what = (TTree*)fLeaves.UncheckedAt(code);
      fLeaves.AddAt(0,code);

      cl = what ? what->IsA() : TTree::Class();
      maininfo = new TFormLeafInfoTTree(fTree,names->GetName(),what);
      previnfo = maininfo;

      delete names;
   } else if (leaf->InheritsFrom(TLeafObject::Class()) ) {
      TBranchObject *bobj = (TBranchObject*)leaf->GetBranch();
      cl = TClass::GetClass(bobj->GetClassName());
   } else if (leaf->InheritsFrom(TLeafElement::Class())) {
      TBranchElement *branchEl = (TBranchElement *)leaf->GetBranch();
      branchEl->SetupAddresses();
      TStreamerInfo *info = branchEl->GetInfo();
      TStreamerElement *element = 0;
      Int_t type = branchEl->GetStreamerType();
      switch(type) {
         case TStreamerInfo::kBase:
         case TStreamerInfo::kObject:
         case TStreamerInfo::kTString:
         case TStreamerInfo::kTNamed:
         case TStreamerInfo::kTObject:
         case TStreamerInfo::kAny:
         case TStreamerInfo::kAnyP:
         case TStreamerInfo::kAnyp:
         case TStreamerInfo::kSTL:
         case TStreamerInfo::kSTLp:
         case TStreamerInfo::kObjectp:
         case TStreamerInfo::kObjectP: {
            element = (TStreamerElement *)info->GetElems()[branchEl->GetID()];
            if (element) cl = element->GetClassPointer();
         }
         break;
         case TStreamerInfo::kOffsetL + TStreamerInfo::kSTL:
         case TStreamerInfo::kOffsetL + TStreamerInfo::kSTLp:
         case TStreamerInfo::kOffsetL + TStreamerInfo::kAny:
         case TStreamerInfo::kOffsetL + TStreamerInfo::kAnyp:
         case TStreamerInfo::kOffsetL + TStreamerInfo::kAnyP:
         case TStreamerInfo::kOffsetL + TStreamerInfo::kObjectp:
         case TStreamerInfo::kOffsetL + TStreamerInfo::kObjectP:
         case TStreamerInfo::kOffsetL + TStreamerInfo::kObject:  {
            element = (TStreamerElement *)info->GetElems()[branchEl->GetID()];
            if (element){
               cl = element->GetClassPointer();
            }
         }
         break;
         case -1: {
            cl = info->GetClass();
         }
         break;
      }

      // If we got a class object, we need to verify whether it is on a
      // split TClonesArray sub branch.
      if (cl && branchEl->GetBranchCount()) {
         if (branchEl->GetType()==31) {
            // This is inside a TClonesArray.

            if (!element) {
               Warning("DefineVariable",
                       "Missing TStreamerElement in object in TClonesArray section");
               return -2;
            }
            TFormLeafInfo* clonesinfo = new TFormLeafInfoClones(cl, 0, element, kTRUE);

            // The following code was commmented out because in THIS case
            // the dimension are actually handled by parsing the title and name of the leaf
            // and branch (see a little further)
            // The dimension needs to be handled!
            // numberOfVarDim += RegisterDimensions(code,clonesinfo);

            maininfo = clonesinfo;

            // We skip some cases because we can assume we have an object.
            Int_t offset=0;
            info->GetStreamerElement(element->GetName(),offset);
            if (type == TStreamerInfo::kObjectp ||
                  type == TStreamerInfo::kObjectP ||
                  type == TStreamerInfo::kOffsetL + TStreamerInfo::kObjectp ||
                  type == TStreamerInfo::kOffsetL + TStreamerInfo::kObjectP ||
                  type == TStreamerInfo::kSTLp ||
                  type == TStreamerInfo::kAnyp ||
                  type == TStreamerInfo::kAnyP ||
                  type == TStreamerInfo::kOffsetL + TStreamerInfo::kSTLp ||
                  type == TStreamerInfo::kOffsetL + TStreamerInfo::kAnyp ||
                  type == TStreamerInfo::kOffsetL + TStreamerInfo::kAnyP) {
               previnfo = new TFormLeafInfoPointer(cl,offset+branchEl->GetOffset(),element);
            } else {
               previnfo = new TFormLeafInfo(cl,offset+branchEl->GetOffset(),element);
            }
            maininfo->fNext = previnfo;
            unwindCollection = kTRUE;

         } else if (branchEl->GetType()==41) {

            // This is inside a Collection

            if (!element) {
               Warning("DefineVariable","Missing TStreamerElement in object in Collection section");
               return -2;
            }
            // First we need to recover the collection.
            TBranchElement *count = branchEl->GetBranchCount();
            TFormLeafInfo* collectioninfo;
            if ( count->GetID() >= 0 ) {
               TStreamerElement *collectionElement =
                  (TStreamerElement *)count->GetInfo()->GetElems()[count->GetID()];
               TClass *collectionCl = collectionElement->GetClassPointer();

               collectioninfo =
                  new TFormLeafInfoCollection(collectionCl, 0, collectionElement, kTRUE);
            } else {
               TClass *collectionCl = TClass::GetClass(count->GetClassName());
               collectioninfo =
                  new TFormLeafInfoCollection(collectionCl, 0, collectionCl, kTRUE);
            }

            // The following code was commmented out because in THIS case
            // the dimension are actually handled by parsing the title and name of the leaf
            // and branch (see a little further)
            // The dimension needs to be handled!
            // numberOfVarDim += RegisterDimensions(code,clonesinfo);

            maininfo = collectioninfo;

            // We skip some cases because we can assume we have an object.
            Int_t offset=0;
            info->GetStreamerElement(element->GetName(),offset);
            if (type == TStreamerInfo::kObjectp ||
                  type == TStreamerInfo::kObjectP ||
                  type == TStreamerInfo::kOffsetL + TStreamerInfo::kObjectp ||
                  type == TStreamerInfo::kOffsetL + TStreamerInfo::kObjectP ||
                  type == TStreamerInfo::kSTLp ||
                  type == TStreamerInfo::kAnyp ||
                  type == TStreamerInfo::kAnyP ||
                  type == TStreamerInfo::kOffsetL + TStreamerInfo::kSTLp ||
                  type == TStreamerInfo::kOffsetL + TStreamerInfo::kAnyp ||
                  type == TStreamerInfo::kOffsetL + TStreamerInfo::kAnyP) {
               previnfo = new TFormLeafInfoPointer(cl,offset+branchEl->GetOffset(),element);
            } else {
               previnfo = new TFormLeafInfo(cl,offset+branchEl->GetOffset(),element);
            }
            maininfo->fNext = previnfo;
            unwindCollection = kTRUE;
         }
      } else if ( branchEl->GetType()==3) {
         TFormLeafInfo* clonesinfo;
         if (useLeafCollectionObject) {
            clonesinfo = new TFormLeafInfoCollectionObject(cl);
         } else {
            clonesinfo = new TFormLeafInfoClones(cl, 0, kTRUE);
            // The dimension needs to be handled!
            numberOfVarDim += RegisterDimensions(code,clonesinfo,maininfo,useLeafCollectionObject);

         }
         maininfo = clonesinfo;
         previnfo = maininfo;

      } else if (!useLeafCollectionObject && branchEl->GetType()==4) {

         TFormLeafInfo* collectioninfo;
         if (useLeafCollectionObject) {
            collectioninfo = new TFormLeafInfoCollectionObject(cl);
         } else {
            collectioninfo = new TFormLeafInfoCollection(cl, 0, cl, kTRUE);
            // The dimension needs to be handled!
            numberOfVarDim += RegisterDimensions(code,collectioninfo,maininfo,useLeafCollectionObject);
         }

         maininfo = collectioninfo;
         previnfo = maininfo;

      } else if (branchEl->GetStreamerType()==-1 && cl && cl->GetCollectionProxy()) {

         if (useLeafCollectionObject) {

            TFormLeafInfo *collectioninfo = new TFormLeafInfoCollectionObject(cl);
            maininfo = collectioninfo;
            previnfo = collectioninfo;

         } else {
            TFormLeafInfo *collectioninfo = new TFormLeafInfoCollection(cl, 0, cl, kTRUE);
            // The dimension needs to be handled!
            numberOfVarDim += RegisterDimensions(code,collectioninfo,maininfo,kFALSE);

            maininfo = collectioninfo;
            previnfo = collectioninfo;

            if (cl->GetCollectionProxy()->GetValueClass()!=0 &&
                cl->GetCollectionProxy()->GetValueClass()->GetCollectionProxy()!=0) {

               TFormLeafInfo *multi = new TFormLeafInfoMultiVarDimCollection(cl,0,
                     cl->GetCollectionProxy()->GetValueClass(),collectioninfo);

               fHasMultipleVarDim[code] = kTRUE;
               numberOfVarDim += RegisterDimensions(code,multi,maininfo,kFALSE);
               previnfo->fNext = multi;
               cl = cl->GetCollectionProxy()->GetValueClass();
               multi->fNext =  new TFormLeafInfoCollection(cl, 0, cl, false);
               previnfo = multi->fNext;

            }
            if (cl->GetCollectionProxy()->GetValueClass()==0 &&
                cl->GetCollectionProxy()->GetType()>0) {

               previnfo->fNext =
                        new TFormLeafInfoNumerical(cl->GetCollectionProxy());
               previnfo = previnfo->fNext;
            } else {
               // nothing to do
            }
         }

      } else if (strlen(right)==0 && cl && element && final) {

         TClass *elemCl = element->GetClassPointer();
         if (!useLeafCollectionObject
             && elemCl && elemCl->GetCollectionProxy()
             && elemCl->GetCollectionProxy()->GetValueClass()
             && elemCl->GetCollectionProxy()->GetValueClass()->GetCollectionProxy()) {

            TFormLeafInfo *collectioninfo =
               new TFormLeafInfoCollection(cl, 0, elemCl);

            // The dimension needs to be handled!
            numberOfVarDim += RegisterDimensions(code,collectioninfo,maininfo,kFALSE);

            maininfo = collectioninfo;
            previnfo = collectioninfo;

            TFormLeafInfo *multi =
               new TFormLeafInfoMultiVarDimCollection(elemCl, 0,
                                                      elemCl->GetCollectionProxy()->GetValueClass(),
                                                      collectioninfo);

            fHasMultipleVarDim[code] = kTRUE;
            numberOfVarDim += RegisterDimensions(code,multi,maininfo,kFALSE);
            previnfo->fNext = multi;
            cl = elemCl->GetCollectionProxy()->GetValueClass();
            multi->fNext =  new TFormLeafInfoCollection(cl, 0, cl, false);
            previnfo = multi->fNext;

            if (cl->GetCollectionProxy()->GetValueClass()==0 &&
                cl->GetCollectionProxy()->GetType()>0) {

               previnfo->fNext =
                  new TFormLeafInfoNumerical(cl->GetCollectionProxy());
               previnfo = previnfo->fNext;
            }

         } else if (!useLeafCollectionObject
               && elemCl && elemCl->GetCollectionProxy()
               && elemCl->GetCollectionProxy()->GetValueClass()==0
               && elemCl->GetCollectionProxy()->GetType()>0) {

            // At this point we have an element which is inside a class (which is not
            // a collection) and this element of a collection of numerical type.
            // (Note: it is not possible to have more than one variable dimension
            //  unless we were supporting variable size C-style array of collection).

            TFormLeafInfo* collectioninfo =
               new TFormLeafInfoCollection(cl, 0, elemCl);

            // The dimension needs to be handled!
            numberOfVarDim += RegisterDimensions(code,collectioninfo,maininfo,kFALSE);

            collectioninfo->fNext =
               new TFormLeafInfoNumerical(elemCl->GetCollectionProxy());

            maininfo = collectioninfo;
            previnfo = maininfo->fNext;

         }  else if (!useLeafCollectionObject
                     && elemCl && elemCl->GetCollectionProxy()) {
            if (elemCl->GetCollectionProxy()->GetValueClass()==TString::Class()) {
               right = "Data()";
            } else if (elemCl->GetCollectionProxy()->GetValueClass()==stdStringClass) {
               right = "c_str()";
            }

         } else if (!element->IsaPointer()) {
            
            maininfo = new TFormLeafInfoDirect(branchEl);
            previnfo = maininfo;
            
         }
      }
      else if ( cl && cl->GetReferenceProxy() )  {
         if ( useLeafCollectionObject || fullExpression[0] == '@' || fullExpression[strlen(scratch)] == '@' ) {
            useLeafReferenceObject = true;
         }
         else  {
            if ( !maininfo )  {
               maininfo = previnfo = new TFormLeafInfoReference(cl, element, 0);
               numberOfVarDim += RegisterDimensions(code,maininfo,maininfo,kFALSE);
            }
            TVirtualRefProxy *refproxy = cl->GetReferenceProxy();
            for(Long64_t i=0; i<leaf->GetBranch()->GetEntries()-readentry; ++i)  {
               R__LoadBranch(leaf->GetBranch(), readentry+i, fQuickLoad);
               void *refobj = maininfo->GetValuePointer(leaf,0);
               if (refobj) {
                  cl = refproxy->GetValueClass(refobj);
               }               
               if ( cl ) break;
            }
            if ( !cl )  {
               Error("DefinedVariable","Failed to access class type of reference target (%s)",element->GetName());
               return -1;
            }
         }
      }
   }

   // Treat the dimension information in the leaf name, title and 2nd branch count
   if (leaf) numberOfVarDim += RegisterDimensions(code,leaf);

   if (cl) {
      if (unwindCollection) {
         // So far we should get here only if we encounter a split collection of a class that contains
         // directly a collection.
         R__ASSERT(numberOfVarDim==1 && maininfo);

         if (!useLeafCollectionObject && cl && cl->GetCollectionProxy()) {
            TFormLeafInfo *multi =
               new TFormLeafInfoMultiVarDimCollection(cl, 0, cl, maininfo);
            fHasMultipleVarDim[code] = kTRUE;
            numberOfVarDim += RegisterDimensions(code,multi,maininfo,kFALSE);
            previnfo->fNext = multi;

            multi->fNext =  new TFormLeafInfoCollection(cl, 0, cl, false);
            previnfo = multi->fNext;

            if (cl->GetCollectionProxy()->GetValueClass()==0 &&
                cl->GetCollectionProxy()->GetType()>0) {

               previnfo->fNext =
                  new TFormLeafInfoNumerical(cl->GetCollectionProxy());
               previnfo = previnfo->fNext;
            }
         } else if (!useLeafCollectionObject && cl == TClonesArray::Class()) {

            TFormLeafInfo *multi =
               new TFormLeafInfoMultiVarDimClones(cl, 0, cl, maininfo);
            fHasMultipleVarDim[code] = kTRUE;
            numberOfVarDim += RegisterDimensions(code,multi,maininfo,kFALSE);
            previnfo->fNext = multi;

            multi->fNext =  new TFormLeafInfoClones(cl, 0, false);
            previnfo = multi->fNext;
         }
      }
      Int_t offset=0;
      if (cl == TString::Class() && strcmp(right,"fData")==0) {
         // For backward compatibility replace TString::fData which no longer exist
         // by a call to TString::Data()
         right = "Data()";
      }
      Int_t nchname = strlen(right);
      TFormLeafInfo *leafinfo = 0;
      TStreamerElement* element = 0;

      // Let see if the leaf was attempted to be casted.
      // Since there would have been something like
      // ((cast_class*)leafname)->....  we need to use
      // paran_level+1
      // Also we disable this functionality in case of TClonesArray
      // because it is not yet allowed to have 'inheritance' (or virtuality)
      // in play in a TClonesArray.
      {
         TClass * casted = (TClass*) castqueue.At(paran_level+1);
         if (casted && cl != TClonesArray::Class()) {
            if ( ! casted->InheritsFrom(cl) ) {
               Error("DefinedVariable","%s does not inherit from %s.  Casting not possible!",
                     casted->GetName(),cl->GetName());
               return -2;
            }
            leafinfo = new TFormLeafInfoCast(cl,casted);
            fHasCast = kTRUE;
            if (maininfo==0) {
               maininfo = leafinfo;
            }
            if (previnfo==0) {
               previnfo = leafinfo;
            } else {
               previnfo->fNext = leafinfo;
               previnfo = leafinfo;
            }
            leafinfo = 0;
            
            cl = casted;
            castqueue.AddAt(0,paran_level);
         }
      }
      Int_t i;
      Bool_t prevUseCollectionObject = useLeafCollectionObject;
      Bool_t useCollectionObject = useLeafCollectionObject;
      Bool_t useReferenceObject = useLeafReferenceObject;
      Bool_t prevUseReferenceObject = useLeafReferenceObject;
      for (i=0, current = &(work[0]); i<=nchname;i++ ) {
         // We will treated the terminator as a token.
         if (right[i] == '(') {
            // Right now we do not allow nested paranthesis
            do {
               *current++ = right[i++];
            } while(right[i]!=')' && right[i]);
            *current++ = right[i];
            *current='\0';
            char *params = strchr(work,'(');
            if (params) {
               *params = 0; params++;
            } else params = (char *) ")";
            if (cl==0) {
               Error("DefinedVariable","Can not call '%s' with a class",work);
               return -1;
            }
            if (cl->GetClassInfo()==0 && !cl->GetCollectionProxy()) {
               Error("DefinedVariable","Class probably unavailable:%s",cl->GetName());
               return -2;
            }
            if (!useCollectionObject && cl == TClonesArray::Class()) {
               // We are not interested in the ClonesArray object but only
               // in its contents.
               // We need to retrieve the class of its content.

               TBranch *clbranch = leaf->GetBranch();
               R__LoadBranch(clbranch,readentry,fQuickLoad);
               TClonesArray * clones;
               if (previnfo) clones = (TClonesArray*)previnfo->GetLocalValuePointer(leaf,0);
               else {
                  Bool_t top = (clbranch==((TBranchElement*)clbranch)->GetMother()
                                 || !leaf->IsOnTerminalBranch());
                  TClass *mother_cl;
                  if (leaf->IsA()==TLeafObject::Class()) {
                     // in this case mother_cl is not really used
                     mother_cl = cl;
                  } else {
                     mother_cl = ((TBranchElement*)clbranch)->GetInfo()->GetClass();
                  }
                  TFormLeafInfo* clonesinfo = new TFormLeafInfoClones(mother_cl, 0, top);

                  // The dimension needs to be handled!
                  numberOfVarDim += RegisterDimensions(code,clonesinfo,maininfo,kFALSE);

                  previnfo = clonesinfo;
                  maininfo = clonesinfo;

                  clones = (TClonesArray*)clonesinfo->GetLocalValuePointer(leaf,0);
               }
               TClass * inside_cl = clones->GetClass();
               cl = inside_cl;

            }
            else if (!useCollectionObject && cl && cl->GetCollectionProxy() ) {

               // We are NEVER (for now!) interested in the ClonesArray object but only
               // in its contents.
               // We need to retrieve the class of its content.

               if (previnfo==0) {

                  Bool_t top = (branch==((TBranchElement*)branch)->GetMother()
                                 || !leaf->IsOnTerminalBranch());

                  TClass *mother_cl;
                  if (leaf->IsA()==TLeafObject::Class()) {
                     // in this case mother_cl is not really used
                     mother_cl = cl;
                  } else {
                     mother_cl = ((TBranchElement*)branch)->GetInfo()->GetClass();
                  }

                  TFormLeafInfo* collectioninfo =
                     new TFormLeafInfoCollection(mother_cl, 0,cl,top);
                  // The dimension needs to be handled!
                  numberOfVarDim += RegisterDimensions(code,collectioninfo,maininfo,kFALSE);

                  previnfo = collectioninfo;
                  maininfo = collectioninfo;

               }

               TClass * inside_cl = cl->GetCollectionProxy()->GetValueClass();
               if (inside_cl) cl = inside_cl;
               else if (cl->GetCollectionProxy()->GetType()>0) {
                  Warning("DefinedVariable","Can not call method on content of %s in %s\n",
                           cl->GetName(),name.Data());
                  return -2;
               }
            }
            TMethodCall *method  = 0;
            if (cl==0) {
               Error("DefinedVariable",
                     "Could not discover the TClass corresponding to (%s)!",
                     right);
               return -2;
            } else if (cl==TClonesArray::Class() && strcmp(work,"size")==0) {
               method = new TMethodCall(cl, "GetEntriesFast", "");
            } else if (cl->GetCollectionProxy() && strcmp(work,"size")==0) {
               if (maininfo==0) {
                  TFormLeafInfo* collectioninfo=0;
                  if (useLeafCollectionObject) {

                     Bool_t top = (branch==((TBranchElement*)branch)->GetMother()
                                 || !leaf->IsOnTerminalBranch());
                     collectioninfo = new TFormLeafInfoCollectionObject(cl,top);
                  }
                  maininfo=previnfo=collectioninfo;
               }
               leafinfo = new TFormLeafInfoCollectionSize(cl);
               cl = 0;
            } else {
               if (cl->GetClassInfo()==0) {
                  Error("DefinedVariable",
                        "Can not call method %s on class without dictionary (%s)!",
                        right,cl->GetName());
                  return -2;
               }
               method = new TMethodCall(cl, work, params);
            }
            if (method) {
               if (!method->GetMethod()) {
                  Error("DefinedVariable","Unknown method:%s in %s",right,cl->GetName());
                  return -1;
               }
               switch(method->ReturnType()) {
                  case TMethodCall::kLong:
                     leafinfo = new TFormLeafInfoMethod(cl,method);
                     cl = 0;
                     break;
                  case TMethodCall::kDouble:
                     leafinfo = new TFormLeafInfoMethod(cl,method);
                     cl = 0;
                     break;
                  case TMethodCall::kString:
                     leafinfo = new TFormLeafInfoMethod(cl,method);
                     // 1 will be replaced by -1 when we know how to use strlen
                     numberOfVarDim += RegisterDimensions(code,1); //NOTE: changed from 0
                     cl = 0;
                     break;
                  case TMethodCall::kOther:
                     {
                        TString return_type =
                          gInterpreter->TypeName(method->GetMethod()->GetReturnTypeName());
                        leafinfo = new TFormLeafInfoMethod(cl,method);
                        cl = (return_type == "void") ? 0 : TClass::GetClass(return_type.Data());
                     }
                     break;
                  default:
                     Error("DefineVariable","Method %s from %s has an impossible return type %d",
                        work,cl->GetName(),method->ReturnType());
                     return -2;
               }
            }
            if (maininfo==0) {
               maininfo = leafinfo;
            }
            if (previnfo==0) {
               previnfo = leafinfo;
            } else {
               previnfo->fNext = leafinfo;
               previnfo = leafinfo;
            }
            leafinfo = 0;
            current = &(work[0]);
            *current = 0;
            prevUseCollectionObject = kFALSE;
            prevUseReferenceObject = kFALSE;
            useCollectionObject = kFALSE;

            if (cl && cl->GetCollectionProxy()) {
               if (numberOfVarDim>1) {
                  Warning("DefinedVariable","TTreeFormula support only 2 level of variables size collections.  Assuming '@' notation for the collection %s.",
                     cl->GetName());
                  leafinfo = new TFormLeafInfo(cl,0,0);
                  useCollectionObject = kTRUE;
               } else if (numberOfVarDim==0) {
                  R__ASSERT(maininfo);
                  leafinfo = new TFormLeafInfoCollection(cl,0,cl);
                  numberOfVarDim += RegisterDimensions(code,leafinfo,maininfo,kFALSE);
               } else if (numberOfVarDim==1) {
                  R__ASSERT(maininfo);
                  leafinfo =
                     new TFormLeafInfoMultiVarDimCollection(cl,0,
                     (TStreamerElement*)0,maininfo);
                  previnfo->fNext = leafinfo;
                  previnfo = leafinfo;
                  leafinfo = new TFormLeafInfoCollection(cl,0,cl);

                  fHasMultipleVarDim[code] = kTRUE;
                  numberOfVarDim += RegisterDimensions(code,leafinfo,maininfo,kFALSE);
               }
               previnfo->fNext = leafinfo;
               previnfo = leafinfo;
               leafinfo = 0;
            }
            continue;
         } else if (right[i] == ')') {
            // We should have the end of a cast operator.  Let's introduce a TFormLeafCast
            // in the chain.
            TClass * casted = (TClass*) ((int(--paran_level)>=0) ? castqueue.At(paran_level) : 0);
            if (casted) {
               leafinfo = new TFormLeafInfoCast(cl,casted);
               fHasCast = kTRUE;

               if (maininfo==0) {
                  maininfo = leafinfo;
               }
               if (previnfo==0) {
                  previnfo = leafinfo;
               } else {
                  previnfo->fNext = leafinfo;
                  previnfo = leafinfo;
               }
               leafinfo = 0;
               current = &(work[0]);
               *current = 0;

               cl = casted;
               continue;

            }
         } else if (i > 0 && (right[i] == '.' || right[i] == '[' || right[i] == '\0') ) {
            // A delimiter happened let's see if what we have seen
            // so far does point to a data member.
            Bool_t needClass = kTRUE;
            *current = '\0';

            // skip it all if there is nothing to look at
            if (strlen(work)==0) continue;

            prevUseCollectionObject = useCollectionObject;
            prevUseReferenceObject = useReferenceObject;
            if (work[0]=='@') {
               useReferenceObject = kTRUE;
               useCollectionObject = kTRUE;
               Int_t l = 0;
               for(l=0;work[l+1]!=0;++l) work[l] = work[l+1];
               work[l] = '\0';
            } else if (work[strlen(work)-1]=='@') {
               useReferenceObject = kTRUE;
               useCollectionObject = kTRUE;
               work[strlen(work)-1] = '\0';
            } else {
               useReferenceObject = kFALSE;
               useCollectionObject = kFALSE;
            }

            Bool_t mustderef = kFALSE;
            if ( !prevUseReferenceObject && cl && cl->GetReferenceProxy() )  {
               R__LoadBranch(leaf->GetBranch(), readentry, fQuickLoad);
               if ( !maininfo )  {
                  maininfo = previnfo = new TFormLeafInfoReference(cl, element, offset);
                  if ( cl->GetReferenceProxy()->HasCounter() )  {
                     numberOfVarDim += RegisterDimensions(code,-1);
                  }
                  prevUseReferenceObject = kFALSE;
               } else {
                  previnfo->fNext = new TFormLeafInfoReference(cl, element, offset);
                  previnfo = previnfo->fNext;
               }
               TVirtualRefProxy *refproxy = cl->GetReferenceProxy();
               cl = 0;
               for(Long64_t entry=0; entry<leaf->GetBranch()->GetEntries()-readentry; ++entry)  {
                  R__LoadBranch(leaf->GetBranch(), readentry+i, fQuickLoad);
                  void *refobj = maininfo->GetValuePointer(leaf,0);
                  if (refobj) {
                     cl = refproxy->GetValueClass(refobj);
                  }
                  if ( cl ) break;
               }
               needClass = kFALSE;
               mustderef = kTRUE;
            }
            else if (!prevUseCollectionObject && cl == TClonesArray::Class()) {
               // We are not interested in the ClonesArray object but only
               // in its contents.
               // We need to retrieve the class of its content.

               TBranch *clbranch = leaf->GetBranch();
               R__LoadBranch(clbranch,readentry,fQuickLoad);
               TClonesArray * clones;
               if (maininfo) {
                  clones = (TClonesArray*)maininfo->GetValuePointer(leaf,0);
               } else {
                  // we have a unsplit TClonesArray leaves
                  // or we did not yet match any of the sub-branches!

                  TClass *mother_cl;
                  if (leaf->IsA()==TLeafObject::Class()) {
                     // in this case mother_cl is not really used
                     mother_cl = cl;
                  } else {
                     mother_cl = ((TBranchElement*)clbranch)->GetInfo()->GetClass();
                  }

                  TFormLeafInfo* clonesinfo = new TFormLeafInfoClones(mother_cl, 0);
                  // The dimension needs to be handled!
                  numberOfVarDim += RegisterDimensions(code,clonesinfo,maininfo,kFALSE);

                  mustderef = kTRUE;
                  previnfo = clonesinfo;
                  maininfo = clonesinfo;

                  if (clbranch->GetListOfBranches()->GetLast()>=0) {
                     if (clbranch->IsA() != TBranchElement::Class()) {
                        Error("DefinedVariable","Unimplemented usage of ClonesArray");
                        return -2;
                     }
                     //clbranch = ((TBranchElement*)clbranch)->GetMother();
                     clones = (TClonesArray*)((TBranchElement*)clbranch)->GetObject();
                  } else
                     clones = (TClonesArray*)clonesinfo->GetLocalValuePointer(leaf,0);
               }
               // NOTE clones can be zero!
               if (clones==0) {
                  Warning("DefinedVariable",
                          "TClonesArray object was not retrievable for %s!",
                          name.Data());
                  return -1;
               }
               TClass * inside_cl = clones->GetClass();
#if 1
               cl = inside_cl; 
#else
/* Maybe we should make those test lead to warning messages */
               if (1 || inside_cl) cl = inside_cl;
               // if inside_cl is nul ... we have a problem of inconsistency :(
               if (0 && strlen(work)==0) {
                  // However in this case we have NO content :(
                  // so let get the number of objects
                  //strcpy(work,"fLast");
               }
#endif
            } else if (!prevUseCollectionObject && cl && cl->GetCollectionProxy() ) {

               // We are NEVER interested in the Collection object but only
               // in its contents.
               // We need to retrieve the class of its content.

               TBranch *clbranch = leaf->GetBranch();
               R__LoadBranch(clbranch,readentry,fQuickLoad);

               if (maininfo==0) {

                  // we have a unsplit Collection leaf
                  // or we did not yet match any of the sub-branches!

                  TClass *mother_cl;
                  if (leaf->IsA()==TLeafObject::Class()) {
                     // in this case mother_cl is not really used
                     mother_cl = cl;
                  } else {
                     mother_cl = ((TBranchElement*)clbranch)->GetInfo()->GetClass();
                  }

                  TFormLeafInfo* collectioninfo =
                     new TFormLeafInfoCollection(mother_cl, 0, cl);
                  // The dimension needs to be handled!
                  numberOfVarDim += RegisterDimensions(code,collectioninfo,maininfo,kFALSE);

                  mustderef = kTRUE;
                  previnfo = collectioninfo;
                  maininfo = collectioninfo;

               } //else if (clbranch->GetStreamerType()==0) {

               //}

               TClass * inside_cl = cl->GetCollectionProxy()->GetValueClass();

               if (!inside_cl && cl->GetCollectionProxy()->GetType() > 0) {
                  Warning("DefinedVariable","No data member in content of %s in %s\n",
                           cl->GetName(),name.Data());
               }
               cl = inside_cl;
               // if inside_cl is nul ... we have a problem of inconsistency.
            }

            if (!cl) {
               Warning("DefinedVariable","Missing class for %s!",name.Data());
            } else {
               element = ((TStreamerInfo*)cl->GetStreamerInfo())->GetStreamerElement(work,offset);
            }

            if (!element && !prevUseCollectionObject) {
               // We allow for looking for a data member inside a class inside
               // a TClonesArray without mentioning the TClonesArrays variable name
               TIter next( cl->GetStreamerInfo()->GetElements() );
               TStreamerElement * curelem;
               while ((curelem = (TStreamerElement*)next())) {
                  if (curelem->GetClassPointer() ==  TClonesArray::Class()) {
                     Int_t clones_offset = 0;
                     ((TStreamerInfo*)cl->GetStreamerInfo())->GetStreamerElement(curelem->GetName(),clones_offset);
                     TFormLeafInfo* clonesinfo =
                        new TFormLeafInfo(cl, clones_offset, curelem);
                     TClonesArray * clones;
                     R__LoadBranch(leaf->GetBranch(),readentry,fQuickLoad);

                     if (previnfo) {
                        previnfo->fNext = clonesinfo;
                        clones = (TClonesArray*)maininfo->GetValuePointer(leaf,0);
                        previnfo->fNext = 0;
                     } else {
                        clones = (TClonesArray*)clonesinfo->GetLocalValuePointer(leaf,0);
                     }

                     TClass *sub_cl = clones->GetClass();
                     if (sub_cl) element = ((TStreamerInfo*)sub_cl->GetStreamerInfo())->GetStreamerElement(work,offset);
                     delete clonesinfo;

                     if (element) {
                        leafinfo = new TFormLeafInfoClones(cl,clones_offset,curelem);
                        numberOfVarDim += RegisterDimensions(code,leafinfo,maininfo,kFALSE);
                        if (maininfo==0) maininfo = leafinfo;
                        if (previnfo==0) previnfo = leafinfo;
                        else {
                           previnfo->fNext = leafinfo;
                           previnfo = leafinfo;
                        }
                        leafinfo = 0;
                        cl = sub_cl;
                        break;
                     }
                  } else if (curelem->GetClassPointer() && curelem->GetClassPointer()->GetCollectionProxy()) {

                     Int_t coll_offset = 0;
                     ((TStreamerInfo*)cl->GetStreamerInfo())->GetStreamerElement(curelem->GetName(),coll_offset);

                     TClass *sub_cl =
                        curelem->GetClassPointer()->GetCollectionProxy()->GetValueClass();
                     if (sub_cl) {
                        element = ((TStreamerInfo*)sub_cl->GetStreamerInfo())->GetStreamerElement(work,offset);
                     }
                     if (element) {
                        if (numberOfVarDim>1) {
                           Warning("DefinedVariable","TTreeFormula support only 2 level of variables size collections.  Assuming '@' notation for the collection %s.",
                                   curelem->GetName());
                           leafinfo = new TFormLeafInfo(cl,coll_offset,curelem);
                           useCollectionObject = kTRUE;
                        } else if (numberOfVarDim==1) {
                           R__ASSERT(maininfo);
                           leafinfo =
                              new TFormLeafInfoMultiVarDimCollection(cl,coll_offset,
                                                                     curelem,maininfo);
                           fHasMultipleVarDim[code] = kTRUE;
                           leafinfo->fNext = new TFormLeafInfoCollection(cl,coll_offset,curelem);
                           numberOfVarDim += RegisterDimensions(code,leafinfo,maininfo,kFALSE);
                        } else {
                           leafinfo = new TFormLeafInfoCollection(cl,coll_offset,curelem);
                           numberOfVarDim += RegisterDimensions(code,leafinfo,maininfo,kFALSE);
                        }
                        if (maininfo==0) maininfo = leafinfo;
                        if (previnfo==0) previnfo = leafinfo;
                        else {
                           previnfo->fNext = leafinfo;
                           previnfo = leafinfo;
                        }
                        if (leafinfo->fNext) {
                           previnfo = leafinfo->fNext;
                        }
                        leafinfo = 0;
                        cl = sub_cl;
                        break;
                     }
                  }
               }

            }

            if (element) {
               Int_t type = element->GetNewType();
               if (type<60 && type!=0) {
                  // This is a basic type ...
                  if (numberOfVarDim>=1 && type>40) {
                     // We have a variable array within a variable array!
                     leafinfo = new TFormLeafInfoMultiVarDim(cl,offset,element,maininfo);
                     fHasMultipleVarDim[code] = kTRUE;
                  } else {
                     if (leafinfo && type<=40 ) {
                        leafinfo->AddOffset(offset,element);
                     } else {
                        leafinfo = new TFormLeafInfo(cl,offset,element);
                     }
                  }
               } else {
                  Bool_t object = kFALSE;
                  Bool_t pointer = kFALSE;
                  Bool_t objarr = kFALSE;
                  switch(type) {
                     case TStreamerInfo::kObjectp:
                     case TStreamerInfo::kObjectP:
                     case TStreamerInfo::kSTLp:
                     case TStreamerInfo::kAnyp:
                     case TStreamerInfo::kAnyP:
                     case TStreamerInfo::kOffsetL + TStreamerInfo::kObjectP:
                     case TStreamerInfo::kOffsetL + TStreamerInfo::kSTLp:
                     case TStreamerInfo::kOffsetL + TStreamerInfo::kAnyp:
                     case TStreamerInfo::kOffsetL + TStreamerInfo::kObjectp:
                     case TStreamerInfo::kOffsetL + TStreamerInfo::kAnyP:
                        pointer = kTRUE;
                        break;
                     case TStreamerInfo::kBase:
                     case TStreamerInfo::kAny :
                     case TStreamerInfo::kSTL:
                     case TStreamerInfo::kObject:
                     case TStreamerInfo::kTString:
                     case TStreamerInfo::kTNamed:
                     case TStreamerInfo::kTObject:
                        object = kTRUE;
                        break;
                     case TStreamerInfo::kOffsetL + TStreamerInfo::kAny:
                     case TStreamerInfo::kOffsetL + TStreamerInfo::kSTL:
                     case TStreamerInfo::kOffsetL + TStreamerInfo::kObject:
                        objarr = kTRUE;
                        break;
                     case TStreamerInfo::kStreamer:
                     case TStreamerInfo::kStreamLoop:
                        // Unsupported case.
                        Error("DefinedVariable",
                              "%s is a datamember of %s BUT is not yet of a supported type (%d)",
                              right,cl ? cl->GetName() : "unknown class",type);
                        return -2;
                     default:
                        // Unknown and Unsupported case.
                        Error("DefinedVariable",
                              "%s is a datamember of %s BUT is not of a unknown type (%d)",
                              right,cl ? cl->GetName() : "unknown class",type);
                        return -2;
                  }

                  if (object && !useCollectionObject &&
                      ( element->GetClassPointer() ==  TClonesArray::Class()
                        || element->GetClassPointer()->GetCollectionProxy() ) )
                  {
                     object = kFALSE;
                  }
                  if (object && leafinfo) {
                     leafinfo->AddOffset(offset,element);
                  } else if (objarr) {
                     // This is an embedded array of objects. We can not increase the offset.
                     leafinfo = new TFormLeafInfo(cl,offset,element);
                     mustderef = kTRUE;
                  } else {

                     if (!useCollectionObject && element->GetClassPointer() ==  TClonesArray::Class()) {

                        leafinfo = new TFormLeafInfoClones(cl,offset,element);
                        mustderef = kTRUE;

                     } else if (!useCollectionObject &&  element->GetClassPointer()
                                && element->GetClassPointer()->GetCollectionProxy()) {

                        mustderef = kTRUE;
                        if (numberOfVarDim>1) {
                           Warning("DefinedVariable","TTreeFormula support only 2 level of variables size collections.  Assuming '@' notation for the collection %s.",
                                   element->GetName());
                           leafinfo = new TFormLeafInfo(cl,offset,element);
                           useCollectionObject = kTRUE;
                        } else if (numberOfVarDim==1) {
                           R__ASSERT(maininfo);
                           leafinfo =
                              new TFormLeafInfoMultiVarDimCollection(cl,offset,element,maininfo);

                           fHasMultipleVarDim[code] = kTRUE;
                           //numberOfVarDim += RegisterDimensions(code,leafinfo);
                           //cl = cl->GetCollectionProxy()->GetValueClass();

                           //if (maininfo==0) maininfo = leafinfo;
                           //if (previnfo==0) previnfo = leafinfo;
                           //else {
                           //   previnfo->fNext = leafinfo;
                           //   previnfo = leafinfo;
                           //}
                           leafinfo->fNext =  new TFormLeafInfoCollection(cl, offset, element);
                           if (element->GetClassPointer()->GetCollectionProxy()->GetValueClass()==0) {
                              TFormLeafInfo *info = new TFormLeafInfoNumerical(
                                 element->GetClassPointer()->GetCollectionProxy());
                              if (leafinfo->fNext) leafinfo->fNext->fNext = info;
                              else leafinfo->fNext = info;
                           }
                        } else {
                           leafinfo =  new TFormLeafInfoCollection(cl, offset, element);

                           TClass *elemCl = element->GetClassPointer();
                           TClass *valueCl = elemCl->GetCollectionProxy()->GetValueClass();
                           if (!maininfo) maininfo = leafinfo;

                           if (valueCl!=0 && valueCl->GetCollectionProxy()!=0) {

                              numberOfVarDim += RegisterDimensions(code,leafinfo,maininfo,kFALSE);
                              if (previnfo==0) previnfo = leafinfo;
                              else {
                                 previnfo->fNext = leafinfo;
                                 previnfo = leafinfo;
                              }
                              leafinfo = new TFormLeafInfoMultiVarDimCollection(elemCl,0,
                                 elemCl->GetCollectionProxy()->GetValueClass(),maininfo);
                              //numberOfVarDim += RegisterDimensions(code,previnfo->fNext);
                              fHasMultipleVarDim[code] = kTRUE;
                              //previnfo = previnfo->fNext;
                              leafinfo->fNext =  new TFormLeafInfoCollection(elemCl,0,
                                 valueCl);
                              elemCl = valueCl;
                           }
                           if (elemCl->GetCollectionProxy() &&
                               elemCl->GetCollectionProxy()->GetValueClass()==0) {
                              TFormLeafInfo *info = new TFormLeafInfoNumerical(elemCl->GetCollectionProxy());
                              if (leafinfo->fNext) leafinfo->fNext->fNext = info;
                              else leafinfo->fNext = info;
                           }
                        }
                     } else if ( (object || pointer) && !useReferenceObject && element->GetClassPointer()->GetReferenceProxy() ) {
                        TClass* c = element->GetClassPointer();
                        R__LoadBranch(leaf->GetBranch(),readentry,fQuickLoad);
                        if ( object )  {
                           leafinfo = new TFormLeafInfoReference(c, element, offset);
                        }
                        else  {
                           leafinfo = new TFormLeafInfoPointer(cl,offset,element);
                           leafinfo->fNext = new TFormLeafInfoReference(c, element, 0);
                        }
                        //if ( c->GetReferenceProxy()->HasCounter() )  {
                        //   numberOfVarDim += RegisterDimensions(code,-1);
                        //}
                        prevUseReferenceObject = kFALSE;
                        needClass = kFALSE;
                        mustderef = kTRUE;
                     } else if (pointer) {
                        // this is a pointer to be followed.
                        leafinfo = new TFormLeafInfoPointer(cl,offset,element);
                        mustderef = kTRUE;
                     } else {
                        // this is an embedded object.
                        R__ASSERT(object);
                        leafinfo = new TFormLeafInfo(cl,offset,element);
                     }
                  }
               }
            } else {
               if (cl) Error("DefinedVariable","%s is not a datamember of %s",work,cl->GetName());
               // no else, we warned earlier that the class was missing.
               return -1;
            }

            numberOfVarDim += RegisterDimensions(code,leafinfo,maininfo,useCollectionObject); // Note or useCollectionObject||prevUseColectionObject
            if (maininfo==0) {
               maininfo = leafinfo;
            }
            if (previnfo==0) {
               previnfo = leafinfo;
            } else if (previnfo!=leafinfo) {
               previnfo->fNext = leafinfo;
               previnfo = leafinfo;
            }
            while (previnfo->fNext) previnfo = previnfo->fNext;

            if ( right[i] != '\0' )  {
               if ( !needClass && mustderef )   {
                  maininfo->SetBranch(leaf->GetBranch());
                  char *ptr = (char*)maininfo->GetValuePointer(leaf,0);
                  TFormLeafInfoReference* refInfo = 0;
                  if ( !maininfo->IsReference() )  {
                     for( TFormLeafInfo* inf = maininfo->fNext; inf; inf = inf->fNext )  {
                        if ( inf->IsReference() )  {
                           refInfo = (TFormLeafInfoReference*)inf;
                        }
                     }
                  }
                  else {
                     refInfo = (TFormLeafInfoReference*)maininfo;
                  }
                  if ( refInfo )  {
                     cl = refInfo->GetValueClass(ptr);
                     if ( !cl )  {
                        Error("DefinedVariable","Failed to access class type of reference target (%s)",element->GetName());
                        return -1;
                     }
                     element = ((TStreamerInfo*)cl->GetStreamerInfo())->GetStreamerElement(work,offset);
                  }
                  else  {
                     Error("DefinedVariable","Failed to access class type of reference target (%s)",element->GetName());
                     return -1;
                  }
               }
               else if ( needClass )  {
                  cl = element->GetClassPointer();
               }
            }
            if (mustderef) leafinfo = 0;
            current = &(work[0]);
            *current = 0;
            R__ASSERT(right[i] != '[');  // We are supposed to have removed all dimensions already!

            if (cl == TString::Class() && strcmp(right+i+1,"fData") == 0) {
               // For backward compatibility replace TString::fData which no longer exist
               // by a call to TString::Data()
               right = ".Data()";
               i = 0;
               nchname = strlen(right);
            }

         } else
            *current++ = right[i];
      }
      if (maininfo) {
         fDataMembers.AddAtAndExpand(maininfo,code);
         if (leaf) fLookupType[code] = kDataMember;
         else fLookupType[code] = kTreeMember;
      }
   }

   if (strlen(work)!=0) {
      // We have something left to analyze.  Let's make this an error case!
      return -1;
   }

   TClass *objClass = EvalClass(code);
   if (objClass && !useLeafCollectionObject && objClass->GetCollectionProxy() && objClass->GetCollectionProxy()->GetValueClass()) {
      TFormLeafInfo *last = 0;
      if ( SwitchToFormLeafInfo(code) ) {
         
         last = (TFormLeafInfo*)fDataMembers.At(code);
         
         if (!last) return action;
         while (last->fNext) { last = last->fNext; }
         
      }
      if (last && last->GetClass() != objClass) {
         TClass *mother_cl;
         if (leaf->IsA()==TLeafObject::Class()) {
            // in this case mother_cl is not really used
            mother_cl = cl;
         } else {
            mother_cl = ((TBranchElement*)branch)->GetInfo()->GetClass();
         }
         
         TFormLeafInfo* collectioninfo = new TFormLeafInfoCollection(mother_cl, 0, objClass, kFALSE);
         // The dimension needs to be handled!
         numberOfVarDim += RegisterDimensions(code,collectioninfo,maininfo,kFALSE);
         last->fNext = collectioninfo;
      }
      numberOfVarDim += RegisterDimensions(code,1); //NOTE: changed from 0
      objClass = objClass->GetCollectionProxy()->GetValueClass();
   }
   if (IsLeafString(code) || objClass == TString::Class() || objClass == stdStringClass) {

      TFormLeafInfo *last = 0;
      if ( SwitchToFormLeafInfo(code) ) {

         last = (TFormLeafInfo*)fDataMembers.At(code);

         if (!last) return action;
         while (last->fNext) { last = last->fNext; }

      }
      const char *funcname = 0;
      if (objClass == TString::Class()) {
         funcname = "Data";
         //tobetested: numberOfVarDim += RegisterDimensions(code,1,0); // Register the dim of the implied char*
      } else if (objClass == stdStringClass) {
         funcname = "c_str";
         //tobetested: numberOfVarDim += RegisterDimensions(code,1,0); // Register the dim of the implied char*
      }
      if (funcname) {
         TMethodCall *method = new TMethodCall(objClass, funcname, "");
         if (last) {
            last->fNext = new TFormLeafInfoMethod(objClass,method);
         } else {
            fDataMembers.AddAtAndExpand(new TFormLeafInfoMethod(objClass,method),code);
            if (leaf) fLookupType[code] = kDataMember;
            else fLookupType[code] = kTreeMember;
         }
      }
      return kDefinedString;
   }

   if (objClass) {
      TMethodCall *method = new TMethodCall(objClass, "AsDouble", "");
      if (method->IsValid()
          && (method->ReturnType() == TMethodCall::kLong || method->ReturnType() == TMethodCall::kDouble)) {
         
         TFormLeafInfo *last = 0;
         if (SwitchToFormLeafInfo(code)) {
            last = (TFormLeafInfo*)fDataMembers.At(code);
            // Improbable case
            if (!last) {
               delete method;
               return action;
            }
            while (last->fNext) { last = last->fNext; }
         }
         if (last) {
            last->fNext = new TFormLeafInfoMethod(objClass,method);
         } else {
            fDataMembers.AddAtAndExpand(new TFormLeafInfoMethod(objClass,method),code);
            if (leaf) fLookupType[code] = kDataMember;
            else fLookupType[code] = kTreeMember;
         }            

         return kDefinedVariable;
      }
      delete method;
      method = new TMethodCall(objClass, "AsString", "");
      if (method->IsValid()
          && method->ReturnType() == TMethodCall::kString) {

         TFormLeafInfo *last = 0;
         if (SwitchToFormLeafInfo(code)) {
            last = (TFormLeafInfo*)fDataMembers.At(code);
            // Improbable case
            if (!last) {
               delete method;
               return action;
            }
            while (last->fNext) { last = last->fNext; }
         }
         if (last) {
            last->fNext = new TFormLeafInfoMethod(objClass,method);
         } else {
            fDataMembers.AddAtAndExpand(new TFormLeafInfoMethod(objClass,method),code);
            if (leaf) fLookupType[code] = kDataMember;
            else fLookupType[code] = kTreeMember;
         }            

         //tobetested: numberOfVarDim += RegisterDimensions(code,1,0); // Register the dim of the implied char*
         return kDefinedString;
      }
      if (method->IsValid()
          && method->ReturnType() == TMethodCall::kOther) {

         TClass *rcl = 0;
         TFunction *f = method->GetMethod();
         if (f) rcl = TClass::GetClass(gInterpreter->TypeName(f->GetReturnTypeName()));
         if ((rcl == TString::Class() || rcl == stdStringClass) ) {

            TFormLeafInfo *last = 0;
            if (SwitchToFormLeafInfo(code)) {
               last = (TFormLeafInfo*)fDataMembers.At(code);
               // Improbable case
               if (!last) {
                  delete method;
                  return action;
               }
               while (last->fNext) { last = last->fNext; }
            }
            if (last) {
               last->fNext = new TFormLeafInfoMethod(objClass,method);
               last = last->fNext;
            } else {
               last = new TFormLeafInfoMethod(objClass,method);
               fDataMembers.AddAtAndExpand(last,code);
               if (leaf) fLookupType[code] = kDataMember;
               else fLookupType[code] = kTreeMember;
            }

            objClass = rcl;

            const char *funcname = 0;
            if (objClass == TString::Class()) {
               funcname = "Data";
            } else if (objClass == stdStringClass) {
               funcname = "c_str";
            }
            if (funcname) {
               method = new TMethodCall(objClass, funcname, "");
               last->fNext = new TFormLeafInfoMethod(objClass,method);
            }
            return kDefinedString;
         }
      }
      delete method;
   }

   return action;
}
//______________________________________________________________________________
Int_t TTreeFormula::FindLeafForExpression(const char* expression, TLeaf*& leaf, TString& leftover, Bool_t& final, UInt_t& paran_level, TObjArray& castqueue, std::vector<std::string>& aliasUsed, Bool_t& useLeafCollectionObject, const char* fullExpression)
{
   // Look for the leaf corresponding to the start of expression.
   // It returns the corresponding leaf if any.
   // It also modify the following arguments:
   //   leftover: contain from expression that was not used to determine the leaf
   //   final:
   //   paran_level: number of un-matched open parenthesis
   //   cast_queue: list of cast to be done
   //   aliases: list of aliases used
   // Return <0 in case of failure
   // Return 0 if a leaf has been found
   // Return 2 if info about the TTree itself has been requested.

   // Later on we will need to read one entry, let's make sure
   // it is a real entry.
   if (fTree->GetTree()==0) {
      fTree->LoadTree(0);
      if (fTree->GetTree()==0) return -1;
   }
   Long64_t readentry = fTree->GetTree()->GetReadEntry();
   if (readentry < 0) readentry=0;
   const char *cname = expression;
   char    first[kMaxLen];  first[0] = '\0';
   char   second[kMaxLen]; second[0] = '\0';
   char    right[kMaxLen];  right[0] = '\0';
   char     work[kMaxLen];   work[0] = '\0';
   char     left[kMaxLen];   left[0] = '\0';
   char  scratch[kMaxLen];
   char scratch2[kMaxLen];
   std::string currentname;
   Int_t previousdot = 0;
   char *current;
   TLeaf *tmp_leaf=0;
   TBranch *branch=0, *tmp_branch=0;
   Int_t nchname = strlen(cname);
   Int_t i;
   Bool_t foundAtSign = kFALSE;

   for (i=0, current = &(work[0]); i<=nchname && !final;i++ ) {
      // We will treated the terminator as a token.
      *current++ = cname[i];

      if (cname[i] == '(') {
         ++paran_level;

         if (current==work+1) {
            // If the expression starts with a paranthesis, we are likely
            // to have a cast operator inside.
            current--;
         }
         continue;
         //i++;
         //while( cname[i]!=')' && cname[i] ) {
         //   *current++ = cname[i++];
         //}
         //*current++ = cname[i];
         ////*current = 0;
         //continue;
      }
      if (cname[i] == ')') {
         if (paran_level==0) {
            Error("DefinedVariable","Unmatched paranthesis in %s",fullExpression);
            return -1;
         }
         // Let's see if work is a classname.
         *(--current) = 0;
         paran_level--;
         TString cast_name = gInterpreter->TypeName(work);
         TClass *cast_cl = TClass::GetClass(cast_name);
         if (cast_cl) {
            // We must have a cast
            castqueue.AddAtAndExpand(cast_cl,paran_level);
            current = &(work[0]);
            *current = 0;
            //            Warning("DefinedVariable","Found cast to %s",cast_fullExpression);
            continue;
         } else if (gROOT->GetType(cast_name)) {
            // We reset work
            current = &(work[0]);
            *current = 0;
            Warning("DefinedVariable",
               "Casting to primary types like \"%s\" is not supported yet",cast_name.Data());
            continue;
         }

         *(current++)=')';
         *current='\0';
         char *params = strchr(work,'(');
         if (params) {
            *params = 0; params++;

            if (branch && !leaf) {
               // We have a branch but not a leaf.  We are likely to have found
               // the top of split branch.
               if (BranchHasMethod(0, branch, work, params, readentry)) {
                  //fprintf(stderr, "Does have a method %s for %s.\n", work, branch->GetName());
               }
            }

            // What we have so far might be a member function of one of the
            // leaves that are not splitted (for example "GetNtrack" for the Event class).
            TIter next(fTree->GetIteratorOnAllLeaves());
            TLeaf* leafcur = 0;
            while (!leaf && (leafcur = (TLeaf*) next())) {
               TBranch* br = leafcur->GetBranch();
               Bool_t yes = BranchHasMethod(leafcur, br, work, params, readentry);
               if (yes) {
                  leaf = leafcur;
                  //fprintf(stderr, "Does have a method %s for %s found in leafcur %s.\n", work, leafcur->GetBranch()->GetName(), leafcur->GetName());
               }
            }
            if (!leaf) {
               // Check for an alias.
               if (strlen(left) && left[strlen(left)-1]=='.') left[strlen(left)-1]=0;
               const char *aliasValue = fTree->GetAlias(left);
               if (aliasValue && strcspn(aliasValue,"+*/-%&!=<>|")==strlen(aliasValue)) {
                  // First check whether we are using this alias recursively (this would
                  // lead to an infinite recursion.
                  if (find(aliasUsed.begin(),
                     aliasUsed.end(),
                     left) != aliasUsed.end()) {
                        Error("DefinedVariable",
                           "The substitution of the branch alias \"%s\" by \"%s\" in \"%s\" failed\n"\
                           "\tbecause \"%s\" is used [recursively] in its own definition!",
                           left,aliasValue,fullExpression,left);
                        return -3;
                  }
                  aliasUsed.push_back(left);
                  TString newExpression = aliasValue;
                  newExpression += (cname+strlen(left));
                  Int_t res = FindLeafForExpression(newExpression, leaf, leftover, final, paran_level,
                     castqueue, aliasUsed, useLeafCollectionObject, fullExpression);
                  if (res<0) {
                     Error("DefinedVariable",
                        "The substitution of the alias \"%s\" by \"%s\" failed.",left,aliasValue);
                     return -3;
                  }
                  return res;
               }

               // This is actually not really any error, we probably received something
               // like "abs(some_val)", let TFormula decompose it first.
               return -1;
            }
            //         if (!leaf->InheritsFrom(TLeafObject::Class()) ) {
            // If the leaf that we found so far is not a TLeafObject then there is
            // nothing we would be able to do.
            //   Error("DefinedVariable","Need a TLeafObject to call a function!");
            // return -1;
            //}
            // We need to recover the info not used.
            strlcpy(right,work,kMaxLen);
            strncat(right,"(",kMaxLen-1-strlen(right));
            strncat(right,params,kMaxLen-1-strlen(right));
            final = kTRUE;

            // we reset work
            current = &(work[0]);
            *current = 0;
            break;
         }
      }
      if (cname[i] == '.' || cname[i] == '\0' || cname[i] == ')') {
         // A delimiter happened let's see if what we have seen
         // so far does point to a leaf.
         *current = '\0';

         Int_t len = strlen(work);
         if (work[0]=='@') {
            foundAtSign = kTRUE;
            Int_t l = 0;
            for(l=0;work[l+1]!=0;++l) work[l] = work[l+1];
            work[l] = '\0';
            --current;
         } else if (len>=2 && work[len-2]=='@') {
            foundAtSign = kTRUE;
            work[len-2] = cname[i];
            work[len-1] = '\0';
            --current;
         } else {
            foundAtSign = kFALSE;
         }

         if (left[0]==0) strlcpy(left,work,kMaxLen);
         if (!leaf && !branch) {
            // So far, we have not found a matching leaf or branch.
            strlcpy(first,work,kMaxLen);

            std::string treename(first);
            if (treename.size() && treename[treename.size()-1]=='.') {
               treename.erase(treename.size()-1);
            }
            if (treename== "This" /* || treename == fTree->GetName() */ ) {
               // Request info about the TTree object itself,
               TNamed *named = new TNamed(fTree->GetName(),fTree->GetName());
               fLeafNames.AddAtAndExpand(named,fNcodes);
               fLeaves.AddAtAndExpand(fTree,fNcodes);
               if (cname[i]) leftover = &(cname[i+1]);
               return 2;
            }
            // The following would allow to access the friend by name
            // however, it would also prevent the access of the leaves
            // within the friend.  We could use the '@' notation here
            // however this would not be aesthetically pleasing :(
            // What we need to do, is add the ability to look ahead to
            // the next 'token' to decide whether we to access the tree
            // or its leaf.
            //} else {
            //   TTree *tfriend = fTree->GetFriend(treename.c_str());
            //   TTree *realtree = fTree->GetTree();
            //   if (!tfriend && realtree != fTree){
            //      // If it is a chain and we did not find a friend,
            //      // let's try with the internal tree.
            //      tfriend = realtree->GetFriend(treename.c_str());
            //   }
            //   if (tfriend) {
            //      TNamed *named = new TNamed(treename.c_str(),tfriend->GetName());
            //      fLeafNames.AddAtAndExpand(named,fNcodes);
            //      fLeaves.AddAtAndExpand(tfriend,fNcodes);
            //      if (cname[i]) leftover = &(cname[i+1]);
            //      return 2;
            //   }
            //}

            branch = fTree->FindBranch(first);
            leaf = fTree->FindLeaf(first);

            // Now look with the delimiter removed (we looked with it first
            // because a dot is allowed at the end of some branches).
            if (cname[i]) first[strlen(first)-1]='\0';
            if (!branch) branch = fTree->FindBranch(first);
            if (!leaf) leaf = fTree->FindLeaf(first);
            TClass* cl = 0;
            if ( branch && branch->InheritsFrom(TBranchElement::Class()) ) {
               int offset=0;
               TBranchElement* bElt = (TBranchElement*)branch;
               TStreamerInfo* info  = bElt->GetInfo();
               TStreamerElement* element = info ? info->GetStreamerElement(first,offset) : 0;
               if (element) cl = element->GetClassPointer();
               if ( cl && !cl->GetReferenceProxy() ) cl = 0;
            }
            if ( cl )  {  // We have a reference class here....
               final = kTRUE;
               useLeafCollectionObject = foundAtSign;
               // we reset work
               current = &(work[0]);
               *current = 0;
            }
            else if (branch && (foundAtSign || cname[i] != 0)  ) {
               // Since we found a branch and there is more information in the name,
               // we do NOT look at the 'IsOnTerminalBranch' status of the leaf
               // we found ... yet!

               if (leaf==0) {
                  // Note we do not know (yet?) what (if anything) to do
                  // for a TBranchObject branch.
                  if (branch->InheritsFrom(TBranchElement::Class()) ) {
                     Int_t type = ((TBranchElement*)branch)->GetType();
                     if ( type == 3 || type ==4) {
                        // We have a Collection branch.
                        leaf = (TLeaf*)branch->GetListOfLeaves()->At(0);
                        if (foundAtSign) {
                           useLeafCollectionObject = foundAtSign;
                           foundAtSign = kFALSE;
                           current = &(work[0]);
                           *current = 0;
                           ++i;
                           break;
                        }
                     }
                  }
               }

               // we reset work
               useLeafCollectionObject = foundAtSign;
               foundAtSign = kFALSE;
               current = &(work[0]);
               *current = 0;
            } else if (leaf || branch) {
               if (leaf && branch) {
                  // We found both a leaf and branch matching the request name
                  // let's see which one is the proper one to use! (On annoying case
                  // is that where the same name is repeated ( varname.varname )

                  // We always give priority to the branch
                  // leaf = 0;
               }
               if (leaf && leaf->IsOnTerminalBranch()) {
                  // This is a non-object leaf, it should NOT be specified more except for
                  // dimensions.
                  final = kTRUE;
               }
               // we reset work
               current = &(work[0]);
               *current = 0;
            } else {
               // What we have so far might be a data member of one of the
               // leaves that are not splitted (for example "fNtrack" for the Event class.
               TLeaf *leafcur = GetLeafWithDatamember(first,work,readentry);
               if (leafcur) {
                  leaf = leafcur;
                  branch = leaf->GetBranch();
                  if (leaf->IsOnTerminalBranch()) {
                     final = kTRUE;
                     strlcpy(right,first,kMaxLen);
                     //We need to put the delimiter back!
                     if (foundAtSign) strncat(right,"@",kMaxLen-1-strlen(right));
                     if (cname[i]=='.') strncat(right,".",kMaxLen-1-strlen(right));

                     // We reset work
                     current = &(work[0]);
                     *current = 0;
                  };
               } else if (cname[i] == '.') {
                  // If we have a branch that match a name preceded by a dot
                  // then we assume we are trying to drill down the branch
                  // Let look if one of the top level branch has a branch with the name
                  // we are looking for.
                  TBranch *branchcur;
                  TIter next( fTree->GetListOfBranches() );
                  while(!branch && (branchcur=(TBranch*)next()) ) {
                     branch = branchcur->FindBranch(first);
                  }
                  if (branch) {
                     // We reset work
                     current = &(work[0]);
                     *current = 0;
                  }
               }
            }
         } else {  // correspond to if (leaf || branch)
            if (final) {
               Error("DefinedVariable", "Unexpected control flow!");
               return -1;
            }

            // No dot is allowed in subbranches and leaves, so
            // we always remove it in the present case.
            if (cname[i]) work[strlen(work)-1] = '\0';
            snprintf(scratch,sizeof(scratch),"%s.%s",first,work);
            snprintf(scratch2,sizeof(scratch2),"%s.%s.%s",first,second,work);

            if (previousdot) {
               currentname = &(work[previousdot+1]);
            }

            // First look for the current 'word' in the list of
            // leaf of the
            if (branch) {
               tmp_leaf = branch->FindLeaf(work);
               if (!tmp_leaf)  tmp_leaf = branch->FindLeaf(scratch);
               if (!tmp_leaf)  tmp_leaf = branch->FindLeaf(scratch2);
               if (!tmp_leaf)  tmp_leaf = branch->FindLeaf(currentname.c_str());
            }
            if (tmp_leaf && tmp_leaf->IsOnTerminalBranch() ) {
               // This is a non-object leaf, it should NOT be specified more except for
               // dimensions.
               final = kTRUE;
            }

            if (branch) {
               tmp_branch = branch->FindBranch(work);
               if (!tmp_branch) tmp_branch = branch->FindBranch(scratch);
               if (!tmp_branch) tmp_branch = branch->FindBranch(scratch2);
               if (!tmp_branch) tmp_branch = branch->FindBranch(currentname.c_str());
            }
            if (tmp_branch) {
               branch=tmp_branch;

               // NOTE: Should we look for a leaf within here?
               if (!final) {
                  tmp_leaf = branch->FindLeaf(work);
                  if (!tmp_leaf)  tmp_leaf = branch->FindLeaf(scratch);
                  if (!tmp_leaf)  tmp_leaf = branch->FindLeaf(scratch2);
                  if (!tmp_leaf)  tmp_leaf = branch->FindLeaf(currentname.c_str());
                  if (tmp_leaf && tmp_leaf->IsOnTerminalBranch() ) {
                     // This is a non-object leaf, it should NOT be specified
                     // more except for dimensions.
                     final = kTRUE;
                     leaf = tmp_leaf;
                  }
               }
            }
            if (tmp_leaf) {
               // Something was found.
               if (second[0]) strncat(second,".",kMaxLen-1-strlen(second));
               strncat(second,work,kMaxLen-1-strlen(second));
               leaf = tmp_leaf;
               useLeafCollectionObject = foundAtSign;
               foundAtSign = kFALSE;

               // we reset work
               current = &(work[0]);
               *current = 0;
            } else {
               //We need to put the delimiter back!
               if (strlen(work)) {
                  if (foundAtSign) {
                     Int_t where = strlen(work);
                     work[where] = '@';
                     work[where+1] = cname[i];
                     ++current;
                     previousdot = where+1;
                  } else {
                     previousdot = strlen(work);
                     work[strlen(work)] = cname[i];
                  }
               } else --current;
            }
         }
      }
   }

   // Copy the left over for later use.
   if (strlen(work)) {
      strncat(right,work,kMaxLen-1-strlen(right));
   }

   if (i<nchname) {
      if (strlen(right) && right[strlen(right)-1]!='.' && cname[i]!='.') {
         // In some cases we remove a little to fast the period, we add
         // it back if we need.  It is assumed that 'right' and the rest of
         // the name was cut by a delimiter, so this should be safe.
         strncat(right,".",kMaxLen-1-strlen(right));
      }
      strncat(right,&cname[i],kMaxLen-1-strlen(right));
   }

   if (!final && branch) {
      if (!leaf) {
         leaf = (TLeaf*)branch->GetListOfLeaves()->UncheckedAt(0);
         if (!leaf) return -1;
      }
      final = leaf->IsOnTerminalBranch();
   }

   if (leaf && leaf->InheritsFrom(TLeafObject::Class()) ) {
      if (strlen(right)==0) strlcpy(right,work,kMaxLen);
   }

   if (leaf==0 && left[0]!=0) {
      if (left[strlen(left)-1]=='.') left[strlen(left)-1]=0;

      // Check for an alias.
      const char *aliasValue = fTree->GetAlias(left);
      if (aliasValue && strcspn(aliasValue,"[]+*/-%&!=<>|")==strlen(aliasValue)) {
         // First check whether we are using this alias recursively (this would
         // lead to an infinite recursion).
         if (find(aliasUsed.begin(),
                  aliasUsed.end(),
                  left) != aliasUsed.end()) {
            Error("DefinedVariable",
                  "The substitution of the branch alias \"%s\" by \"%s\" in \"%s\" failed\n"\
                  "\tbecause \"%s\" is used [recursively] in its own definition!",
                  left,aliasValue,fullExpression,left);
            return -3;
         }
         aliasUsed.push_back(left);
         TString newExpression = aliasValue;
         newExpression += (cname+strlen(left));
         Int_t res = FindLeafForExpression(newExpression, leaf, leftover, final, paran_level,
                                           castqueue, aliasUsed, useLeafCollectionObject, fullExpression);
         if (res<0) {
            Error("DefinedVariable",
                  "The substitution of the alias \"%s\" by \"%s\" failed.",left,aliasValue);
            return -3;
         }
         return res;
      }
   }
   leftover = right;

   return 0;
}

//______________________________________________________________________________
Int_t TTreeFormula::DefinedVariable(TString &name, Int_t &action)
{
//*-*-*-*-*-*Check if name is in the list of Tree/Branch leaves*-*-*-*-*
//*-*        ==================================================
//
//   This member function redefines the function in TFormula
//   If a leaf has a name corresponding to the argument name, then
//   returns a new code.
//   A TTreeFormula may contain more than one variable.
//   For each variable referenced, the pointers to the corresponding
//   branch and leaf is stored in the object arrays fBranches and fLeaves.
//
//   name can be :
//      - Leaf_Name (simple variable or data member of a ClonesArray)
//      - Branch_Name.Leaf_Name
//      - Branch_Name.Method_Name
//      - Leaf_Name[index]
//      - Branch_Name.Leaf_Name[index]
//      - Branch_Name.Leaf_Name[index1]
//      - Branch_Name.Leaf_Name[][index2]
//      - Branch_Name.Leaf_Name[index1][index2]
//   New additions:
//      - Branch_Name.Leaf_Name[OtherLeaf_Name]
//      - Branch_Name.Datamember_Name
//      - '.' can be replaced by '->'
//   and
//      - Branch_Name[index1].Leaf_Name[index2]
//      - Leaf_name[index].Action().OtherAction(param)
//      - Leaf_name[index].Action()[val].OtherAction(param)
//
//   The expected returns values are
//     -2 :  the name has been recognized but won't be usable
//     -1 :  the name has not been recognized
//    >=0 :  the name has been recognized, return the internal code for this name.
//


   action = kDefinedVariable;
   if (!fTree) return -1;

   fNpar = 0;
   if (name.Length() > kMaxLen) return -1;
   Int_t i,k;

   if (name == "Entry$") {
      Int_t code = fNcodes++;
      fCodes[code] = 0;
      fLookupType[code] = kIndexOfEntry;
      return code;
   }
   if (name == "LocalEntry$") {
      Int_t code = fNcodes++;
      fCodes[code] = 0;
      fLookupType[code] = kIndexOfLocalEntry;
      return code;
   }
   if (name == "Entries$") {
      Int_t code = fNcodes++;
      fCodes[code] = 0;
      fLookupType[code] = kEntries;
      SetBit(kNeedEntries);
      fManager->SetBit(kNeedEntries);
      return code;
   }
   if (name == "Iteration$") {
      Int_t code = fNcodes++;
      fCodes[code] = 0;
      fLookupType[code] = kIteration;
      return code;
   }
   if (name == "Length$") {
      Int_t code = fNcodes++;
      fCodes[code] = 0;
      fLookupType[code] = kLength;
      return code;
   }
   static const char *lenfunc = "Length$(";
   if (strncmp(name.Data(),"Length$(",strlen(lenfunc))==0
       && name[name.Length()-1]==')') {

      TString subform = name.Data()+strlen(lenfunc);
      subform.Remove( subform.Length() - 1 );
      TTreeFormula *lengthForm = new TTreeFormula("lengthForm",subform,fTree);
      fAliases.AddAtAndExpand(lengthForm,fNoper);
      Int_t code = fNcodes++;
      fCodes[code] = 0;
      fLookupType[code] = kLengthFunc;
      return code;
   }
   static const char *minfunc = "Min$(";
   if (strncmp(name.Data(),"Min$(",strlen(minfunc))==0
       && name[name.Length()-1]==')') {
      
      TString subform = name.Data()+strlen(minfunc);
      subform.Remove( subform.Length() - 1 );
      TTreeFormula *minForm = new TTreeFormula("minForm",subform,fTree);
      fAliases.AddAtAndExpand(minForm,fNoper);
      Int_t code = fNcodes++;
      fCodes[code] = 0;
      fLookupType[code] = kMin;
      return code;
   }
   static const char *maxfunc = "Max$(";
   if (strncmp(name.Data(),"Max$(",strlen(maxfunc))==0
       && name[name.Length()-1]==')') {
      
      TString subform = name.Data()+strlen(maxfunc);
      subform.Remove( subform.Length() - 1 );
      TTreeFormula *maxForm = new TTreeFormula("maxForm",subform,fTree);
      fAliases.AddAtAndExpand(maxForm,fNoper);
      Int_t code = fNcodes++;
      fCodes[code] = 0;
      fLookupType[code] = kMax;
      return code;
   }
   static const char *sumfunc = "Sum$(";
   if (strncmp(name.Data(),"Sum$(",strlen(sumfunc))==0
       && name[name.Length()-1]==')') {
      
      TString subform = name.Data()+strlen(sumfunc);
      subform.Remove( subform.Length() - 1 );
      TTreeFormula *sumForm = new TTreeFormula("sumForm",subform,fTree);
      fAliases.AddAtAndExpand(sumForm,fNoper);
      Int_t code = fNcodes++;
      fCodes[code] = 0;
      fLookupType[code] = kSum;
      return code;
   }
   
   
   
   // Check for $Alt(expression1,expression2)
   Int_t res = DefineAlternate(name.Data());
   if (res!=0) {
      // There was either a syntax error or we found $Alt
      if (res<0) return res;
      action = res;
      return 0;
   }

   // Find the top level leaf and deal with dimensions

   char    cname[kMaxLen];  strlcpy(cname,name.Data(),kMaxLen);
   char     dims[kMaxLen];   dims[0] = '\0';

   Bool_t final = kFALSE;

   UInt_t paran_level = 0;
   TObjArray castqueue;

   // First, it is easier to remove all dimensions information from 'cname'
   Int_t cnamelen = strlen(cname);
   for(i=0,k=0; i<cnamelen; ++i, ++k) {
      if (cname[i] == '[') {
         int bracket = i;
         int bracket_level = 1;
         int j;
         for (j=++i; j<cnamelen && (bracket_level>0 || cname[j]=='['); j++, i++) {
            if (cname[j]=='[') bracket_level++;
            else if (cname[j]==']') bracket_level--;
         }
         if (bracket_level != 0) {
            //Error("DefinedVariable","Bracket unbalanced");
            return -1;
         }
         strncat(dims,&cname[bracket],j-bracket);
         //k += j-bracket;
      }
      if (i!=k) cname[k] = cname[i];
   }
   cname[k]='\0';

   Bool_t useLeafCollectionObject = kFALSE;
   TString leftover;
   TLeaf *leaf = 0;
   {
      std::vector<std::string> aliasSofar = fAliasesUsed;
      res = FindLeafForExpression(cname, leaf, leftover, final, paran_level, castqueue, aliasSofar, useLeafCollectionObject, name);
   }
   if (res<0) return res;

   if (!leaf && res!=2) {
      // Check for an alias.
      const char *aliasValue = fTree->GetAlias(cname);
      if (aliasValue) {
         // First check whether we are using this alias recursively (this would
         // lead to an infinite recursion.
         if (find(fAliasesUsed.begin(),
                  fAliasesUsed.end(),
                  cname) != fAliasesUsed.end()) {
            Error("DefinedVariable",
                  "The substitution of the alias \"%s\" by \"%s\" failed\n"\
                  "\tbecause \"%s\" is recursively used in its own definition!",
                  cname,aliasValue,cname);
            return -3;
         }


         if (strcspn(aliasValue,"+*/-%&!=<>|")!=strlen(aliasValue)) {
            // If the alias contains an operator, we need to use a nested formula
            // (since DefinedVariable must only add one entry to the operation's list).
            
            // Need to check the aliases used so far
            std::vector<std::string> aliasSofar = fAliasesUsed;
            aliasSofar.push_back( cname );

            TString subValue( aliasValue );
            if (dims[0]) {
               subValue += dims;
            }

            TTreeFormula *subform = new TTreeFormula(cname,subValue,fTree,aliasSofar); // Need to pass the aliases used so far.

            if (subform->GetNdim()==0) {
               delete subform;
               Error("DefinedVariable",
                     "The substitution of the alias \"%s\" by \"%s\" failed.",cname,aliasValue);
               return -3;
            }

            fManager->Add(subform);
            fAliases.AddAtAndExpand(subform,fNoper);

            if (subform->IsString()) {
               action = kAliasString;
               return 0;
            } else {
               action = kAlias;
               return 0;
            }
         } else { /* assumes strcspn(aliasValue,"[]")!=strlen(aliasValue) */
            TString thisAlias( aliasValue );
            thisAlias += dims;
            Int_t aliasRes = DefinedVariable(thisAlias,action);
            if (aliasRes<0) {
               // We failed but DefinedVariable has not printed why yet.
               // and because we want thoses to be printed _before_ the notice
               // of the failure of the substitution, we need to print them here.
               if (aliasRes==-1) {
                  Error("Compile", " Bad numerical expression : \"%s\"",thisAlias.Data()); 
               } else if (aliasRes==-2) {
                  Error("Compile", " Part of the Variable \"%s\" exists but some of it is not accessible or useable",thisAlias.Data()); 
                  
               }
               Error("DefinedVariable",
                     "The substitution of the alias \"%s\" by \"%s\" failed.",cname,aliasValue);
               return -3;               
            }
            return aliasRes;
         }
      }
   }


   if (leaf || res==2) {

      if (leaf && leaf->GetBranch() && leaf->GetBranch()->TestBit(kDoNotProcess)) {
         Error("DefinedVariable","the branch \"%s\" has to be enabled to be used",leaf->GetBranch()->GetName());
         return -2;
      }

      Int_t code = fNcodes++;

      // If needed will now parse the indexes specified for
      // arrays.
      if (dims[0]) {
         char *current = &( dims[0] );
         Int_t dim = 0;
         TString varindex;
         Int_t index;
         Int_t scanindex ;
         while (current) {
            current++;
            if (current[0] == ']') {
               fIndexes[code][dim] = -1; // Loop over all elements;
            } else {
               scanindex = sscanf(current,"%d",&index);
               if (scanindex) {
                  fIndexes[code][dim] = index;
               } else {
                  fIndexes[code][dim] = -2; // Index is calculated via a variable.
                  varindex = current;
                  char *end = (char*)(varindex.Data());
                  for(char bracket_level = 0;*end!=0;end++) {
                     if (*end=='[') bracket_level++;
                     if (bracket_level==0 && *end==']') break;
                     if (*end==']') bracket_level--;
                  }
                  *end = '\0';
                  fVarIndexes[code][dim] = new TTreeFormula("index_var",
                                                            varindex,
                                                            fTree);
                  current += strlen(varindex)+1; // move to the end of the index array
               }
            }
            dim ++;
            if (dim >= kMAXFORMDIM) {
               // NOTE: test that dim this is NOT too big!!
               break;
            }
            current = (char*)strstr( current, "[" );
         }
      }

      // Now that we have cleaned-up the expression, let's compare it to the content
      // of the leaf!

      res = ParseWithLeaf(leaf,leftover,final,paran_level,castqueue,useLeafCollectionObject,name);
      if (res<0) return res;
      if (res>0) action = res;
      return code;
   }

//*-*- May be a graphical cut ?
   TCutG *gcut = (TCutG*)gROOT->GetListOfSpecials()->FindObject(name.Data());
   if (gcut) {
      if (gcut->GetObjectX()) {
         if(!gcut->GetObjectX()->InheritsFrom(TTreeFormula::Class())) {
            delete gcut->GetObjectX(); gcut->SetObjectX(0);
         }
      }
      if (gcut->GetObjectY()) {
         if(!gcut->GetObjectY()->InheritsFrom(TTreeFormula::Class())) {
            delete gcut->GetObjectY(); gcut->SetObjectY(0);
         }
      }

      Int_t code = fNcodes;

      if (strlen(gcut->GetVarX()) && strlen(gcut->GetVarY()) ) {

         TTreeFormula *fx = new TTreeFormula("f_x",gcut->GetVarX(),fTree);
         gcut->SetObjectX(fx);

         TTreeFormula *fy = new TTreeFormula("f_y",gcut->GetVarY(),fTree);
         gcut->SetObjectY(fy);

         fCodes[code] = -2;

      } else if (strlen(gcut->GetVarX())) {

         // Let's build the equivalent formula:
         // min(gcut->X) <= VarX <= max(gcut->Y)
         Double_t min = 0;
         Double_t max = 0;
         Int_t n = gcut->GetN();
         Double_t *x = gcut->GetX();
         min = max = x[0];
         for(Int_t i2 = 1; i2<n; i2++) {
            if (x[i2] < min) min = x[i2];
            if (x[i2] > max) max = x[i2];
         }
         TString formula = "(";
         formula += min;
         formula += "<=";
         formula += gcut->GetVarX();
         formula += " && ";
         formula += gcut->GetVarX();
         formula += "<=";
         formula += max;
         formula += ")";

         TTreeFormula *fx = new TTreeFormula("f_x",formula.Data(),fTree);
         gcut->SetObjectX(fx);

         fCodes[code] = -1;

      } else {

         Error("DefinedVariable","Found a TCutG without leaf information (%s)",
               gcut->GetName());
         return -1;

      }

      fExternalCuts.AddAtAndExpand(gcut,code);
      fNcodes++;
      fLookupType[code] = -1;
      return code;
   }

   //may be an entrylist
   TEntryList *elist = dynamic_cast<TEntryList*> (gDirectory->Get(name.Data()));
   if (elist) {
      Int_t code = fNcodes;
      fCodes[code] = 0;
      fExternalCuts.AddAtAndExpand(elist, code);
      fNcodes++;
      fLookupType[code] = kEntryList;
      return code;

   }

   return -1;
}

//______________________________________________________________________________
TLeaf* TTreeFormula::GetLeafWithDatamember(const char* topchoice, const char* nextchoice, Long64_t readentry) const
{

   // Return the leaf (if any) which contains an object containing
   // a data member which has the name provided in the arguments.

   TClass * cl = 0;
   TIter nextleaf (fTree->GetIteratorOnAllLeaves());
   TFormLeafInfo* clonesinfo = 0;
   TLeaf *leafcur;
   while ((leafcur = (TLeaf*)nextleaf())) {
      // The following code is used somewhere else, we need to factor it out.

      // Here since we are interested in data member, we want to consider only
      // 'terminal' branch and leaf.
      cl = 0;
      if (leafcur->InheritsFrom(TLeafObject::Class()) &&
          leafcur->GetBranch()->GetListOfBranches()->Last()==0) {
         TLeafObject *lobj = (TLeafObject*)leafcur;
         cl = lobj->GetClass();
      } else if (leafcur->InheritsFrom(TLeafElement::Class()) && leafcur->IsOnTerminalBranch()) {
         TLeafElement * lElem = (TLeafElement*) leafcur;
         if (lElem->IsOnTerminalBranch()) {
            TBranchElement *branchEl = (TBranchElement *)leafcur->GetBranch();
            Int_t type = branchEl->GetStreamerType();
            if (type==-1) {
               cl =  branchEl->GetInfo()->GetClass();
            } else if (type>60 || type==0) {
               // Case of an object data member.  Here we allow for the
               // variable name to be ommitted.  Eg, for Event.root with split
               // level 1 or above  Draw("GetXaxis") is the same as Draw("fH.GetXaxis()")
               TStreamerElement* element = (TStreamerElement*)
                  branchEl->GetInfo()->GetElems()[branchEl->GetID()];
               if (element) cl = element->GetClassPointer();
               else cl = 0;
            }
         }

      }
      if (clonesinfo) { delete clonesinfo; clonesinfo = 0; }
      if (cl ==  TClonesArray::Class()) {
         // We have a unsplit TClonesArray leaves
         // In this case we assume that cl is the class in which the TClonesArray
         // belongs.
         R__LoadBranch(leafcur->GetBranch(),readentry,fQuickLoad);
         TClonesArray * clones;

         TBranch *branch = leafcur->GetBranch();
         if  (   branch->IsA()==TBranchElement::Class()
                 && ((TBranchElement*)branch)->GetType()==31) {

            // We have an unsplit TClonesArray as part of a split TClonesArray!

            // Let's not dig any further.  If the user really wants a data member
            // inside the nested TClonesArray, it has to specify it explicitly.

            continue;

         } else {
            Bool_t toplevel = (branch == branch->GetMother());
            clonesinfo = new TFormLeafInfoClones(cl, 0, toplevel);
            clones = (TClonesArray*)clonesinfo->GetLocalValuePointer(leafcur,0);
         }
         if (clones) cl = clones->GetClass();
      } else if (cl && cl->GetCollectionProxy()) {

         // We have a unsplit Collection leaves
         // In this case we assume that cl is the class in which the TClonesArray
         // belongs.

         TBranch *branch = leafcur->GetBranch();
         if  (   branch->IsA()==TBranchElement::Class()
                 && ((TBranchElement*)branch)->GetType()==41) {

            // We have an unsplit Collection as part of a split Collection!

            // Let's not dig any further.  If the user really wants a data member
            // inside the nested Collection, it has to specify it explicitly.

            continue;

         } else {
            clonesinfo = new TFormLeafInfoCollection(cl, 0);
         }
         cl = cl->GetCollectionProxy()->GetValueClass();
      }
      if (cl) {
         // Now that we have the class, let's check if the topchoice is of its datamember
         // or if the nextchoice is a datamember of one of its datamember.
         Int_t offset;
         TStreamerInfo* info =  (TStreamerInfo*)cl->GetStreamerInfo();
         TStreamerElement* element = info?info->GetStreamerElement(topchoice,offset):0;
         if (!element) {
            TIter nextel( cl->GetStreamerInfo()->GetElements() );
            TStreamerElement * curelem;
            while ((curelem = (TStreamerElement*)nextel())) {

               if (curelem->GetClassPointer() ==  TClonesArray::Class()) {
                  // In case of a TClonesArray we need to load the data and read the
                  // clonesArray object before being able to look into the class inside.
                  // We need to do that because we are never interested in the TClonesArray
                  // itself but only in the object inside.
                  TBranch *branch = leafcur->GetBranch();
                  TFormLeafInfo *leafinfo = 0;
                  if (clonesinfo) {
                     leafinfo = clonesinfo;
                  } else if (branch->IsA()==TBranchElement::Class()
                             && ((TBranchElement*)branch)->GetType()==31) {
                     // Case of a sub branch of a TClonesArray
                     TBranchElement *branchEl = (TBranchElement*)branch;
                     TStreamerInfo *bel_info = branchEl->GetInfo();
                     TClass * mother_cl = ((TBranchElement*)branch)->GetInfo()->GetClass();
                     TStreamerElement *bel_element =
                        (TStreamerElement *)bel_info->GetElems()[branchEl->GetID()];
                     leafinfo = new TFormLeafInfoClones(mother_cl, 0, bel_element, kTRUE);
                  }

                  Int_t clones_offset = 0;
                  ((TStreamerInfo*)cl->GetStreamerInfo())->GetStreamerElement(curelem->GetName(),clones_offset);
                  TFormLeafInfo* sub_clonesinfo = new TFormLeafInfo(cl, clones_offset, curelem);
                  if (leafinfo)
                     if (leafinfo->fNext) leafinfo->fNext->fNext = sub_clonesinfo;
                     else leafinfo->fNext = sub_clonesinfo;
                  else leafinfo = sub_clonesinfo;

                  R__LoadBranch(branch,readentry,fQuickLoad);

                  TClonesArray * clones = (TClonesArray*)leafinfo->GetValuePointer(leafcur,0);

                  delete leafinfo; clonesinfo = 0;
                  // If TClonesArray object does not exist we have no information, so let go
                  // on.  This is a weakish test since the TClonesArray object might exist in
                  // the next entry ... In other word, we ONLY rely on the information available
                  // in entry #0.
                  if (!clones) continue;
                  TClass *sub_cl = clones->GetClass();

                  // Now that we finally have the inside class, let's query it.
                  element = ((TStreamerInfo*)sub_cl->GetStreamerInfo())->GetStreamerElement(nextchoice,offset);
                  if (element) break;
               } // if clones array
               else if (curelem->GetClassPointer() && curelem->GetClassPointer()->GetCollectionProxy()) {

                  TClass *sub_cl = curelem->GetClassPointer()->GetCollectionProxy()->GetValueClass();

                  while(sub_cl && sub_cl->GetCollectionProxy())
                     sub_cl = sub_cl->GetCollectionProxy()->GetValueClass();

                  // Now that we finally have the inside class, let's query it.
                  if (sub_cl) element = ((TStreamerInfo*)sub_cl->GetStreamerInfo())->GetStreamerElement(nextchoice,offset);
                  if (element) break;

               }
            } // loop on elements
         }
         if (element) break;
         else cl = 0;
      }
   }
   delete clonesinfo;
   if (cl) {
      return leafcur;
   } else {
      return 0;
   }
}

//______________________________________________________________________________
Bool_t TTreeFormula::BranchHasMethod(TLeaf* leafcur, TBranch* branch, const char* method, const char* params, Long64_t readentry) const
{
   // Return the leaf (if any) of the tree with contains an object of a class
   // having a method which has the name provided in the argument.

   TClass *cl = 0;
   TLeafObject* lobj = 0;

   // Since the user does not want this branch to be loaded anyway, we just
   // skip it.  This prevents us from warning the user that the method might
   // be on a disabled branch.  However, and more usefully, this allows the
   // user to avoid error messages from branches that cannot be currently
   // read without warnings/errors.

   if (branch->TestBit(kDoNotProcess)) {
      return kFALSE;
   }

   // FIXME: The following code is used somewhere else, we need to factor it out.
   if (branch->InheritsFrom(TBranchObject::Class())) {
      lobj = (TLeafObject*) branch->GetListOfLeaves()->At(0);
      cl = lobj->GetClass();
   } else if (branch->InheritsFrom(TBranchElement::Class())) {
      TBranchElement* branchEl = (TBranchElement*) branch;
      Int_t type = branchEl->GetStreamerType();
      if (type == -1) {
         cl = branchEl->GetInfo()->GetClass();
      } else if (type > 60) {
         // Case of an object data member.  Here we allow for the
         // variable name to be ommitted.  Eg, for Event.root with split
         // level 1 or above  Draw("GetXaxis") is the same as Draw("fH.GetXaxis()")
         TStreamerElement* element = (TStreamerElement*) branchEl->GetInfo()->GetElems()[branchEl->GetID()];
         if (element) {
            cl = element->GetClassPointer();
         } else {
            cl = 0;
         }
         if ((cl == TClonesArray::Class()) && (branchEl->GetType() == 31)) {
            // we have a TClonesArray inside a split TClonesArray,
            // Let's not dig any further.  If the user really wants a data member
            // inside the nested TClonesArray, it has to specify it explicitly.
            cl = 0;
         }
         // NOTE do we need code for Collection here?
      }
   }

   if (cl == TClonesArray::Class()) {
      // We might be try to call a method of the top class inside a
      // TClonesArray.
      // Since the leaf was not terminal, we might have a split or
      // unsplit and/or top leaf/branch.
      TClonesArray* clones = 0;
      R__LoadBranch(branch, readentry, fQuickLoad);
      if (branch->InheritsFrom(TBranchObject::Class())) {
         clones = (TClonesArray*) lobj->GetObject();
      } else if (branch->InheritsFrom(TBranchElement::Class())) {
         // We do not know exactly where the leaf of the TClonesArray is
         // in the hierachy but we still need to get the correct class
         // holder.
         TBranchElement* bc = (TBranchElement*) branch;
         if (bc == bc->GetMother()) {
            // Top level branch
            //clones = *((TClonesArray**) bc->GetAddress());
            clones = (TClonesArray*) bc->GetObject();
         } else if (!leafcur || !leafcur->IsOnTerminalBranch()) {
            TStreamerElement* element = (TStreamerElement*) bc->GetInfo()->GetElems()[bc->GetID()];
            if (element->IsaPointer()) {
               clones = *((TClonesArray**) bc->GetAddress());
               //clones = *((TClonesArray**) bc->GetObject());
            } else {
               //clones = (TClonesArray*) bc->GetAddress();
               clones = (TClonesArray*) bc->GetObject();
            }
         }
         if (!clones) {
            R__LoadBranch(bc, readentry, fQuickLoad);
            TClass* mother_cl;
            mother_cl = bc->GetInfo()->GetClass();
            TFormLeafInfo* clonesinfo = new TFormLeafInfoClones(mother_cl, 0);
            // if (!leafcur) { leafcur = (TLeaf*) branch->GetListOfLeaves()->At(0); }
            clones = (TClonesArray*) clonesinfo->GetLocalValuePointer(leafcur, 0);
            // cl = clones->GetClass();
            delete clonesinfo;
         }
      } else {
         Error("BranchHasMethod","A TClonesArray was stored in a branch type no yet support (i.e. neither TBranchObject nor TBranchElement): %s",branch->IsA()->GetName());
         return kFALSE;
      }
      cl = clones->GetClass();
   } else if (cl && cl->GetCollectionProxy()) {
      cl = cl->GetCollectionProxy()->GetValueClass();
   }

   if (cl) {
      if (cl->GetClassInfo()) {
         if (cl->GetMethodAllAny(method)) {
            // Let's try to see if the function we found belongs to the current
            // class.  Note that this implementation currently can not work if
            // one the argument is another leaf or data member of the object.
            // (Anyway we do NOT support this case).
            TMethodCall* methodcall = new TMethodCall(cl, method, params);
            if (methodcall->GetMethod()) {
               // We have a method that works.
               // We will use it.
               return kTRUE;
            }
            delete methodcall;
         }
      }
   }

   return kFALSE;
}

//______________________________________________________________________________
Int_t TTreeFormula::GetRealInstance(Int_t instance, Int_t codeindex) {
      // Now let calculate what physical instance we really need.
      // Some redundant code is used to speed up the cases where
      // they are no dimensions.
      // We know that instance is less that fCumulUsedSize[0] so
      // we can skip the modulo when virt_dim is 0.
      Int_t real_instance = 0;
      Int_t virt_dim;

      Bool_t check = kFALSE;
      if (codeindex<0) {
         codeindex = 0;
         check = kTRUE;
      }

      TFormLeafInfo * info = 0;
      Int_t max_dim = fNdimensions[codeindex];
      if ( max_dim ) {
         virt_dim = 0;
         max_dim--;

         if (!fManager->fMultiVarDim) {
            if (fIndexes[codeindex][0]>=0) {
               real_instance = fIndexes[codeindex][0] * fCumulSizes[codeindex][1];
            } else {
               Int_t local_index;
               local_index = ( instance / fManager->fCumulUsedSizes[virt_dim+1]);
               if (fIndexes[codeindex][0]==-2) {
                  // NOTE: Should we check that this is a valid index?
                  if (check) {
                     Int_t index_real_instance = fVarIndexes[codeindex][0]->GetRealInstance(local_index,-1);
                     if (index_real_instance > fVarIndexes[codeindex][0]->fNdata[0]) {
                        // out of bounds
                        return fNdata[0]+1;
                     }
                  }
                  if (fDidBooleanOptimization && local_index!=0) {
                     // Force the loading of the index.
                     fVarIndexes[codeindex][0]->LoadBranches();
                  }
                  local_index = (Int_t)fVarIndexes[codeindex][0]->EvalInstance(local_index);
                  if (local_index<0) {
                     Error("EvalInstance","Index %s is out of bound (%d) in formula %s",
                           fVarIndexes[codeindex][0]->GetTitle(),
                           local_index,
                           GetTitle());
                     return fNdata[0]+1;
                  }
               }
               real_instance = local_index * fCumulSizes[codeindex][1];
               virt_dim ++;
            }
         } else {
            // NOTE: We assume that ONLY the first dimension of a leaf can have a variable
            // size AND contain the index for the size of yet another sub-dimension.
            // I.e. a variable size array inside a variable size array can only have its
            // size vary with the VERY FIRST physical dimension of the leaf.
            // Thus once the index of the first dimension is found, all other dimensions
            // are fixed!

            // NOTE: We could unroll some of this loops to avoid a few tests.
            if (fHasMultipleVarDim[codeindex]) {
               info = (TFormLeafInfo *)(fDataMembers.At(codeindex));
               // if (info && info->GetVarDim()==-1) info = 0;
            }
            Int_t local_index;

            switch (fIndexes[codeindex][0]) {
            case -2:
               if (fDidBooleanOptimization && instance!=0) {
                  // Force the loading of the index.
                  fVarIndexes[codeindex][0]->LoadBranches();
               }
               local_index = (Int_t)fVarIndexes[codeindex][0]->EvalInstance(instance);
               if (local_index<0) {
                  Error("EvalInstance","Index %s is out of bound (%d) in formula %s",
                        fVarIndexes[codeindex][0]->GetTitle(),
                        local_index,
                        GetTitle());
                  local_index = 0;
               }
               break;
            case -1: {
                  local_index = 0;
                  Int_t virt_accum = 0;
                  Int_t maxloop = fManager->fCumulUsedVarDims->GetSize();
                  if (maxloop == 0) {
                     local_index--;
                     instance = fNdata[0]+1; // out of bounds.
                     if (check) return fNdata[0]+1;
                  } else {
                     do {
                        virt_accum += fManager->fCumulUsedVarDims->GetArray()[local_index];
                        local_index++;
                     } while( instance >= virt_accum && local_index<maxloop);
                     if (local_index==maxloop && (instance >= virt_accum)) {
                        local_index--;
                        instance = fNdata[0]+1; // out of bounds.
                        if (check) return fNdata[0]+1;
                     } else {
                        local_index--;
                        if (fManager->fCumulUsedVarDims->At(local_index)) {
                           instance -= (virt_accum - fManager->fCumulUsedVarDims->At(local_index));
                        } else {
                           instance = fNdata[0]+1; // out of bounds.
                           if (check) return fNdata[0]+1;
                        }
                     }
                  }
                  virt_dim ++;
               }
               break;
            default:
               local_index = fIndexes[codeindex][0];
            }

            // Inform the (appropriate) MultiVarLeafInfo that the clones array index is
            // local_index.

            if (fManager->fVarDims[kMAXFORMDIM]) {
               fManager->fCumulUsedSizes[kMAXFORMDIM] = fManager->fVarDims[kMAXFORMDIM]->At(local_index);
            } else {
               fManager->fCumulUsedSizes[kMAXFORMDIM] = fManager->fUsedSizes[kMAXFORMDIM];
            }
            for(Int_t d = kMAXFORMDIM-1; d>0; d--) {
               if (fManager->fVarDims[d]) {
                  fManager->fCumulUsedSizes[d] = fManager->fCumulUsedSizes[d+1] * fManager->fVarDims[d]->At(local_index);
               } else {
                  fManager->fCumulUsedSizes[d] = fManager->fCumulUsedSizes[d+1] * fManager->fUsedSizes[d];
               }
            }
            if (info) {
               // When we have multiple variable dimensions, the LeafInfo only expect
               // the instance after the primary index has been set.
               info->SetPrimaryIndex(local_index);
               real_instance = 0;

               // Let's update fCumulSizes for the rest of the code.
               Int_t vdim = info->GetVarDim();
               Int_t isize = info->GetSize(local_index);
               if (fIndexes[codeindex][vdim]>=0) {
                  info->SetSecondaryIndex(fIndexes[codeindex][vdim]); 
               }
               if  (isize!=1 && fIndexes[codeindex][vdim]>isize) {
                  // We are out of bounds!
                  return fNdata[0]+1;
               }
               fCumulSizes[codeindex][vdim] =  isize*fCumulSizes[codeindex][vdim+1];
               for(Int_t k=vdim -1; k>0; --k) {
                  fCumulSizes[codeindex][k] = fCumulSizes[codeindex][k+1]*fFixedSizes[codeindex][k];
               }
            } else {
               real_instance = local_index * fCumulSizes[codeindex][1];
            }
         }
         if (max_dim>0) {
            for (Int_t dim = 1; dim < max_dim; dim++) {
               if (fIndexes[codeindex][dim]>=0) {
                  real_instance += fIndexes[codeindex][dim] * fCumulSizes[codeindex][dim+1];
               } else {
                  Int_t local_index;
                  if (virt_dim && fManager->fCumulUsedSizes[virt_dim]>1) {
                     local_index = ( ( instance % fManager->fCumulUsedSizes[virt_dim] )
                                     / fManager->fCumulUsedSizes[virt_dim+1]);
                  } else {
                     local_index = ( instance / fManager->fCumulUsedSizes[virt_dim+1]);
                  }
                  if (fIndexes[codeindex][dim]==-2) {
                     // NOTE: Should we check that this is a valid index?
                     if (fDidBooleanOptimization && local_index!=0) {
                        // Force the loading of the index.
                        fVarIndexes[codeindex][dim]->LoadBranches();
                     }
                     local_index = (Int_t)fVarIndexes[codeindex][dim]->EvalInstance(local_index);
                     if (local_index<0 ||
                         local_index>=(fCumulSizes[codeindex][dim]/fCumulSizes[codeindex][dim+1])) {
                        Error("EvalInstance","Index %s is out of bound (%d/%d) in formula %s",
                              fVarIndexes[codeindex][dim]->GetTitle(),
                              local_index,
                              (fCumulSizes[codeindex][dim]/fCumulSizes[codeindex][dim+1]),
                              GetTitle());
                        local_index = (fCumulSizes[codeindex][dim]/fCumulSizes[codeindex][dim+1])-1;
                     }
                  }
                  real_instance += local_index * fCumulSizes[codeindex][dim+1];
                  virt_dim ++;
               }
            }
            if (fIndexes[codeindex][max_dim]>=0) {
               if (!info) real_instance += fIndexes[codeindex][max_dim];
            } else {
               Int_t local_index;
               if (virt_dim && fManager->fCumulUsedSizes[virt_dim]>1) {
                  local_index = instance % fManager->fCumulUsedSizes[virt_dim];
               } else {
                  local_index = instance;
               }
               if (info && local_index>=fCumulSizes[codeindex][max_dim]) {
                  // We are out of bounds! [Multiple var dims, See same message a few line above]
                  return fNdata[0]+1;
               }
               if (fIndexes[codeindex][max_dim]==-2) {
                  if (fDidBooleanOptimization && local_index!=0) {
                     // Force the loading of the index.
                     fVarIndexes[codeindex][max_dim]->LoadBranches();
                  }
                  local_index = (Int_t)fVarIndexes[codeindex][max_dim]->EvalInstance(local_index);
                  if (local_index<0 ||
                         local_index>=fCumulSizes[codeindex][max_dim]) {
                     Error("EvalInstance","Index %s is of out bound (%d/%d) in formula %s",
                           fVarIndexes[codeindex][max_dim]->GetTitle(),
                           local_index,
                           fCumulSizes[codeindex][max_dim],
                           GetTitle());
                     local_index = fCumulSizes[codeindex][max_dim]-1;
                  }
               }
               real_instance += local_index;
            }
         } // if (max_dim-1>0)
      } // if (max_dim)

      return real_instance;
}

//______________________________________________________________________________
TClass* TTreeFormula::EvalClass() const
{
//  Evaluate the class of this treeformula
//
//  If the 'value' of this formula is a simple pointer to an object,
//  this function returns the TClass corresponding to its type.

   if (fNoper != 1 || fNcodes <=0 ) return 0;

   return EvalClass(0);
}

//______________________________________________________________________________
TClass* TTreeFormula::EvalClass(Int_t oper) const
{
//  Evaluate the class of the operation oper
//
//  If the 'value' in the requested operation is a simple pointer to an object,
//  this function returns the TClass corresponding to its type.

   TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(oper);
   switch(fLookupType[oper]) {
      case kDirect: {
         if (leaf->IsA()==TLeafObject::Class()) {
            return ((TLeafObject*)leaf)->GetClass();
         } else if ( leaf->IsA()==TLeafElement::Class()) {
            TBranchElement * branch = (TBranchElement*)((TLeafElement*)leaf)->GetBranch();
            TStreamerInfo * info = branch->GetInfo();
            Int_t id = branch->GetID();
            if (id>=0) {
               if (info==0 || info->GetElems()==0) {
                  // we probably do not have a way to know the class of the object.
                  return 0;
               }
               TStreamerElement* elem = (TStreamerElement*)info->GetElems()[id];
               if (elem==0) {
                  // we probably do not have a way to know the class of the object.
                  return 0;
               } else {
                  return elem->GetClass();
               }
            } else return TClass::GetClass( branch->GetClassName() );
         } else {
            return 0;
         }
      }
      case kMethod: return 0; // kMethod is deprecated so let's no waste time implementing this.
      case kTreeMember:
      case kDataMember: {
         TObject *obj = fDataMembers.UncheckedAt(oper);
         if (!obj) return 0;
         return ((TFormLeafInfo*)obj)->GetClass();
      }

      default: return 0;
   }


}

//______________________________________________________________________________
void* TTreeFormula::EvalObject(int instance)
{
//*-*-*-*-*-*-*-*-*-*-*Evaluate this treeformula*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
//*-*                  =========================
//
//  Return the address of the object pointed to by the formula.
//  Return 0 if the formula is not a single object
//  The object type can be retrieved using by call EvalClass();

   if (fNoper != 1 || fNcodes <=0 ) return 0;


   switch (fLookupType[0]) {
      case kIndexOfEntry:
      case kIndexOfLocalEntry:
      case kEntries:
      case kLength:
      case kLengthFunc:
      case kIteration:
      case kEntryList:
         return 0;
   }

   TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(0);

   Int_t real_instance = GetRealInstance(instance,0);

   if (instance==0 || fNeedLoading) {
      fNeedLoading = kFALSE;
      R__LoadBranch(leaf->GetBranch(),
                    leaf->GetBranch()->GetTree()->GetReadEntry(),
                    fQuickLoad);
   }
   else if (real_instance>fNdata[0]) return 0;
   if (fAxis) {
      return 0;
   }
   switch(fLookupType[0]) {
      case kDirect: {
         if (real_instance) {
            Warning("EvalObject","Not yet implement for kDirect and arrays (for %s).\nPlease contact the developers",GetName());
         }
         return leaf->GetValuePointer();
      }
      case kMethod: return GetValuePointerFromMethod(0,leaf);
      case kTreeMember:
      case kDataMember: return ((TFormLeafInfo*)fDataMembers.UncheckedAt(0))->GetValuePointer(leaf,real_instance);
      default: return 0;
   }


}


//______________________________________________________________________________
const char* TTreeFormula::EvalStringInstance(Int_t instance)
{
   // Eval the instance as a string.

   const Int_t kMAXSTRINGFOUND = 10;
   const char *stringStack[kMAXSTRINGFOUND];

   if (fNoper==1 && fNcodes>0 && IsString()) {
      TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(0);

      Int_t real_instance = GetRealInstance(instance,0);

      if (instance==0 || fNeedLoading) {
         fNeedLoading = kFALSE;
         TBranch *branch = leaf->GetBranch();
         R__LoadBranch(branch,branch->GetTree()->GetReadEntry(),fQuickLoad);
      } else if (real_instance>=fNdata[0]) {
         return 0;
      }

      if (fLookupType[0]==kDirect) {
         return (char*)leaf->GetValuePointer();
      } else {
         return  (char*)GetLeafInfo(0)->GetValuePointer(leaf,real_instance);
      }
   }

   EvalInstance(instance,stringStack);

   return stringStack[0];
}

#define TT_EVAL_INIT                                                                            \
   TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(0);                                                \
                                                                                                \
   const Int_t real_instance = GetRealInstance(instance,0);                                     \
                                                                                                \
   if (instance==0) fNeedLoading = kTRUE;                                                       \
   if (real_instance>fNdata[0]) return 0;                                                       \
                                                                                                \
   /* Since the only operation in this formula is reading this branch,                          \
      we are guaranteed that this function is first called with instance==0 and                 \
      hence we are guaranteed that the branch is always properly read */                        \
                                                                                                \
   if (fNeedLoading) {                                                                          \
      fNeedLoading = kFALSE;                                                                    \
      TBranch *br = leaf->GetBranch();                                                          \
      Long64_t tentry = br->GetTree()->GetReadEntry();                                          \
      R__LoadBranch(br,tentry,fQuickLoad);                                                      \
   }                                                                                            \
                                                                                                \
   if (fAxis) {                                                                                 \
      char * label;                                                                             \
      /* This portion is a duplicate (for speed reason) of the code                             \
         located  in the main for loop at "a tree string" (and in EvalStringInstance) */        \
      if (fLookupType[0]==kDirect) {                                                            \
         label = (char*)leaf->GetValuePointer();                                                \
      } else {                                                                                  \
         label = (char*)GetLeafInfo(0)->GetValuePointer(leaf,instance);                         \
      }                                                                                         \
      Int_t bin = fAxis->FindBin(label);                                                        \
      return bin-0.5;                                                                           \
   }

#define TREE_EVAL_INIT                                                                          \
   const Int_t real_instance = GetRealInstance(instance,0);                                     \
                                                                                                \
   if (real_instance>fNdata[0]) return 0;                                                       \
                                                                                                \
   if (fAxis) {                                                                                 \
      char * label;                                                                             \
      /* This portion is a duplicate (for speed reason) of the code                             \
         located  in the main for loop at "a tree string" (and in EvalStringInstance) */        \
      label = (char*)GetLeafInfo(0)->GetValuePointer((TLeaf*)0x0,instance);                     \
      Int_t bin = fAxis->FindBin(label);                                                        \
      return bin-0.5;                                                                           \
   }

#define TT_EVAL_INIT_LOOP                                                                       \
   TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(code);                                             \
                                                                                                \
   /* Now let calculate what physical instance we really need.  */                              \
   const Int_t real_instance = GetRealInstance(instance,code);                                  \
                                                                                                \
   if (willLoad) {                                                                              \
      TBranch *branch = (TBranch*)fBranches.UncheckedAt(code);                                  \
      if (branch) {                                                                             \
         Long64_t treeEntry = branch->GetTree()->GetReadEntry();                                \
         R__LoadBranch(branch,treeEntry,fQuickLoad);                                            \
      } else if (fDidBooleanOptimization) {                                                     \
         branch = leaf->GetBranch();                                                            \
         Long64_t treeEntry = branch->GetTree()->GetReadEntry();                                \
         if (branch->GetReadEntry() != treeEntry) branch->GetEntry( treeEntry );                \
      }                                                                                         \
   } else {                                                                                     \
      /* In the cases where we are behind (i.e. right of) a potential boolean optimization      \
         this tree variable reading may have not been executed with instance==0 which would     \
         result in the branch being potentially not read in. */                                 \
      if (fDidBooleanOptimization) {                                                            \
         TBranch *br = leaf->GetBranch();                                                       \
         Long64_t treeEntry = br->GetTree()->GetReadEntry();                                    \
         if (br->GetReadEntry() != treeEntry) br->GetEntry( treeEntry );                        \
      }                                                                                         \
   }                                                                                            \
   if (real_instance>fNdata[code]) return 0;

#define TREE_EVAL_INIT_LOOP                                                                     \
   /* Now let calculate what physical instance we really need.  */                              \
   const Int_t real_instance = GetRealInstance(instance,code);                                  \
                                                                                                \
   if (real_instance>fNdata[code]) return 0;

namespace {
   Double_t Summing(TTreeFormula *sum) {
      Int_t len = sum->GetNdata();
      Double_t res = 0;
      for (int i=0; i<len; ++i) res += sum->EvalInstance(i);
      return res;
   }
   Double_t FindMin(TTreeFormula *arr) {
      Int_t len = arr->GetNdata();
      Double_t res = 0;
      if (len) {
         res = arr->EvalInstance(0);
         for (int i=1; i<len; ++i) {
            Double_t val = arr->EvalInstance(i);
            if (val < res) {
               res = val;
            }
         }
      }
      return res;
   }
   Double_t FindMax(TTreeFormula *arr) {
      Int_t len = arr->GetNdata();
      Double_t res = 0;
      if (len) {
         res = arr->EvalInstance(0);
         for (int i=1; i<len; ++i) {
            Double_t val = arr->EvalInstance(i);
            if (val > res) {
               res = val;
            }
         }
      }
      return res;
   }
   Double_t FindMin(TTreeFormula *arr, TTreeFormula *condition) {
      Int_t len = arr->GetNdata();
      Double_t res = 0;
      if (len) {
         int i = 0;
         Double_t condval;
         do {
            condval = condition->EvalInstance(i);
            ++i;
         } while (!condval && i<len);
         if (i==len) {
            return 0;
         }
         if (i!=1) {
            // Insure the loading of the branch.
            arr->EvalInstance(0);
         }
         // Now we know that i>0 && i<len and cond==true
         res = arr->EvalInstance(i-1);
         for (; i<len; ++i) {
            condval = condition->EvalInstance(i);
            if (condval) {
               Double_t val = arr->EvalInstance(i);
               if (val < res) {
                  res = val;
               }
            }
         }
      }
      return res;
   }
   Double_t FindMax(TTreeFormula *arr, TTreeFormula *condition) {
      Int_t len = arr->GetNdata();
      Double_t res = 0;
      if (len) {
         int i = 0;
         Double_t condval;
         do {
            condval = condition->EvalInstance(i);
            ++i;
         } while (!condval && i<len);
         if (i==len) {
            return 0;
         }
         if (i!=1) {
            // Insure the loading of the branch.
            arr->EvalInstance(0);
         }
         // Now we know that i>0 && i<len and cond==true
         res = arr->EvalInstance(i-1);
         for (; i<len; ++i) {
            condval = condition->EvalInstance(i);
            if (condval) {
               Double_t val = arr->EvalInstance(i);
               if (val > res) {
                  res = val;
               }
            }
         }
      }
      return res;
   }
}

//______________________________________________________________________________
Double_t TTreeFormula::EvalInstance(Int_t instance, const char *stringStackArg[])
{
//*-*-*-*-*-*-*-*-*-*-*Evaluate this treeformula*-*-*-*-*-*-*-*-*-*-*-*-*-*-*
//*-*                  =========================
//

// Note that the redundance and structure in this code is tailored to improve
// efficiencies.

   if (TestBit(kMissingLeaf)) return 0;
   if (fNoper == 1 && fNcodes > 0) {

      switch (fLookupType[0]) {
         case kDirect:     {
            TT_EVAL_INIT;
            Double_t result = leaf->GetValue(real_instance);
            return result;
         }
         case kMethod:     {
            TT_EVAL_INIT;
            ((TFormLeafInfo*)fDataMembers.UncheckedAt(0))->SetBranch(leaf->GetBranch());
            return GetValueFromMethod(0,leaf);
         }
         case kDataMember: {
            TT_EVAL_INIT;
            ((TFormLeafInfo*)fDataMembers.UncheckedAt(0))->SetBranch(leaf->GetBranch());
            return ((TFormLeafInfo*)fDataMembers.UncheckedAt(0))->GetValue(leaf,real_instance);
         }
         case kTreeMember: {
            TREE_EVAL_INIT;
            return ((TFormLeafInfo*)fDataMembers.UncheckedAt(0))->GetValue((TLeaf*)0x0,real_instance);
         }
         case kIndexOfEntry: return (Double_t)fTree->GetReadEntry();
         case kIndexOfLocalEntry: return (Double_t)fTree->GetTree()->GetReadEntry();
         case kEntries:      return (Double_t)fTree->GetEntries();
         case kLength:       return fManager->fNdata;
         case kLengthFunc:   return ((TTreeFormula*)fAliases.UncheckedAt(0))->GetNdata();
         case kIteration:    return instance;
         case kSum:          return Summing((TTreeFormula*)fAliases.UncheckedAt(0));
         case kMin:          return FindMin((TTreeFormula*)fAliases.UncheckedAt(0));
         case kMax:          return FindMax((TTreeFormula*)fAliases.UncheckedAt(0));
         case kEntryList: {
            TEntryList *elist = (TEntryList*)fExternalCuts.At(0);
            return elist->Contains(fTree->GetTree()->GetReadEntry());
         }
         case -1: break;
      }
      switch (fCodes[0]) {
         case -2: {
            TCutG *gcut = (TCutG*)fExternalCuts.At(0);
            TTreeFormula *fx = (TTreeFormula *)gcut->GetObjectX();
            TTreeFormula *fy = (TTreeFormula *)gcut->GetObjectY();
            Double_t xcut = fx->EvalInstance(instance);
            Double_t ycut = fy->EvalInstance(instance);
            return gcut->IsInside(xcut,ycut);
         }
         case -1: {
            TCutG *gcut = (TCutG*)fExternalCuts.At(0);
            TTreeFormula *fx = (TTreeFormula *)gcut->GetObjectX();
            return fx->EvalInstance(instance);
         }
         default: return 0;
      }
   }

   Double_t tab[kMAXFOUND];
   const Int_t kMAXSTRINGFOUND = 10;
   const char *stringStackLocal[kMAXSTRINGFOUND];
   const char **stringStack = stringStackArg?stringStackArg:stringStackLocal;

   const bool willLoad = (instance==0 || fNeedLoading); fNeedLoading = kFALSE;
   if (willLoad) fDidBooleanOptimization = kFALSE;

   Int_t pos  = 0;
   Int_t pos2 = 0;
   for (Int_t i=0; i<fNoper ; ++i) {

      const Int_t oper = GetOper()[i];
      const Int_t newaction = oper >> kTFOperShift;

      if (newaction<kDefinedVariable) {
         // TFormula operands.

         // one of the most used cases
         if (newaction==kConstant) { pos++; tab[pos-1] = fConst[(oper & kTFOperMask)]; continue; }

         switch(newaction) {

            case kEnd        : return tab[0];
            case kAdd        : pos--; tab[pos-1] += tab[pos]; continue;
            case kSubstract  : pos--; tab[pos-1] -= tab[pos]; continue;
            case kMultiply   : pos--; tab[pos-1] *= tab[pos]; continue;
            case kDivide     : pos--; if (tab[pos] == 0) tab[pos-1] = 0; //  division by 0
                                      else               tab[pos-1] /= tab[pos];
                                      continue;
            case kModulo     : {pos--;
                                Long64_t int1((Long64_t)tab[pos-1]);
                                Long64_t int2((Long64_t)tab[pos]);
                                tab[pos-1] = Double_t(int1%int2);
                                continue;}

            case kcos  : tab[pos-1] = TMath::Cos(tab[pos-1]); continue;
            case ksin  : tab[pos-1] = TMath::Sin(tab[pos-1]); continue;
            case ktan  : if (TMath::Cos(tab[pos-1]) == 0) {tab[pos-1] = 0;} // { tangente indeterminee }
                         else tab[pos-1] = TMath::Tan(tab[pos-1]);
                         continue;
            case kacos : if (TMath::Abs(tab[pos-1]) > 1) {tab[pos-1] = 0;} //  indetermination
                         else tab[pos-1] = TMath::ACos(tab[pos-1]);
                         continue;
            case kasin : if (TMath::Abs(tab[pos-1]) > 1) {tab[pos-1] = 0;} //  indetermination
                         else tab[pos-1] = TMath::ASin(tab[pos-1]);
                         continue;
            case katan : tab[pos-1] = TMath::ATan(tab[pos-1]); continue;
            case kcosh : tab[pos-1] = TMath::CosH(tab[pos-1]); continue;
            case ksinh : tab[pos-1] = TMath::SinH(tab[pos-1]); continue;
            case ktanh : if (TMath::CosH(tab[pos-1]) == 0) {tab[pos-1] = 0;} // { tangente indeterminee }
                         else tab[pos-1] = TMath::TanH(tab[pos-1]);
                         continue;
            case kacosh: if (tab[pos-1] < 1) {tab[pos-1] = 0;} //  indetermination
                         else tab[pos-1] = TMath::ACosH(tab[pos-1]);
                         continue;
            case kasinh: tab[pos-1] = TMath::ASinH(tab[pos-1]); continue;
            case katanh: if (TMath::Abs(tab[pos-1]) > 1) {tab[pos-1] = 0;} // indetermination
                     else tab[pos-1] = TMath::ATanH(tab[pos-1]); continue;
            case katan2: pos--; tab[pos-1] = TMath::ATan2(tab[pos-1],tab[pos]); continue;

            case kfmod : pos--; tab[pos-1] = fmod(tab[pos-1],tab[pos]); continue;
            case kpow  : pos--; tab[pos-1] = TMath::Power(tab[pos-1],tab[pos]); continue;
            case ksq   : tab[pos-1] = tab[pos-1]*tab[pos-1]; continue;
            case ksqrt : tab[pos-1] = TMath::Sqrt(TMath::Abs(tab[pos-1])); continue;

            case kstrstr : pos2 -= 2; pos++;if (strstr(stringStack[pos2],stringStack[pos2+1])) tab[pos-1]=1;
                                        else tab[pos-1]=0; continue;

            case kmin : pos--; tab[pos-1] = TMath::Min(tab[pos-1],tab[pos]); continue;
            case kmax : pos--; tab[pos-1] = TMath::Max(tab[pos-1],tab[pos]); continue;

            case klog  : if (tab[pos-1] > 0) tab[pos-1] = TMath::Log(tab[pos-1]);
                         else {tab[pos-1] = 0;} //{indetermination }
                          continue;
            case kexp  : { Double_t dexp = tab[pos-1];
                           if (dexp < -700) {tab[pos-1] = 0; continue;}
                           if (dexp >  700) {tab[pos-1] = TMath::Exp(700); continue;}
                           tab[pos-1] = TMath::Exp(dexp); continue;
                         }
            case klog10: if (tab[pos-1] > 0) tab[pos-1] = TMath::Log10(tab[pos-1]);
                         else {tab[pos-1] = 0;} //{indetermination }
                         continue;

            case kpi   : pos++; tab[pos-1] = TMath::ACos(-1); continue;

            case kabs  : tab[pos-1] = TMath::Abs(tab[pos-1]); continue;
            case ksign : if (tab[pos-1] < 0) tab[pos-1] = -1; else tab[pos-1] = 1; continue;
            case kint  : tab[pos-1] = Double_t(Int_t(tab[pos-1])); continue;
            case kSignInv: tab[pos-1] = -1 * tab[pos-1]; continue;
            case krndm : pos++; tab[pos-1] = gRandom->Rndm(1); continue;

            case kAnd  : pos--; if (tab[pos-1]!=0 && tab[pos]!=0) tab[pos-1]=1;
                                else tab[pos-1]=0; continue;
            case kOr   : pos--; if (tab[pos-1]!=0 || tab[pos]!=0) tab[pos-1]=1;
                                else tab[pos-1]=0; continue;

            case kEqual      : pos--; tab[pos-1] = (tab[pos-1] == tab[pos]) ? 1 : 0; continue;
            case kNotEqual   : pos--; tab[pos-1] = (tab[pos-1] != tab[pos]) ? 1 : 0; continue;
            case kLess       : pos--; tab[pos-1] = (tab[pos-1] <  tab[pos]) ? 1 : 0; continue;
            case kGreater    : pos--; tab[pos-1] = (tab[pos-1] >  tab[pos]) ? 1 : 0; continue;
            case kLessThan   : pos--; tab[pos-1] = (tab[pos-1] <= tab[pos]) ? 1 : 0; continue;
            case kGreaterThan: pos--; tab[pos-1] = (tab[pos-1] >= tab[pos]) ? 1 : 0; continue;
            case kNot        :        tab[pos-1] = (tab[pos-1] !=        0) ? 0 : 1; continue;

            case kStringEqual : pos2 -= 2; pos++; if (!strcmp(stringStack[pos2+1],stringStack[pos2])) tab[pos-1]=1;
                                                  else tab[pos-1]=0; continue;
            case kStringNotEqual: pos2 -= 2; pos++;if (strcmp(stringStack[pos2+1],stringStack[pos2])) tab[pos-1]=1;
                                                   else tab[pos-1]=0; continue;

            case kBitAnd    : pos--; tab[pos-1]= ((Long64_t) tab[pos-1]) & ((Long64_t) tab[pos]); continue;
            case kBitOr     : pos--; tab[pos-1]= ((Long64_t) tab[pos-1]) | ((Long64_t) tab[pos]); continue;
            case kLeftShift : pos--; tab[pos-1]= ((Long64_t) tab[pos-1]) <<((Long64_t) tab[pos]); continue;
            case kRightShift: pos--; tab[pos-1]= ((Long64_t) tab[pos-1]) >>((Long64_t) tab[pos]); continue;

            case kJump   : i = (oper & kTFOperMask); continue;
            case kJumpIf : pos--; if (!tab[pos]) i = (oper & kTFOperMask); continue;

            case kStringConst: {
               // String
               pos2++; stringStack[pos2-1] = (char*)fExpr[i].Data();
               continue;
            }

            case kBoolOptimize: {
               // boolean operation optimizer

               int param = (oper & kTFOperMask);
               Bool_t skip = kFALSE;
               int op = param % 10; // 1 is && , 2 is ||

               if (op == 1 && (!tab[pos-1]) ) {
                  // &&: skip the right part if the left part is already false

                  skip = kTRUE;

                  // Preserve the existing behavior (i.e. the result of a&&b is
                  // either 0 or 1)
                  tab[pos-1] = 0;

               } else if (op == 2 && tab[pos-1] ) {
                  // ||: skip the right part if the left part is already true

                  skip = kTRUE;

                  // Preserve the existing behavior (i.e. the result of a||b is
                  // either 0 or 1)
                  tab[pos-1] = 1;
               }

               if (skip) {
                  int toskip = param / 10;
                  i += toskip;
                  if (willLoad) fDidBooleanOptimization = kTRUE;
              }
               continue;
            }

            case kFunctionCall: {
               // an external function call

               int param = (oper & kTFOperMask);
               int fno   = param / 1000;
               int nargs = param % 1000;

               // Retrieve the function
               TMethodCall *method = (TMethodCall*)fFunctions.At(fno);

               // Set the arguments
               method->ResetParam();
               if (nargs) {
                  UInt_t argloc = pos-nargs;
                  for(Int_t j=0;j<nargs;j++,argloc++,pos--) {
                     method->SetParam( tab[argloc] );
                  }
               }
               pos++;
               Double_t ret = 0;
               method->Execute(ret);
               tab[pos-1] = ret; // check for the correct conversion!

               continue;
            }

//         case kParameter:    { pos++; tab[pos-1] = fParams[(oper & kTFOperMask)]; continue; }
         }

      } else {
         // TTreeFormula operands.

         // a tree variable (the most used case).

         if (newaction == kDefinedVariable) {

            const Int_t code = (oper & kTFOperMask);
            const Int_t lookupType = fLookupType[code];
            switch (lookupType) {
               case kIndexOfEntry: tab[pos++] = (Double_t)fTree->GetReadEntry(); continue;
               case kIndexOfLocalEntry: tab[pos++] = (Double_t)fTree->GetTree()->GetReadEntry(); continue;
               case kEntries:      tab[pos++] = (Double_t)fTree->GetEntries(); continue;
               case kLength:       tab[pos++] = fManager->fNdata; continue;
               case kLengthFunc:   tab[pos++] = ((TTreeFormula*)fAliases.UncheckedAt(i))->GetNdata(); continue;
               case kIteration:    tab[pos++] = instance; continue;
               case kSum:          tab[pos++] = Summing((TTreeFormula*)fAliases.UncheckedAt(i)); continue;
               case kMin:          tab[pos++] = FindMin((TTreeFormula*)fAliases.UncheckedAt(i)); continue;
               case kMax:          tab[pos++] = FindMax((TTreeFormula*)fAliases.UncheckedAt(i)); continue;

               case kDirect:     { TT_EVAL_INIT_LOOP; tab[pos++] = leaf->GetValue(real_instance); continue; }
               case kMethod:     { TT_EVAL_INIT_LOOP; tab[pos++] = GetValueFromMethod(code,leaf); continue; }
               case kDataMember: { TT_EVAL_INIT_LOOP; tab[pos++] = ((TFormLeafInfo*)fDataMembers.UncheckedAt(code))->
                                          GetValue(leaf,real_instance); continue; }
               case kTreeMember: { TREE_EVAL_INIT_LOOP; tab[pos++] = ((TFormLeafInfo*)fDataMembers.UncheckedAt(code))->
                                          GetValue((TLeaf*)0x0,real_instance); continue; }
               case kEntryList: { TEntryList *elist = (TEntryList*)fExternalCuts.At(code);
                  tab[pos++] = elist->Contains(fTree->GetReadEntry());
                  continue;}
               case -1: break;
               default: tab[pos++] = 0; continue;
            }
            switch (fCodes[code]) {
               case -2: {
                  TCutG *gcut = (TCutG*)fExternalCuts.At(code);
                  TTreeFormula *fx = (TTreeFormula *)gcut->GetObjectX();
                  TTreeFormula *fy = (TTreeFormula *)gcut->GetObjectY();
                  Double_t xcut = fx->EvalInstance(instance);
                  Double_t ycut = fy->EvalInstance(instance);
                  tab[pos++] = gcut->IsInside(xcut,ycut);
                  continue;
               }
               case -1: {
                  TCutG *gcut = (TCutG*)fExternalCuts.At(code);
                  TTreeFormula *fx = (TTreeFormula *)gcut->GetObjectX();
                  tab[pos++] = fx->EvalInstance(instance);
                  continue;
               }
               default: {
                  tab[pos++] = 0;
                  continue;
               }
            }
         }
         switch(newaction) {

            // a TTree Variable Alias (i.e. a sub-TTreeFormula)
            case kAlias: {
               int aliasN = i;
               TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(aliasN));
               R__ASSERT(subform);

               Double_t param = subform->EvalInstance(instance);

               tab[pos] = param; pos++;
               continue;
            }
            // a TTree Variable Alias String (i.e. a sub-TTreeFormula)
            case kAliasString: {
               int aliasN = i;
               TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(aliasN));
               R__ASSERT(subform);

               pos2++;
               stringStack[pos2-1] = subform->EvalStringInstance(instance);
               continue;
            }
            case kMinIf: {
               int alternateN = i;
               TTreeFormula *primary = static_cast<TTreeFormula*>(fAliases.UncheckedAt(alternateN));
               TTreeFormula *condition = static_cast<TTreeFormula*>(fAliases.UncheckedAt(alternateN+1));
               Double_t param = FindMin(primary,condition);
               ++i; // skip the place holder for the condition
               tab[pos] = param; pos++;
               continue;
            }
            case kMaxIf: {
               int alternateN = i;
               TTreeFormula *primary = static_cast<TTreeFormula*>(fAliases.UncheckedAt(alternateN));
               TTreeFormula *condition = static_cast<TTreeFormula*>(fAliases.UncheckedAt(alternateN+1));
               Double_t param = FindMax(primary,condition);
               ++i; // skip the place holder for the condition
               tab[pos] = param; pos++;
               continue;
            }
               
            // a TTree Variable Alternate (i.e. a sub-TTreeFormula)
            case kAlternate: {
               int alternateN = i;
               TTreeFormula *primary = static_cast<TTreeFormula*>(fAliases.UncheckedAt(alternateN));

               // First check whether we are in range for the primary formula
               if (instance < primary->GetNdata()) {

                  Double_t param = primary->EvalInstance(instance);

                  ++i; // skip the alternate value.

                  tab[pos] = param; pos++;
               } else {
                  // The primary is not in rancge, we will calculate the alternate value
                  // via the next operation (which will be a intentional).

                  // kAlias no operations
               }
               continue;
            }
            case kAlternateString: {
               int alternateN = i;
               TTreeFormula *primary = static_cast<TTreeFormula*>(fAliases.UncheckedAt(alternateN));

               // First check whether we are in range for the primary formula
               if (instance < primary->GetNdata()) {

                  pos2++;
                  stringStack[pos2-1] = primary->EvalStringInstance(instance);

                  ++i; // skip the alternate value.

               } else {
                  // The primary is not in rancge, we will calculate the alternate value
                  // via the next operation (which will be a kAlias).

                  // intentional no operations
               }
               continue;
            }

            // a tree string
            case kDefinedString: {
               Int_t string_code = (oper & kTFOperMask);
               TLeaf *leafc = (TLeaf*)fLeaves.UncheckedAt(string_code);

               // Now let calculate what physical instance we really need.
               const Int_t real_instance = GetRealInstance(instance,string_code);

               if (instance==0 || fNeedLoading) {
                  fNeedLoading = kFALSE;
                  TBranch *branch = leafc->GetBranch();
                  Long64_t readentry = branch->GetTree()->GetReadEntry();
                  R__LoadBranch(branch,readentry,fQuickLoad);
               } else {
                  // In the cases where we are behind (i.e. right of) a potential boolean optimization
                  // this tree variable reading may have not been executed with instance==0 which would
                  // result in the branch being potentially not read in.
                  if (fDidBooleanOptimization) {
                     TBranch *br = leafc->GetBranch();
                     Long64_t treeEntry = br->GetTree()->GetReadEntry();
                     R__LoadBranch(br,treeEntry,kTRUE);
                  }
                  if (real_instance>fNdata[string_code]) return 0;
               }
               pos2++;
               if (fLookupType[string_code]==kDirect) {
                  stringStack[pos2-1] = (char*)leafc->GetValuePointer();
               } else {
                  stringStack[pos2-1] = (char*)GetLeafInfo(string_code)->GetValuePointer(leafc,real_instance);
               }
               continue;
            }

         }
      }

      R__ASSERT(i<fNoper);
   }

   Double_t result = tab[0];
   return result;
}

//______________________________________________________________________________
TFormLeafInfo *TTreeFormula::GetLeafInfo(Int_t code) const
{
//*-*-*-*-*-*-*-*Return DataMember corresponding to code*-*-*-*-*-*
//*-*            =======================================
//
//  function called by TLeafObject::GetValue
//  with the value of fLookupType computed in TTreeFormula::DefinedVariable

   return (TFormLeafInfo *)fDataMembers.UncheckedAt(code);

}

//______________________________________________________________________________
TLeaf *TTreeFormula::GetLeaf(Int_t n) const
{
//*-*-*-*-*-*-*-*Return leaf corresponding to serial number n*-*-*-*-*-*
//*-*            ============================================
//

   return (TLeaf*)fLeaves.UncheckedAt(n);
}

//______________________________________________________________________________
TMethodCall *TTreeFormula::GetMethodCall(Int_t code) const
{
//*-*-*-*-*-*-*-*Return methodcall corresponding to code*-*-*-*-*-*
//*-*            =======================================
//
//  function called by TLeafObject::GetValue
//  with the value of fLookupType computed in TTreeFormula::DefinedVariable

   return (TMethodCall *)fMethods.UncheckedAt(code);

}

//______________________________________________________________________________
Int_t TTreeFormula::GetNdata()
{
//*-*-*-*-*-*-*-*Return number of available instances in the formula-*-*-*-*-*-*
//*-*            ===================================================
//

  return fManager->GetNdata();
}

//______________________________________________________________________________
Double_t TTreeFormula::GetValueFromMethod(Int_t i, TLeaf* leaf) const
{
   // Return result of a leafobject method.

   TMethodCall* m = GetMethodCall(i);

   if (!m) {
      return 0.0;
   }

   void* thisobj = 0;
   if (leaf->InheritsFrom(TLeafObject::Class())) {
      thisobj = ((TLeafObject*) leaf)->GetObject();
   } else {
      TBranchElement* branch = (TBranchElement*) ((TLeafElement*) leaf)->GetBranch();
      Int_t id = branch->GetID();
      // FIXME: This is wrong for a top-level branch.
      Int_t offset = 0;
      if (id > -1) {
         TStreamerInfo* info = branch->GetInfo();
         if (info) {
            offset = info->GetOffsets()[id];
         } else {
            Warning("GetValueFromMethod", "No streamer info for branch %s.", branch->GetName());
         }
      }
      if (id < 0) {
         char* address = branch->GetObject();
         thisobj = address;
      } else {
         //char* address = branch->GetAddress();
         char* address = branch->GetObject();
         if (address) {
            thisobj = *((char**) (address + offset));
         } else {
            // FIXME: If the address is not set, the object won't be either!
            thisobj = branch->GetObject();
         }
      }
   }

   TMethodCall::EReturnType r = m->ReturnType();

   if (r == TMethodCall::kLong) {
      Long_t l = 0;
      m->Execute(thisobj, l);
      return (Double_t) l;
   }

   if (r == TMethodCall::kDouble) {
      Double_t d = 0.0;
      m->Execute(thisobj, d);
      return d;
   }

   m->Execute(thisobj);

   return 0;
}

//______________________________________________________________________________
void* TTreeFormula::GetValuePointerFromMethod(Int_t i, TLeaf* leaf) const
{
   // Return result of a leafobject method.

   TMethodCall* m = GetMethodCall(i);

   if (!m) {
      return 0;
   }

   void* thisobj;
   if (leaf->InheritsFrom(TLeafObject::Class())) {
      thisobj = ((TLeafObject*) leaf)->GetObject();
   } else {
      TBranchElement* branch = (TBranchElement*) ((TLeafElement*) leaf)->GetBranch();
      Int_t id = branch->GetID();
      Int_t offset = 0;
      if (id > -1) {
         TStreamerInfo* info = branch->GetInfo();
         if (info) {
            offset = info->GetOffsets()[id];
         } else {
            Warning("GetValuePointerFromMethod", "No streamer info for branch %s.", branch->GetName());
         }
      }
      if (id < 0) {
         char* address = branch->GetObject();
         thisobj = address;
      } else {
         //char* address = branch->GetAddress();
         char* address = branch->GetObject();
         if (address) {
            thisobj = *((char**) (address + offset));
         } else {
            // FIXME: If the address is not set, the object won't be either!
            thisobj = branch->GetObject();
         }
      }
   }

   TMethodCall::EReturnType r = m->ReturnType();

   if (r == TMethodCall::kLong) {
      Long_t l = 0;
      m->Execute(thisobj, l);
      return 0;
   }

   if (r == TMethodCall::kDouble) {
      Double_t d = 0.0;
      m->Execute(thisobj, d);
      return 0;
   }

   if (r == TMethodCall::kOther) {
      char* c = 0;
      m->Execute(thisobj, &c);
      return c;
   }

   m->Execute(thisobj);

   return 0;
}

//______________________________________________________________________________
Bool_t TTreeFormula::IsInteger(Bool_t fast) const
{
   // return TRUE if the formula corresponds to one single Tree leaf
   // and this leaf is short, int or unsigned short, int
   // When a leaf is of type integer or string, the generated histogram is forced
   // to have an integer bin width

   if (fast) {
      if (TestBit(kIsInteger)) return kTRUE;
      else                     return kFALSE;
   }
   
   if (fNoper==2 && GetAction(0)==kAlternate) {
      TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(0));
      R__ASSERT(subform);
      return subform->IsInteger(kFALSE);
   }
   
   if (GetAction(0)==kMinIf || GetAction(0)==kMaxIf) {
      return kFALSE;
   }

   if (fNoper > 1) return kFALSE;

   if (GetAction(0)==kAlias) {
      TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(0));
      R__ASSERT(subform);
      return subform->IsInteger(kFALSE);
   }

   if (fLeaves.GetEntries() != 1) {
      switch (fLookupType[0]) {
         case kIndexOfEntry:
         case kIndexOfLocalEntry:
         case kEntries:
         case kLength:
         case kLengthFunc:
         case kIteration:
           return kTRUE;
         case kSum:
         case kMin:
         case kMax:
         case kEntryList:
         default:
           return kFALSE;
      }
   }

   if (EvalClass()==TBits::Class()) return kTRUE;

   if (IsLeafInteger(0) || IsLeafString(0)) return kTRUE;
   return kFALSE;
}

//______________________________________________________________________________
Bool_t TTreeFormula::IsLeafInteger(Int_t code) const
{
   // return TRUE if the leaf corresponding to code is short, int or unsigned
   // short, int When a leaf is of type integer, the generated histogram is
   // forced to have an integer bin width

   TLeaf *leaf = (TLeaf*)fLeaves.At(code);
   if (!leaf) {
      switch (fLookupType[code]) {
         case kIndexOfEntry:
         case kIndexOfLocalEntry:
         case kEntries:
         case kLength:
         case kLengthFunc:
         case kIteration:
           return kTRUE;
         case kSum:
         case kMin:
         case kMax:
         case kEntryList:
         default:
           return kFALSE;
      }
   }
   if (fAxis) return kTRUE;
   TFormLeafInfo * info;
   switch (fLookupType[code]) {
      case kMethod:
      case kTreeMember:
      case kDataMember:
         info = GetLeafInfo(code);
         return info->IsInteger();
      case kDirect:
         break;
   }
   if (!strcmp(leaf->GetTypeName(),"Int_t"))    return kTRUE;
   if (!strcmp(leaf->GetTypeName(),"Short_t"))  return kTRUE;
   if (!strcmp(leaf->GetTypeName(),"UInt_t"))   return kTRUE;
   if (!strcmp(leaf->GetTypeName(),"UShort_t")) return kTRUE;
   if (!strcmp(leaf->GetTypeName(),"Bool_t"))   return kTRUE;
   if (!strcmp(leaf->GetTypeName(),"Char_t"))   return kTRUE;
   if (!strcmp(leaf->GetTypeName(),"UChar_t"))  return kTRUE;
   if (!strcmp(leaf->GetTypeName(),"string"))   return kTRUE;
   return kFALSE;
}

//______________________________________________________________________________
Bool_t TTreeFormula::IsString() const
{
   // return TRUE if the formula is a string

   return TestBit(kIsCharacter) || (fNoper==1 && IsString(0));
}

//______________________________________________________________________________
Bool_t TTreeFormula::IsString(Int_t oper) const
{
   // (fOper[i]>=105000 && fOper[i]<110000) || fOper[i] == kStrings)

   // return true if the expression at the index 'oper' is to be treated as
   // as string

   if (TFormula::IsString(oper)) return kTRUE;
   if (GetAction(oper)==kDefinedString) return kTRUE;
   if (GetAction(oper)==kAliasString) return kTRUE;
   if (GetAction(oper)==kAlternateString) return kTRUE;
   return kFALSE;
}

//______________________________________________________________________________
Bool_t  TTreeFormula::IsLeafString(Int_t code) const
{
   // return TRUE if the leaf or data member corresponding to code is a string
   TLeaf *leaf = (TLeaf*)fLeaves.At(code);
   TFormLeafInfo * info;
   if (fLookupType[code]==kTreeMember) {
      info = GetLeafInfo(code);
      return info->IsString();
   }

   switch(fLookupType[code]) {
      case kDirect:
         if ( !leaf->IsUnsigned() && (leaf->InheritsFrom(TLeafC::Class()) || leaf->InheritsFrom(TLeafB::Class()) ) ) {
            // Need to find out if it is an 'array' or a pointer.
            if (leaf->GetLenStatic() > 1) return kTRUE;

            // Now we need to differantiate between a variable length array and
            // a TClonesArray.
            if (leaf->GetLeafCount()) {
               const char* indexname = leaf->GetLeafCount()->GetName();
               if (indexname[strlen(indexname)-1] == '_' ) {
                  // This in a clones array
                  return kFALSE;
               } else {
                  // this is a variable length char array
                  return kTRUE;
               }
            }
            return kFALSE;
         } else if (leaf->InheritsFrom(TLeafElement::Class())) {
            TBranchElement * br = (TBranchElement*)leaf->GetBranch();
            Int_t bid = br->GetID();
            if (bid < 0) return kFALSE;
            if (br->GetInfo()==0 || br->GetInfo()->GetElems()==0) {
               // Case where the file is corrupted is some ways.
               // We can not get to the actual type of the data
               // let's assume it is NOT a string.
               return kFALSE;
            }
            TStreamerElement * elem = (TStreamerElement*) br->GetInfo()->GetElems()[bid];
            if (!elem) {
               // Case where the file is corrupted is some ways.
               // We can not get to the actual type of the data
               // let's assume it is NOT a string.
               return kFALSE;
            }
            if (elem->GetNewType()== TStreamerInfo::kOffsetL +kChar_t) {
               // Check whether a specific element of the string is specified!
               if (fIndexes[code][fNdimensions[code]-1] != -1) return kFALSE;
               return kTRUE;
            }
            if ( elem->GetNewType()== TStreamerInfo::kCharStar) {
               // Check whether a specific element of the string is specified!
               if (fNdimensions[code] && fIndexes[code][fNdimensions[code]-1] != -1) return kFALSE;
               return kTRUE;
            }
            return kFALSE;
         } else {
            return kFALSE;
         }
      case kMethod:
         //TMethodCall *m = GetMethodCall(code);
         //TMethodCall::EReturnType r = m->ReturnType();
         return kFALSE;
      case kDataMember:
         info = GetLeafInfo(code);
         return info->IsString();
      default:
         return kFALSE;
   }
}

//______________________________________________________________________________
char *TTreeFormula::PrintValue(Int_t mode) const
{
// Return value of variable as a string
//
//      mode = -2 : Print line with ***
//      mode = -1 : Print column names
//      mode = 0  : Print column values

   return PrintValue(mode,0);
}

//______________________________________________________________________________
char *TTreeFormula::PrintValue(Int_t mode, Int_t instance, const char *decform) const
{
// Return value of variable as a string
//
//      mode = -2 : Print line with ***
//      mode = -1 : Print column names
//      mode = 0  : Print column values
//  decform contains the requested format (with the same convention as printf).
//

   const int kMAXLENGTH = 1024;
   static char value[kMAXLENGTH];

   if (mode == -2) {
      for (int i = 0; i < kMAXLENGTH-1; i++)
         value[i] = '*';
      value[kMAXLENGTH-1] = 0;
   } else if (mode == -1) {
      snprintf(value, kMAXLENGTH-1, "%s", GetTitle());
   } else if (mode == 0) {
      if ( (fNstring && fNval==0 && fNoper==1) ||
           (TestBit(kIsCharacter)) )
      {
         const char * val = 0;
         if (instance<fNdata[0]) {
            if (fLookupType[0]==kTreeMember) {
               val = (char*)GetLeafInfo(0)->GetValuePointer((TLeaf*)0x0,instance);
            } else {
               TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(0);
               TBranch *branch = leaf->GetBranch();
               Long64_t readentry = branch->GetTree()->GetReadEntry();
               R__LoadBranch(branch,readentry,fQuickLoad);
               if (fLookupType[0]==kDirect && fNoper==1) {
                  val = (const char*)leaf->GetValuePointer();
               } else {
                  val = ((TTreeFormula*)this)->EvalStringInstance(instance);
               }
            }
         }
         if (val) {
            strlcpy(value, val, kMAXLENGTH);
         } else {
            value[0] = '\0';
         }
         value[kMAXLENGTH-1] = 0;
      } else {
         //NOTE: This is terrible form ... but is forced upon us by the fact that we can not
         //use the mutable keyword AND we should keep PrintValue const.
         Int_t real_instance = ((TTreeFormula*)this)->GetRealInstance(instance,-1);
         if (real_instance<fNdata[0]) {
            Ssiz_t len = strlen(decform);
            Char_t outputSizeLevel = 1; 
            char *expo = 0;
            if (len>2) {
               switch (decform[len-2]) {
                  case 'l':
                  case 'L': {
                     outputSizeLevel = 2; 
                     if (len>3 && tolower(decform[len-3])=='l') {
                        outputSizeLevel = 3;
                     }
                     break;
                  }
                  case 'h': outputSizeLevel = 0; break;
               }
            }
            switch(decform[len-1]) {
               case 'c':
               case 'd':
               case 'i':
               { 
                  switch (outputSizeLevel) {
                     case 0:  snprintf(value,kMAXLENGTH,Form("%%%s",decform),(Short_t)((TTreeFormula*)this)->EvalInstance(instance)); break;
                     case 2:  snprintf(value,kMAXLENGTH,Form("%%%s",decform),(Long_t)((TTreeFormula*)this)->EvalInstance(instance)); break;
                     case 3:  snprintf(value,kMAXLENGTH,Form("%%%s",decform),(Long64_t)((TTreeFormula*)this)->EvalInstance(instance)); break;
                     case 1:
                     default: snprintf(value,kMAXLENGTH,Form("%%%s",decform),(Int_t)((TTreeFormula*)this)->EvalInstance(instance)); break;
                  }
                  break;
               }
               case 'o': 
               case 'x':
               case 'X':
               case 'u':
               { 
                  switch (outputSizeLevel) {
                     case 0:  snprintf(value,kMAXLENGTH,Form("%%%s",decform),(UShort_t)((TTreeFormula*)this)->EvalInstance(instance)); break;
                     case 2:  snprintf(value,kMAXLENGTH,Form("%%%s",decform),(ULong_t)((TTreeFormula*)this)->EvalInstance(instance)); break;
                     case 3:  snprintf(value,kMAXLENGTH,Form("%%%s",decform),(ULong64_t)((TTreeFormula*)this)->EvalInstance(instance)); break;
                     case 1:
                     default: snprintf(value,kMAXLENGTH,Form("%%%s",decform),(UInt_t)((TTreeFormula*)this)->EvalInstance(instance)); break;
                  }
                  break;
               }
               case 'f':
               case 'e':
               case 'E':
               case 'g':
               case 'G':
               {
                  switch (outputSizeLevel) {
                     case 2:  snprintf(value,kMAXLENGTH,Form("%%%s",decform),(long double)((TTreeFormula*)this)->EvalInstance(instance)); break;
                     case 1:
                     default: snprintf(value,kMAXLENGTH,Form("%%%s",decform),((TTreeFormula*)this)->EvalInstance(instance)); break;
                  }
                  expo = strchr(value,'e');
                  break;
               }
               default:
                  snprintf(value,kMAXLENGTH,Form("%%%sg",decform),((TTreeFormula*)this)->EvalInstance(instance));
                  expo = strchr(value,'e');
            }
            if (expo) {
               // If there is an exponent we may be longer than planned.
               // so let's trim off the excess precission!
               UInt_t declen = atoi(decform);
               if (strlen(value)>declen) {
                  UInt_t off = strlen(value)-declen;
                  char *start = expo - off;
                  UInt_t vlen = strlen(expo);
                  for(UInt_t z=0;z<=vlen;++z) {
                     start[z] = expo[z];
                  }
                  //strcpy(expo-off,expo);
               }
            }
         } else {
            if (isalpha(decform[strlen(decform)-1])) {
               TString short_decform(decform);
               short_decform.Remove(short_decform.Length()-1);
               snprintf(value,kMAXLENGTH,Form(" %%%sc",short_decform.Data()),' ');               
            } else {
               snprintf(value,kMAXLENGTH,Form(" %%%sc",decform),' ');
            }
            
         }
      }
   }
   return &value[0];
}

//______________________________________________________________________________
void TTreeFormula::ResetLoading()
{
   // Tell the formula that we are going to request a new entry.

   fNeedLoading = kTRUE;
   fDidBooleanOptimization = kFALSE;

   for(Int_t i=0; i<fNcodes; ++i) {
      UInt_t max_dim = fNdimensions[i];
      for(UInt_t dim=0; dim<max_dim ;++dim) {
         if (fVarIndexes[i][dim]) {
            fVarIndexes[i][dim]->ResetLoading();
         }
      }
   }
   Int_t n = fAliases.GetLast();
   if ( fNoper < n ) {
      n = fNoper;
   }
   for(Int_t k=0; k <= n; ++k) {
      TTreeFormula *f = static_cast<TTreeFormula*>(fAliases.UncheckedAt(k));
      if (f) {
         f->ResetLoading();
      }
   }
}

//______________________________________________________________________________
void TTreeFormula::SetAxis(TAxis *axis)
{
   // Set the axis (in particular get the type).

   if (!axis) {fAxis = 0; return;}
   if (TestBit(kIsCharacter)) {
      fAxis = axis;
      if (fNoper==1 && GetAction(0)==kAliasString){
         TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(0));
         R__ASSERT(subform);
         subform->SetAxis(axis);
      } else if (fNoper==2 && GetAction(0)==kAlternateString){
         TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(0));
         R__ASSERT(subform);
         subform->SetAxis(axis);
      }
   }
   if (IsInteger()) axis->SetBit(TAxis::kIsInteger);
}

//______________________________________________________________________________
void TTreeFormula::Streamer(TBuffer &R__b)
{
   // Stream an object of class TTreeFormula.

   if (R__b.IsReading()) {
      UInt_t R__s, R__c;
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
      if (R__v > 2) {
         R__b.ReadClassBuffer(TTreeFormula::Class(), this, R__v, R__s, R__c);
         return;
      }
      //====process old versions before automatic schema evolution
      TFormula::Streamer(R__b);
      R__b >> fTree;
      R__b >> fNcodes;
      R__b.ReadFastArray(fCodes, fNcodes);
      R__b >> fMultiplicity;
      Int_t instance;
      R__b >> instance; //data member removed
      R__b >> fNindex;
      if (fNindex) {
         fLookupType = new Int_t[fNindex];
         R__b.ReadFastArray(fLookupType, fNindex);
      }
      fMethods.Streamer(R__b);
      //====end of old versions

   } else {
      R__b.WriteClassBuffer(TTreeFormula::Class(),this);
   }
}

//______________________________________________________________________________
Bool_t TTreeFormula::StringToNumber(Int_t oper)
{
   // Try to 'demote' a string into an array bytes.  If this is not possible,
   // return false.
   
   Int_t code = GetActionParam(oper);
   if (GetAction(oper)==kDefinedString && fLookupType[code]==kDirect) {
      if (oper>0 && GetAction(oper-1)==kJump) {
         // We are the second hand of a ternary operator, let's not do the fixing.
         return kFALSE;
      }
      TLeaf *leaf = (TLeaf*)fLeaves.At(code);
      if (leaf &&  (leaf->InheritsFrom(TLeafC::Class()) || leaf->InheritsFrom(TLeafB::Class()) ) ) {
         SetAction(oper, kDefinedVariable, code );
         fNval++;
         fNstring--;
         return kTRUE;
      }
   }
   return kFALSE;
}


//______________________________________________________________________________
void TTreeFormula::UpdateFormulaLeaves()
{
   // this function is called TTreePlayer::UpdateFormulaLeaves, itself
   // 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.

   // A safer alternative would be to recompile the whole thing .... However
   // currently compile HAS TO be called from the constructor!

   Int_t nleaves = fLeafNames.GetEntriesFast();
   ResetBit( kMissingLeaf );
   for (Int_t i=0;i<nleaves;i++) {
      if (!fTree) break;
      if (!fLeafNames[i]) continue;
      
      TLeaf *leaf = fTree->GetLeaf(fLeafNames[i]->GetTitle(),fLeafNames[i]->GetName());
      fLeaves[i] = leaf;
      if (fBranches[i] && leaf) {
         fBranches[i] = leaf->GetBranch();
         // Since sometimes we might no read all the branches for all the entries, we 
         // might sometimes only read the branch count and thus reset the colleciton
         // but might not read the data branches, to insure that a subsequent read 
         // from TTreeFormula will properly load the data branches even if fQuickLoad is true,
         // we reset the entry of all branches in the TTree.
         ((TBranch*)fBranches[i])->ResetReadEntry();
      }
      if (leaf==0) SetBit( kMissingLeaf );
   }
   for (Int_t j=0; j<kMAXCODES; j++) {
      for (Int_t k = 0; k<kMAXFORMDIM; k++) {
         if (fVarIndexes[j][k]) {
            fVarIndexes[j][k]->UpdateFormulaLeaves();
         }
      }
      if (fLookupType[j]==kDataMember || fLookupType[j]==kTreeMember) GetLeafInfo(j)->Update();
      if (j<fNval && fCodes[j]<0) {
         TCutG *gcut = (TCutG*)fExternalCuts.At(j);
         if (gcut) {
           TTreeFormula *fx = (TTreeFormula *)gcut->GetObjectX();
           TTreeFormula *fy = (TTreeFormula *)gcut->GetObjectY();
           if (fx) fx->UpdateFormulaLeaves();
           if (fy) fy->UpdateFormulaLeaves();
         }
      }
   }
   for(Int_t k=0;k<fNoper;k++) {
      const Int_t oper = GetOper()[k];
      switch(oper >> kTFOperShift) {
         case kAlias:
         case kAliasString:
         case kAlternate:
         case kAlternateString:
         case kMinIf:
         case kMaxIf:
         {
            TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(k));
            R__ASSERT(subform);
            subform->UpdateFormulaLeaves();
            break;
         }
         case kDefinedVariable:
         {
            Int_t code = GetActionParam(k);
            if (fCodes[code]==0) switch(fLookupType[code]) {
               case kLengthFunc:
               case kSum:
               case kMin:
               case kMax:
               {
                  TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(k));
                  R__ASSERT(subform);
                  subform->UpdateFormulaLeaves();
                  break;
               }
               default:
                  break;
            }
         }
         default:
            break;
      }
   }
}

//______________________________________________________________________________
void TTreeFormula::ResetDimensions() {
   // Populate the TTreeFormulaManager with the dimension information.

   Int_t i,k;

   // Now that we saw all the expressions and variables AND that
   // we know whether arrays of chars are treated as string or
   // not, we can properly setup the dimensions.
   TIter next(fDimensionSetup);
   Int_t last_code = -1;
   Int_t virt_dim = 0;
   for(TDimensionInfo * info; (info = (TDimensionInfo*)next()); ) {
      if (last_code!=info->fCode) {
         // We know that the list is ordered by code number then by
         // dimension.  Thus a different code means that we need to
         // restart at the lowest dimensions.
         virt_dim = 0;
         last_code = info->fCode;
         fNdimensions[last_code] = 0;
      }

      if (GetAction(info->fOper)==kDefinedString) {

         // We have a string used as a string (and not an array of number)
         // We need to determine which is the last dimension and skip it.
         TDimensionInfo *nextinfo = (TDimensionInfo*)next();
         while(nextinfo && nextinfo->fCode==info->fCode) {
            DefineDimensions(info->fCode,info->fSize, info->fMultiDim, virt_dim);
            nextinfo = (TDimensionInfo*)next();
         }
         if (!nextinfo) break;

         info = nextinfo;
         virt_dim = 0;
         last_code = info->fCode;
         fNdimensions[last_code] = 0;

         info->fSize = 1; // Maybe this should actually do nothing!
      }


      DefineDimensions(info->fCode,info->fSize, info->fMultiDim, virt_dim);
   }

   fMultiplicity = 0;
   for(i=0;i<fNoper;i++) {
      Int_t action = GetAction(i);

      if (action==kMinIf || action==kMaxIf) {
         // Skip/Ignore the 2nd args
         ++i;
         continue;
      }
      if (action==kAlias || action==kAliasString) {
         TTreeFormula *subform = static_cast<TTreeFormula*>(fAliases.UncheckedAt(i));
         R__ASSERT(subform);
         switch(subform->GetMultiplicity()) {
            case 0: break;
            case 1: fMultiplicity = 1; break;
            case 2: if (fMultiplicity!=1) fMultiplicity = 2; break;
         }
         fManager->Add(subform);
         // since we are addint to this manager 'subform->ResetDimensions();'
         // will be called a little latter
         continue;
      }
      if (action==kDefinedString) {
      //if (fOper[i] >= 105000 && fOper[i]<110000) {
         // We have a string used as a string

         // This dormant portion of code would be used if (when?) we allow the histogramming
         // of the integral content (as opposed to the string content) of strings
         // held in a variable size container delimited by a null (as opposed to
         // a fixed size container or variable size container whose size is controlled
         // by a variable).  In GetNdata, we will then use strlen to grab the current length.
         //fCumulSizes[i][fNdimensions[i]-1] = 1;
         //fUsedSizes[fNdimensions[i]-1] = -TMath::Abs(fUsedSizes[fNdimensions[i]-1]);
         //fUsedSizes[0] = - TMath::Abs( fUsedSizes[0]);

         //continue;
      }
   }

   for (i=0;i<fNcodes;i++) {
      if (fCodes[i] < 0) {
         TCutG *gcut = (TCutG*)fExternalCuts.At(i);
         if (!gcut) continue;
         TTreeFormula *fx = (TTreeFormula *)gcut->GetObjectX();
         TTreeFormula *fy = (TTreeFormula *)gcut->GetObjectY();

         if (fx) {
            switch(fx->GetMultiplicity()) {
               case 0: break;
               case 1: fMultiplicity = 1; break;
               case 2: if (fMultiplicity!=1) fMultiplicity = 2; break;
            }
            fManager->Add(fx);
         }
         if (fy) {
            switch(fy->GetMultiplicity()) {
               case 0: break;
               case 1: fMultiplicity = 1; break;
               case 2: if (fMultiplicity!=1) fMultiplicity = 2; break;
            }
            fManager->Add(fy);
         }

         continue;
      }

      if (fLookupType[i]==kIteration) {
          fMultiplicity = 1;
          continue;
      }

      TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(i);
      if (!leaf) continue;

      // Reminder of the meaning of fMultiplicity:
      //  -1: Only one or 0 element per entry but contains variable length
      //      -array! (Only used for TTreeFormulaManager)
      //   0: Only one element per entry, no variable length array
      //   1: loop over the elements of a variable length array
      //   2: loop over elements of fixed length array (nData is the same for all entry)

      if (leaf->GetLeafCount()) {
         // We assume only one possible variable length dimension (the left most)
         fMultiplicity = 1;
      } else if (fLookupType[i]==kDataMember) {
         TFormLeafInfo * leafinfo = GetLeafInfo(i);
         TStreamerElement * elem = leafinfo->fElement;
         if (fMultiplicity!=1) {
            if (leafinfo->HasCounter() ) fMultiplicity = 1;
            else if (elem && elem->GetArrayDim()>0) fMultiplicity = 2;
            else if (leaf->GetLenStatic()>1) fMultiplicity = 2;
         }
      } else {
         if (leaf->GetLenStatic()>1 && fMultiplicity!=1) fMultiplicity = 2;
      }
      if (fMultiplicity!=1) {
         // If the leaf belongs to a friend tree which has an index, we might
         // be in the case where some entry do not exist.
            
         TTree *realtree = fTree ? fTree->GetTree() : 0;
         TTree *tleaf = leaf->GetBranch()->GetTree();
         if (tleaf && tleaf != realtree && tleaf->GetTreeIndex()) {
            // Reset the multiplicity if we have a friend tree with an index.
            fMultiplicity = 1;
         }
      }

      Int_t virt_dim2 = 0;
      for (k = 0; k < fNdimensions[i]; k++) {
         // At this point fCumulSizes[i][k] actually contain the physical
         // dimension of the k-th dimensions.
         if ( (fCumulSizes[i][k]>=0) && (fIndexes[i][k] >= fCumulSizes[i][k]) ) {
            // unreacheable element requested:
            fManager->CancelDimension(virt_dim2); // fCumulUsedSizes[virt_dim2] = 0;
         }
         if ( fIndexes[i][k] < 0 ) virt_dim2++;
         fFixedSizes[i][k] = fCumulSizes[i][k];
      }

      // Add up the cumulative size
      for (k = fNdimensions[i]; (k > 0); k--) {
         // NOTE: When support for inside variable dimension is added this
         // will become inacurate (since one of the value in the middle of the chain
         // is unknown until GetNdata is called.
         fCumulSizes[i][k-1] *= TMath::Abs(fCumulSizes[i][k]);
      }
      // NOTE: We assume that the inside variable dimensions are dictated by the
      // first index.
      if (fCumulSizes[i][0]>0) fNdata[i] = fCumulSizes[i][0];

      //for (k = 0; k<kMAXFORMDIM; k++) {
      //   if (fVarIndexes[i][k]) fManager->Add(fVarIndexes[i][k]);
      //}

   }
}

//______________________________________________________________________________
void TTreeFormula::LoadBranches()
{
   // Make sure that all the branches have been loaded properly.

   Int_t i;
   for (i=0; i<fNoper ; ++i) {
      TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(i);
      if (leaf==0) continue;

      TBranch *br = leaf->GetBranch();
      Long64_t treeEntry = br->GetTree()->GetReadEntry();
      R__LoadBranch(br,treeEntry,kTRUE);

      TTreeFormula *alias = (TTreeFormula*)fAliases.UncheckedAt(i);
      if (alias) alias->LoadBranches();

      Int_t max_dim = fNdimensions[i];
      for (Int_t dim = 0; dim < max_dim; ++dim) {
         if (fVarIndexes[i][dim]) fVarIndexes[i][dim]->LoadBranches();
      }
   }
}

//______________________________________________________________________________
Bool_t TTreeFormula::LoadCurrentDim() {

   // Calculate the actual dimension for the current entry.

   Int_t size;
   Bool_t outofbounds = kFALSE;

   for (Int_t i=0;i<fNcodes;i++) {
      if (fCodes[i] < 0) continue;

      // NOTE: Currently only the leafcount can indicates a dimension that
      // is physically variable.  So only the left-most dimension is variable.
      // When an API is introduced to be able to determine a variable inside dimensions
      // one would need to add a way to recalculate the values of fCumulSizes for this
      // leaf.  This would probably require the addition of a new data member
      // fSizes[kMAXCODES][kMAXFORMDIM];
      // Also note that EvalInstance expect all the values (but the very first one)
      // of fCumulSizes to be positive.  So indicating that a physical dimension is
      // variable (expected for the first one) can NOT be done via negative values of
      // fCumulSizes.

      TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(i);
      if (!leaf) {
         switch(fLookupType[i]) {
            case kDirect: 
            case kMethod:
            case kTreeMember:
            case kDataMember:
               fNdata[i] = 0;
               outofbounds = kTRUE;
         }
         continue;
      }

      TTree *realtree = fTree->GetTree();
      TTree *tleaf = leaf->GetBranch()->GetTree();
      if (tleaf && tleaf != realtree && tleaf->GetTreeIndex()) {
         if (tleaf->GetReadEntry() < 0) {
            fNdata[i] = 0;
            outofbounds = kTRUE;
            continue;
         } else {
            fNdata[i] = fCumulSizes[i][0];
         }
      }
      Bool_t hasBranchCount2 = kFALSE;
      if (leaf->GetLeafCount()) {
         TLeaf* leafcount = leaf->GetLeafCount();
         TBranch *branchcount = leafcount->GetBranch();
         TFormLeafInfo * info = 0;
         if (leaf->IsA() == TLeafElement::Class()) {
            //if branchcount address not yet set, GetEntry will set the address
            // read branchcount value
            Long64_t readentry = leaf->GetBranch()->GetTree()->GetReadEntry();
            if (readentry < 0) readentry=0;
            if (!branchcount->GetAddress()) {
               R__LoadBranch(branchcount, readentry, fQuickLoad);
            } else {
               // Since we do not read the full branch let's reset the read entry number
               // so that a subsequent read from TTreeFormula will properly load the full
               // object even if fQuickLoad is true.
               branchcount->TBranch::GetEntry(readentry);
               branchcount->ResetReadEntry();
            }

            size = ((TBranchElement*)branchcount)->GetNdata();
            // Reading the size as above is correct only when the branchcount
            // is of streamer type kCounter which require the underlying data
            // member to be signed integral type.

            TBranchElement* branch = (TBranchElement*) leaf->GetBranch();

            // NOTE: could be sped up
            if (fHasMultipleVarDim[i]) {// info && info->GetVarDim()>=0) {
               info = (TFormLeafInfo* )fDataMembers.At(i);
               if (branch->GetBranchCount2()) R__LoadBranch(branch->GetBranchCount2(),readentry,fQuickLoad);
               else R__LoadBranch(branch,readentry,fQuickLoad);

               // Here we need to add the code to take in consideration the
               // double variable length
               // We fill up the array of sizes in the TLeafInfo:
               info->LoadSizes(branch);
               hasBranchCount2 = kTRUE;
               if (info->GetVirtVarDim()>=0) info->UpdateSizes(fManager->fVarDims[info->GetVirtVarDim()]);

               // Refresh the fCumulSizes[i] to have '1' for the
               // double variable dimensions
               Int_t vdim = info->GetVarDim();
               fCumulSizes[i][vdim] =  fCumulSizes[i][vdim+1];
               for(Int_t k=vdim -1; k>=0; k--) {
                  fCumulSizes[i][k] = fCumulSizes[i][k+1]*fFixedSizes[i][k];
               }
               // Update fCumulUsedSizes
               // UpdateMultiVarSizes(vdim,info,i)
               //Int_t fixed = fCumulSizes[i][vdim+1];
               //for(Int_t k=vdim - 1; k>=0; k++) {
               //   Int_t fixed *= fFixedSizes[i][k];
               //   for(Int_t l=0;l<size; l++) {
               //     fCumulSizes[i][k] += info->GetSize(l) * fixed;
               //}
            }
         } else {
            Long64_t readentry = leaf->GetBranch()->GetTree()->GetReadEntry();
            if (readentry < 0) readentry=0;
            R__LoadBranch(branchcount,readentry,fQuickLoad);
            size = leaf->GetLen() / leaf->GetLenStatic();
         }
         if (hasBranchCount2) {
            // We assume that fCumulSizes[i][1] contains the product of the fixed sizes
            fNdata[i] = fCumulSizes[i][1] * ((TFormLeafInfo *)fDataMembers.At(i))->GetSumOfSizes();
         } else {
            fNdata[i] = size * fCumulSizes[i][1];
         }
         if (fIndexes[i][0]==-1) {
            // Case where the index is not specified AND the 1st dimension has a variable
            // size.
            if (fManager->fUsedSizes[0]==1 || (size<fManager->fUsedSizes[0]) ) fManager->fUsedSizes[0] = size;
            if (info && fIndexes[i][info->GetVarDim()]>=0) {
               for(Int_t j=0; j<size; j++) {
                  if (fIndexes[i][info->GetVarDim()] >= info->GetSize(j)) {
                     info->SetSize(j,0);
                     if (size>fManager->fCumulUsedVarDims->GetSize()) fManager->fCumulUsedVarDims->Set(size);
                     fManager->fCumulUsedVarDims->AddAt(-1,j);
                  } else if (fIndexes[i][info->GetVarDim()]>=0) {
                     // There is an index and it is not too large
                     info->SetSize(j,1);
                     if (size>fManager->fCumulUsedVarDims->GetSize()) fManager->fCumulUsedVarDims->Set(size);
                     fManager->fCumulUsedVarDims->AddAt(1,j);
                  }
               }
            }
         } else if (fIndexes[i][0] >= size) {
            // unreacheable element requested:
            fManager->fUsedSizes[0] = 0;
            fNdata[i] = 0;
            outofbounds = kTRUE;
         } else if (hasBranchCount2) {
            TFormLeafInfo *info2;
            info2 = (TFormLeafInfo *)fDataMembers.At(i);
            if (fIndexes[i][0]<0
                || fIndexes[i][info2->GetVarDim()] >= info2->GetSize(fIndexes[i][0])) {
               // unreacheable element requested:
               fManager->fUsedSizes[0] = 0;
               fNdata[i] = 0;
               outofbounds = kTRUE;
            }
         }
      } else if (fLookupType[i]==kDataMember) {
         TFormLeafInfo *leafinfo = (TFormLeafInfo*)fDataMembers.UncheckedAt(i);
         if (leafinfo->HasCounter()) {
            TBranch *branch = leaf->GetBranch();
            Long64_t readentry = branch->GetTree()->GetReadEntry();
            if (readentry < 0) readentry=0;
            R__LoadBranch(branch,readentry,fQuickLoad);
            size = (Int_t) leafinfo->GetCounterValue(leaf);
            if (fIndexes[i][0]==-1) {
               // Case where the index is not specified AND the 1st dimension has a variable
               // size.
               if (fManager->fUsedSizes[0]==1 || (size<fManager->fUsedSizes[0]) ) {
                  fManager->fUsedSizes[0] = size;
               }
            } else if (fIndexes[i][0] >= size) {
               // unreacheable element requested:
               fManager->fUsedSizes[0] = 0;
               fNdata[i] = 0;
               outofbounds = kTRUE;
            } else {
               fNdata[i] = size*fCumulSizes[i][1];
            }
            Int_t vdim = leafinfo->GetVarDim();
            if (vdim>=0) {
               // Here we need to add the code to take in consideration the
               // double variable length
               // We fill up the array of sizes in the TLeafInfo:
               // here we can assume that branch is a TBranch element because the other style does NOT support this type
               // of complexity.
               leafinfo->LoadSizes(branch);
               hasBranchCount2 = kTRUE;
               if (fIndexes[i][0]==-1&&fIndexes[i][vdim] >= 0) {
                  for(int z=0; z<size; ++z) {
                     if (fIndexes[i][vdim] >= leafinfo->GetSize(z)) {
                        leafinfo->SetSize(z,0);
                        // --fManager->fUsedSizes[0];
                     } else if (fIndexes[i][vdim] >= 0 ) {
                        leafinfo->SetSize(z,1);
                     }
                  }
               }
               leafinfo->UpdateSizes(fManager->fVarDims[vdim]);

               // Refresh the fCumulSizes[i] to have '1' for the
               // double variable dimensions
               fCumulSizes[i][vdim] =  fCumulSizes[i][vdim+1];
               for(Int_t k=vdim -1; k>=0; k--) {
                  fCumulSizes[i][k] = fCumulSizes[i][k+1]*fFixedSizes[i][k];
               }
               fNdata[i] = fCumulSizes[i][1] * leafinfo->GetSumOfSizes();
            } else {
               fNdata[i] = size * fCumulSizes[i][1];
            }
         } else if (leafinfo->GetMultiplicity()==-1) {
            TBranch *branch = leaf->GetBranch();
            Long64_t readentry = branch->GetTree()->GetReadEntry();
            if (readentry < 0) readentry=0;
            R__LoadBranch(branch,readentry,fQuickLoad);
            if (leafinfo->GetNdata(leaf)==0) {
               outofbounds = kTRUE;
            }
         }
      }
      // However we allow several dimensions that virtually vary via the size of their
      // index variables.  So we have code to recalculate fCumulUsedSizes.
      Int_t index;
      TFormLeafInfo * info = 0;
      if (fLookupType[i]!=kDirect) {
         info = (TFormLeafInfo *)fDataMembers.At(i);
      }
      for(Int_t k=0, virt_dim=0; k < fNdimensions[i]; k++) {
         if (fIndexes[i][k]<0) {
            if (fIndexes[i][k]==-2 && fManager->fVirtUsedSizes[virt_dim]<0) {

               // if fVirtUsedSize[virt_dim] is positive then VarIndexes[i][k]->GetNdata()
               // is always the same and has already been factored in fUsedSize[virt_dim]
               index = fVarIndexes[i][k]->GetNdata();
               if (index==1) {
                  // We could either have a variable size array which is currently of size one
                  // or a single element that might or not might not be present (and is currently present!)
                  if (fVarIndexes[i][k]->GetManager()->GetMultiplicity()==1) {
                     if (index<fManager->fUsedSizes[virt_dim]) fManager->fUsedSizes[virt_dim] = index;
                  }

               } else if (fManager->fUsedSizes[virt_dim]==-fManager->fVirtUsedSizes[virt_dim] ||
                          index<fManager->fUsedSizes[virt_dim]) {
                  fManager->fUsedSizes[virt_dim] = index;
               }

            } else if (hasBranchCount2 && info && k==info->GetVarDim()) {
               // NOTE: We assume the indexing of variable sizes on the first index!
               if (fIndexes[i][0]>=0) {
                  index = info->GetSize(fIndexes[i][0]);
                  if (fManager->fUsedSizes[virt_dim]==1 || (index!=1 && index<fManager->fUsedSizes[virt_dim]) )
                     fManager->fUsedSizes[virt_dim] = index;
               }
            }
            virt_dim++;
         } else if (hasBranchCount2 && info && k==info->GetVarDim()) {

            // nothing to do, at some point I thought this might be useful:
            // if (fIndexes[i][k]>=0) {
            //    index = info->GetSize(fIndexes[i][k]);
            //    if (fManager->fUsedSizes[virt_dim]==1 || (index!=1 && index<fManager->fUsedSizes[virt_dim]) )
            //      fManager->fUsedSizes[virt_dim] = index;
            //    virt_dim++;
            // }

         }
      }
   }
   return ! outofbounds;



}

void TTreeFormula::Convert(UInt_t oldversion)
{
   // Convert the fOper of a TTTreeFormula version fromVersion to the current in memory version

   enum { kOldAlias           = /*TFormula::kVariable*/ 100000+10000+1,
          kOldAliasString     = kOldAlias+1,
          kOldAlternate       = kOldAlias+2,
          kOldAlternateString = kOldAliasString+2
   };

   for (int k=0; k<fNoper; k++) {
      // First hide from TFormula convertion

      Int_t action = GetOper()[k];

      switch (action) {

         case kOldAlias:            GetOper()[k] = -kOldAlias; break;
         case kOldAliasString:      GetOper()[k] = -kOldAliasString; break;
         case kOldAlternate:        GetOper()[k] = -kOldAlternate; break;
         case kOldAlternateString:  GetOper()[k] = -kOldAlternateString; break;
      }
   }

   TFormula::Convert(oldversion);

   for (int i=0,offset=0; i<fNoper; i++) {
      Int_t action = GetOper()[i+offset];

      switch (action) {
         case -kOldAlias:            SetAction(i, kAlias, 0); break;
         case -kOldAliasString:      SetAction(i, kAliasString, 0); break;
         case -kOldAlternate:        SetAction(i, kAlternate, 0); break;
         case -kOldAlternateString:  SetAction(i, kAlternateString, 0); break;
      }
   }

}

//______________________________________________________________________________
Bool_t TTreeFormula::SwitchToFormLeafInfo(Int_t code)
{
   // Convert the underlying lookup method from the direct technique
   // (dereferencing the address held by the branch) to the method using
   // TFormLeafInfo.  This is in particular usefull in the case where we
   // need to append an additional TFormLeafInfo (for example to call a
   // method).
   // Return false if the switch was unsuccessfull (basically in the
   // case of an old style split tree).

   TFormLeafInfo *last = 0;
   TLeaf *leaf = (TLeaf*)fLeaves.At(code);
   if (!leaf) return kFALSE;

   if (fLookupType[code]==kDirect) {
      if (leaf->InheritsFrom(TLeafElement::Class())) {
         TBranchElement * br = (TBranchElement*)leaf->GetBranch();
         if (br->GetType()==31) {
            // sub branch of a TClonesArray
            TStreamerInfo *info = br->GetInfo();
            TClass* cl = info->GetClass();
            TStreamerElement *element = (TStreamerElement *)info->GetElems()[br->GetID()];
            TFormLeafInfo* clonesinfo = new TFormLeafInfoClones(cl, 0, element, kTRUE);
            Int_t offset;
            info->GetStreamerElement(element->GetName(),offset);
            clonesinfo->fNext = new TFormLeafInfo(cl,offset+br->GetOffset(),element);
            last = clonesinfo->fNext;
            fDataMembers.AddAtAndExpand(clonesinfo,code);
            fLookupType[code]=kDataMember;

         } else if (br->GetType()==41) {
            // sub branch of a Collection

            TBranchElement *count = br->GetBranchCount();
            TFormLeafInfo* collectioninfo;
            if ( count->GetID() >= 0 ) {
               TStreamerElement *collectionElement =
                  (TStreamerElement *)count->GetInfo()->GetElems()[count->GetID()];
               TClass *collectionCl = collectionElement->GetClassPointer();

               collectioninfo =
                  new TFormLeafInfoCollection(collectionCl, 0, collectionElement, kTRUE);
            } else {
               TClass *collectionCl = TClass::GetClass(count->GetClassName());
               collectioninfo =
                  new TFormLeafInfoCollection(collectionCl, 0, collectionCl, kTRUE);
            }

            TStreamerInfo *info = br->GetInfo();
            TClass* cl = info->GetClass();
            TStreamerElement *element = (TStreamerElement *)info->GetElems()[br->GetID()];
            Int_t offset;
            info->GetStreamerElement(element->GetName(),offset);
            collectioninfo->fNext = new TFormLeafInfo(cl,offset+br->GetOffset(),element);
            last = collectioninfo->fNext;
            fDataMembers.AddAtAndExpand(collectioninfo,code);
            fLookupType[code]=kDataMember;

         } else if (br->GetID()<0) { 
            return kFALSE;
         } else {
            last = new TFormLeafInfoDirect(br);
            fDataMembers.AddAtAndExpand(last,code);
            fLookupType[code]=kDataMember;
         }
      } else {
         //last = new TFormLeafInfoDirect(br);
         //fDataMembers.AddAtAndExpand(last,code);
         //fLookupType[code]=kDataMember;
         return kFALSE;
      }
   }
   return kTRUE;
}
 TTreeFormula.cxx:1
 TTreeFormula.cxx:2
 TTreeFormula.cxx:3
 TTreeFormula.cxx:4
 TTreeFormula.cxx:5
 TTreeFormula.cxx:6
 TTreeFormula.cxx:7
 TTreeFormula.cxx:8
 TTreeFormula.cxx:9
 TTreeFormula.cxx:10
 TTreeFormula.cxx:11
 TTreeFormula.cxx:12
 TTreeFormula.cxx:13
 TTreeFormula.cxx:14
 TTreeFormula.cxx:15
 TTreeFormula.cxx:16
 TTreeFormula.cxx:17
 TTreeFormula.cxx:18
 TTreeFormula.cxx:19
 TTreeFormula.cxx:20
 TTreeFormula.cxx:21
 TTreeFormula.cxx:22
 TTreeFormula.cxx:23
 TTreeFormula.cxx:24
 TTreeFormula.cxx:25
 TTreeFormula.cxx:26
 TTreeFormula.cxx:27
 TTreeFormula.cxx:28
 TTreeFormula.cxx:29
 TTreeFormula.cxx:30
 TTreeFormula.cxx:31
 TTreeFormula.cxx:32
 TTreeFormula.cxx:33
 TTreeFormula.cxx:34
 TTreeFormula.cxx:35
 TTreeFormula.cxx:36
 TTreeFormula.cxx:37
 TTreeFormula.cxx:38
 TTreeFormula.cxx:39
 TTreeFormula.cxx:40
 TTreeFormula.cxx:41
 TTreeFormula.cxx:42
 TTreeFormula.cxx:43
 TTreeFormula.cxx:44
 TTreeFormula.cxx:45
 TTreeFormula.cxx:46
 TTreeFormula.cxx:47
 TTreeFormula.cxx:48
 TTreeFormula.cxx:49
 TTreeFormula.cxx:50
 TTreeFormula.cxx:51
 TTreeFormula.cxx:52
 TTreeFormula.cxx:53
 TTreeFormula.cxx:54
 TTreeFormula.cxx:55
 TTreeFormula.cxx:56
 TTreeFormula.cxx:57
 TTreeFormula.cxx:58
 TTreeFormula.cxx:59
 TTreeFormula.cxx:60
 TTreeFormula.cxx:61
 TTreeFormula.cxx:62
 TTreeFormula.cxx:63
 TTreeFormula.cxx:64
 TTreeFormula.cxx:65
 TTreeFormula.cxx:66
 TTreeFormula.cxx:67
 TTreeFormula.cxx:68
 TTreeFormula.cxx:69
 TTreeFormula.cxx:70
 TTreeFormula.cxx:71
 TTreeFormula.cxx:72
 TTreeFormula.cxx:73
 TTreeFormula.cxx:74
 TTreeFormula.cxx:75
 TTreeFormula.cxx:76
 TTreeFormula.cxx:77
 TTreeFormula.cxx:78
 TTreeFormula.cxx:79
 TTreeFormula.cxx:80
 TTreeFormula.cxx:81
 TTreeFormula.cxx:82
 TTreeFormula.cxx:83
 TTreeFormula.cxx:84
 TTreeFormula.cxx:85
 TTreeFormula.cxx:86
 TTreeFormula.cxx:87
 TTreeFormula.cxx:88
 TTreeFormula.cxx:89
 TTreeFormula.cxx:90
 TTreeFormula.cxx:91
 TTreeFormula.cxx:92
 TTreeFormula.cxx:93
 TTreeFormula.cxx:94
 TTreeFormula.cxx:95
 TTreeFormula.cxx:96
 TTreeFormula.cxx:97
 TTreeFormula.cxx:98
 TTreeFormula.cxx:99
 TTreeFormula.cxx:100
 TTreeFormula.cxx:101
 TTreeFormula.cxx:102
 TTreeFormula.cxx:103
 TTreeFormula.cxx:104
 TTreeFormula.cxx:105
 TTreeFormula.cxx:106
 TTreeFormula.cxx:107
 TTreeFormula.cxx:108
 TTreeFormula.cxx:109
 TTreeFormula.cxx:110
 TTreeFormula.cxx:111
 TTreeFormula.cxx:112
 TTreeFormula.cxx:113
 TTreeFormula.cxx:114
 TTreeFormula.cxx:115
 TTreeFormula.cxx:116
 TTreeFormula.cxx:117
 TTreeFormula.cxx:118
 TTreeFormula.cxx:119
 TTreeFormula.cxx:120
 TTreeFormula.cxx:121
 TTreeFormula.cxx:122
 TTreeFormula.cxx:123
 TTreeFormula.cxx:124
 TTreeFormula.cxx:125
 TTreeFormula.cxx:126
 TTreeFormula.cxx:127
 TTreeFormula.cxx:128
 TTreeFormula.cxx:129
 TTreeFormula.cxx:130
 TTreeFormula.cxx:131
 TTreeFormula.cxx:132
 TTreeFormula.cxx:133
 TTreeFormula.cxx:134
 TTreeFormula.cxx:135
 TTreeFormula.cxx:136
 TTreeFormula.cxx:137
 TTreeFormula.cxx:138
 TTreeFormula.cxx:139
 TTreeFormula.cxx:140
 TTreeFormula.cxx:141
 TTreeFormula.cxx:142
 TTreeFormula.cxx:143
 TTreeFormula.cxx:144
 TTreeFormula.cxx:145
 TTreeFormula.cxx:146
 TTreeFormula.cxx:147
 TTreeFormula.cxx:148
 TTreeFormula.cxx:149
 TTreeFormula.cxx:150
 TTreeFormula.cxx:151
 TTreeFormula.cxx:152
 TTreeFormula.cxx:153
 TTreeFormula.cxx:154
 TTreeFormula.cxx:155
 TTreeFormula.cxx:156
 TTreeFormula.cxx:157
 TTreeFormula.cxx:158
 TTreeFormula.cxx:159
 TTreeFormula.cxx:160
 TTreeFormula.cxx:161
 TTreeFormula.cxx:162
 TTreeFormula.cxx:163
 TTreeFormula.cxx:164
 TTreeFormula.cxx:165
 TTreeFormula.cxx:166
 TTreeFormula.cxx:167
 TTreeFormula.cxx:168
 TTreeFormula.cxx:169
 TTreeFormula.cxx:170
 TTreeFormula.cxx:171
 TTreeFormula.cxx:172
 TTreeFormula.cxx:173
 TTreeFormula.cxx:174
 TTreeFormula.cxx:175
 TTreeFormula.cxx:176
 TTreeFormula.cxx:177
 TTreeFormula.cxx:178
 TTreeFormula.cxx:179
 TTreeFormula.cxx:180
 TTreeFormula.cxx:181
 TTreeFormula.cxx:182
 TTreeFormula.cxx:183
 TTreeFormula.cxx:184
 TTreeFormula.cxx:185
 TTreeFormula.cxx:186
 TTreeFormula.cxx:187
 TTreeFormula.cxx:188
 TTreeFormula.cxx:189
 TTreeFormula.cxx:190
 TTreeFormula.cxx:191
 TTreeFormula.cxx:192
 TTreeFormula.cxx:193
 TTreeFormula.cxx:194
 TTreeFormula.cxx:195
 TTreeFormula.cxx:196
 TTreeFormula.cxx:197
 TTreeFormula.cxx:198
 TTreeFormula.cxx:199
 TTreeFormula.cxx:200
 TTreeFormula.cxx:201
 TTreeFormula.cxx:202
 TTreeFormula.cxx:203
 TTreeFormula.cxx:204
 TTreeFormula.cxx:205
 TTreeFormula.cxx:206
 TTreeFormula.cxx:207
 TTreeFormula.cxx:208
 TTreeFormula.cxx:209
 TTreeFormula.cxx:210
 TTreeFormula.cxx:211
 TTreeFormula.cxx:212
 TTreeFormula.cxx:213
 TTreeFormula.cxx:214
 TTreeFormula.cxx:215
 TTreeFormula.cxx:216
 TTreeFormula.cxx:217
 TTreeFormula.cxx:218
 TTreeFormula.cxx:219
 TTreeFormula.cxx:220
 TTreeFormula.cxx:221
 TTreeFormula.cxx:222
 TTreeFormula.cxx:223
 TTreeFormula.cxx:224
 TTreeFormula.cxx:225
 TTreeFormula.cxx:226
 TTreeFormula.cxx:227
 TTreeFormula.cxx:228
 TTreeFormula.cxx:229
 TTreeFormula.cxx:230
 TTreeFormula.cxx:231
 TTreeFormula.cxx:232
 TTreeFormula.cxx:233
 TTreeFormula.cxx:234
 TTreeFormula.cxx:235
 TTreeFormula.cxx:236
 TTreeFormula.cxx:237
 TTreeFormula.cxx:238
 TTreeFormula.cxx:239
 TTreeFormula.cxx:240
 TTreeFormula.cxx:241
 TTreeFormula.cxx:242
 TTreeFormula.cxx:243
 TTreeFormula.cxx:244
 TTreeFormula.cxx:245
 TTreeFormula.cxx:246
 TTreeFormula.cxx:247
 TTreeFormula.cxx:248
 TTreeFormula.cxx:249
 TTreeFormula.cxx:250
 TTreeFormula.cxx:251
 TTreeFormula.cxx:252
 TTreeFormula.cxx:253
 TTreeFormula.cxx:254
 TTreeFormula.cxx:255
 TTreeFormula.cxx:256
 TTreeFormula.cxx:257
 TTreeFormula.cxx:258
 TTreeFormula.cxx:259
 TTreeFormula.cxx:260
 TTreeFormula.cxx:261
 TTreeFormula.cxx:262
 TTreeFormula.cxx:263
 TTreeFormula.cxx:264
 TTreeFormula.cxx:265
 TTreeFormula.cxx:266
 TTreeFormula.cxx:267
 TTreeFormula.cxx:268
 TTreeFormula.cxx:269
 TTreeFormula.cxx:270
 TTreeFormula.cxx:271
 TTreeFormula.cxx:272
 TTreeFormula.cxx:273
 TTreeFormula.cxx:274
 TTreeFormula.cxx:275
 TTreeFormula.cxx:276
 TTreeFormula.cxx:277
 TTreeFormula.cxx:278
 TTreeFormula.cxx:279
 TTreeFormula.cxx:280
 TTreeFormula.cxx:281
 TTreeFormula.cxx:282
 TTreeFormula.cxx:283
 TTreeFormula.cxx:284
 TTreeFormula.cxx:285
 TTreeFormula.cxx:286
 TTreeFormula.cxx:287
 TTreeFormula.cxx:288
 TTreeFormula.cxx:289
 TTreeFormula.cxx:290
 TTreeFormula.cxx:291
 TTreeFormula.cxx:292
 TTreeFormula.cxx:293
 TTreeFormula.cxx:294
 TTreeFormula.cxx:295
 TTreeFormula.cxx:296
 TTreeFormula.cxx:297
 TTreeFormula.cxx:298
 TTreeFormula.cxx:299
 TTreeFormula.cxx:300
 TTreeFormula.cxx:301
 TTreeFormula.cxx:302
 TTreeFormula.cxx:303
 TTreeFormula.cxx:304
 TTreeFormula.cxx:305
 TTreeFormula.cxx:306
 TTreeFormula.cxx:307
 TTreeFormula.cxx:308
 TTreeFormula.cxx:309
 TTreeFormula.cxx:310
 TTreeFormula.cxx:311
 TTreeFormula.cxx:312
 TTreeFormula.cxx:313
 TTreeFormula.cxx:314
 TTreeFormula.cxx:315
 TTreeFormula.cxx:316
 TTreeFormula.cxx:317
 TTreeFormula.cxx:318
 TTreeFormula.cxx:319
 TTreeFormula.cxx:320
 TTreeFormula.cxx:321
 TTreeFormula.cxx:322
 TTreeFormula.cxx:323
 TTreeFormula.cxx:324
 TTreeFormula.cxx:325
 TTreeFormula.cxx:326
 TTreeFormula.cxx:327
 TTreeFormula.cxx:328
 TTreeFormula.cxx:329
 TTreeFormula.cxx:330
 TTreeFormula.cxx:331
 TTreeFormula.cxx:332
 TTreeFormula.cxx:333
 TTreeFormula.cxx:334
 TTreeFormula.cxx:335
 TTreeFormula.cxx:336
 TTreeFormula.cxx:337
 TTreeFormula.cxx:338
 TTreeFormula.cxx:339
 TTreeFormula.cxx:340
 TTreeFormula.cxx:341
 TTreeFormula.cxx:342
 TTreeFormula.cxx:343
 TTreeFormula.cxx:344
 TTreeFormula.cxx:345
 TTreeFormula.cxx:346
 TTreeFormula.cxx:347
 TTreeFormula.cxx:348
 TTreeFormula.cxx:349
 TTreeFormula.cxx:350
 TTreeFormula.cxx:351
 TTreeFormula.cxx:352
 TTreeFormula.cxx:353
 TTreeFormula.cxx:354
 TTreeFormula.cxx:355
 TTreeFormula.cxx:356
 TTreeFormula.cxx:357
 TTreeFormula.cxx:358
 TTreeFormula.cxx:359
 TTreeFormula.cxx:360
 TTreeFormula.cxx:361
 TTreeFormula.cxx:362
 TTreeFormula.cxx:363
 TTreeFormula.cxx:364
 TTreeFormula.cxx:365
 TTreeFormula.cxx:366
 TTreeFormula.cxx:367
 TTreeFormula.cxx:368
 TTreeFormula.cxx:369
 TTreeFormula.cxx:370
 TTreeFormula.cxx:371
 TTreeFormula.cxx:372
 TTreeFormula.cxx:373
 TTreeFormula.cxx:374
 TTreeFormula.cxx:375
 TTreeFormula.cxx:376
 TTreeFormula.cxx:377
 TTreeFormula.cxx:378
 TTreeFormula.cxx:379
 TTreeFormula.cxx:380
 TTreeFormula.cxx:381
 TTreeFormula.cxx:382
 TTreeFormula.cxx:383
 TTreeFormula.cxx:384
 TTreeFormula.cxx:385
 TTreeFormula.cxx:386
 TTreeFormula.cxx:387
 TTreeFormula.cxx:388
 TTreeFormula.cxx:389
 TTreeFormula.cxx:390
 TTreeFormula.cxx:391
 TTreeFormula.cxx:392
 TTreeFormula.cxx:393
 TTreeFormula.cxx:394
 TTreeFormula.cxx:395
 TTreeFormula.cxx:396
 TTreeFormula.cxx:397
 TTreeFormula.cxx:398
 TTreeFormula.cxx:399
 TTreeFormula.cxx:400
 TTreeFormula.cxx:401
 TTreeFormula.cxx:402
 TTreeFormula.cxx:403
 TTreeFormula.cxx:404
 TTreeFormula.cxx:405
 TTreeFormula.cxx:406
 TTreeFormula.cxx:407
 TTreeFormula.cxx:408
 TTreeFormula.cxx:409
 TTreeFormula.cxx:410
 TTreeFormula.cxx:411
 TTreeFormula.cxx:412
 TTreeFormula.cxx:413
 TTreeFormula.cxx:414
 TTreeFormula.cxx:415
 TTreeFormula.cxx:416
 TTreeFormula.cxx:417
 TTreeFormula.cxx:418
 TTreeFormula.cxx:419
 TTreeFormula.cxx:420
 TTreeFormula.cxx:421
 TTreeFormula.cxx:422
 TTreeFormula.cxx:423
 TTreeFormula.cxx:424
 TTreeFormula.cxx:425
 TTreeFormula.cxx:426
 TTreeFormula.cxx:427
 TTreeFormula.cxx:428
 TTreeFormula.cxx:429
 TTreeFormula.cxx:430
 TTreeFormula.cxx:431
 TTreeFormula.cxx:432
 TTreeFormula.cxx:433
 TTreeFormula.cxx:434
 TTreeFormula.cxx:435
 TTreeFormula.cxx:436
 TTreeFormula.cxx:437
 TTreeFormula.cxx:438
 TTreeFormula.cxx:439
 TTreeFormula.cxx:440
 TTreeFormula.cxx:441
 TTreeFormula.cxx:442
 TTreeFormula.cxx:443
 TTreeFormula.cxx:444
 TTreeFormula.cxx:445
 TTreeFormula.cxx:446
 TTreeFormula.cxx:447
 TTreeFormula.cxx:448
 TTreeFormula.cxx:449
 TTreeFormula.cxx:450
 TTreeFormula.cxx:451
 TTreeFormula.cxx:452
 TTreeFormula.cxx:453
 TTreeFormula.cxx:454
 TTreeFormula.cxx:455
 TTreeFormula.cxx:456
 TTreeFormula.cxx:457
 TTreeFormula.cxx:458
 TTreeFormula.cxx:459
 TTreeFormula.cxx:460
 TTreeFormula.cxx:461
 TTreeFormula.cxx:462
 TTreeFormula.cxx:463
 TTreeFormula.cxx:464
 TTreeFormula.cxx:465
 TTreeFormula.cxx:466
 TTreeFormula.cxx:467
 TTreeFormula.cxx:468
 TTreeFormula.cxx:469
 TTreeFormula.cxx:470
 TTreeFormula.cxx:471
 TTreeFormula.cxx:472
 TTreeFormula.cxx:473
 TTreeFormula.cxx:474
 TTreeFormula.cxx:475
 TTreeFormula.cxx:476
 TTreeFormula.cxx:477
 TTreeFormula.cxx:478
 TTreeFormula.cxx:479
 TTreeFormula.cxx:480
 TTreeFormula.cxx:481
 TTreeFormula.cxx:482
 TTreeFormula.cxx:483
 TTreeFormula.cxx:484
 TTreeFormula.cxx:485
 TTreeFormula.cxx:486
 TTreeFormula.cxx:487
 TTreeFormula.cxx:488
 TTreeFormula.cxx:489
 TTreeFormula.cxx:490
 TTreeFormula.cxx:491
 TTreeFormula.cxx:492
 TTreeFormula.cxx:493
 TTreeFormula.cxx:494
 TTreeFormula.cxx:495
 TTreeFormula.cxx:496
 TTreeFormula.cxx:497
 TTreeFormula.cxx:498
 TTreeFormula.cxx:499
 TTreeFormula.cxx:500
 TTreeFormula.cxx:501
 TTreeFormula.cxx:502
 TTreeFormula.cxx:503
 TTreeFormula.cxx:504
 TTreeFormula.cxx:505
 TTreeFormula.cxx:506
 TTreeFormula.cxx:507
 TTreeFormula.cxx:508
 TTreeFormula.cxx:509
 TTreeFormula.cxx:510
 TTreeFormula.cxx:511
 TTreeFormula.cxx:512
 TTreeFormula.cxx:513
 TTreeFormula.cxx:514
 TTreeFormula.cxx:515
 TTreeFormula.cxx:516
 TTreeFormula.cxx:517
 TTreeFormula.cxx:518
 TTreeFormula.cxx:519
 TTreeFormula.cxx:520
 TTreeFormula.cxx:521
 TTreeFormula.cxx:522
 TTreeFormula.cxx:523
 TTreeFormula.cxx:524
 TTreeFormula.cxx:525
 TTreeFormula.cxx:526
 TTreeFormula.cxx:527
 TTreeFormula.cxx:528
 TTreeFormula.cxx:529
 TTreeFormula.cxx:530
 TTreeFormula.cxx:531
 TTreeFormula.cxx:532
 TTreeFormula.cxx:533
 TTreeFormula.cxx:534
 TTreeFormula.cxx:535
 TTreeFormula.cxx:536
 TTreeFormula.cxx:537
 TTreeFormula.cxx:538
 TTreeFormula.cxx:539
 TTreeFormula.cxx:540
 TTreeFormula.cxx:541
 TTreeFormula.cxx:542
 TTreeFormula.cxx:543
 TTreeFormula.cxx:544
 TTreeFormula.cxx:545
 TTreeFormula.cxx:546
 TTreeFormula.cxx:547
 TTreeFormula.cxx:548
 TTreeFormula.cxx:549
 TTreeFormula.cxx:550
 TTreeFormula.cxx:551
 TTreeFormula.cxx:552
 TTreeFormula.cxx:553
 TTreeFormula.cxx:554
 TTreeFormula.cxx:555
 TTreeFormula.cxx:556
 TTreeFormula.cxx:557
 TTreeFormula.cxx:558
 TTreeFormula.cxx:559
 TTreeFormula.cxx:560
 TTreeFormula.cxx:561
 TTreeFormula.cxx:562
 TTreeFormula.cxx:563
 TTreeFormula.cxx:564
 TTreeFormula.cxx:565
 TTreeFormula.cxx:566
 TTreeFormula.cxx:567
 TTreeFormula.cxx:568
 TTreeFormula.cxx:569
 TTreeFormula.cxx:570
 TTreeFormula.cxx:571
 TTreeFormula.cxx:572
 TTreeFormula.cxx:573
 TTreeFormula.cxx:574
 TTreeFormula.cxx:575
 TTreeFormula.cxx:576
 TTreeFormula.cxx:577
 TTreeFormula.cxx:578
 TTreeFormula.cxx:579
 TTreeFormula.cxx:580
 TTreeFormula.cxx:581
 TTreeFormula.cxx:582
 TTreeFormula.cxx:583
 TTreeFormula.cxx:584
 TTreeFormula.cxx:585
 TTreeFormula.cxx:586
 TTreeFormula.cxx:587
 TTreeFormula.cxx:588
 TTreeFormula.cxx:589
 TTreeFormula.cxx:590
 TTreeFormula.cxx:591
 TTreeFormula.cxx:592
 TTreeFormula.cxx:593
 TTreeFormula.cxx:594
 TTreeFormula.cxx:595
 TTreeFormula.cxx:596
 TTreeFormula.cxx:597
 TTreeFormula.cxx:598
 TTreeFormula.cxx:599
 TTreeFormula.cxx:600
 TTreeFormula.cxx:601
 TTreeFormula.cxx:602
 TTreeFormula.cxx:603
 TTreeFormula.cxx:604
 TTreeFormula.cxx:605
 TTreeFormula.cxx:606
 TTreeFormula.cxx:607
 TTreeFormula.cxx:608
 TTreeFormula.cxx:609
 TTreeFormula.cxx:610
 TTreeFormula.cxx:611
 TTreeFormula.cxx:612
 TTreeFormula.cxx:613
 TTreeFormula.cxx:614
 TTreeFormula.cxx:615
 TTreeFormula.cxx:616
 TTreeFormula.cxx:617
 TTreeFormula.cxx:618
 TTreeFormula.cxx:619
 TTreeFormula.cxx:620
 TTreeFormula.cxx:621
 TTreeFormula.cxx:622
 TTreeFormula.cxx:623
 TTreeFormula.cxx:624
 TTreeFormula.cxx:625
 TTreeFormula.cxx:626
 TTreeFormula.cxx:627
 TTreeFormula.cxx:628
 TTreeFormula.cxx:629
 TTreeFormula.cxx:630
 TTreeFormula.cxx:631
 TTreeFormula.cxx:632
 TTreeFormula.cxx:633
 TTreeFormula.cxx:634
 TTreeFormula.cxx:635
 TTreeFormula.cxx:636
 TTreeFormula.cxx:637
 TTreeFormula.cxx:638
 TTreeFormula.cxx:639
 TTreeFormula.cxx:640
 TTreeFormula.cxx:641
 TTreeFormula.cxx:642
 TTreeFormula.cxx:643
 TTreeFormula.cxx:644
 TTreeFormula.cxx:645
 TTreeFormula.cxx:646
 TTreeFormula.cxx:647
 TTreeFormula.cxx:648
 TTreeFormula.cxx:649
 TTreeFormula.cxx:650
 TTreeFormula.cxx:651
 TTreeFormula.cxx:652
 TTreeFormula.cxx:653
 TTreeFormula.cxx:654
 TTreeFormula.cxx:655
 TTreeFormula.cxx:656
 TTreeFormula.cxx:657
 TTreeFormula.cxx:658
 TTreeFormula.cxx:659
 TTreeFormula.cxx:660
 TTreeFormula.cxx:661
 TTreeFormula.cxx:662
 TTreeFormula.cxx:663
 TTreeFormula.cxx:664
 TTreeFormula.cxx:665
 TTreeFormula.cxx:666
 TTreeFormula.cxx:667
 TTreeFormula.cxx:668
 TTreeFormula.cxx:669
 TTreeFormula.cxx:670
 TTreeFormula.cxx:671
 TTreeFormula.cxx:672
 TTreeFormula.cxx:673
 TTreeFormula.cxx:674
 TTreeFormula.cxx:675
 TTreeFormula.cxx:676
 TTreeFormula.cxx:677
 TTreeFormula.cxx:678
 TTreeFormula.cxx:679
 TTreeFormula.cxx:680
 TTreeFormula.cxx:681
 TTreeFormula.cxx:682
 TTreeFormula.cxx:683
 TTreeFormula.cxx:684
 TTreeFormula.cxx:685
 TTreeFormula.cxx:686
 TTreeFormula.cxx:687
 TTreeFormula.cxx:688
 TTreeFormula.cxx:689
 TTreeFormula.cxx:690
 TTreeFormula.cxx:691
 TTreeFormula.cxx:692
 TTreeFormula.cxx:693
 TTreeFormula.cxx:694
 TTreeFormula.cxx:695
 TTreeFormula.cxx:696
 TTreeFormula.cxx:697
 TTreeFormula.cxx:698
 TTreeFormula.cxx:699
 TTreeFormula.cxx:700
 TTreeFormula.cxx:701
 TTreeFormula.cxx:702
 TTreeFormula.cxx:703
 TTreeFormula.cxx:704
 TTreeFormula.cxx:705
 TTreeFormula.cxx:706
 TTreeFormula.cxx:707
 TTreeFormula.cxx:708
 TTreeFormula.cxx:709
 TTreeFormula.cxx:710
 TTreeFormula.cxx:711
 TTreeFormula.cxx:712
 TTreeFormula.cxx:713
 TTreeFormula.cxx:714
 TTreeFormula.cxx:715
 TTreeFormula.cxx:716
 TTreeFormula.cxx:717
 TTreeFormula.cxx:718
 TTreeFormula.cxx:719
 TTreeFormula.cxx:720
 TTreeFormula.cxx:721
 TTreeFormula.cxx:722
 TTreeFormula.cxx:723
 TTreeFormula.cxx:724
 TTreeFormula.cxx:725
 TTreeFormula.cxx:726
 TTreeFormula.cxx:727
 TTreeFormula.cxx:728
 TTreeFormula.cxx:729
 TTreeFormula.cxx:730
 TTreeFormula.cxx:731
 TTreeFormula.cxx:732
 TTreeFormula.cxx:733
 TTreeFormula.cxx:734
 TTreeFormula.cxx:735
 TTreeFormula.cxx:736
 TTreeFormula.cxx:737
 TTreeFormula.cxx:738
 TTreeFormula.cxx:739
 TTreeFormula.cxx:740
 TTreeFormula.cxx:741
 TTreeFormula.cxx:742
 TTreeFormula.cxx:743
 TTreeFormula.cxx:744
 TTreeFormula.cxx:745
 TTreeFormula.cxx:746
 TTreeFormula.cxx:747
 TTreeFormula.cxx:748
 TTreeFormula.cxx:749
 TTreeFormula.cxx:750
 TTreeFormula.cxx:751
 TTreeFormula.cxx:752
 TTreeFormula.cxx:753
 TTreeFormula.cxx:754
 TTreeFormula.cxx:755
 TTreeFormula.cxx:756
 TTreeFormula.cxx:757
 TTreeFormula.cxx:758
 TTreeFormula.cxx:759
 TTreeFormula.cxx:760
 TTreeFormula.cxx:761
 TTreeFormula.cxx:762
 TTreeFormula.cxx:763
 TTreeFormula.cxx:764
 TTreeFormula.cxx:765
 TTreeFormula.cxx:766
 TTreeFormula.cxx:767
 TTreeFormula.cxx:768
 TTreeFormula.cxx:769
 TTreeFormula.cxx:770
 TTreeFormula.cxx:771
 TTreeFormula.cxx:772
 TTreeFormula.cxx:773
 TTreeFormula.cxx:774
 TTreeFormula.cxx:775
 TTreeFormula.cxx:776
 TTreeFormula.cxx:777
 TTreeFormula.cxx:778
 TTreeFormula.cxx:779
 TTreeFormula.cxx:780
 TTreeFormula.cxx:781
 TTreeFormula.cxx:782
 TTreeFormula.cxx:783
 TTreeFormula.cxx:784
 TTreeFormula.cxx:785
 TTreeFormula.cxx:786
 TTreeFormula.cxx:787
 TTreeFormula.cxx:788
 TTreeFormula.cxx:789
 TTreeFormula.cxx:790
 TTreeFormula.cxx:791
 TTreeFormula.cxx:792
 TTreeFormula.cxx:793
 TTreeFormula.cxx:794
 TTreeFormula.cxx:795
 TTreeFormula.cxx:796
 TTreeFormula.cxx:797
 TTreeFormula.cxx:798
 TTreeFormula.cxx:799
 TTreeFormula.cxx:800
 TTreeFormula.cxx:801
 TTreeFormula.cxx:802
 TTreeFormula.cxx:803
 TTreeFormula.cxx:804
 TTreeFormula.cxx:805
 TTreeFormula.cxx:806
 TTreeFormula.cxx:807
 TTreeFormula.cxx:808
 TTreeFormula.cxx:809
 TTreeFormula.cxx:810
 TTreeFormula.cxx:811
 TTreeFormula.cxx:812
 TTreeFormula.cxx:813
 TTreeFormula.cxx:814
 TTreeFormula.cxx:815
 TTreeFormula.cxx:816
 TTreeFormula.cxx:817
 TTreeFormula.cxx:818
 TTreeFormula.cxx:819
 TTreeFormula.cxx:820
 TTreeFormula.cxx:821
 TTreeFormula.cxx:822
 TTreeFormula.cxx:823
 TTreeFormula.cxx:824
 TTreeFormula.cxx:825
 TTreeFormula.cxx:826
 TTreeFormula.cxx:827
 TTreeFormula.cxx:828
 TTreeFormula.cxx:829
 TTreeFormula.cxx:830
 TTreeFormula.cxx:831
 TTreeFormula.cxx:832
 TTreeFormula.cxx:833
 TTreeFormula.cxx:834
 TTreeFormula.cxx:835
 TTreeFormula.cxx:836
 TTreeFormula.cxx:837
 TTreeFormula.cxx:838
 TTreeFormula.cxx:839
 TTreeFormula.cxx:840
 TTreeFormula.cxx:841
 TTreeFormula.cxx:842
 TTreeFormula.cxx:843
 TTreeFormula.cxx:844
 TTreeFormula.cxx:845
 TTreeFormula.cxx:846
 TTreeFormula.cxx:847
 TTreeFormula.cxx:848
 TTreeFormula.cxx:849
 TTreeFormula.cxx:850
 TTreeFormula.cxx:851
 TTreeFormula.cxx:852
 TTreeFormula.cxx:853
 TTreeFormula.cxx:854
 TTreeFormula.cxx:855
 TTreeFormula.cxx:856
 TTreeFormula.cxx:857
 TTreeFormula.cxx:858
 TTreeFormula.cxx:859
 TTreeFormula.cxx:860
 TTreeFormula.cxx:861
 TTreeFormula.cxx:862
 TTreeFormula.cxx:863
 TTreeFormula.cxx:864
 TTreeFormula.cxx:865
 TTreeFormula.cxx:866
 TTreeFormula.cxx:867
 TTreeFormula.cxx:868
 TTreeFormula.cxx:869
 TTreeFormula.cxx:870
 TTreeFormula.cxx:871
 TTreeFormula.cxx:872
 TTreeFormula.cxx:873
 TTreeFormula.cxx:874
 TTreeFormula.cxx:875
 TTreeFormula.cxx:876
 TTreeFormula.cxx:877
 TTreeFormula.cxx:878
 TTreeFormula.cxx:879
 TTreeFormula.cxx:880
 TTreeFormula.cxx:881
 TTreeFormula.cxx:882
 TTreeFormula.cxx:883
 TTreeFormula.cxx:884
 TTreeFormula.cxx:885
 TTreeFormula.cxx:886
 TTreeFormula.cxx:887
 TTreeFormula.cxx:888
 TTreeFormula.cxx:889
 TTreeFormula.cxx:890
 TTreeFormula.cxx:891
 TTreeFormula.cxx:892
 TTreeFormula.cxx:893
 TTreeFormula.cxx:894
 TTreeFormula.cxx:895
 TTreeFormula.cxx:896
 TTreeFormula.cxx:897
 TTreeFormula.cxx:898
 TTreeFormula.cxx:899
 TTreeFormula.cxx:900
 TTreeFormula.cxx:901
 TTreeFormula.cxx:902
 TTreeFormula.cxx:903
 TTreeFormula.cxx:904
 TTreeFormula.cxx:905
 TTreeFormula.cxx:906
 TTreeFormula.cxx:907
 TTreeFormula.cxx:908
 TTreeFormula.cxx:909
 TTreeFormula.cxx:910
 TTreeFormula.cxx:911
 TTreeFormula.cxx:912
 TTreeFormula.cxx:913
 TTreeFormula.cxx:914
 TTreeFormula.cxx:915
 TTreeFormula.cxx:916
 TTreeFormula.cxx:917
 TTreeFormula.cxx:918
 TTreeFormula.cxx:919
 TTreeFormula.cxx:920
 TTreeFormula.cxx:921
 TTreeFormula.cxx:922
 TTreeFormula.cxx:923
 TTreeFormula.cxx:924
 TTreeFormula.cxx:925
 TTreeFormula.cxx:926
 TTreeFormula.cxx:927
 TTreeFormula.cxx:928
 TTreeFormula.cxx:929
 TTreeFormula.cxx:930
 TTreeFormula.cxx:931
 TTreeFormula.cxx:932
 TTreeFormula.cxx:933
 TTreeFormula.cxx:934
 TTreeFormula.cxx:935
 TTreeFormula.cxx:936
 TTreeFormula.cxx:937
 TTreeFormula.cxx:938
 TTreeFormula.cxx:939
 TTreeFormula.cxx:940
 TTreeFormula.cxx:941
 TTreeFormula.cxx:942
 TTreeFormula.cxx:943
 TTreeFormula.cxx:944
 TTreeFormula.cxx:945
 TTreeFormula.cxx:946
 TTreeFormula.cxx:947
 TTreeFormula.cxx:948
 TTreeFormula.cxx:949
 TTreeFormula.cxx:950
 TTreeFormula.cxx:951
 TTreeFormula.cxx:952
 TTreeFormula.cxx:953
 TTreeFormula.cxx:954
 TTreeFormula.cxx:955
 TTreeFormula.cxx:956
 TTreeFormula.cxx:957
 TTreeFormula.cxx:958
 TTreeFormula.cxx:959
 TTreeFormula.cxx:960
 TTreeFormula.cxx:961
 TTreeFormula.cxx:962
 TTreeFormula.cxx:963
 TTreeFormula.cxx:964
 TTreeFormula.cxx:965
 TTreeFormula.cxx:966
 TTreeFormula.cxx:967
 TTreeFormula.cxx:968
 TTreeFormula.cxx:969
 TTreeFormula.cxx:970
 TTreeFormula.cxx:971
 TTreeFormula.cxx:972
 TTreeFormula.cxx:973
 TTreeFormula.cxx:974
 TTreeFormula.cxx:975
 TTreeFormula.cxx:976
 TTreeFormula.cxx:977
 TTreeFormula.cxx:978
 TTreeFormula.cxx:979
 TTreeFormula.cxx:980
 TTreeFormula.cxx:981
 TTreeFormula.cxx:982
 TTreeFormula.cxx:983
 TTreeFormula.cxx:984
 TTreeFormula.cxx:985
 TTreeFormula.cxx:986
 TTreeFormula.cxx:987
 TTreeFormula.cxx:988
 TTreeFormula.cxx:989
 TTreeFormula.cxx:990
 TTreeFormula.cxx:991
 TTreeFormula.cxx:992
 TTreeFormula.cxx:993
 TTreeFormula.cxx:994
 TTreeFormula.cxx:995
 TTreeFormula.cxx:996
 TTreeFormula.cxx:997
 TTreeFormula.cxx:998
 TTreeFormula.cxx:999
 TTreeFormula.cxx:1000
 TTreeFormula.cxx:1001
 TTreeFormula.cxx:1002
 TTreeFormula.cxx:1003
 TTreeFormula.cxx:1004
 TTreeFormula.cxx:1005
 TTreeFormula.cxx:1006
 TTreeFormula.cxx:1007
 TTreeFormula.cxx:1008
 TTreeFormula.cxx:1009
 TTreeFormula.cxx:1010
 TTreeFormula.cxx:1011
 TTreeFormula.cxx:1012
 TTreeFormula.cxx:1013
 TTreeFormula.cxx:1014
 TTreeFormula.cxx:1015
 TTreeFormula.cxx:1016
 TTreeFormula.cxx:1017
 TTreeFormula.cxx:1018
 TTreeFormula.cxx:1019
 TTreeFormula.cxx:1020
 TTreeFormula.cxx:1021
 TTreeFormula.cxx:1022
 TTreeFormula.cxx:1023
 TTreeFormula.cxx:1024
 TTreeFormula.cxx:1025
 TTreeFormula.cxx:1026
 TTreeFormula.cxx:1027
 TTreeFormula.cxx:1028
 TTreeFormula.cxx:1029
 TTreeFormula.cxx:1030
 TTreeFormula.cxx:1031
 TTreeFormula.cxx:1032
 TTreeFormula.cxx:1033
 TTreeFormula.cxx:1034
 TTreeFormula.cxx:1035
 TTreeFormula.cxx:1036
 TTreeFormula.cxx:1037
 TTreeFormula.cxx:1038
 TTreeFormula.cxx:1039
 TTreeFormula.cxx:1040
 TTreeFormula.cxx:1041
 TTreeFormula.cxx:1042
 TTreeFormula.cxx:1043
 TTreeFormula.cxx:1044
 TTreeFormula.cxx:1045
 TTreeFormula.cxx:1046
 TTreeFormula.cxx:1047
 TTreeFormula.cxx:1048
 TTreeFormula.cxx:1049
 TTreeFormula.cxx:1050
 TTreeFormula.cxx:1051
 TTreeFormula.cxx:1052
 TTreeFormula.cxx:1053
 TTreeFormula.cxx:1054
 TTreeFormula.cxx:1055
 TTreeFormula.cxx:1056
 TTreeFormula.cxx:1057
 TTreeFormula.cxx:1058
 TTreeFormula.cxx:1059
 TTreeFormula.cxx:1060
 TTreeFormula.cxx:1061
 TTreeFormula.cxx:1062
 TTreeFormula.cxx:1063
 TTreeFormula.cxx:1064
 TTreeFormula.cxx:1065
 TTreeFormula.cxx:1066
 TTreeFormula.cxx:1067
 TTreeFormula.cxx:1068
 TTreeFormula.cxx:1069
 TTreeFormula.cxx:1070
 TTreeFormula.cxx:1071
 TTreeFormula.cxx:1072
 TTreeFormula.cxx:1073
 TTreeFormula.cxx:1074
 TTreeFormula.cxx:1075
 TTreeFormula.cxx:1076
 TTreeFormula.cxx:1077
 TTreeFormula.cxx:1078
 TTreeFormula.cxx:1079
 TTreeFormula.cxx:1080
 TTreeFormula.cxx:1081
 TTreeFormula.cxx:1082
 TTreeFormula.cxx:1083
 TTreeFormula.cxx:1084
 TTreeFormula.cxx:1085
 TTreeFormula.cxx:1086
 TTreeFormula.cxx:1087
 TTreeFormula.cxx:1088
 TTreeFormula.cxx:1089
 TTreeFormula.cxx:1090
 TTreeFormula.cxx:1091
 TTreeFormula.cxx:1092
 TTreeFormula.cxx:1093
 TTreeFormula.cxx:1094
 TTreeFormula.cxx:1095
 TTreeFormula.cxx:1096
 TTreeFormula.cxx:1097
 TTreeFormula.cxx:1098
 TTreeFormula.cxx:1099
 TTreeFormula.cxx:1100
 TTreeFormula.cxx:1101
 TTreeFormula.cxx:1102
 TTreeFormula.cxx:1103
 TTreeFormula.cxx:1104
 TTreeFormula.cxx:1105
 TTreeFormula.cxx:1106
 TTreeFormula.cxx:1107
 TTreeFormula.cxx:1108
 TTreeFormula.cxx:1109
 TTreeFormula.cxx:1110
 TTreeFormula.cxx:1111
 TTreeFormula.cxx:1112
 TTreeFormula.cxx:1113
 TTreeFormula.cxx:1114
 TTreeFormula.cxx:1115
 TTreeFormula.cxx:1116
 TTreeFormula.cxx:1117
 TTreeFormula.cxx:1118
 TTreeFormula.cxx:1119
 TTreeFormula.cxx:1120
 TTreeFormula.cxx:1121
 TTreeFormula.cxx:1122
 TTreeFormula.cxx:1123
 TTreeFormula.cxx:1124
 TTreeFormula.cxx:1125
 TTreeFormula.cxx:1126
 TTreeFormula.cxx:1127
 TTreeFormula.cxx:1128
 TTreeFormula.cxx:1129
 TTreeFormula.cxx:1130
 TTreeFormula.cxx:1131
 TTreeFormula.cxx:1132
 TTreeFormula.cxx:1133
 TTreeFormula.cxx:1134
 TTreeFormula.cxx:1135
 TTreeFormula.cxx:1136
 TTreeFormula.cxx:1137
 TTreeFormula.cxx:1138
 TTreeFormula.cxx:1139
 TTreeFormula.cxx:1140
 TTreeFormula.cxx:1141
 TTreeFormula.cxx:1142
 TTreeFormula.cxx:1143
 TTreeFormula.cxx:1144
 TTreeFormula.cxx:1145
 TTreeFormula.cxx:1146
 TTreeFormula.cxx:1147
 TTreeFormula.cxx:1148
 TTreeFormula.cxx:1149
 TTreeFormula.cxx:1150
 TTreeFormula.cxx:1151
 TTreeFormula.cxx:1152
 TTreeFormula.cxx:1153
 TTreeFormula.cxx:1154
 TTreeFormula.cxx:1155
 TTreeFormula.cxx:1156
 TTreeFormula.cxx:1157
 TTreeFormula.cxx:1158
 TTreeFormula.cxx:1159
 TTreeFormula.cxx:1160
 TTreeFormula.cxx:1161
 TTreeFormula.cxx:1162
 TTreeFormula.cxx:1163
 TTreeFormula.cxx:1164
 TTreeFormula.cxx:1165
 TTreeFormula.cxx:1166
 TTreeFormula.cxx:1167
 TTreeFormula.cxx:1168
 TTreeFormula.cxx:1169
 TTreeFormula.cxx:1170
 TTreeFormula.cxx:1171
 TTreeFormula.cxx:1172
 TTreeFormula.cxx:1173
 TTreeFormula.cxx:1174
 TTreeFormula.cxx:1175
 TTreeFormula.cxx:1176
 TTreeFormula.cxx:1177
 TTreeFormula.cxx:1178
 TTreeFormula.cxx:1179
 TTreeFormula.cxx:1180
 TTreeFormula.cxx:1181
 TTreeFormula.cxx:1182
 TTreeFormula.cxx:1183
 TTreeFormula.cxx:1184
 TTreeFormula.cxx:1185
 TTreeFormula.cxx:1186
 TTreeFormula.cxx:1187
 TTreeFormula.cxx:1188
 TTreeFormula.cxx:1189
 TTreeFormula.cxx:1190
 TTreeFormula.cxx:1191
 TTreeFormula.cxx:1192
 TTreeFormula.cxx:1193
 TTreeFormula.cxx:1194
 TTreeFormula.cxx:1195
 TTreeFormula.cxx:1196
 TTreeFormula.cxx:1197
 TTreeFormula.cxx:1198
 TTreeFormula.cxx:1199
 TTreeFormula.cxx:1200
 TTreeFormula.cxx:1201
 TTreeFormula.cxx:1202
 TTreeFormula.cxx:1203
 TTreeFormula.cxx:1204
 TTreeFormula.cxx:1205
 TTreeFormula.cxx:1206
 TTreeFormula.cxx:1207
 TTreeFormula.cxx:1208
 TTreeFormula.cxx:1209
 TTreeFormula.cxx:1210
 TTreeFormula.cxx:1211
 TTreeFormula.cxx:1212
 TTreeFormula.cxx:1213
 TTreeFormula.cxx:1214
 TTreeFormula.cxx:1215
 TTreeFormula.cxx:1216
 TTreeFormula.cxx:1217
 TTreeFormula.cxx:1218
 TTreeFormula.cxx:1219
 TTreeFormula.cxx:1220
 TTreeFormula.cxx:1221
 TTreeFormula.cxx:1222
 TTreeFormula.cxx:1223
 TTreeFormula.cxx:1224
 TTreeFormula.cxx:1225
 TTreeFormula.cxx:1226
 TTreeFormula.cxx:1227
 TTreeFormula.cxx:1228
 TTreeFormula.cxx:1229
 TTreeFormula.cxx:1230
 TTreeFormula.cxx:1231
 TTreeFormula.cxx:1232
 TTreeFormula.cxx:1233
 TTreeFormula.cxx:1234
 TTreeFormula.cxx:1235
 TTreeFormula.cxx:1236
 TTreeFormula.cxx:1237
 TTreeFormula.cxx:1238
 TTreeFormula.cxx:1239
 TTreeFormula.cxx:1240
 TTreeFormula.cxx:1241
 TTreeFormula.cxx:1242
 TTreeFormula.cxx:1243
 TTreeFormula.cxx:1244
 TTreeFormula.cxx:1245
 TTreeFormula.cxx:1246
 TTreeFormula.cxx:1247
 TTreeFormula.cxx:1248
 TTreeFormula.cxx:1249
 TTreeFormula.cxx:1250
 TTreeFormula.cxx:1251
 TTreeFormula.cxx:1252
 TTreeFormula.cxx:1253
 TTreeFormula.cxx:1254
 TTreeFormula.cxx:1255
 TTreeFormula.cxx:1256
 TTreeFormula.cxx:1257
 TTreeFormula.cxx:1258
 TTreeFormula.cxx:1259
 TTreeFormula.cxx:1260
 TTreeFormula.cxx:1261
 TTreeFormula.cxx:1262
 TTreeFormula.cxx:1263
 TTreeFormula.cxx:1264
 TTreeFormula.cxx:1265
 TTreeFormula.cxx:1266
 TTreeFormula.cxx:1267
 TTreeFormula.cxx:1268
 TTreeFormula.cxx:1269
 TTreeFormula.cxx:1270
 TTreeFormula.cxx:1271
 TTreeFormula.cxx:1272
 TTreeFormula.cxx:1273
 TTreeFormula.cxx:1274
 TTreeFormula.cxx:1275
 TTreeFormula.cxx:1276
 TTreeFormula.cxx:1277
 TTreeFormula.cxx:1278
 TTreeFormula.cxx:1279
 TTreeFormula.cxx:1280
 TTreeFormula.cxx:1281
 TTreeFormula.cxx:1282
 TTreeFormula.cxx:1283
 TTreeFormula.cxx:1284
 TTreeFormula.cxx:1285
 TTreeFormula.cxx:1286
 TTreeFormula.cxx:1287
 TTreeFormula.cxx:1288
 TTreeFormula.cxx:1289
 TTreeFormula.cxx:1290
 TTreeFormula.cxx:1291
 TTreeFormula.cxx:1292
 TTreeFormula.cxx:1293
 TTreeFormula.cxx:1294
 TTreeFormula.cxx:1295
 TTreeFormula.cxx:1296
 TTreeFormula.cxx:1297
 TTreeFormula.cxx:1298
 TTreeFormula.cxx:1299
 TTreeFormula.cxx:1300
 TTreeFormula.cxx:1301
 TTreeFormula.cxx:1302
 TTreeFormula.cxx:1303
 TTreeFormula.cxx:1304
 TTreeFormula.cxx:1305
 TTreeFormula.cxx:1306
 TTreeFormula.cxx:1307
 TTreeFormula.cxx:1308
 TTreeFormula.cxx:1309
 TTreeFormula.cxx:1310
 TTreeFormula.cxx:1311
 TTreeFormula.cxx:1312
 TTreeFormula.cxx:1313
 TTreeFormula.cxx:1314
 TTreeFormula.cxx:1315
 TTreeFormula.cxx:1316
 TTreeFormula.cxx:1317
 TTreeFormula.cxx:1318
 TTreeFormula.cxx:1319
 TTreeFormula.cxx:1320
 TTreeFormula.cxx:1321
 TTreeFormula.cxx:1322
 TTreeFormula.cxx:1323
 TTreeFormula.cxx:1324
 TTreeFormula.cxx:1325
 TTreeFormula.cxx:1326
 TTreeFormula.cxx:1327
 TTreeFormula.cxx:1328
 TTreeFormula.cxx:1329
 TTreeFormula.cxx:1330
 TTreeFormula.cxx:1331
 TTreeFormula.cxx:1332
 TTreeFormula.cxx:1333
 TTreeFormula.cxx:1334
 TTreeFormula.cxx:1335
 TTreeFormula.cxx:1336
 TTreeFormula.cxx:1337
 TTreeFormula.cxx:1338
 TTreeFormula.cxx:1339
 TTreeFormula.cxx:1340
 TTreeFormula.cxx:1341
 TTreeFormula.cxx:1342
 TTreeFormula.cxx:1343
 TTreeFormula.cxx:1344
 TTreeFormula.cxx:1345
 TTreeFormula.cxx:1346
 TTreeFormula.cxx:1347
 TTreeFormula.cxx:1348
 TTreeFormula.cxx:1349
 TTreeFormula.cxx:1350
 TTreeFormula.cxx:1351
 TTreeFormula.cxx:1352
 TTreeFormula.cxx:1353
 TTreeFormula.cxx:1354
 TTreeFormula.cxx:1355
 TTreeFormula.cxx:1356
 TTreeFormula.cxx:1357
 TTreeFormula.cxx:1358
 TTreeFormula.cxx:1359
 TTreeFormula.cxx:1360
 TTreeFormula.cxx:1361
 TTreeFormula.cxx:1362
 TTreeFormula.cxx:1363
 TTreeFormula.cxx:1364
 TTreeFormula.cxx:1365
 TTreeFormula.cxx:1366
 TTreeFormula.cxx:1367
 TTreeFormula.cxx:1368
 TTreeFormula.cxx:1369
 TTreeFormula.cxx:1370
 TTreeFormula.cxx:1371
 TTreeFormula.cxx:1372
 TTreeFormula.cxx:1373
 TTreeFormula.cxx:1374
 TTreeFormula.cxx:1375
 TTreeFormula.cxx:1376
 TTreeFormula.cxx:1377
 TTreeFormula.cxx:1378
 TTreeFormula.cxx:1379
 TTreeFormula.cxx:1380
 TTreeFormula.cxx:1381
 TTreeFormula.cxx:1382
 TTreeFormula.cxx:1383
 TTreeFormula.cxx:1384
 TTreeFormula.cxx:1385
 TTreeFormula.cxx:1386
 TTreeFormula.cxx:1387
 TTreeFormula.cxx:1388
 TTreeFormula.cxx:1389
 TTreeFormula.cxx:1390
 TTreeFormula.cxx:1391
 TTreeFormula.cxx:1392
 TTreeFormula.cxx:1393
 TTreeFormula.cxx:1394
 TTreeFormula.cxx:1395
 TTreeFormula.cxx:1396
 TTreeFormula.cxx:1397
 TTreeFormula.cxx:1398
 TTreeFormula.cxx:1399
 TTreeFormula.cxx:1400
 TTreeFormula.cxx:1401
 TTreeFormula.cxx:1402
 TTreeFormula.cxx:1403
 TTreeFormula.cxx:1404
 TTreeFormula.cxx:1405
 TTreeFormula.cxx:1406
 TTreeFormula.cxx:1407
 TTreeFormula.cxx:1408
 TTreeFormula.cxx:1409
 TTreeFormula.cxx:1410
 TTreeFormula.cxx:1411
 TTreeFormula.cxx:1412
 TTreeFormula.cxx:1413
 TTreeFormula.cxx:1414
 TTreeFormula.cxx:1415
 TTreeFormula.cxx:1416
 TTreeFormula.cxx:1417
 TTreeFormula.cxx:1418
 TTreeFormula.cxx:1419
 TTreeFormula.cxx:1420
 TTreeFormula.cxx:1421
 TTreeFormula.cxx:1422
 TTreeFormula.cxx:1423
 TTreeFormula.cxx:1424
 TTreeFormula.cxx:1425
 TTreeFormula.cxx:1426
 TTreeFormula.cxx:1427
 TTreeFormula.cxx:1428
 TTreeFormula.cxx:1429
 TTreeFormula.cxx:1430
 TTreeFormula.cxx:1431
 TTreeFormula.cxx:1432
 TTreeFormula.cxx:1433
 TTreeFormula.cxx:1434
 TTreeFormula.cxx:1435
 TTreeFormula.cxx:1436
 TTreeFormula.cxx:1437
 TTreeFormula.cxx:1438
 TTreeFormula.cxx:1439
 TTreeFormula.cxx:1440
 TTreeFormula.cxx:1441
 TTreeFormula.cxx:1442
 TTreeFormula.cxx:1443
 TTreeFormula.cxx:1444
 TTreeFormula.cxx:1445
 TTreeFormula.cxx:1446
 TTreeFormula.cxx:1447
 TTreeFormula.cxx:1448
 TTreeFormula.cxx:1449
 TTreeFormula.cxx:1450
 TTreeFormula.cxx:1451
 TTreeFormula.cxx:1452
 TTreeFormula.cxx:1453
 TTreeFormula.cxx:1454
 TTreeFormula.cxx:1455
 TTreeFormula.cxx:1456
 TTreeFormula.cxx:1457
 TTreeFormula.cxx:1458
 TTreeFormula.cxx:1459
 TTreeFormula.cxx:1460
 TTreeFormula.cxx:1461
 TTreeFormula.cxx:1462
 TTreeFormula.cxx:1463
 TTreeFormula.cxx:1464
 TTreeFormula.cxx:1465
 TTreeFormula.cxx:1466
 TTreeFormula.cxx:1467
 TTreeFormula.cxx:1468
 TTreeFormula.cxx:1469
 TTreeFormula.cxx:1470
 TTreeFormula.cxx:1471
 TTreeFormula.cxx:1472
 TTreeFormula.cxx:1473
 TTreeFormula.cxx:1474
 TTreeFormula.cxx:1475
 TTreeFormula.cxx:1476
 TTreeFormula.cxx:1477
 TTreeFormula.cxx:1478
 TTreeFormula.cxx:1479
 TTreeFormula.cxx:1480
 TTreeFormula.cxx:1481
 TTreeFormula.cxx:1482
 TTreeFormula.cxx:1483
 TTreeFormula.cxx:1484
 TTreeFormula.cxx:1485
 TTreeFormula.cxx:1486
 TTreeFormula.cxx:1487
 TTreeFormula.cxx:1488
 TTreeFormula.cxx:1489
 TTreeFormula.cxx:1490
 TTreeFormula.cxx:1491
 TTreeFormula.cxx:1492
 TTreeFormula.cxx:1493
 TTreeFormula.cxx:1494
 TTreeFormula.cxx:1495
 TTreeFormula.cxx:1496
 TTreeFormula.cxx:1497
 TTreeFormula.cxx:1498
 TTreeFormula.cxx:1499
 TTreeFormula.cxx:1500
 TTreeFormula.cxx:1501
 TTreeFormula.cxx:1502
 TTreeFormula.cxx:1503
 TTreeFormula.cxx:1504
 TTreeFormula.cxx:1505
 TTreeFormula.cxx:1506
 TTreeFormula.cxx:1507
 TTreeFormula.cxx:1508
 TTreeFormula.cxx:1509
 TTreeFormula.cxx:1510
 TTreeFormula.cxx:1511
 TTreeFormula.cxx:1512
 TTreeFormula.cxx:1513
 TTreeFormula.cxx:1514
 TTreeFormula.cxx:1515
 TTreeFormula.cxx:1516
 TTreeFormula.cxx:1517
 TTreeFormula.cxx:1518
 TTreeFormula.cxx:1519
 TTreeFormula.cxx:1520
 TTreeFormula.cxx:1521
 TTreeFormula.cxx:1522
 TTreeFormula.cxx:1523
 TTreeFormula.cxx:1524
 TTreeFormula.cxx:1525
 TTreeFormula.cxx:1526
 TTreeFormula.cxx:1527
 TTreeFormula.cxx:1528
 TTreeFormula.cxx:1529
 TTreeFormula.cxx:1530
 TTreeFormula.cxx:1531
 TTreeFormula.cxx:1532
 TTreeFormula.cxx:1533
 TTreeFormula.cxx:1534
 TTreeFormula.cxx:1535
 TTreeFormula.cxx:1536
 TTreeFormula.cxx:1537
 TTreeFormula.cxx:1538
 TTreeFormula.cxx:1539
 TTreeFormula.cxx:1540
 TTreeFormula.cxx:1541
 TTreeFormula.cxx:1542
 TTreeFormula.cxx:1543
 TTreeFormula.cxx:1544
 TTreeFormula.cxx:1545
 TTreeFormula.cxx:1546
 TTreeFormula.cxx:1547
 TTreeFormula.cxx:1548
 TTreeFormula.cxx:1549
 TTreeFormula.cxx:1550
 TTreeFormula.cxx:1551
 TTreeFormula.cxx:1552
 TTreeFormula.cxx:1553
 TTreeFormula.cxx:1554
 TTreeFormula.cxx:1555
 TTreeFormula.cxx:1556
 TTreeFormula.cxx:1557
 TTreeFormula.cxx:1558
 TTreeFormula.cxx:1559
 TTreeFormula.cxx:1560
 TTreeFormula.cxx:1561
 TTreeFormula.cxx:1562
 TTreeFormula.cxx:1563
 TTreeFormula.cxx:1564
 TTreeFormula.cxx:1565
 TTreeFormula.cxx:1566
 TTreeFormula.cxx:1567
 TTreeFormula.cxx:1568
 TTreeFormula.cxx:1569
 TTreeFormula.cxx:1570
 TTreeFormula.cxx:1571
 TTreeFormula.cxx:1572
 TTreeFormula.cxx:1573
 TTreeFormula.cxx:1574
 TTreeFormula.cxx:1575
 TTreeFormula.cxx:1576
 TTreeFormula.cxx:1577
 TTreeFormula.cxx:1578
 TTreeFormula.cxx:1579
 TTreeFormula.cxx:1580
 TTreeFormula.cxx:1581
 TTreeFormula.cxx:1582
 TTreeFormula.cxx:1583
 TTreeFormula.cxx:1584
 TTreeFormula.cxx:1585
 TTreeFormula.cxx:1586
 TTreeFormula.cxx:1587
 TTreeFormula.cxx:1588
 TTreeFormula.cxx:1589
 TTreeFormula.cxx:1590
 TTreeFormula.cxx:1591
 TTreeFormula.cxx:1592
 TTreeFormula.cxx:1593
 TTreeFormula.cxx:1594
 TTreeFormula.cxx:1595
 TTreeFormula.cxx:1596
 TTreeFormula.cxx:1597
 TTreeFormula.cxx:1598
 TTreeFormula.cxx:1599
 TTreeFormula.cxx:1600
 TTreeFormula.cxx:1601
 TTreeFormula.cxx:1602
 TTreeFormula.cxx:1603
 TTreeFormula.cxx:1604
 TTreeFormula.cxx:1605
 TTreeFormula.cxx:1606
 TTreeFormula.cxx:1607
 TTreeFormula.cxx:1608
 TTreeFormula.cxx:1609
 TTreeFormula.cxx:1610
 TTreeFormula.cxx:1611
 TTreeFormula.cxx:1612
 TTreeFormula.cxx:1613
 TTreeFormula.cxx:1614
 TTreeFormula.cxx:1615
 TTreeFormula.cxx:1616
 TTreeFormula.cxx:1617
 TTreeFormula.cxx:1618
 TTreeFormula.cxx:1619
 TTreeFormula.cxx:1620
 TTreeFormula.cxx:1621
 TTreeFormula.cxx:1622
 TTreeFormula.cxx:1623
 TTreeFormula.cxx:1624
 TTreeFormula.cxx:1625
 TTreeFormula.cxx:1626
 TTreeFormula.cxx:1627
 TTreeFormula.cxx:1628
 TTreeFormula.cxx:1629
 TTreeFormula.cxx:1630
 TTreeFormula.cxx:1631
 TTreeFormula.cxx:1632
 TTreeFormula.cxx:1633
 TTreeFormula.cxx:1634
 TTreeFormula.cxx:1635
 TTreeFormula.cxx:1636
 TTreeFormula.cxx:1637
 TTreeFormula.cxx:1638
 TTreeFormula.cxx:1639
 TTreeFormula.cxx:1640
 TTreeFormula.cxx:1641
 TTreeFormula.cxx:1642
 TTreeFormula.cxx:1643
 TTreeFormula.cxx:1644
 TTreeFormula.cxx:1645
 TTreeFormula.cxx:1646
 TTreeFormula.cxx:1647
 TTreeFormula.cxx:1648
 TTreeFormula.cxx:1649
 TTreeFormula.cxx:1650
 TTreeFormula.cxx:1651
 TTreeFormula.cxx:1652
 TTreeFormula.cxx:1653
 TTreeFormula.cxx:1654
 TTreeFormula.cxx:1655
 TTreeFormula.cxx:1656
 TTreeFormula.cxx:1657
 TTreeFormula.cxx:1658
 TTreeFormula.cxx:1659
 TTreeFormula.cxx:1660
 TTreeFormula.cxx:1661
 TTreeFormula.cxx:1662
 TTreeFormula.cxx:1663
 TTreeFormula.cxx:1664
 TTreeFormula.cxx:1665
 TTreeFormula.cxx:1666
 TTreeFormula.cxx:1667
 TTreeFormula.cxx:1668
 TTreeFormula.cxx:1669
 TTreeFormula.cxx:1670
 TTreeFormula.cxx:1671
 TTreeFormula.cxx:1672
 TTreeFormula.cxx:1673
 TTreeFormula.cxx:1674
 TTreeFormula.cxx:1675
 TTreeFormula.cxx:1676
 TTreeFormula.cxx:1677
 TTreeFormula.cxx:1678
 TTreeFormula.cxx:1679
 TTreeFormula.cxx:1680
 TTreeFormula.cxx:1681
 TTreeFormula.cxx:1682
 TTreeFormula.cxx:1683
 TTreeFormula.cxx:1684
 TTreeFormula.cxx:1685
 TTreeFormula.cxx:1686
 TTreeFormula.cxx:1687
 TTreeFormula.cxx:1688
 TTreeFormula.cxx:1689
 TTreeFormula.cxx:1690
 TTreeFormula.cxx:1691
 TTreeFormula.cxx:1692
 TTreeFormula.cxx:1693
 TTreeFormula.cxx:1694
 TTreeFormula.cxx:1695
 TTreeFormula.cxx:1696
 TTreeFormula.cxx:1697
 TTreeFormula.cxx:1698
 TTreeFormula.cxx:1699
 TTreeFormula.cxx:1700
 TTreeFormula.cxx:1701
 TTreeFormula.cxx:1702
 TTreeFormula.cxx:1703
 TTreeFormula.cxx:1704
 TTreeFormula.cxx:1705
 TTreeFormula.cxx:1706
 TTreeFormula.cxx:1707
 TTreeFormula.cxx:1708
 TTreeFormula.cxx:1709
 TTreeFormula.cxx:1710
 TTreeFormula.cxx:1711
 TTreeFormula.cxx:1712
 TTreeFormula.cxx:1713
 TTreeFormula.cxx:1714
 TTreeFormula.cxx:1715
 TTreeFormula.cxx:1716
 TTreeFormula.cxx:1717
 TTreeFormula.cxx:1718
 TTreeFormula.cxx:1719
 TTreeFormula.cxx:1720
 TTreeFormula.cxx:1721
 TTreeFormula.cxx:1722
 TTreeFormula.cxx:1723
 TTreeFormula.cxx:1724
 TTreeFormula.cxx:1725
 TTreeFormula.cxx:1726
 TTreeFormula.cxx:1727
 TTreeFormula.cxx:1728
 TTreeFormula.cxx:1729
 TTreeFormula.cxx:1730
 TTreeFormula.cxx:1731
 TTreeFormula.cxx:1732
 TTreeFormula.cxx:1733
 TTreeFormula.cxx:1734
 TTreeFormula.cxx:1735
 TTreeFormula.cxx:1736
 TTreeFormula.cxx:1737
 TTreeFormula.cxx:1738
 TTreeFormula.cxx:1739
 TTreeFormula.cxx:1740
 TTreeFormula.cxx:1741
 TTreeFormula.cxx:1742
 TTreeFormula.cxx:1743
 TTreeFormula.cxx:1744
 TTreeFormula.cxx:1745
 TTreeFormula.cxx:1746
 TTreeFormula.cxx:1747
 TTreeFormula.cxx:1748
 TTreeFormula.cxx:1749
 TTreeFormula.cxx:1750
 TTreeFormula.cxx:1751
 TTreeFormula.cxx:1752
 TTreeFormula.cxx:1753
 TTreeFormula.cxx:1754
 TTreeFormula.cxx:1755
 TTreeFormula.cxx:1756
 TTreeFormula.cxx:1757
 TTreeFormula.cxx:1758
 TTreeFormula.cxx:1759
 TTreeFormula.cxx:1760
 TTreeFormula.cxx:1761
 TTreeFormula.cxx:1762
 TTreeFormula.cxx:1763
 TTreeFormula.cxx:1764
 TTreeFormula.cxx:1765
 TTreeFormula.cxx:1766
 TTreeFormula.cxx:1767
 TTreeFormula.cxx:1768
 TTreeFormula.cxx:1769
 TTreeFormula.cxx:1770
 TTreeFormula.cxx:1771
 TTreeFormula.cxx:1772
 TTreeFormula.cxx:1773
 TTreeFormula.cxx:1774
 TTreeFormula.cxx:1775
 TTreeFormula.cxx:1776
 TTreeFormula.cxx:1777
 TTreeFormula.cxx:1778
 TTreeFormula.cxx:1779
 TTreeFormula.cxx:1780
 TTreeFormula.cxx:1781
 TTreeFormula.cxx:1782
 TTreeFormula.cxx:1783
 TTreeFormula.cxx:1784
 TTreeFormula.cxx:1785
 TTreeFormula.cxx:1786
 TTreeFormula.cxx:1787
 TTreeFormula.cxx:1788
 TTreeFormula.cxx:1789
 TTreeFormula.cxx:1790
 TTreeFormula.cxx:1791
 TTreeFormula.cxx:1792
 TTreeFormula.cxx:1793
 TTreeFormula.cxx:1794
 TTreeFormula.cxx:1795
 TTreeFormula.cxx:1796
 TTreeFormula.cxx:1797
 TTreeFormula.cxx:1798
 TTreeFormula.cxx:1799
 TTreeFormula.cxx:1800
 TTreeFormula.cxx:1801
 TTreeFormula.cxx:1802
 TTreeFormula.cxx:1803
 TTreeFormula.cxx:1804
 TTreeFormula.cxx:1805
 TTreeFormula.cxx:1806
 TTreeFormula.cxx:1807
 TTreeFormula.cxx:1808
 TTreeFormula.cxx:1809
 TTreeFormula.cxx:1810
 TTreeFormula.cxx:1811
 TTreeFormula.cxx:1812
 TTreeFormula.cxx:1813
 TTreeFormula.cxx:1814
 TTreeFormula.cxx:1815
 TTreeFormula.cxx:1816
 TTreeFormula.cxx:1817
 TTreeFormula.cxx:1818
 TTreeFormula.cxx:1819
 TTreeFormula.cxx:1820
 TTreeFormula.cxx:1821
 TTreeFormula.cxx:1822
 TTreeFormula.cxx:1823
 TTreeFormula.cxx:1824
 TTreeFormula.cxx:1825
 TTreeFormula.cxx:1826
 TTreeFormula.cxx:1827
 TTreeFormula.cxx:1828
 TTreeFormula.cxx:1829
 TTreeFormula.cxx:1830
 TTreeFormula.cxx:1831
 TTreeFormula.cxx:1832
 TTreeFormula.cxx:1833
 TTreeFormula.cxx:1834
 TTreeFormula.cxx:1835
 TTreeFormula.cxx:1836
 TTreeFormula.cxx:1837
 TTreeFormula.cxx:1838
 TTreeFormula.cxx:1839
 TTreeFormula.cxx:1840
 TTreeFormula.cxx:1841
 TTreeFormula.cxx:1842
 TTreeFormula.cxx:1843
 TTreeFormula.cxx:1844
 TTreeFormula.cxx:1845
 TTreeFormula.cxx:1846
 TTreeFormula.cxx:1847
 TTreeFormula.cxx:1848
 TTreeFormula.cxx:1849
 TTreeFormula.cxx:1850
 TTreeFormula.cxx:1851
 TTreeFormula.cxx:1852
 TTreeFormula.cxx:1853
 TTreeFormula.cxx:1854
 TTreeFormula.cxx:1855
 TTreeFormula.cxx:1856
 TTreeFormula.cxx:1857
 TTreeFormula.cxx:1858
 TTreeFormula.cxx:1859
 TTreeFormula.cxx:1860
 TTreeFormula.cxx:1861
 TTreeFormula.cxx:1862
 TTreeFormula.cxx:1863
 TTreeFormula.cxx:1864
 TTreeFormula.cxx:1865
 TTreeFormula.cxx:1866
 TTreeFormula.cxx:1867
 TTreeFormula.cxx:1868
 TTreeFormula.cxx:1869
 TTreeFormula.cxx:1870
 TTreeFormula.cxx:1871
 TTreeFormula.cxx:1872
 TTreeFormula.cxx:1873
 TTreeFormula.cxx:1874
 TTreeFormula.cxx:1875
 TTreeFormula.cxx:1876
 TTreeFormula.cxx:1877
 TTreeFormula.cxx:1878
 TTreeFormula.cxx:1879
 TTreeFormula.cxx:1880
 TTreeFormula.cxx:1881
 TTreeFormula.cxx:1882
 TTreeFormula.cxx:1883
 TTreeFormula.cxx:1884
 TTreeFormula.cxx:1885
 TTreeFormula.cxx:1886
 TTreeFormula.cxx:1887
 TTreeFormula.cxx:1888
 TTreeFormula.cxx:1889
 TTreeFormula.cxx:1890
 TTreeFormula.cxx:1891
 TTreeFormula.cxx:1892
 TTreeFormula.cxx:1893
 TTreeFormula.cxx:1894
 TTreeFormula.cxx:1895
 TTreeFormula.cxx:1896
 TTreeFormula.cxx:1897
 TTreeFormula.cxx:1898
 TTreeFormula.cxx:1899
 TTreeFormula.cxx:1900
 TTreeFormula.cxx:1901
 TTreeFormula.cxx:1902
 TTreeFormula.cxx:1903
 TTreeFormula.cxx:1904
 TTreeFormula.cxx:1905
 TTreeFormula.cxx:1906
 TTreeFormula.cxx:1907
 TTreeFormula.cxx:1908
 TTreeFormula.cxx:1909
 TTreeFormula.cxx:1910
 TTreeFormula.cxx:1911
 TTreeFormula.cxx:1912
 TTreeFormula.cxx:1913
 TTreeFormula.cxx:1914
 TTreeFormula.cxx:1915
 TTreeFormula.cxx:1916
 TTreeFormula.cxx:1917
 TTreeFormula.cxx:1918
 TTreeFormula.cxx:1919
 TTreeFormula.cxx:1920
 TTreeFormula.cxx:1921
 TTreeFormula.cxx:1922
 TTreeFormula.cxx:1923
 TTreeFormula.cxx:1924
 TTreeFormula.cxx:1925
 TTreeFormula.cxx:1926
 TTreeFormula.cxx:1927
 TTreeFormula.cxx:1928
 TTreeFormula.cxx:1929
 TTreeFormula.cxx:1930
 TTreeFormula.cxx:1931
 TTreeFormula.cxx:1932
 TTreeFormula.cxx:1933
 TTreeFormula.cxx:1934
 TTreeFormula.cxx:1935
 TTreeFormula.cxx:1936
 TTreeFormula.cxx:1937
 TTreeFormula.cxx:1938
 TTreeFormula.cxx:1939
 TTreeFormula.cxx:1940
 TTreeFormula.cxx:1941
 TTreeFormula.cxx:1942
 TTreeFormula.cxx:1943
 TTreeFormula.cxx:1944
 TTreeFormula.cxx:1945
 TTreeFormula.cxx:1946
 TTreeFormula.cxx:1947
 TTreeFormula.cxx:1948
 TTreeFormula.cxx:1949
 TTreeFormula.cxx:1950
 TTreeFormula.cxx:1951
 TTreeFormula.cxx:1952
 TTreeFormula.cxx:1953
 TTreeFormula.cxx:1954
 TTreeFormula.cxx:1955
 TTreeFormula.cxx:1956
 TTreeFormula.cxx:1957
 TTreeFormula.cxx:1958
 TTreeFormula.cxx:1959
 TTreeFormula.cxx:1960
 TTreeFormula.cxx:1961
 TTreeFormula.cxx:1962
 TTreeFormula.cxx:1963
 TTreeFormula.cxx:1964
 TTreeFormula.cxx:1965
 TTreeFormula.cxx:1966
 TTreeFormula.cxx:1967
 TTreeFormula.cxx:1968
 TTreeFormula.cxx:1969
 TTreeFormula.cxx:1970
 TTreeFormula.cxx:1971
 TTreeFormula.cxx:1972
 TTreeFormula.cxx:1973
 TTreeFormula.cxx:1974
 TTreeFormula.cxx:1975
 TTreeFormula.cxx:1976
 TTreeFormula.cxx:1977
 TTreeFormula.cxx:1978
 TTreeFormula.cxx:1979
 TTreeFormula.cxx:1980
 TTreeFormula.cxx:1981
 TTreeFormula.cxx:1982
 TTreeFormula.cxx:1983
 TTreeFormula.cxx:1984
 TTreeFormula.cxx:1985
 TTreeFormula.cxx:1986
 TTreeFormula.cxx:1987
 TTreeFormula.cxx:1988
 TTreeFormula.cxx:1989
 TTreeFormula.cxx:1990
 TTreeFormula.cxx:1991
 TTreeFormula.cxx:1992
 TTreeFormula.cxx:1993
 TTreeFormula.cxx:1994
 TTreeFormula.cxx:1995
 TTreeFormula.cxx:1996
 TTreeFormula.cxx:1997
 TTreeFormula.cxx:1998
 TTreeFormula.cxx:1999
 TTreeFormula.cxx:2000
 TTreeFormula.cxx:2001
 TTreeFormula.cxx:2002
 TTreeFormula.cxx:2003
 TTreeFormula.cxx:2004
 TTreeFormula.cxx:2005
 TTreeFormula.cxx:2006
 TTreeFormula.cxx:2007
 TTreeFormula.cxx:2008
 TTreeFormula.cxx:2009
 TTreeFormula.cxx:2010
 TTreeFormula.cxx:2011
 TTreeFormula.cxx:2012
 TTreeFormula.cxx:2013
 TTreeFormula.cxx:2014
 TTreeFormula.cxx:2015
 TTreeFormula.cxx:2016
 TTreeFormula.cxx:2017
 TTreeFormula.cxx:2018
 TTreeFormula.cxx:2019
 TTreeFormula.cxx:2020
 TTreeFormula.cxx:2021
 TTreeFormula.cxx:2022
 TTreeFormula.cxx:2023
 TTreeFormula.cxx:2024
 TTreeFormula.cxx:2025
 TTreeFormula.cxx:2026
 TTreeFormula.cxx:2027
 TTreeFormula.cxx:2028
 TTreeFormula.cxx:2029
 TTreeFormula.cxx:2030
 TTreeFormula.cxx:2031
 TTreeFormula.cxx:2032
 TTreeFormula.cxx:2033
 TTreeFormula.cxx:2034
 TTreeFormula.cxx:2035
 TTreeFormula.cxx:2036
 TTreeFormula.cxx:2037
 TTreeFormula.cxx:2038
 TTreeFormula.cxx:2039
 TTreeFormula.cxx:2040
 TTreeFormula.cxx:2041
 TTreeFormula.cxx:2042
 TTreeFormula.cxx:2043
 TTreeFormula.cxx:2044
 TTreeFormula.cxx:2045
 TTreeFormula.cxx:2046
 TTreeFormula.cxx:2047
 TTreeFormula.cxx:2048
 TTreeFormula.cxx:2049
 TTreeFormula.cxx:2050
 TTreeFormula.cxx:2051
 TTreeFormula.cxx:2052
 TTreeFormula.cxx:2053
 TTreeFormula.cxx:2054
 TTreeFormula.cxx:2055
 TTreeFormula.cxx:2056
 TTreeFormula.cxx:2057
 TTreeFormula.cxx:2058
 TTreeFormula.cxx:2059
 TTreeFormula.cxx:2060
 TTreeFormula.cxx:2061
 TTreeFormula.cxx:2062
 TTreeFormula.cxx:2063
 TTreeFormula.cxx:2064
 TTreeFormula.cxx:2065
 TTreeFormula.cxx:2066
 TTreeFormula.cxx:2067
 TTreeFormula.cxx:2068
 TTreeFormula.cxx:2069
 TTreeFormula.cxx:2070
 TTreeFormula.cxx:2071
 TTreeFormula.cxx:2072
 TTreeFormula.cxx:2073
 TTreeFormula.cxx:2074
 TTreeFormula.cxx:2075
 TTreeFormula.cxx:2076
 TTreeFormula.cxx:2077
 TTreeFormula.cxx:2078
 TTreeFormula.cxx:2079
 TTreeFormula.cxx:2080
 TTreeFormula.cxx:2081
 TTreeFormula.cxx:2082
 TTreeFormula.cxx:2083
 TTreeFormula.cxx:2084
 TTreeFormula.cxx:2085
 TTreeFormula.cxx:2086
 TTreeFormula.cxx:2087
 TTreeFormula.cxx:2088
 TTreeFormula.cxx:2089
 TTreeFormula.cxx:2090
 TTreeFormula.cxx:2091
 TTreeFormula.cxx:2092
 TTreeFormula.cxx:2093
 TTreeFormula.cxx:2094
 TTreeFormula.cxx:2095
 TTreeFormula.cxx:2096
 TTreeFormula.cxx:2097
 TTreeFormula.cxx:2098
 TTreeFormula.cxx:2099
 TTreeFormula.cxx:2100
 TTreeFormula.cxx:2101
 TTreeFormula.cxx:2102
 TTreeFormula.cxx:2103
 TTreeFormula.cxx:2104
 TTreeFormula.cxx:2105
 TTreeFormula.cxx:2106
 TTreeFormula.cxx:2107
 TTreeFormula.cxx:2108
 TTreeFormula.cxx:2109
 TTreeFormula.cxx:2110
 TTreeFormula.cxx:2111
 TTreeFormula.cxx:2112
 TTreeFormula.cxx:2113
 TTreeFormula.cxx:2114
 TTreeFormula.cxx:2115
 TTreeFormula.cxx:2116
 TTreeFormula.cxx:2117
 TTreeFormula.cxx:2118
 TTreeFormula.cxx:2119
 TTreeFormula.cxx:2120
 TTreeFormula.cxx:2121
 TTreeFormula.cxx:2122
 TTreeFormula.cxx:2123
 TTreeFormula.cxx:2124
 TTreeFormula.cxx:2125
 TTreeFormula.cxx:2126
 TTreeFormula.cxx:2127
 TTreeFormula.cxx:2128
 TTreeFormula.cxx:2129
 TTreeFormula.cxx:2130
 TTreeFormula.cxx:2131
 TTreeFormula.cxx:2132
 TTreeFormula.cxx:2133
 TTreeFormula.cxx:2134
 TTreeFormula.cxx:2135
 TTreeFormula.cxx:2136
 TTreeFormula.cxx:2137
 TTreeFormula.cxx:2138
 TTreeFormula.cxx:2139
 TTreeFormula.cxx:2140
 TTreeFormula.cxx:2141
 TTreeFormula.cxx:2142
 TTreeFormula.cxx:2143
 TTreeFormula.cxx:2144
 TTreeFormula.cxx:2145
 TTreeFormula.cxx:2146
 TTreeFormula.cxx:2147
 TTreeFormula.cxx:2148
 TTreeFormula.cxx:2149
 TTreeFormula.cxx:2150
 TTreeFormula.cxx:2151
 TTreeFormula.cxx:2152
 TTreeFormula.cxx:2153
 TTreeFormula.cxx:2154
 TTreeFormula.cxx:2155
 TTreeFormula.cxx:2156
 TTreeFormula.cxx:2157
 TTreeFormula.cxx:2158
 TTreeFormula.cxx:2159
 TTreeFormula.cxx:2160
 TTreeFormula.cxx:2161
 TTreeFormula.cxx:2162
 TTreeFormula.cxx:2163
 TTreeFormula.cxx:2164
 TTreeFormula.cxx:2165
 TTreeFormula.cxx:2166
 TTreeFormula.cxx:2167
 TTreeFormula.cxx:2168
 TTreeFormula.cxx:2169
 TTreeFormula.cxx:2170
 TTreeFormula.cxx:2171
 TTreeFormula.cxx:2172
 TTreeFormula.cxx:2173
 TTreeFormula.cxx:2174
 TTreeFormula.cxx:2175
 TTreeFormula.cxx:2176
 TTreeFormula.cxx:2177
 TTreeFormula.cxx:2178
 TTreeFormula.cxx:2179
 TTreeFormula.cxx:2180
 TTreeFormula.cxx:2181
 TTreeFormula.cxx:2182
 TTreeFormula.cxx:2183
 TTreeFormula.cxx:2184
 TTreeFormula.cxx:2185
 TTreeFormula.cxx:2186
 TTreeFormula.cxx:2187
 TTreeFormula.cxx:2188
 TTreeFormula.cxx:2189
 TTreeFormula.cxx:2190
 TTreeFormula.cxx:2191
 TTreeFormula.cxx:2192
 TTreeFormula.cxx:2193
 TTreeFormula.cxx:2194
 TTreeFormula.cxx:2195
 TTreeFormula.cxx:2196
 TTreeFormula.cxx:2197
 TTreeFormula.cxx:2198
 TTreeFormula.cxx:2199
 TTreeFormula.cxx:2200
 TTreeFormula.cxx:2201
 TTreeFormula.cxx:2202
 TTreeFormula.cxx:2203
 TTreeFormula.cxx:2204
 TTreeFormula.cxx:2205
 TTreeFormula.cxx:2206
 TTreeFormula.cxx:2207
 TTreeFormula.cxx:2208
 TTreeFormula.cxx:2209
 TTreeFormula.cxx:2210
 TTreeFormula.cxx:2211
 TTreeFormula.cxx:2212
 TTreeFormula.cxx:2213
 TTreeFormula.cxx:2214
 TTreeFormula.cxx:2215
 TTreeFormula.cxx:2216
 TTreeFormula.cxx:2217
 TTreeFormula.cxx:2218
 TTreeFormula.cxx:2219
 TTreeFormula.cxx:2220
 TTreeFormula.cxx:2221
 TTreeFormula.cxx:2222
 TTreeFormula.cxx:2223
 TTreeFormula.cxx:2224
 TTreeFormula.cxx:2225
 TTreeFormula.cxx:2226
 TTreeFormula.cxx:2227
 TTreeFormula.cxx:2228
 TTreeFormula.cxx:2229
 TTreeFormula.cxx:2230
 TTreeFormula.cxx:2231
 TTreeFormula.cxx:2232
 TTreeFormula.cxx:2233
 TTreeFormula.cxx:2234
 TTreeFormula.cxx:2235
 TTreeFormula.cxx:2236
 TTreeFormula.cxx:2237
 TTreeFormula.cxx:2238
 TTreeFormula.cxx:2239
 TTreeFormula.cxx:2240
 TTreeFormula.cxx:2241
 TTreeFormula.cxx:2242
 TTreeFormula.cxx:2243
 TTreeFormula.cxx:2244
 TTreeFormula.cxx:2245
 TTreeFormula.cxx:2246
 TTreeFormula.cxx:2247
 TTreeFormula.cxx:2248
 TTreeFormula.cxx:2249
 TTreeFormula.cxx:2250
 TTreeFormula.cxx:2251
 TTreeFormula.cxx:2252
 TTreeFormula.cxx:2253
 TTreeFormula.cxx:2254
 TTreeFormula.cxx:2255
 TTreeFormula.cxx:2256
 TTreeFormula.cxx:2257
 TTreeFormula.cxx:2258
 TTreeFormula.cxx:2259
 TTreeFormula.cxx:2260
 TTreeFormula.cxx:2261
 TTreeFormula.cxx:2262
 TTreeFormula.cxx:2263
 TTreeFormula.cxx:2264
 TTreeFormula.cxx:2265
 TTreeFormula.cxx:2266
 TTreeFormula.cxx:2267
 TTreeFormula.cxx:2268
 TTreeFormula.cxx:2269
 TTreeFormula.cxx:2270
 TTreeFormula.cxx:2271
 TTreeFormula.cxx:2272
 TTreeFormula.cxx:2273
 TTreeFormula.cxx:2274
 TTreeFormula.cxx:2275
 TTreeFormula.cxx:2276
 TTreeFormula.cxx:2277
 TTreeFormula.cxx:2278
 TTreeFormula.cxx:2279
 TTreeFormula.cxx:2280
 TTreeFormula.cxx:2281
 TTreeFormula.cxx:2282
 TTreeFormula.cxx:2283
 TTreeFormula.cxx:2284
 TTreeFormula.cxx:2285
 TTreeFormula.cxx:2286
 TTreeFormula.cxx:2287
 TTreeFormula.cxx:2288
 TTreeFormula.cxx:2289
 TTreeFormula.cxx:2290
 TTreeFormula.cxx:2291
 TTreeFormula.cxx:2292
 TTreeFormula.cxx:2293
 TTreeFormula.cxx:2294
 TTreeFormula.cxx:2295
 TTreeFormula.cxx:2296
 TTreeFormula.cxx:2297
 TTreeFormula.cxx:2298
 TTreeFormula.cxx:2299
 TTreeFormula.cxx:2300
 TTreeFormula.cxx:2301
 TTreeFormula.cxx:2302
 TTreeFormula.cxx:2303
 TTreeFormula.cxx:2304
 TTreeFormula.cxx:2305
 TTreeFormula.cxx:2306
 TTreeFormula.cxx:2307
 TTreeFormula.cxx:2308
 TTreeFormula.cxx:2309
 TTreeFormula.cxx:2310
 TTreeFormula.cxx:2311
 TTreeFormula.cxx:2312
 TTreeFormula.cxx:2313
 TTreeFormula.cxx:2314
 TTreeFormula.cxx:2315
 TTreeFormula.cxx:2316
 TTreeFormula.cxx:2317
 TTreeFormula.cxx:2318
 TTreeFormula.cxx:2319
 TTreeFormula.cxx:2320
 TTreeFormula.cxx:2321
 TTreeFormula.cxx:2322
 TTreeFormula.cxx:2323
 TTreeFormula.cxx:2324
 TTreeFormula.cxx:2325
 TTreeFormula.cxx:2326
 TTreeFormula.cxx:2327
 TTreeFormula.cxx:2328
 TTreeFormula.cxx:2329
 TTreeFormula.cxx:2330
 TTreeFormula.cxx:2331
 TTreeFormula.cxx:2332
 TTreeFormula.cxx:2333
 TTreeFormula.cxx:2334
 TTreeFormula.cxx:2335
 TTreeFormula.cxx:2336
 TTreeFormula.cxx:2337
 TTreeFormula.cxx:2338
 TTreeFormula.cxx:2339
 TTreeFormula.cxx:2340
 TTreeFormula.cxx:2341
 TTreeFormula.cxx:2342
 TTreeFormula.cxx:2343
 TTreeFormula.cxx:2344
 TTreeFormula.cxx:2345
 TTreeFormula.cxx:2346
 TTreeFormula.cxx:2347
 TTreeFormula.cxx:2348
 TTreeFormula.cxx:2349
 TTreeFormula.cxx:2350
 TTreeFormula.cxx:2351
 TTreeFormula.cxx:2352
 TTreeFormula.cxx:2353
 TTreeFormula.cxx:2354
 TTreeFormula.cxx:2355
 TTreeFormula.cxx:2356
 TTreeFormula.cxx:2357
 TTreeFormula.cxx:2358
 TTreeFormula.cxx:2359
 TTreeFormula.cxx:2360
 TTreeFormula.cxx:2361
 TTreeFormula.cxx:2362
 TTreeFormula.cxx:2363
 TTreeFormula.cxx:2364
 TTreeFormula.cxx:2365
 TTreeFormula.cxx:2366
 TTreeFormula.cxx:2367
 TTreeFormula.cxx:2368
 TTreeFormula.cxx:2369
 TTreeFormula.cxx:2370
 TTreeFormula.cxx:2371
 TTreeFormula.cxx:2372
 TTreeFormula.cxx:2373
 TTreeFormula.cxx:2374
 TTreeFormula.cxx:2375
 TTreeFormula.cxx:2376
 TTreeFormula.cxx:2377
 TTreeFormula.cxx:2378
 TTreeFormula.cxx:2379
 TTreeFormula.cxx:2380
 TTreeFormula.cxx:2381
 TTreeFormula.cxx:2382
 TTreeFormula.cxx:2383
 TTreeFormula.cxx:2384
 TTreeFormula.cxx:2385
 TTreeFormula.cxx:2386
 TTreeFormula.cxx:2387
 TTreeFormula.cxx:2388
 TTreeFormula.cxx:2389
 TTreeFormula.cxx:2390
 TTreeFormula.cxx:2391
 TTreeFormula.cxx:2392
 TTreeFormula.cxx:2393
 TTreeFormula.cxx:2394
 TTreeFormula.cxx:2395
 TTreeFormula.cxx:2396
 TTreeFormula.cxx:2397
 TTreeFormula.cxx:2398
 TTreeFormula.cxx:2399
 TTreeFormula.cxx:2400
 TTreeFormula.cxx:2401
 TTreeFormula.cxx:2402
 TTreeFormula.cxx:2403
 TTreeFormula.cxx:2404
 TTreeFormula.cxx:2405
 TTreeFormula.cxx:2406
 TTreeFormula.cxx:2407
 TTreeFormula.cxx:2408
 TTreeFormula.cxx:2409
 TTreeFormula.cxx:2410
 TTreeFormula.cxx:2411
 TTreeFormula.cxx:2412
 TTreeFormula.cxx:2413
 TTreeFormula.cxx:2414
 TTreeFormula.cxx:2415
 TTreeFormula.cxx:2416
 TTreeFormula.cxx:2417
 TTreeFormula.cxx:2418
 TTreeFormula.cxx:2419
 TTreeFormula.cxx:2420
 TTreeFormula.cxx:2421
 TTreeFormula.cxx:2422
 TTreeFormula.cxx:2423
 TTreeFormula.cxx:2424
 TTreeFormula.cxx:2425
 TTreeFormula.cxx:2426
 TTreeFormula.cxx:2427
 TTreeFormula.cxx:2428
 TTreeFormula.cxx:2429
 TTreeFormula.cxx:2430
 TTreeFormula.cxx:2431
 TTreeFormula.cxx:2432
 TTreeFormula.cxx:2433
 TTreeFormula.cxx:2434
 TTreeFormula.cxx:2435
 TTreeFormula.cxx:2436
 TTreeFormula.cxx:2437
 TTreeFormula.cxx:2438
 TTreeFormula.cxx:2439
 TTreeFormula.cxx:2440
 TTreeFormula.cxx:2441
 TTreeFormula.cxx:2442
 TTreeFormula.cxx:2443
 TTreeFormula.cxx:2444
 TTreeFormula.cxx:2445
 TTreeFormula.cxx:2446
 TTreeFormula.cxx:2447
 TTreeFormula.cxx:2448
 TTreeFormula.cxx:2449
 TTreeFormula.cxx:2450
 TTreeFormula.cxx:2451
 TTreeFormula.cxx:2452
 TTreeFormula.cxx:2453
 TTreeFormula.cxx:2454
 TTreeFormula.cxx:2455
 TTreeFormula.cxx:2456
 TTreeFormula.cxx:2457
 TTreeFormula.cxx:2458
 TTreeFormula.cxx:2459
 TTreeFormula.cxx:2460
 TTreeFormula.cxx:2461
 TTreeFormula.cxx:2462
 TTreeFormula.cxx:2463
 TTreeFormula.cxx:2464
 TTreeFormula.cxx:2465
 TTreeFormula.cxx:2466
 TTreeFormula.cxx:2467
 TTreeFormula.cxx:2468
 TTreeFormula.cxx:2469
 TTreeFormula.cxx:2470
 TTreeFormula.cxx:2471
 TTreeFormula.cxx:2472
 TTreeFormula.cxx:2473
 TTreeFormula.cxx:2474
 TTreeFormula.cxx:2475
 TTreeFormula.cxx:2476
 TTreeFormula.cxx:2477
 TTreeFormula.cxx:2478
 TTreeFormula.cxx:2479
 TTreeFormula.cxx:2480
 TTreeFormula.cxx:2481
 TTreeFormula.cxx:2482
 TTreeFormula.cxx:2483
 TTreeFormula.cxx:2484
 TTreeFormula.cxx:2485
 TTreeFormula.cxx:2486
 TTreeFormula.cxx:2487
 TTreeFormula.cxx:2488
 TTreeFormula.cxx:2489
 TTreeFormula.cxx:2490
 TTreeFormula.cxx:2491
 TTreeFormula.cxx:2492
 TTreeFormula.cxx:2493
 TTreeFormula.cxx:2494
 TTreeFormula.cxx:2495
 TTreeFormula.cxx:2496
 TTreeFormula.cxx:2497
 TTreeFormula.cxx:2498
 TTreeFormula.cxx:2499
 TTreeFormula.cxx:2500
 TTreeFormula.cxx:2501
 TTreeFormula.cxx:2502
 TTreeFormula.cxx:2503
 TTreeFormula.cxx:2504
 TTreeFormula.cxx:2505
 TTreeFormula.cxx:2506
 TTreeFormula.cxx:2507
 TTreeFormula.cxx:2508
 TTreeFormula.cxx:2509
 TTreeFormula.cxx:2510
 TTreeFormula.cxx:2511
 TTreeFormula.cxx:2512
 TTreeFormula.cxx:2513
 TTreeFormula.cxx:2514
 TTreeFormula.cxx:2515
 TTreeFormula.cxx:2516
 TTreeFormula.cxx:2517
 TTreeFormula.cxx:2518
 TTreeFormula.cxx:2519
 TTreeFormula.cxx:2520
 TTreeFormula.cxx:2521
 TTreeFormula.cxx:2522
 TTreeFormula.cxx:2523
 TTreeFormula.cxx:2524
 TTreeFormula.cxx:2525
 TTreeFormula.cxx:2526
 TTreeFormula.cxx:2527
 TTreeFormula.cxx:2528
 TTreeFormula.cxx:2529
 TTreeFormula.cxx:2530
 TTreeFormula.cxx:2531
 TTreeFormula.cxx:2532
 TTreeFormula.cxx:2533
 TTreeFormula.cxx:2534
 TTreeFormula.cxx:2535
 TTreeFormula.cxx:2536
 TTreeFormula.cxx:2537
 TTreeFormula.cxx:2538
 TTreeFormula.cxx:2539
 TTreeFormula.cxx:2540
 TTreeFormula.cxx:2541
 TTreeFormula.cxx:2542
 TTreeFormula.cxx:2543
 TTreeFormula.cxx:2544
 TTreeFormula.cxx:2545
 TTreeFormula.cxx:2546
 TTreeFormula.cxx:2547
 TTreeFormula.cxx:2548
 TTreeFormula.cxx:2549
 TTreeFormula.cxx:2550
 TTreeFormula.cxx:2551
 TTreeFormula.cxx:2552
 TTreeFormula.cxx:2553
 TTreeFormula.cxx:2554
 TTreeFormula.cxx:2555
 TTreeFormula.cxx:2556
 TTreeFormula.cxx:2557
 TTreeFormula.cxx:2558
 TTreeFormula.cxx:2559
 TTreeFormula.cxx:2560
 TTreeFormula.cxx:2561
 TTreeFormula.cxx:2562
 TTreeFormula.cxx:2563
 TTreeFormula.cxx:2564
 TTreeFormula.cxx:2565
 TTreeFormula.cxx:2566
 TTreeFormula.cxx:2567
 TTreeFormula.cxx:2568
 TTreeFormula.cxx:2569
 TTreeFormula.cxx:2570
 TTreeFormula.cxx:2571
 TTreeFormula.cxx:2572
 TTreeFormula.cxx:2573
 TTreeFormula.cxx:2574
 TTreeFormula.cxx:2575
 TTreeFormula.cxx:2576
 TTreeFormula.cxx:2577
 TTreeFormula.cxx:2578
 TTreeFormula.cxx:2579
 TTreeFormula.cxx:2580
 TTreeFormula.cxx:2581
 TTreeFormula.cxx:2582
 TTreeFormula.cxx:2583
 TTreeFormula.cxx:2584
 TTreeFormula.cxx:2585
 TTreeFormula.cxx:2586
 TTreeFormula.cxx:2587
 TTreeFormula.cxx:2588
 TTreeFormula.cxx:2589
 TTreeFormula.cxx:2590
 TTreeFormula.cxx:2591
 TTreeFormula.cxx:2592
 TTreeFormula.cxx:2593
 TTreeFormula.cxx:2594
 TTreeFormula.cxx:2595
 TTreeFormula.cxx:2596
 TTreeFormula.cxx:2597
 TTreeFormula.cxx:2598
 TTreeFormula.cxx:2599
 TTreeFormula.cxx:2600
 TTreeFormula.cxx:2601
 TTreeFormula.cxx:2602
 TTreeFormula.cxx:2603
 TTreeFormula.cxx:2604
 TTreeFormula.cxx:2605
 TTreeFormula.cxx:2606
 TTreeFormula.cxx:2607
 TTreeFormula.cxx:2608
 TTreeFormula.cxx:2609
 TTreeFormula.cxx:2610
 TTreeFormula.cxx:2611
 TTreeFormula.cxx:2612
 TTreeFormula.cxx:2613
 TTreeFormula.cxx:2614
 TTreeFormula.cxx:2615
 TTreeFormula.cxx:2616
 TTreeFormula.cxx:2617
 TTreeFormula.cxx:2618
 TTreeFormula.cxx:2619
 TTreeFormula.cxx:2620
 TTreeFormula.cxx:2621
 TTreeFormula.cxx:2622
 TTreeFormula.cxx:2623
 TTreeFormula.cxx:2624
 TTreeFormula.cxx:2625
 TTreeFormula.cxx:2626
 TTreeFormula.cxx:2627
 TTreeFormula.cxx:2628
 TTreeFormula.cxx:2629
 TTreeFormula.cxx:2630
 TTreeFormula.cxx:2631
 TTreeFormula.cxx:2632
 TTreeFormula.cxx:2633
 TTreeFormula.cxx:2634
 TTreeFormula.cxx:2635
 TTreeFormula.cxx:2636
 TTreeFormula.cxx:2637
 TTreeFormula.cxx:2638
 TTreeFormula.cxx:2639
 TTreeFormula.cxx:2640
 TTreeFormula.cxx:2641
 TTreeFormula.cxx:2642
 TTreeFormula.cxx:2643
 TTreeFormula.cxx:2644
 TTreeFormula.cxx:2645
 TTreeFormula.cxx:2646
 TTreeFormula.cxx:2647
 TTreeFormula.cxx:2648
 TTreeFormula.cxx:2649
 TTreeFormula.cxx:2650
 TTreeFormula.cxx:2651
 TTreeFormula.cxx:2652
 TTreeFormula.cxx:2653
 TTreeFormula.cxx:2654
 TTreeFormula.cxx:2655
 TTreeFormula.cxx:2656
 TTreeFormula.cxx:2657
 TTreeFormula.cxx:2658
 TTreeFormula.cxx:2659
 TTreeFormula.cxx:2660
 TTreeFormula.cxx:2661
 TTreeFormula.cxx:2662
 TTreeFormula.cxx:2663
 TTreeFormula.cxx:2664
 TTreeFormula.cxx:2665
 TTreeFormula.cxx:2666
 TTreeFormula.cxx:2667
 TTreeFormula.cxx:2668
 TTreeFormula.cxx:2669
 TTreeFormula.cxx:2670
 TTreeFormula.cxx:2671
 TTreeFormula.cxx:2672
 TTreeFormula.cxx:2673
 TTreeFormula.cxx:2674
 TTreeFormula.cxx:2675
 TTreeFormula.cxx:2676
 TTreeFormula.cxx:2677
 TTreeFormula.cxx:2678
 TTreeFormula.cxx:2679
 TTreeFormula.cxx:2680
 TTreeFormula.cxx:2681
 TTreeFormula.cxx:2682
 TTreeFormula.cxx:2683
 TTreeFormula.cxx:2684
 TTreeFormula.cxx:2685
 TTreeFormula.cxx:2686
 TTreeFormula.cxx:2687
 TTreeFormula.cxx:2688
 TTreeFormula.cxx:2689
 TTreeFormula.cxx:2690
 TTreeFormula.cxx:2691
 TTreeFormula.cxx:2692
 TTreeFormula.cxx:2693
 TTreeFormula.cxx:2694
 TTreeFormula.cxx:2695
 TTreeFormula.cxx:2696
 TTreeFormula.cxx:2697
 TTreeFormula.cxx:2698
 TTreeFormula.cxx:2699
 TTreeFormula.cxx:2700
 TTreeFormula.cxx:2701
 TTreeFormula.cxx:2702
 TTreeFormula.cxx:2703
 TTreeFormula.cxx:2704
 TTreeFormula.cxx:2705
 TTreeFormula.cxx:2706
 TTreeFormula.cxx:2707
 TTreeFormula.cxx:2708
 TTreeFormula.cxx:2709
 TTreeFormula.cxx:2710
 TTreeFormula.cxx:2711
 TTreeFormula.cxx:2712
 TTreeFormula.cxx:2713
 TTreeFormula.cxx:2714
 TTreeFormula.cxx:2715
 TTreeFormula.cxx:2716
 TTreeFormula.cxx:2717
 TTreeFormula.cxx:2718
 TTreeFormula.cxx:2719
 TTreeFormula.cxx:2720
 TTreeFormula.cxx:2721
 TTreeFormula.cxx:2722
 TTreeFormula.cxx:2723
 TTreeFormula.cxx:2724
 TTreeFormula.cxx:2725
 TTreeFormula.cxx:2726
 TTreeFormula.cxx:2727
 TTreeFormula.cxx:2728
 TTreeFormula.cxx:2729
 TTreeFormula.cxx:2730
 TTreeFormula.cxx:2731
 TTreeFormula.cxx:2732
 TTreeFormula.cxx:2733
 TTreeFormula.cxx:2734
 TTreeFormula.cxx:2735
 TTreeFormula.cxx:2736
 TTreeFormula.cxx:2737
 TTreeFormula.cxx:2738
 TTreeFormula.cxx:2739
 TTreeFormula.cxx:2740
 TTreeFormula.cxx:2741
 TTreeFormula.cxx:2742
 TTreeFormula.cxx:2743
 TTreeFormula.cxx:2744
 TTreeFormula.cxx:2745
 TTreeFormula.cxx:2746
 TTreeFormula.cxx:2747
 TTreeFormula.cxx:2748
 TTreeFormula.cxx:2749
 TTreeFormula.cxx:2750
 TTreeFormula.cxx:2751
 TTreeFormula.cxx:2752
 TTreeFormula.cxx:2753
 TTreeFormula.cxx:2754
 TTreeFormula.cxx:2755
 TTreeFormula.cxx:2756
 TTreeFormula.cxx:2757
 TTreeFormula.cxx:2758
 TTreeFormula.cxx:2759
 TTreeFormula.cxx:2760
 TTreeFormula.cxx:2761
 TTreeFormula.cxx:2762
 TTreeFormula.cxx:2763
 TTreeFormula.cxx:2764
 TTreeFormula.cxx:2765
 TTreeFormula.cxx:2766
 TTreeFormula.cxx:2767
 TTreeFormula.cxx:2768
 TTreeFormula.cxx:2769
 TTreeFormula.cxx:2770
 TTreeFormula.cxx:2771
 TTreeFormula.cxx:2772
 TTreeFormula.cxx:2773
 TTreeFormula.cxx:2774
 TTreeFormula.cxx:2775
 TTreeFormula.cxx:2776
 TTreeFormula.cxx:2777
 TTreeFormula.cxx:2778
 TTreeFormula.cxx:2779
 TTreeFormula.cxx:2780
 TTreeFormula.cxx:2781
 TTreeFormula.cxx:2782
 TTreeFormula.cxx:2783
 TTreeFormula.cxx:2784
 TTreeFormula.cxx:2785
 TTreeFormula.cxx:2786
 TTreeFormula.cxx:2787
 TTreeFormula.cxx:2788
 TTreeFormula.cxx:2789
 TTreeFormula.cxx:2790
 TTreeFormula.cxx:2791
 TTreeFormula.cxx:2792
 TTreeFormula.cxx:2793
 TTreeFormula.cxx:2794
 TTreeFormula.cxx:2795
 TTreeFormula.cxx:2796
 TTreeFormula.cxx:2797
 TTreeFormula.cxx:2798
 TTreeFormula.cxx:2799
 TTreeFormula.cxx:2800
 TTreeFormula.cxx:2801
 TTreeFormula.cxx:2802
 TTreeFormula.cxx:2803
 TTreeFormula.cxx:2804
 TTreeFormula.cxx:2805
 TTreeFormula.cxx:2806
 TTreeFormula.cxx:2807
 TTreeFormula.cxx:2808
 TTreeFormula.cxx:2809
 TTreeFormula.cxx:2810
 TTreeFormula.cxx:2811
 TTreeFormula.cxx:2812
 TTreeFormula.cxx:2813
 TTreeFormula.cxx:2814
 TTreeFormula.cxx:2815
 TTreeFormula.cxx:2816
 TTreeFormula.cxx:2817
 TTreeFormula.cxx:2818
 TTreeFormula.cxx:2819
 TTreeFormula.cxx:2820
 TTreeFormula.cxx:2821
 TTreeFormula.cxx:2822
 TTreeFormula.cxx:2823
 TTreeFormula.cxx:2824
 TTreeFormula.cxx:2825
 TTreeFormula.cxx:2826
 TTreeFormula.cxx:2827
 TTreeFormula.cxx:2828
 TTreeFormula.cxx:2829
 TTreeFormula.cxx:2830
 TTreeFormula.cxx:2831
 TTreeFormula.cxx:2832
 TTreeFormula.cxx:2833
 TTreeFormula.cxx:2834
 TTreeFormula.cxx:2835
 TTreeFormula.cxx:2836
 TTreeFormula.cxx:2837
 TTreeFormula.cxx:2838
 TTreeFormula.cxx:2839
 TTreeFormula.cxx:2840
 TTreeFormula.cxx:2841
 TTreeFormula.cxx:2842
 TTreeFormula.cxx:2843
 TTreeFormula.cxx:2844
 TTreeFormula.cxx:2845
 TTreeFormula.cxx:2846
 TTreeFormula.cxx:2847
 TTreeFormula.cxx:2848
 TTreeFormula.cxx:2849
 TTreeFormula.cxx:2850
 TTreeFormula.cxx:2851
 TTreeFormula.cxx:2852
 TTreeFormula.cxx:2853
 TTreeFormula.cxx:2854
 TTreeFormula.cxx:2855
 TTreeFormula.cxx:2856
 TTreeFormula.cxx:2857
 TTreeFormula.cxx:2858
 TTreeFormula.cxx:2859
 TTreeFormula.cxx:2860
 TTreeFormula.cxx:2861
 TTreeFormula.cxx:2862
 TTreeFormula.cxx:2863
 TTreeFormula.cxx:2864
 TTreeFormula.cxx:2865
 TTreeFormula.cxx:2866
 TTreeFormula.cxx:2867
 TTreeFormula.cxx:2868
 TTreeFormula.cxx:2869
 TTreeFormula.cxx:2870
 TTreeFormula.cxx:2871
 TTreeFormula.cxx:2872
 TTreeFormula.cxx:2873
 TTreeFormula.cxx:2874
 TTreeFormula.cxx:2875
 TTreeFormula.cxx:2876
 TTreeFormula.cxx:2877
 TTreeFormula.cxx:2878
 TTreeFormula.cxx:2879
 TTreeFormula.cxx:2880
 TTreeFormula.cxx:2881
 TTreeFormula.cxx:2882
 TTreeFormula.cxx:2883
 TTreeFormula.cxx:2884
 TTreeFormula.cxx:2885
 TTreeFormula.cxx:2886
 TTreeFormula.cxx:2887
 TTreeFormula.cxx:2888
 TTreeFormula.cxx:2889
 TTreeFormula.cxx:2890
 TTreeFormula.cxx:2891
 TTreeFormula.cxx:2892
 TTreeFormula.cxx:2893
 TTreeFormula.cxx:2894
 TTreeFormula.cxx:2895
 TTreeFormula.cxx:2896
 TTreeFormula.cxx:2897
 TTreeFormula.cxx:2898
 TTreeFormula.cxx:2899
 TTreeFormula.cxx:2900
 TTreeFormula.cxx:2901
 TTreeFormula.cxx:2902
 TTreeFormula.cxx:2903
 TTreeFormula.cxx:2904
 TTreeFormula.cxx:2905
 TTreeFormula.cxx:2906
 TTreeFormula.cxx:2907
 TTreeFormula.cxx:2908
 TTreeFormula.cxx:2909
 TTreeFormula.cxx:2910
 TTreeFormula.cxx:2911
 TTreeFormula.cxx:2912
 TTreeFormula.cxx:2913
 TTreeFormula.cxx:2914
 TTreeFormula.cxx:2915
 TTreeFormula.cxx:2916
 TTreeFormula.cxx:2917
 TTreeFormula.cxx:2918
 TTreeFormula.cxx:2919
 TTreeFormula.cxx:2920
 TTreeFormula.cxx:2921
 TTreeFormula.cxx:2922
 TTreeFormula.cxx:2923
 TTreeFormula.cxx:2924
 TTreeFormula.cxx:2925
 TTreeFormula.cxx:2926
 TTreeFormula.cxx:2927
 TTreeFormula.cxx:2928
 TTreeFormula.cxx:2929
 TTreeFormula.cxx:2930
 TTreeFormula.cxx:2931
 TTreeFormula.cxx:2932
 TTreeFormula.cxx:2933
 TTreeFormula.cxx:2934
 TTreeFormula.cxx:2935
 TTreeFormula.cxx:2936
 TTreeFormula.cxx:2937
 TTreeFormula.cxx:2938
 TTreeFormula.cxx:2939
 TTreeFormula.cxx:2940
 TTreeFormula.cxx:2941
 TTreeFormula.cxx:2942
 TTreeFormula.cxx:2943
 TTreeFormula.cxx:2944
 TTreeFormula.cxx:2945
 TTreeFormula.cxx:2946
 TTreeFormula.cxx:2947
 TTreeFormula.cxx:2948
 TTreeFormula.cxx:2949
 TTreeFormula.cxx:2950
 TTreeFormula.cxx:2951
 TTreeFormula.cxx:2952
 TTreeFormula.cxx:2953
 TTreeFormula.cxx:2954
 TTreeFormula.cxx:2955
 TTreeFormula.cxx:2956
 TTreeFormula.cxx:2957
 TTreeFormula.cxx:2958
 TTreeFormula.cxx:2959
 TTreeFormula.cxx:2960
 TTreeFormula.cxx:2961
 TTreeFormula.cxx:2962
 TTreeFormula.cxx:2963
 TTreeFormula.cxx:2964
 TTreeFormula.cxx:2965
 TTreeFormula.cxx:2966
 TTreeFormula.cxx:2967
 TTreeFormula.cxx:2968
 TTreeFormula.cxx:2969
 TTreeFormula.cxx:2970
 TTreeFormula.cxx:2971
 TTreeFormula.cxx:2972
 TTreeFormula.cxx:2973
 TTreeFormula.cxx:2974
 TTreeFormula.cxx:2975
 TTreeFormula.cxx:2976
 TTreeFormula.cxx:2977
 TTreeFormula.cxx:2978
 TTreeFormula.cxx:2979
 TTreeFormula.cxx:2980
 TTreeFormula.cxx:2981
 TTreeFormula.cxx:2982
 TTreeFormula.cxx:2983
 TTreeFormula.cxx:2984
 TTreeFormula.cxx:2985
 TTreeFormula.cxx:2986
 TTreeFormula.cxx:2987
 TTreeFormula.cxx:2988
 TTreeFormula.cxx:2989
 TTreeFormula.cxx:2990
 TTreeFormula.cxx:2991
 TTreeFormula.cxx:2992
 TTreeFormula.cxx:2993
 TTreeFormula.cxx:2994
 TTreeFormula.cxx:2995
 TTreeFormula.cxx:2996
 TTreeFormula.cxx:2997
 TTreeFormula.cxx:2998
 TTreeFormula.cxx:2999
 TTreeFormula.cxx:3000
 TTreeFormula.cxx:3001
 TTreeFormula.cxx:3002
 TTreeFormula.cxx:3003
 TTreeFormula.cxx:3004
 TTreeFormula.cxx:3005
 TTreeFormula.cxx:3006
 TTreeFormula.cxx:3007
 TTreeFormula.cxx:3008
 TTreeFormula.cxx:3009
 TTreeFormula.cxx:3010
 TTreeFormula.cxx:3011
 TTreeFormula.cxx:3012
 TTreeFormula.cxx:3013
 TTreeFormula.cxx:3014
 TTreeFormula.cxx:3015
 TTreeFormula.cxx:3016
 TTreeFormula.cxx:3017
 TTreeFormula.cxx:3018
 TTreeFormula.cxx:3019
 TTreeFormula.cxx:3020
 TTreeFormula.cxx:3021
 TTreeFormula.cxx:3022
 TTreeFormula.cxx:3023
 TTreeFormula.cxx:3024
 TTreeFormula.cxx:3025
 TTreeFormula.cxx:3026
 TTreeFormula.cxx:3027
 TTreeFormula.cxx:3028
 TTreeFormula.cxx:3029
 TTreeFormula.cxx:3030
 TTreeFormula.cxx:3031
 TTreeFormula.cxx:3032
 TTreeFormula.cxx:3033
 TTreeFormula.cxx:3034
 TTreeFormula.cxx:3035
 TTreeFormula.cxx:3036
 TTreeFormula.cxx:3037
 TTreeFormula.cxx:3038
 TTreeFormula.cxx:3039
 TTreeFormula.cxx:3040
 TTreeFormula.cxx:3041
 TTreeFormula.cxx:3042
 TTreeFormula.cxx:3043
 TTreeFormula.cxx:3044
 TTreeFormula.cxx:3045
 TTreeFormula.cxx:3046
 TTreeFormula.cxx:3047
 TTreeFormula.cxx:3048
 TTreeFormula.cxx:3049
 TTreeFormula.cxx:3050
 TTreeFormula.cxx:3051
 TTreeFormula.cxx:3052
 TTreeFormula.cxx:3053
 TTreeFormula.cxx:3054
 TTreeFormula.cxx:3055
 TTreeFormula.cxx:3056
 TTreeFormula.cxx:3057
 TTreeFormula.cxx:3058
 TTreeFormula.cxx:3059
 TTreeFormula.cxx:3060
 TTreeFormula.cxx:3061
 TTreeFormula.cxx:3062
 TTreeFormula.cxx:3063
 TTreeFormula.cxx:3064
 TTreeFormula.cxx:3065
 TTreeFormula.cxx:3066
 TTreeFormula.cxx:3067
 TTreeFormula.cxx:3068
 TTreeFormula.cxx:3069
 TTreeFormula.cxx:3070
 TTreeFormula.cxx:3071
 TTreeFormula.cxx:3072
 TTreeFormula.cxx:3073
 TTreeFormula.cxx:3074
 TTreeFormula.cxx:3075
 TTreeFormula.cxx:3076
 TTreeFormula.cxx:3077
 TTreeFormula.cxx:3078
 TTreeFormula.cxx:3079
 TTreeFormula.cxx:3080
 TTreeFormula.cxx:3081
 TTreeFormula.cxx:3082
 TTreeFormula.cxx:3083
 TTreeFormula.cxx:3084
 TTreeFormula.cxx:3085
 TTreeFormula.cxx:3086
 TTreeFormula.cxx:3087
 TTreeFormula.cxx:3088
 TTreeFormula.cxx:3089
 TTreeFormula.cxx:3090
 TTreeFormula.cxx:3091
 TTreeFormula.cxx:3092
 TTreeFormula.cxx:3093
 TTreeFormula.cxx:3094
 TTreeFormula.cxx:3095
 TTreeFormula.cxx:3096
 TTreeFormula.cxx:3097
 TTreeFormula.cxx:3098
 TTreeFormula.cxx:3099
 TTreeFormula.cxx:3100
 TTreeFormula.cxx:3101
 TTreeFormula.cxx:3102
 TTreeFormula.cxx:3103
 TTreeFormula.cxx:3104
 TTreeFormula.cxx:3105
 TTreeFormula.cxx:3106
 TTreeFormula.cxx:3107
 TTreeFormula.cxx:3108
 TTreeFormula.cxx:3109
 TTreeFormula.cxx:3110
 TTreeFormula.cxx:3111
 TTreeFormula.cxx:3112
 TTreeFormula.cxx:3113
 TTreeFormula.cxx:3114
 TTreeFormula.cxx:3115
 TTreeFormula.cxx:3116
 TTreeFormula.cxx:3117
 TTreeFormula.cxx:3118
 TTreeFormula.cxx:3119
 TTreeFormula.cxx:3120
 TTreeFormula.cxx:3121
 TTreeFormula.cxx:3122
 TTreeFormula.cxx:3123
 TTreeFormula.cxx:3124
 TTreeFormula.cxx:3125
 TTreeFormula.cxx:3126
 TTreeFormula.cxx:3127
 TTreeFormula.cxx:3128
 TTreeFormula.cxx:3129
 TTreeFormula.cxx:3130
 TTreeFormula.cxx:3131
 TTreeFormula.cxx:3132
 TTreeFormula.cxx:3133
 TTreeFormula.cxx:3134
 TTreeFormula.cxx:3135
 TTreeFormula.cxx:3136
 TTreeFormula.cxx:3137
 TTreeFormula.cxx:3138
 TTreeFormula.cxx:3139
 TTreeFormula.cxx:3140
 TTreeFormula.cxx:3141
 TTreeFormula.cxx:3142
 TTreeFormula.cxx:3143
 TTreeFormula.cxx:3144
 TTreeFormula.cxx:3145
 TTreeFormula.cxx:3146
 TTreeFormula.cxx:3147
 TTreeFormula.cxx:3148
 TTreeFormula.cxx:3149
 TTreeFormula.cxx:3150
 TTreeFormula.cxx:3151
 TTreeFormula.cxx:3152
 TTreeFormula.cxx:3153
 TTreeFormula.cxx:3154
 TTreeFormula.cxx:3155
 TTreeFormula.cxx:3156
 TTreeFormula.cxx:3157
 TTreeFormula.cxx:3158
 TTreeFormula.cxx:3159
 TTreeFormula.cxx:3160
 TTreeFormula.cxx:3161
 TTreeFormula.cxx:3162
 TTreeFormula.cxx:3163
 TTreeFormula.cxx:3164
 TTreeFormula.cxx:3165
 TTreeFormula.cxx:3166
 TTreeFormula.cxx:3167
 TTreeFormula.cxx:3168
 TTreeFormula.cxx:3169
 TTreeFormula.cxx:3170
 TTreeFormula.cxx:3171
 TTreeFormula.cxx:3172
 TTreeFormula.cxx:3173
 TTreeFormula.cxx:3174
 TTreeFormula.cxx:3175
 TTreeFormula.cxx:3176
 TTreeFormula.cxx:3177
 TTreeFormula.cxx:3178
 TTreeFormula.cxx:3179
 TTreeFormula.cxx:3180
 TTreeFormula.cxx:3181
 TTreeFormula.cxx:3182
 TTreeFormula.cxx:3183
 TTreeFormula.cxx:3184
 TTreeFormula.cxx:3185
 TTreeFormula.cxx:3186
 TTreeFormula.cxx:3187
 TTreeFormula.cxx:3188
 TTreeFormula.cxx:3189
 TTreeFormula.cxx:3190
 TTreeFormula.cxx:3191
 TTreeFormula.cxx:3192
 TTreeFormula.cxx:3193
 TTreeFormula.cxx:3194
 TTreeFormula.cxx:3195
 TTreeFormula.cxx:3196
 TTreeFormula.cxx:3197
 TTreeFormula.cxx:3198
 TTreeFormula.cxx:3199
 TTreeFormula.cxx:3200
 TTreeFormula.cxx:3201
 TTreeFormula.cxx:3202
 TTreeFormula.cxx:3203
 TTreeFormula.cxx:3204
 TTreeFormula.cxx:3205
 TTreeFormula.cxx:3206
 TTreeFormula.cxx:3207
 TTreeFormula.cxx:3208
 TTreeFormula.cxx:3209
 TTreeFormula.cxx:3210
 TTreeFormula.cxx:3211
 TTreeFormula.cxx:3212
 TTreeFormula.cxx:3213
 TTreeFormula.cxx:3214
 TTreeFormula.cxx:3215
 TTreeFormula.cxx:3216
 TTreeFormula.cxx:3217
 TTreeFormula.cxx:3218
 TTreeFormula.cxx:3219
 TTreeFormula.cxx:3220
 TTreeFormula.cxx:3221
 TTreeFormula.cxx:3222
 TTreeFormula.cxx:3223
 TTreeFormula.cxx:3224
 TTreeFormula.cxx:3225
 TTreeFormula.cxx:3226
 TTreeFormula.cxx:3227
 TTreeFormula.cxx:3228
 TTreeFormula.cxx:3229
 TTreeFormula.cxx:3230
 TTreeFormula.cxx:3231
 TTreeFormula.cxx:3232
 TTreeFormula.cxx:3233
 TTreeFormula.cxx:3234
 TTreeFormula.cxx:3235
 TTreeFormula.cxx:3236
 TTreeFormula.cxx:3237
 TTreeFormula.cxx:3238
 TTreeFormula.cxx:3239
 TTreeFormula.cxx:3240
 TTreeFormula.cxx:3241
 TTreeFormula.cxx:3242
 TTreeFormula.cxx:3243
 TTreeFormula.cxx:3244
 TTreeFormula.cxx:3245
 TTreeFormula.cxx:3246
 TTreeFormula.cxx:3247
 TTreeFormula.cxx:3248
 TTreeFormula.cxx:3249
 TTreeFormula.cxx:3250
 TTreeFormula.cxx:3251
 TTreeFormula.cxx:3252
 TTreeFormula.cxx:3253
 TTreeFormula.cxx:3254
 TTreeFormula.cxx:3255
 TTreeFormula.cxx:3256
 TTreeFormula.cxx:3257
 TTreeFormula.cxx:3258
 TTreeFormula.cxx:3259
 TTreeFormula.cxx:3260
 TTreeFormula.cxx:3261
 TTreeFormula.cxx:3262
 TTreeFormula.cxx:3263
 TTreeFormula.cxx:3264
 TTreeFormula.cxx:3265
 TTreeFormula.cxx:3266
 TTreeFormula.cxx:3267
 TTreeFormula.cxx:3268
 TTreeFormula.cxx:3269
 TTreeFormula.cxx:3270
 TTreeFormula.cxx:3271
 TTreeFormula.cxx:3272
 TTreeFormula.cxx:3273
 TTreeFormula.cxx:3274
 TTreeFormula.cxx:3275
 TTreeFormula.cxx:3276
 TTreeFormula.cxx:3277
 TTreeFormula.cxx:3278
 TTreeFormula.cxx:3279
 TTreeFormula.cxx:3280
 TTreeFormula.cxx:3281
 TTreeFormula.cxx:3282
 TTreeFormula.cxx:3283
 TTreeFormula.cxx:3284
 TTreeFormula.cxx:3285
 TTreeFormula.cxx:3286
 TTreeFormula.cxx:3287
 TTreeFormula.cxx:3288
 TTreeFormula.cxx:3289
 TTreeFormula.cxx:3290
 TTreeFormula.cxx:3291
 TTreeFormula.cxx:3292
 TTreeFormula.cxx:3293
 TTreeFormula.cxx:3294
 TTreeFormula.cxx:3295
 TTreeFormula.cxx:3296
 TTreeFormula.cxx:3297
 TTreeFormula.cxx:3298
 TTreeFormula.cxx:3299
 TTreeFormula.cxx:3300
 TTreeFormula.cxx:3301
 TTreeFormula.cxx:3302
 TTreeFormula.cxx:3303
 TTreeFormula.cxx:3304
 TTreeFormula.cxx:3305
 TTreeFormula.cxx:3306
 TTreeFormula.cxx:3307
 TTreeFormula.cxx:3308
 TTreeFormula.cxx:3309
 TTreeFormula.cxx:3310
 TTreeFormula.cxx:3311
 TTreeFormula.cxx:3312
 TTreeFormula.cxx:3313
 TTreeFormula.cxx:3314
 TTreeFormula.cxx:3315
 TTreeFormula.cxx:3316
 TTreeFormula.cxx:3317
 TTreeFormula.cxx:3318
 TTreeFormula.cxx:3319
 TTreeFormula.cxx:3320
 TTreeFormula.cxx:3321
 TTreeFormula.cxx:3322
 TTreeFormula.cxx:3323
 TTreeFormula.cxx:3324
 TTreeFormula.cxx:3325
 TTreeFormula.cxx:3326
 TTreeFormula.cxx:3327
 TTreeFormula.cxx:3328
 TTreeFormula.cxx:3329
 TTreeFormula.cxx:3330
 TTreeFormula.cxx:3331
 TTreeFormula.cxx:3332
 TTreeFormula.cxx:3333
 TTreeFormula.cxx:3334
 TTreeFormula.cxx:3335
 TTreeFormula.cxx:3336
 TTreeFormula.cxx:3337
 TTreeFormula.cxx:3338
 TTreeFormula.cxx:3339
 TTreeFormula.cxx:3340
 TTreeFormula.cxx:3341
 TTreeFormula.cxx:3342
 TTreeFormula.cxx:3343
 TTreeFormula.cxx:3344
 TTreeFormula.cxx:3345
 TTreeFormula.cxx:3346
 TTreeFormula.cxx:3347
 TTreeFormula.cxx:3348
 TTreeFormula.cxx:3349
 TTreeFormula.cxx:3350
 TTreeFormula.cxx:3351
 TTreeFormula.cxx:3352
 TTreeFormula.cxx:3353
 TTreeFormula.cxx:3354
 TTreeFormula.cxx:3355
 TTreeFormula.cxx:3356
 TTreeFormula.cxx:3357
 TTreeFormula.cxx:3358
 TTreeFormula.cxx:3359
 TTreeFormula.cxx:3360
 TTreeFormula.cxx:3361
 TTreeFormula.cxx:3362
 TTreeFormula.cxx:3363
 TTreeFormula.cxx:3364
 TTreeFormula.cxx:3365
 TTreeFormula.cxx:3366
 TTreeFormula.cxx:3367
 TTreeFormula.cxx:3368
 TTreeFormula.cxx:3369
 TTreeFormula.cxx:3370
 TTreeFormula.cxx:3371
 TTreeFormula.cxx:3372
 TTreeFormula.cxx:3373
 TTreeFormula.cxx:3374
 TTreeFormula.cxx:3375
 TTreeFormula.cxx:3376
 TTreeFormula.cxx:3377
 TTreeFormula.cxx:3378
 TTreeFormula.cxx:3379
 TTreeFormula.cxx:3380
 TTreeFormula.cxx:3381
 TTreeFormula.cxx:3382
 TTreeFormula.cxx:3383
 TTreeFormula.cxx:3384
 TTreeFormula.cxx:3385
 TTreeFormula.cxx:3386
 TTreeFormula.cxx:3387
 TTreeFormula.cxx:3388
 TTreeFormula.cxx:3389
 TTreeFormula.cxx:3390
 TTreeFormula.cxx:3391
 TTreeFormula.cxx:3392
 TTreeFormula.cxx:3393
 TTreeFormula.cxx:3394
 TTreeFormula.cxx:3395
 TTreeFormula.cxx:3396
 TTreeFormula.cxx:3397
 TTreeFormula.cxx:3398
 TTreeFormula.cxx:3399
 TTreeFormula.cxx:3400
 TTreeFormula.cxx:3401
 TTreeFormula.cxx:3402
 TTreeFormula.cxx:3403
 TTreeFormula.cxx:3404
 TTreeFormula.cxx:3405
 TTreeFormula.cxx:3406
 TTreeFormula.cxx:3407
 TTreeFormula.cxx:3408
 TTreeFormula.cxx:3409
 TTreeFormula.cxx:3410
 TTreeFormula.cxx:3411
 TTreeFormula.cxx:3412
 TTreeFormula.cxx:3413
 TTreeFormula.cxx:3414
 TTreeFormula.cxx:3415
 TTreeFormula.cxx:3416
 TTreeFormula.cxx:3417
 TTreeFormula.cxx:3418
 TTreeFormula.cxx:3419
 TTreeFormula.cxx:3420
 TTreeFormula.cxx:3421
 TTreeFormula.cxx:3422
 TTreeFormula.cxx:3423
 TTreeFormula.cxx:3424
 TTreeFormula.cxx:3425
 TTreeFormula.cxx:3426
 TTreeFormula.cxx:3427
 TTreeFormula.cxx:3428
 TTreeFormula.cxx:3429
 TTreeFormula.cxx:3430
 TTreeFormula.cxx:3431
 TTreeFormula.cxx:3432
 TTreeFormula.cxx:3433
 TTreeFormula.cxx:3434
 TTreeFormula.cxx:3435
 TTreeFormula.cxx:3436
 TTreeFormula.cxx:3437
 TTreeFormula.cxx:3438
 TTreeFormula.cxx:3439
 TTreeFormula.cxx:3440
 TTreeFormula.cxx:3441
 TTreeFormula.cxx:3442
 TTreeFormula.cxx:3443
 TTreeFormula.cxx:3444
 TTreeFormula.cxx:3445
 TTreeFormula.cxx:3446
 TTreeFormula.cxx:3447
 TTreeFormula.cxx:3448
 TTreeFormula.cxx:3449
 TTreeFormula.cxx:3450
 TTreeFormula.cxx:3451
 TTreeFormula.cxx:3452
 TTreeFormula.cxx:3453
 TTreeFormula.cxx:3454
 TTreeFormula.cxx:3455
 TTreeFormula.cxx:3456
 TTreeFormula.cxx:3457
 TTreeFormula.cxx:3458
 TTreeFormula.cxx:3459
 TTreeFormula.cxx:3460
 TTreeFormula.cxx:3461
 TTreeFormula.cxx:3462
 TTreeFormula.cxx:3463
 TTreeFormula.cxx:3464
 TTreeFormula.cxx:3465
 TTreeFormula.cxx:3466
 TTreeFormula.cxx:3467
 TTreeFormula.cxx:3468
 TTreeFormula.cxx:3469
 TTreeFormula.cxx:3470
 TTreeFormula.cxx:3471
 TTreeFormula.cxx:3472
 TTreeFormula.cxx:3473
 TTreeFormula.cxx:3474
 TTreeFormula.cxx:3475
 TTreeFormula.cxx:3476
 TTreeFormula.cxx:3477
 TTreeFormula.cxx:3478
 TTreeFormula.cxx:3479
 TTreeFormula.cxx:3480
 TTreeFormula.cxx:3481
 TTreeFormula.cxx:3482
 TTreeFormula.cxx:3483
 TTreeFormula.cxx:3484
 TTreeFormula.cxx:3485
 TTreeFormula.cxx:3486
 TTreeFormula.cxx:3487
 TTreeFormula.cxx:3488
 TTreeFormula.cxx:3489
 TTreeFormula.cxx:3490
 TTreeFormula.cxx:3491
 TTreeFormula.cxx:3492
 TTreeFormula.cxx:3493
 TTreeFormula.cxx:3494
 TTreeFormula.cxx:3495
 TTreeFormula.cxx:3496
 TTreeFormula.cxx:3497
 TTreeFormula.cxx:3498
 TTreeFormula.cxx:3499
 TTreeFormula.cxx:3500
 TTreeFormula.cxx:3501
 TTreeFormula.cxx:3502
 TTreeFormula.cxx:3503
 TTreeFormula.cxx:3504
 TTreeFormula.cxx:3505
 TTreeFormula.cxx:3506
 TTreeFormula.cxx:3507
 TTreeFormula.cxx:3508
 TTreeFormula.cxx:3509
 TTreeFormula.cxx:3510
 TTreeFormula.cxx:3511
 TTreeFormula.cxx:3512
 TTreeFormula.cxx:3513
 TTreeFormula.cxx:3514
 TTreeFormula.cxx:3515
 TTreeFormula.cxx:3516
 TTreeFormula.cxx:3517
 TTreeFormula.cxx:3518
 TTreeFormula.cxx:3519
 TTreeFormula.cxx:3520
 TTreeFormula.cxx:3521
 TTreeFormula.cxx:3522
 TTreeFormula.cxx:3523
 TTreeFormula.cxx:3524
 TTreeFormula.cxx:3525
 TTreeFormula.cxx:3526
 TTreeFormula.cxx:3527
 TTreeFormula.cxx:3528
 TTreeFormula.cxx:3529
 TTreeFormula.cxx:3530
 TTreeFormula.cxx:3531
 TTreeFormula.cxx:3532
 TTreeFormula.cxx:3533
 TTreeFormula.cxx:3534
 TTreeFormula.cxx:3535
 TTreeFormula.cxx:3536
 TTreeFormula.cxx:3537
 TTreeFormula.cxx:3538
 TTreeFormula.cxx:3539
 TTreeFormula.cxx:3540
 TTreeFormula.cxx:3541
 TTreeFormula.cxx:3542
 TTreeFormula.cxx:3543
 TTreeFormula.cxx:3544
 TTreeFormula.cxx:3545
 TTreeFormula.cxx:3546
 TTreeFormula.cxx:3547
 TTreeFormula.cxx:3548
 TTreeFormula.cxx:3549
 TTreeFormula.cxx:3550
 TTreeFormula.cxx:3551
 TTreeFormula.cxx:3552
 TTreeFormula.cxx:3553
 TTreeFormula.cxx:3554
 TTreeFormula.cxx:3555
 TTreeFormula.cxx:3556
 TTreeFormula.cxx:3557
 TTreeFormula.cxx:3558
 TTreeFormula.cxx:3559
 TTreeFormula.cxx:3560
 TTreeFormula.cxx:3561
 TTreeFormula.cxx:3562
 TTreeFormula.cxx:3563
 TTreeFormula.cxx:3564
 TTreeFormula.cxx:3565
 TTreeFormula.cxx:3566
 TTreeFormula.cxx:3567
 TTreeFormula.cxx:3568
 TTreeFormula.cxx:3569
 TTreeFormula.cxx:3570
 TTreeFormula.cxx:3571
 TTreeFormula.cxx:3572
 TTreeFormula.cxx:3573
 TTreeFormula.cxx:3574
 TTreeFormula.cxx:3575
 TTreeFormula.cxx:3576
 TTreeFormula.cxx:3577
 TTreeFormula.cxx:3578
 TTreeFormula.cxx:3579
 TTreeFormula.cxx:3580
 TTreeFormula.cxx:3581
 TTreeFormula.cxx:3582
 TTreeFormula.cxx:3583
 TTreeFormula.cxx:3584
 TTreeFormula.cxx:3585
 TTreeFormula.cxx:3586
 TTreeFormula.cxx:3587
 TTreeFormula.cxx:3588
 TTreeFormula.cxx:3589
 TTreeFormula.cxx:3590
 TTreeFormula.cxx:3591
 TTreeFormula.cxx:3592
 TTreeFormula.cxx:3593
 TTreeFormula.cxx:3594
 TTreeFormula.cxx:3595
 TTreeFormula.cxx:3596
 TTreeFormula.cxx:3597
 TTreeFormula.cxx:3598
 TTreeFormula.cxx:3599
 TTreeFormula.cxx:3600
 TTreeFormula.cxx:3601
 TTreeFormula.cxx:3602
 TTreeFormula.cxx:3603
 TTreeFormula.cxx:3604
 TTreeFormula.cxx:3605
 TTreeFormula.cxx:3606
 TTreeFormula.cxx:3607
 TTreeFormula.cxx:3608
 TTreeFormula.cxx:3609
 TTreeFormula.cxx:3610
 TTreeFormula.cxx:3611
 TTreeFormula.cxx:3612
 TTreeFormula.cxx:3613
 TTreeFormula.cxx:3614
 TTreeFormula.cxx:3615
 TTreeFormula.cxx:3616
 TTreeFormula.cxx:3617
 TTreeFormula.cxx:3618
 TTreeFormula.cxx:3619
 TTreeFormula.cxx:3620
 TTreeFormula.cxx:3621
 TTreeFormula.cxx:3622
 TTreeFormula.cxx:3623
 TTreeFormula.cxx:3624
 TTreeFormula.cxx:3625
 TTreeFormula.cxx:3626
 TTreeFormula.cxx:3627
 TTreeFormula.cxx:3628
 TTreeFormula.cxx:3629
 TTreeFormula.cxx:3630
 TTreeFormula.cxx:3631
 TTreeFormula.cxx:3632
 TTreeFormula.cxx:3633
 TTreeFormula.cxx:3634
 TTreeFormula.cxx:3635
 TTreeFormula.cxx:3636
 TTreeFormula.cxx:3637
 TTreeFormula.cxx:3638
 TTreeFormula.cxx:3639
 TTreeFormula.cxx:3640
 TTreeFormula.cxx:3641
 TTreeFormula.cxx:3642
 TTreeFormula.cxx:3643
 TTreeFormula.cxx:3644
 TTreeFormula.cxx:3645
 TTreeFormula.cxx:3646
 TTreeFormula.cxx:3647
 TTreeFormula.cxx:3648
 TTreeFormula.cxx:3649
 TTreeFormula.cxx:3650
 TTreeFormula.cxx:3651
 TTreeFormula.cxx:3652
 TTreeFormula.cxx:3653
 TTreeFormula.cxx:3654
 TTreeFormula.cxx:3655
 TTreeFormula.cxx:3656
 TTreeFormula.cxx:3657
 TTreeFormula.cxx:3658
 TTreeFormula.cxx:3659
 TTreeFormula.cxx:3660
 TTreeFormula.cxx:3661
 TTreeFormula.cxx:3662
 TTreeFormula.cxx:3663
 TTreeFormula.cxx:3664
 TTreeFormula.cxx:3665
 TTreeFormula.cxx:3666
 TTreeFormula.cxx:3667
 TTreeFormula.cxx:3668
 TTreeFormula.cxx:3669
 TTreeFormula.cxx:3670
 TTreeFormula.cxx:3671
 TTreeFormula.cxx:3672
 TTreeFormula.cxx:3673
 TTreeFormula.cxx:3674
 TTreeFormula.cxx:3675
 TTreeFormula.cxx:3676
 TTreeFormula.cxx:3677
 TTreeFormula.cxx:3678
 TTreeFormula.cxx:3679
 TTreeFormula.cxx:3680
 TTreeFormula.cxx:3681
 TTreeFormula.cxx:3682
 TTreeFormula.cxx:3683
 TTreeFormula.cxx:3684
 TTreeFormula.cxx:3685
 TTreeFormula.cxx:3686
 TTreeFormula.cxx:3687
 TTreeFormula.cxx:3688
 TTreeFormula.cxx:3689
 TTreeFormula.cxx:3690
 TTreeFormula.cxx:3691
 TTreeFormula.cxx:3692
 TTreeFormula.cxx:3693
 TTreeFormula.cxx:3694
 TTreeFormula.cxx:3695
 TTreeFormula.cxx:3696
 TTreeFormula.cxx:3697
 TTreeFormula.cxx:3698
 TTreeFormula.cxx:3699
 TTreeFormula.cxx:3700
 TTreeFormula.cxx:3701
 TTreeFormula.cxx:3702
 TTreeFormula.cxx:3703
 TTreeFormula.cxx:3704
 TTreeFormula.cxx:3705
 TTreeFormula.cxx:3706
 TTreeFormula.cxx:3707
 TTreeFormula.cxx:3708
 TTreeFormula.cxx:3709
 TTreeFormula.cxx:3710
 TTreeFormula.cxx:3711
 TTreeFormula.cxx:3712
 TTreeFormula.cxx:3713
 TTreeFormula.cxx:3714
 TTreeFormula.cxx:3715
 TTreeFormula.cxx:3716
 TTreeFormula.cxx:3717
 TTreeFormula.cxx:3718
 TTreeFormula.cxx:3719
 TTreeFormula.cxx:3720
 TTreeFormula.cxx:3721
 TTreeFormula.cxx:3722
 TTreeFormula.cxx:3723
 TTreeFormula.cxx:3724
 TTreeFormula.cxx:3725
 TTreeFormula.cxx:3726
 TTreeFormula.cxx:3727
 TTreeFormula.cxx:3728
 TTreeFormula.cxx:3729
 TTreeFormula.cxx:3730
 TTreeFormula.cxx:3731
 TTreeFormula.cxx:3732
 TTreeFormula.cxx:3733
 TTreeFormula.cxx:3734
 TTreeFormula.cxx:3735
 TTreeFormula.cxx:3736
 TTreeFormula.cxx:3737
 TTreeFormula.cxx:3738
 TTreeFormula.cxx:3739
 TTreeFormula.cxx:3740
 TTreeFormula.cxx:3741
 TTreeFormula.cxx:3742
 TTreeFormula.cxx:3743
 TTreeFormula.cxx:3744
 TTreeFormula.cxx:3745
 TTreeFormula.cxx:3746
 TTreeFormula.cxx:3747
 TTreeFormula.cxx:3748
 TTreeFormula.cxx:3749
 TTreeFormula.cxx:3750
 TTreeFormula.cxx:3751
 TTreeFormula.cxx:3752
 TTreeFormula.cxx:3753
 TTreeFormula.cxx:3754
 TTreeFormula.cxx:3755
 TTreeFormula.cxx:3756
 TTreeFormula.cxx:3757
 TTreeFormula.cxx:3758
 TTreeFormula.cxx:3759
 TTreeFormula.cxx:3760
 TTreeFormula.cxx:3761
 TTreeFormula.cxx:3762
 TTreeFormula.cxx:3763
 TTreeFormula.cxx:3764
 TTreeFormula.cxx:3765
 TTreeFormula.cxx:3766
 TTreeFormula.cxx:3767
 TTreeFormula.cxx:3768
 TTreeFormula.cxx:3769
 TTreeFormula.cxx:3770
 TTreeFormula.cxx:3771
 TTreeFormula.cxx:3772
 TTreeFormula.cxx:3773
 TTreeFormula.cxx:3774
 TTreeFormula.cxx:3775
 TTreeFormula.cxx:3776
 TTreeFormula.cxx:3777
 TTreeFormula.cxx:3778
 TTreeFormula.cxx:3779
 TTreeFormula.cxx:3780
 TTreeFormula.cxx:3781
 TTreeFormula.cxx:3782
 TTreeFormula.cxx:3783
 TTreeFormula.cxx:3784
 TTreeFormula.cxx:3785
 TTreeFormula.cxx:3786
 TTreeFormula.cxx:3787
 TTreeFormula.cxx:3788
 TTreeFormula.cxx:3789
 TTreeFormula.cxx:3790
 TTreeFormula.cxx:3791
 TTreeFormula.cxx:3792
 TTreeFormula.cxx:3793
 TTreeFormula.cxx: