ROOT logo
/*****************************************************************************
 * Project: RooFit                                                           *
 * Package: RooFitCore                                                       *
 * @(#)root/roofitcore:$Id$
 * Authors:                                                                  *
 *   WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.edu       *
 *   DK, David Kirkby,    UC Irvine,         dkirkby@uci.edu                 *
 *                                                                           *
 * Copyright (c) 2000-2005, Regents of the University of California          *
 *                          and Stanford University. All rights reserved.    *
 *                                                                           *
 * Redistribution and use in source and binary forms,                        *
 * with or without modification, are permitted according to the terms        *
 * listed in LICENSE (http://roofit.sourceforge.net/license.txt)             *
 *****************************************************************************/

//////////////////////////////////////////////////////////////////////////////
// 
// BEGIN_HTML
// RooAbsData is the common abstract base class for binned and unbinned
// datasets. The abstract interface defines plotting and tabulating entry
// points for its contents and provides an iterator over its elements
// (bins for binned data sets, data points for unbinned datasets).
// END_HTML
//
//

#include "RooFit.h"
#include "Riostream.h"

#include "TClass.h"
#include "TMath.h"

#include "RooAbsData.h"
#include "RooAbsData.h"
#include "RooFormulaVar.h"
#include "RooCmdConfig.h"
#include "RooAbsRealLValue.h"
#include "RooMsgService.h"
#include "RooMultiCategory.h"
#include "Roo1DTable.h"
#include "RooAbsDataStore.h"
#include "RooVectorDataStore.h"
#include "RooTreeDataStore.h"
#include "RooDataHist.h"
#include "RooCompositeDataStore.h"
#include "RooCategory.h"
#include "RooTrace.h"

#include "RooRealVar.h"
#include "RooGlobalFunc.h"
#include "RooPlot.h"
#include "RooCurve.h"
#include "RooHist.h"

#include "TMatrixDSym.h"
#include "TPaveText.h"
#include "TH1.h"
#include "TH2.h"
#include "TH3.h"


using namespace std;

ClassImp(RooAbsData)
;

static std::map<RooAbsData*,int> _dcc ;

RooAbsData::StorageType RooAbsData::defaultStorageType=RooAbsData::Vector ;


//_____________________________________________________________________________
void RooAbsData::setDefaultStorageType(RooAbsData::StorageType s) 
{
  defaultStorageType = s ;
}


//_____________________________________________________________________________
RooAbsData::StorageType RooAbsData::getDefaultStorageType( ) 
{
  return defaultStorageType;
}


//_____________________________________________________________________________
void RooAbsData::claimVars(RooAbsData* data) 
{
  _dcc[data]++ ;
  //cout << "RooAbsData(" << data << ") claim incremented to " << _dcc[data] << endl ;
}


//_____________________________________________________________________________
Bool_t RooAbsData::releaseVars(RooAbsData* data) 
{
  // If return value is true variables can be deleted
  if (_dcc[data]>0) {
    _dcc[data]-- ;
  }

  //cout << "RooAbsData(" << data << ") claim decremented to " << _dcc[data] << endl ;
  return (_dcc[data]==0) ;
}


//_____________________________________________________________________________
RooAbsData::RooAbsData() 
{
  // Default constructor
  claimVars(this) ;
  _dstore = 0 ;
  _iterator = _vars.createIterator() ;
  _cacheIter = _cachedVars.createIterator() ;

  RooTrace::create(this) ;
}



//_____________________________________________________________________________
RooAbsData::RooAbsData(const char *name, const char *title, const RooArgSet& vars, RooAbsDataStore* dstore) :
  TNamed(name,title), _vars("Dataset Variables"), _cachedVars("Cached Variables"), _dstore(dstore)
{
  // Constructor from a set of variables. Only fundamental elements of vars
  // (RooRealVar,RooCategory etc) are stored as part of the dataset

  //cout << "created dataset " << this << endl ;
  claimVars(this) ;

  // clone the fundamentals of the given data set into internal buffer
  TIterator* iter = vars.createIterator() ;
  RooAbsArg *var;
  while((0 != (var= (RooAbsArg*)iter->Next()))) {
    if (!var->isFundamental()) {
      coutE(InputArguments) << "RooAbsDataStore::initialize(" << GetName() 
			    << "): Data set cannot contain non-fundamental types, ignoring " 
			    << var->GetName() << endl ;
    } else {
      _vars.addClone(*var);
    }
  }
  delete iter ;

  // reconnect any parameterized ranges to internal dataset observables
  iter = _vars.createIterator() ;
  while((0 != (var= (RooAbsArg*)iter->Next()))) {
    var->attachDataSet(*this) ;
  } 
  delete iter ;

  _iterator= _vars.createIterator();
  _cacheIter = _cachedVars.createIterator() ;

  RooTrace::create(this) ;
}



//_____________________________________________________________________________
RooAbsData::RooAbsData(const RooAbsData& other, const char* newname) : 
  TNamed(newname?newname:other.GetName(),other.GetTitle()), 
  RooPrintable(other), _vars(),
  _cachedVars("Cached Variables")
{
  // Copy constructor

  //cout << "created dataset " << this << endl ;
  claimVars(this) ;
  _vars.addClone(other._vars) ;

  // reconnect any parameterized ranges to internal dataset observables
  TIterator* iter = _vars.createIterator() ;
  RooAbsArg* var ;
  while((0 != (var= (RooAbsArg*)iter->Next()))) {
    var->attachDataSet(*this) ;
  } 
  delete iter ;


  _iterator= _vars.createIterator();
  _cacheIter = _cachedVars.createIterator() ;


  if (other._ownedComponents.size()>0) {

    // copy owned components here

    map<string,RooAbsDataStore*> smap ;
    for (std::map<std::string,RooAbsData*>::const_iterator itero =other._ownedComponents.begin() ; itero!=other._ownedComponents.end() ; ++itero ) {
      RooAbsData* dclone = (RooAbsData*) itero->second->Clone() ;
      _ownedComponents[itero->first] = dclone ;
      smap[itero->first] = dclone->store() ;
    }

//     if (!dynamic_cast<const RooCompositeDataStore*>(other.store())) {
//       cout << "Huh, have owned components, but store is not composite?" << endl ;
//     }

    RooCategory* idx = (RooCategory*) _vars.find(*((RooCompositeDataStore*)other.store())->index()) ;
    _dstore = new RooCompositeDataStore(newname?newname:other.GetName(),other.GetTitle(),_vars,*idx,smap) ;
    
  } else {
    
    // Convert to vector store if default is vector
    _dstore = other._dstore->clone(_vars,newname?newname:other.GetName()) ;
  }

  RooTrace::create(this) ;
}



//_____________________________________________________________________________
RooAbsData::~RooAbsData() 
{
  // Destructor

  if (releaseVars(this)) {
    // will cause content to be deleted subsequently in dtor
  } else {
    _vars.releaseOwnership() ; 
  }
  
  // delete owned contents.
  delete _dstore ;
  delete _iterator ;
  delete _cacheIter ;

  // Delete owned dataset components
  for(map<std::string,RooAbsData*>::iterator iter = _ownedComponents.begin() ; iter!= _ownedComponents.end() ; ++iter) {
    delete iter->second ;
  }

  RooTrace::destroy(this) ;
}



//_____________________________________________________________________________
void RooAbsData::convertToVectorStore() 
{
  // Convert tree-based storage to vector-based storage
  
  if (dynamic_cast<RooTreeDataStore*>(_dstore)) {
    RooVectorDataStore* newStore =  new RooVectorDataStore(*(RooTreeDataStore*)_dstore,_vars,GetName()) ;
    delete _dstore ;
    _dstore = newStore ;
  }
}




//_____________________________________________________________________________
Bool_t RooAbsData::changeObservableName(const char* from, const char* to)
{
  Bool_t ret =  _dstore->changeObservableName(from,to) ;
  
  RooAbsArg* tmp = _vars.find(from) ;
  if (tmp) {
    tmp->SetName(to) ;
  }
  return ret ;
}





//_____________________________________________________________________________
void RooAbsData::fill()
{
  _dstore->fill() ;
}





//_____________________________________________________________________________
Int_t RooAbsData::numEntries() const
{
  return _dstore->numEntries() ;
}





//_____________________________________________________________________________
void RooAbsData::reset()
{
  _dstore->reset() ;
}




//_____________________________________________________________________________
const RooArgSet* RooAbsData::get(Int_t index) const 
{
  checkInit() ;
  return _dstore->get(index) ;
}




//_____________________________________________________________________________
void RooAbsData::cacheArgs(const RooAbsArg* cacheOwner, RooArgSet& varSet, const RooArgSet* nset, Bool_t skipZeroWeights) 
{
  // Internal method -- Cache given set of functions with data
  _dstore->cacheArgs(cacheOwner,varSet,nset,skipZeroWeights) ;
}





//_____________________________________________________________________________
void RooAbsData::resetCache() 
{
  // Internal method -- Remove cached function values
  _dstore->resetCache() ;
  _cachedVars.removeAll() ;
}



//_____________________________________________________________________________
void RooAbsData::attachCache(const RooAbsArg* newOwner, const RooArgSet& cachedVars) 
{
  // Internal method -- Attach dataset copied with cache contents to copied instances of functions
  _dstore->attachCache(newOwner, cachedVars) ;
}








//_____________________________________________________________________________
void RooAbsData::setArgStatus(const RooArgSet& set, Bool_t active) 
{
  _dstore->setArgStatus(set,active) ;
}




//_____________________________________________________________________________
void RooAbsData::setDirtyProp(Bool_t flag) 
{ 
  // Control propagation of dirty flags from observables in dataset
  _dstore->setDirtyProp(flag) ; 
}

  




//_____________________________________________________________________________
RooAbsData* RooAbsData::reduce(const RooCmdArg& arg1,const RooCmdArg& arg2,const RooCmdArg& arg3,const RooCmdArg& arg4,
			       const RooCmdArg& arg5,const RooCmdArg& arg6,const RooCmdArg& arg7,const RooCmdArg& arg8) 
{
  // Create a reduced copy of this dataset. The caller takes ownership of the returned dataset
  //
  // The following optional named arguments are accepted
  //
  //   SelectVars(const RooArgSet& vars) -- Only retain the listed observables in the output dataset
  //   Cut(const char* expression)       -- Only retain event surviving the given cut expression
  //   Cut(const RooFormulaVar& expr)    -- Only retain event surviving the given cut formula
  //   CutRange(const char* name)        -- Only retain events inside range with given name. Multiple CutRange
  //                                        arguments may be given to select multiple ranges
  //   EventRange(int lo, int hi)        -- Only retain events with given sequential event numbers
  //   Name(const char* name)            -- Give specified name to output dataset
  //   Title(const char* name)           -- Give specified title to output dataset
  //

  // Define configuration for this method
  RooCmdConfig pc(Form("RooAbsData::reduce(%s)",GetName())) ;
  pc.defineString("name","Name",0,"") ;
  pc.defineString("title","Title",0,"") ;
  pc.defineString("cutRange","CutRange",0,"") ;
  pc.defineString("cutSpec","CutSpec",0,"") ;
  pc.defineObject("cutVar","CutVar",0,0) ;
  pc.defineInt("evtStart","EventRange",0,0) ;
  pc.defineInt("evtStop","EventRange",1,2000000000) ;
  pc.defineObject("varSel","SelectVars",0,0) ;
  pc.defineMutex("CutVar","CutSpec") ;

  // Process & check varargs 
  pc.process(arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8) ;
  if (!pc.ok(kTRUE)) {
    return 0 ;
  }

  // Extract values from named arguments
  const char* cutRange = pc.getString("cutRange",0,kTRUE) ;
  const char* cutSpec = pc.getString("cutSpec",0,kTRUE) ;
  RooFormulaVar* cutVar = static_cast<RooFormulaVar*>(pc.getObject("cutVar",0)) ;
  Int_t nStart = pc.getInt("evtStart",0) ;
  Int_t nStop = pc.getInt("evtStop",2000000000) ;
  RooArgSet* varSet = static_cast<RooArgSet*>(pc.getObject("varSel")) ;
  const char* name = pc.getString("name",0,kTRUE) ;
  const char* title = pc.getString("title",0,kTRUE) ;

  // Make sure varSubset doesn't contain any variable not in this dataset
  RooArgSet varSubset ;
  if (varSet) {
    varSubset.add(*varSet) ;
    TIterator* iter = varSubset.createIterator() ;
    RooAbsArg* arg ;
    while((arg=(RooAbsArg*)iter->Next())) {
      if (!_vars.find(arg->GetName())) {
	coutW(InputArguments) << "RooAbsData::reduce(" << GetName() << ") WARNING: variable " 
			      << arg->GetName() << " not in dataset, ignored" << endl ;
	varSubset.remove(*arg) ;
      }
    }
    delete iter ;    
  } else {
    varSubset.add(*get()) ;
  }

  RooAbsData* ret = 0 ;
  if (cutSpec) {

    RooFormulaVar cutVarTmp(cutSpec,cutSpec,*get()) ;
    ret =  reduceEng(varSubset,&cutVarTmp,cutRange,nStart,nStop,kFALSE) ;      

  } else if (cutVar) {

    ret = reduceEng(varSubset,cutVar,cutRange,nStart,nStop,kFALSE) ;

  } else {

    ret = reduceEng(varSubset,0,cutRange,nStart,nStop,kFALSE) ;

  }
  
  if (!ret) return 0 ;

  if (name) {
    ret->SetName(name) ;
  }
  if (title) {
    ret->SetTitle(title) ;
  }

  return ret ;
}



//_____________________________________________________________________________
RooAbsData* RooAbsData::reduce(const char* cut) 
{ 
  // Create a subset of the data set by applying the given cut on the data points.
  // The cut expression can refer to any variable in the data set. For cuts involving 
  // other variables, such as intermediate formula objects, use the equivalent 
  // reduce method specifying the as a RooFormulVar reference.

  RooFormulaVar cutVar(cut,cut,*get()) ;
  return reduceEng(*get(),&cutVar,0,0,2000000000,kFALSE) ;
}



//_____________________________________________________________________________
RooAbsData* RooAbsData::reduce(const RooFormulaVar& cutVar) 
{
  // Create a subset of the data set by applying the given cut on the data points.
  // The 'cutVar' formula variable is used to select the subset of data points to be 
  // retained in the reduced data collection.

  return reduceEng(*get(),&cutVar,0,0,2000000000,kFALSE) ;
}



//_____________________________________________________________________________
RooAbsData* RooAbsData::reduce(const RooArgSet& varSubset, const char* cut) 
{
  // Create a subset of the data set by applying the given cut on the data points
  // and reducing the dimensions to the specified set.
  // 
  // The cut expression can refer to any variable in the data set. For cuts involving 
  // other variables, such as intermediate formula objects, use the equivalent 
  // reduce method specifying the as a RooFormulVar reference.

  // Make sure varSubset doesn't contain any variable not in this dataset
  RooArgSet varSubset2(varSubset) ;
  TIterator* iter = varSubset.createIterator() ;
  RooAbsArg* arg ;
  while((arg=(RooAbsArg*)iter->Next())) {
    if (!_vars.find(arg->GetName())) {
      coutW(InputArguments) << "RooAbsData::reduce(" << GetName() << ") WARNING: variable " 
			    << arg->GetName() << " not in dataset, ignored" << endl ;
      varSubset2.remove(*arg) ;
    }
  }
  delete iter ;

  if (cut && strlen(cut)>0) {
    RooFormulaVar cutVar(cut,cut,*get()) ;
    return reduceEng(varSubset2,&cutVar,0,0,2000000000,kFALSE) ;      
  } 
  return reduceEng(varSubset2,0,0,0,2000000000,kFALSE) ;
}



//_____________________________________________________________________________
RooAbsData* RooAbsData::reduce(const RooArgSet& varSubset, const RooFormulaVar& cutVar) 
{
  // Create a subset of the data set by applying the given cut on the data points
  // and reducing the dimensions to the specified set.
  // 
  // The 'cutVar' formula variable is used to select the subset of data points to be 
  // retained in the reduced data collection.

  // Make sure varSubset doesn't contain any variable not in this dataset
  RooArgSet varSubset2(varSubset) ;
  TIterator* iter = varSubset.createIterator() ;
  RooAbsArg* arg ;
  while((arg=(RooAbsArg*)iter->Next())) {
    if (!_vars.find(arg->GetName())) {
      coutW(InputArguments) << "RooAbsData::reduce(" << GetName() << ") WARNING: variable " 
			    << arg->GetName() << " not in dataset, ignored" << endl ;
      varSubset2.remove(*arg) ;
    }
  }
  delete iter ;

  return reduceEng(varSubset2,&cutVar,0,0,2000000000,kFALSE) ;
}



//_____________________________________________________________________________
Double_t RooAbsData::weightError(ErrorType) const 
{ 
  // Return error on current weight (dummy implementation returning zero)
  return 0 ; 
} 



//_____________________________________________________________________________
void RooAbsData::weightError(Double_t& lo, Double_t& hi, ErrorType) const 
{ 
  // Return asymmetric error on weight. (Dummy implementation returning zero)
  lo=0 ; hi=0 ; 
} 



//_____________________________________________________________________________
RooPlot* RooAbsData::plotOn(RooPlot* frame, const RooCmdArg& arg1, const RooCmdArg& arg2,
			    const RooCmdArg& arg3, const RooCmdArg& arg4, const RooCmdArg& arg5, 
			    const RooCmdArg& arg6, const RooCmdArg& arg7, const RooCmdArg& arg8) const
{
  // Plot dataset on specified frame. By default an unbinned dataset will use the default binning of
  // the target frame. A binned dataset will by default retain its intrinsic binning.
  //
  // The following optional named arguments can be used to modify the default behavior
  //
  // Data representation options
  // ---------------------------
  // Asymmetry(const RooCategory& c) -- Show the asymmetry of the daya in given two-state category [F(+)-F(-)] / [F(+)+F(-)]. 
  //                                    Category must have two states with indices -1 and +1 or three states with indeces -1,0 and +1.
  // DataError(RooAbsData::EType)    -- Select the type of error drawn: Poisson (default) draws asymmetric Poisson
  //                                    confidence intervals. SumW2 draws symmetric sum-of-weights error
  // Binning(int nbins, double xlo,  -- Use specified binning to draw dataset
  //                    double xhi)
  // Binning(const RooAbsBinning&)   -- Use specified binning to draw dataset
  // Binning(const char* name)       -- Use binning with specified name to draw dataset
  // RefreshNorm(Bool_t flag)        -- Force refreshing for PDF normalization information in frame.
  //                                    If set, any subsequent PDF will normalize to this dataset, even if it is
  //                                    not the first one added to the frame. By default only the 1st dataset
  //                                    added to a frame will update the normalization information
  // Rescale(Double_t factor)        -- Apply global rescaling factor to histogram
  //
  // Histogram drawing options
  // -------------------------
  // DrawOption(const char* opt)     -- Select ROOT draw option for resulting TGraph object
  // LineStyle(Int_t style)          -- Select line style by ROOT line style code, default is solid
  // LineColor(Int_t color)          -- Select line color by ROOT color code, default is black
  // LineWidth(Int_t width)          -- Select line with in pixels, default is 3
  // MarkerStyle(Int_t style)        -- Select the ROOT marker style, default is 21
  // MarkerColor(Int_t color)        -- Select the ROOT marker color, default is black
  // MarkerSize(Double_t size)       -- Select the ROOT marker size
  // XErrorSize(Double_t frac)       -- Select size of X error bar as fraction of the bin width, default is 1
  //
  //
  // Misc. other options
  // -------------------
  // Name(const chat* name)          -- Give curve specified name in frame. Useful if curve is to be referenced later
  // Invisble(Bool_t flag)           -- Add curve to frame, but do not display. Useful in combination AddTo()
  // AddTo(const char* name,         -- Add constructed histogram to already existing histogram with given name and relative weight factors
  // double_t wgtSelf, double_t wgtOther)
  // 
  //                                    
  RooLinkedList l ;
  l.Add((TObject*)&arg1) ;  l.Add((TObject*)&arg2) ;  
  l.Add((TObject*)&arg3) ;  l.Add((TObject*)&arg4) ;
  l.Add((TObject*)&arg5) ;  l.Add((TObject*)&arg6) ;  
  l.Add((TObject*)&arg7) ;  l.Add((TObject*)&arg8) ;
  return plotOn(frame,l) ;  
}




//_____________________________________________________________________________
TH1 *RooAbsData::createHistogram(const char* varNameList, Int_t xbins, Int_t ybins, Int_t zbins) const
{
  // Create and fill a ROOT histogram TH1,TH2 or TH3 with the values of this dataset for the variables with given names
  // The range of each observable that is histogrammed is always automatically calculated from the distribution in
  // the dataset. The number of bins can be controlled using the [xyz]bins parameters. For a greater degree of control
  // use the createHistogram() method below with named arguments
  //
  // The caller takes ownership of the returned histogram

  // Parse list of variable names
  char buf[1024] ;
  strlcpy(buf,varNameList,1024) ;
  char* varName = strtok(buf,",:") ;
  
  RooRealVar* xvar = (RooRealVar*) get()->find(varName) ;
  if (!xvar) {
    coutE(InputArguments) << "RooAbsData::createHistogram(" << GetName() << ") ERROR: dataset does not contain an observable named " << varName << endl ;
    return 0 ;
  }
  varName = strtok(0,",") ; 
  RooRealVar* yvar = varName ? (RooRealVar*) get()->find(varName) : 0 ;
  if (varName && !yvar) {
    coutE(InputArguments) << "RooAbsData::createHistogram(" << GetName() << ") ERROR: dataset does not contain an observable named " << varName << endl ;
    return 0 ;
  }
  varName = strtok(0,",") ;  
  RooRealVar* zvar = varName ? (RooRealVar*) get()->find(varName) : 0 ;
  if (varName && !zvar) {
    coutE(InputArguments) << "RooAbsData::createHistogram(" << GetName() << ") ERROR: dataset does not contain an observable named " << varName << endl ;
    return 0 ;
  }

  // Construct list of named arguments to pass to the implementation version of createHistogram()

  RooLinkedList argList ; 
  if (xbins<=0  || !xvar->hasMax() || !xvar->hasMin() ) {
    argList.Add(RooFit::AutoBinning(xbins==0?xvar->numBins():abs(xbins)).Clone()) ;
  } else {
    argList.Add(RooFit::Binning(xbins).Clone()) ;
  }
 
  if (yvar) {        
    if (ybins<=0 || !yvar->hasMax() || !yvar->hasMin() ) {
      argList.Add(RooFit::YVar(*yvar,RooFit::AutoBinning(ybins==0?yvar->numBins():abs(ybins))).Clone()) ;
    } else {
      argList.Add(RooFit::YVar(*yvar,RooFit::Binning(ybins)).Clone()) ;
    }
  }

  if (zvar) {    
    if (zbins<=0 || !zvar->hasMax() || !zvar->hasMin() ) {
      argList.Add(RooFit::ZVar(*zvar,RooFit::AutoBinning(zbins==0?zvar->numBins():abs(zbins))).Clone()) ;
    } else {
      argList.Add(RooFit::ZVar(*zvar,RooFit::Binning(zbins)).Clone()) ;
    }
  }



  // Call implementation function
  TH1* result = createHistogram(GetName(),*xvar,argList) ;

  // Delete temporary list of RooCmdArgs 
  argList.Delete() ;

  return result ;
}



//_____________________________________________________________________________
TH1 *RooAbsData::createHistogram(const char *name, const RooAbsRealLValue& xvar,
				 const RooCmdArg& arg1, const RooCmdArg& arg2, const RooCmdArg& arg3, const RooCmdArg& arg4, 
				 const RooCmdArg& arg5, const RooCmdArg& arg6, const RooCmdArg& arg7, const RooCmdArg& arg8) const 
{
  // Create and fill a ROOT histogram TH1,TH2 or TH3 with the values of this dataset. 
  //
  // This function accepts the following arguments
  //
  // name -- Name of the ROOT histogram
  // xvar -- Observable to be mapped on x axis of ROOT histogram
  //
  // AutoBinning(Int_t nbins, Double_y margin)    -- Automatically calculate range with given added fractional margin, set binning to nbins
  // AutoSymBinning(Int_t nbins, Double_y margin) -- Automatically calculate range with given added fractional margin, 
  //                                                 with additional constraint that mean of data is in center of range, set binning to nbins
  // Binning(const char* name)                    -- Apply binning with given name to x axis of histogram
  // Binning(RooAbsBinning& binning)              -- Apply specified binning to x axis of histogram
  // Binning(int nbins, double lo, double hi)     -- Apply specified binning to x axis of histogram
  //
  // YVar(const RooAbsRealLValue& var,...)    -- Observable to be mapped on y axis of ROOT histogram
  // ZVar(const RooAbsRealLValue& var,...)    -- Observable to be mapped on z axis of ROOT histogram
  //
  // The YVar() and ZVar() arguments can be supplied with optional Binning() Auto(Sym)Range() arguments to control the binning of the Y and Z axes, e.g.
  // createHistogram("histo",x,Binning(-1,1,20), YVar(y,Binning(-1,1,30)), ZVar(z,Binning("zbinning")))
  //
  // The caller takes ownership of the returned histogram

  RooLinkedList l ;
  l.Add((TObject*)&arg1) ;  l.Add((TObject*)&arg2) ;  
  l.Add((TObject*)&arg3) ;  l.Add((TObject*)&arg4) ;
  l.Add((TObject*)&arg5) ;  l.Add((TObject*)&arg6) ;  
  l.Add((TObject*)&arg7) ;  l.Add((TObject*)&arg8) ;

  return createHistogram(name,xvar,l) ;
}


//_____________________________________________________________________________
TH1 *RooAbsData::createHistogram(const char *name, const RooAbsRealLValue& xvar, const RooLinkedList& argListIn) const
{
  // Internal method that implements histogram filling
  RooLinkedList argList(argListIn) ;
  
  // Define configuration for this method
  RooCmdConfig pc(Form("RooAbsData::createHistogram(%s)",GetName())) ;
  pc.defineString("cutRange","CutRange",0,"",kTRUE) ;
  pc.defineString("cutString","CutSpec",0,"") ;
  pc.defineObject("yvar","YVar",0,0) ;
  pc.defineObject("zvar","ZVar",0,0) ;
  pc.allowUndefined() ;
  
  // Process & check varargs 
  pc.process(argList) ;
  if (!pc.ok(kTRUE)) {
    return 0 ;
  }

  const char* cutSpec = pc.getString("cutString",0,kTRUE) ;
  const char* cutRange = pc.getString("cutRange",0,kTRUE) ;

  RooArgList vars(xvar) ;
  RooAbsArg* yvar = static_cast<RooAbsArg*>(pc.getObject("yvar")) ;
  if (yvar) {
    vars.add(*yvar) ;
  }
  RooAbsArg* zvar = static_cast<RooAbsArg*>(pc.getObject("zvar")) ;
  if (zvar) {
    vars.add(*zvar) ;
  }

  pc.stripCmdList(argList,"CutRange,CutSpec") ;

  // Swap Auto(Sym)RangeData with a Binning command
  RooLinkedList ownedCmds ;
  RooCmdArg* autoRD = (RooCmdArg*) argList.find("AutoRangeData") ;
  if (autoRD) {
    Double_t xmin,xmax ;
    getRange((RooRealVar&)xvar,xmin,xmax,autoRD->getDouble(0),autoRD->getInt(0)) ;
    RooCmdArg* bincmd = (RooCmdArg*) RooFit::Binning(autoRD->getInt(1),xmin,xmax).Clone() ;
    ownedCmds.Add(bincmd) ;
    argList.Replace(autoRD,bincmd) ;
  }

  if (yvar) {
    RooCmdArg* autoRDY = (RooCmdArg*) ((RooCmdArg*)argList.find("YVar"))->subArgs().find("AutoRangeData") ;
    if (autoRDY) {
      Double_t ymin,ymax ;
      getRange((RooRealVar&)(*yvar),ymin,ymax,autoRDY->getDouble(0),autoRDY->getInt(0)) ;
      RooCmdArg* bincmd = (RooCmdArg*) RooFit::Binning(autoRDY->getInt(1),ymin,ymax).Clone() ;
      //ownedCmds.Add(bincmd) ;
      ((RooCmdArg*)argList.find("YVar"))->subArgs().Replace(autoRDY,bincmd) ;
      delete autoRDY ;
    }
  }

  if (zvar) {
    RooCmdArg* autoRDZ = (RooCmdArg*) ((RooCmdArg*)argList.find("ZVar"))->subArgs().find("AutoRangeData") ;
    if (autoRDZ) {
      Double_t zmin,zmax ;
      getRange((RooRealVar&)(*zvar),zmin,zmax,autoRDZ->getDouble(0),autoRDZ->getInt(0)) ;
      RooCmdArg* bincmd = (RooCmdArg*) RooFit::Binning(autoRDZ->getInt(1),zmin,zmax).Clone() ;
      //ownedCmds.Add(bincmd) ;
      ((RooCmdArg*)argList.find("ZVar"))->subArgs().Replace(autoRDZ,bincmd) ;
      delete autoRDZ ;
    }
  }


  TH1* histo = xvar.createHistogram(name,argList) ;
  fillHistogram(histo,vars,cutSpec,cutRange) ;

  ownedCmds.Delete() ;

  return histo ;
}




//_____________________________________________________________________________
Roo1DTable* RooAbsData::table(const RooArgSet& catSet, const char* cuts, const char* opts) const 
{
  // Construct table for product of categories in catSet
  RooArgSet catSet2 ;

  string prodName("(") ;
  TIterator* iter = catSet.createIterator() ;
  RooAbsArg* arg ;
  while((arg=(RooAbsArg*)iter->Next())) {
    if (dynamic_cast<RooAbsCategory*>(arg)) {
      RooAbsCategory* varsArg = dynamic_cast<RooAbsCategory*>(_vars.find(arg->GetName())) ;
      if (varsArg != 0) catSet2.add(*varsArg) ;
      else catSet2.add(*arg) ;
      if (prodName.length()>1) {
	prodName += " x " ;
      }
      prodName += arg->GetName() ;
    } else {
      coutW(InputArguments) << "RooAbsData::table(" << GetName() << ") non-RooAbsCategory input argument " << arg->GetName() << " ignored" << endl ;
    }
  }
  prodName += ")" ;
  delete iter ;

  RooMultiCategory tmp(prodName.c_str(),prodName.c_str(),catSet2) ;
  return table(tmp,cuts,opts) ;
}




//_____________________________________________________________________________
void RooAbsData::printName(ostream& os) const 
{
  // Print name of dataset

  os << GetName() ;
}



//_____________________________________________________________________________
void RooAbsData::printTitle(ostream& os) const 
{
  // Print title of dataset
  os << GetTitle() ;
}



//_____________________________________________________________________________
void RooAbsData::printClassName(ostream& os) const 
{
  // Print class name of dataset
  os << IsA()->GetName() ;
}



//_____________________________________________________________________________
void RooAbsData::printMultiline(ostream& os, Int_t contents, Bool_t verbose, TString indent) const
{
  _dstore->printMultiline(os,contents,verbose,indent) ;
}




//_____________________________________________________________________________
Int_t RooAbsData::defaultPrintContents(Option_t* /*opt*/) const 
{
  // Define default print options, for a given print style

  return kName|kClassName|kArgs|kValue ;
}



//_____________________________________________________________________________
Double_t RooAbsData::standMoment(RooRealVar &var, Double_t order, const char* cutSpec, const char* cutRange) const 
{
  // Calculate standardized moment < (X - <X>)^n > / sigma^n,  where n = order.
  // 
  // If cutSpec and/or cutRange are specified
  // the moment is calculated on the subset of the data which pass the C++ cut specification expression 'cutSpec'
  // and/or are inside the range named 'cutRange'

  // Hardwire invariant answer for first and second moment
  if (order==1) return 0 ;
  if (order==2) return 1 ;

  return moment(var,order,cutSpec,cutRange) / TMath::Power(sigma(var,cutSpec,cutRange),order) ; 
}



//_____________________________________________________________________________
Double_t RooAbsData::moment(RooRealVar &var, Double_t order, const char* cutSpec, const char* cutRange) const 
{
  // Calculate moment < (X - <X>)^n > where n = order.
  // 
  // If cutSpec and/or cutRange are specified
  // the moment is calculated on the subset of the data which pass the C++ cut specification expression 'cutSpec'
  // and/or are inside the range named 'cutRange'

  Double_t offset = order>1 ? moment(var,1,cutSpec,cutRange) : 0 ;
  return moment(var,order,offset,cutSpec,cutRange) ;

}





//_____________________________________________________________________________
Double_t RooAbsData::moment(RooRealVar &var, Double_t order, Double_t offset, const char* cutSpec, const char* cutRange) const
{
  // Return the 'order'-ed moment of observable 'var' in this dataset. If offset is non-zero it is subtracted
  // from the values of 'var' prior to the moment calculation. If cutSpec and/or cutRange are specified
  // the moment is calculated on the subset of the data which pass the C++ cut specification expression 'cutSpec'
  // and/or are inside the range named 'cutRange'

  // Lookup variable in dataset
  RooRealVar *varPtr= (RooRealVar*) _vars.find(var.GetName());
  if(0 == varPtr) {
    coutE(InputArguments) << "RooDataSet::moment(" << GetName() << ") ERROR: unknown variable: " << var.GetName() << endl ;
    return 0;
  }

  // Check if found variable is of type RooRealVar
  if (!dynamic_cast<RooRealVar*>(varPtr)) {
    coutE(InputArguments) << "RooDataSet::moment(" << GetName() << ") ERROR: variable " << var.GetName() << " is not of type RooRealVar" << endl ;
    return 0;
  }

  // Check if dataset is not empty
  if(sumEntries(cutSpec, cutRange) == 0.) {
    coutE(InputArguments) << "RooDataSet::moment(" << GetName() << ") WARNING: empty dataset" << endl ;
    return 0;
  }

  // Setup RooFormulaVar for cutSpec if it is present
  RooFormula* select = 0 ;
  if (cutSpec) {
    select = new RooFormula("select",cutSpec,*get()) ;
  }


  // Calculate requested moment
  Double_t sum(0);
  const RooArgSet* vars ;
  for(Int_t index= 0; index < numEntries(); index++) {
    vars = get(index) ;
    if (select && select->eval()==0) continue ;
    if (cutRange && vars->allInRange(cutRange)) continue ;
    
    sum+= weight() * TMath::Power(varPtr->getVal() - offset,order);
  }
  return sum/sumEntries(cutSpec, cutRange);
}




//_____________________________________________________________________________
RooRealVar* RooAbsData::dataRealVar(const char* methodname, RooRealVar& extVar) const 
{
  // Internal method to check if given RooRealVar maps to a RooRealVar in this dataset

  // Lookup variable in dataset
  RooRealVar *xdata = (RooRealVar*) _vars.find(extVar.GetName());
  if(!xdata) {
    coutE(InputArguments) << "RooDataSet::" << methodname << "(" << GetName() << ") ERROR: variable : " << extVar.GetName() << " is not in data" << endl ;
    return 0;
  }
  // Check if found variable is of type RooRealVar
  if (!dynamic_cast<RooRealVar*>(xdata)) {
    coutE(InputArguments) << "RooDataSet::" << methodname << "(" << GetName() << ") ERROR: variable : " << extVar.GetName() << " is not of type RooRealVar in data" << endl ;
    return 0;
  }
  return xdata;
}


//_____________________________________________________________________________
Double_t RooAbsData::corrcov(RooRealVar &x,RooRealVar &y, const char* cutSpec, const char* cutRange, Bool_t corr) const 
{
  // Internal method to calculate single correlation and covariance elements

  // Lookup variable in dataset
  RooRealVar *xdata = dataRealVar(corr?"correlation":"covariance",x) ;
  RooRealVar *ydata = dataRealVar(corr?"correlation":"covariance",y) ;
  if (!xdata||!ydata) return 0 ;

  // Check if dataset is not empty
  if(sumEntries(cutSpec, cutRange) == 0.) {
    coutW(InputArguments) << "RooDataSet::" << (corr?"correlation":"covariance") << "(" << GetName() << ") WARNING: empty dataset, returning zero" << endl ;
    return 0;
  }

  // Setup RooFormulaVar for cutSpec if it is present
  RooFormula* select = cutSpec ? new RooFormula("select",cutSpec,*get()) : 0 ;

  // Calculate requested moment
  Double_t xysum(0),xsum(0),ysum(0),x2sum(0),y2sum(0);
  const RooArgSet* vars ;
  for(Int_t index= 0; index < numEntries(); index++) {
    vars = get(index) ;
    if (select && select->eval()==0) continue ;
    if (cutRange && vars->allInRange(cutRange)) continue ;

    xysum += weight()*xdata->getVal()*ydata->getVal() ;
    xsum += weight()*xdata->getVal() ;
    ysum += weight()*ydata->getVal() ;
    if (corr) {
      x2sum += weight()*xdata->getVal()*xdata->getVal() ;
      y2sum += weight()*ydata->getVal()*ydata->getVal() ;
    }
  }

  // Normalize entries
  xysum/=sumEntries(cutSpec, cutRange) ;
  xsum/=sumEntries(cutSpec, cutRange) ;
  ysum/=sumEntries(cutSpec, cutRange) ;
  if (corr) {
    x2sum/=sumEntries(cutSpec, cutRange) ;
    y2sum/=sumEntries(cutSpec, cutRange) ;
  }

  // Cleanup
  if (select) delete select ;

  // Return covariance or correlation as requested
  if (corr) {
    return (xysum-xsum*ysum)/(sqrt(x2sum-(xsum*xsum))*sqrt(y2sum-(ysum*ysum))) ;
  } else {
    return (xysum-xsum*ysum);
  }
}



//_____________________________________________________________________________
TMatrixDSym* RooAbsData::corrcovMatrix(const RooArgList& vars, const char* cutSpec, const char* cutRange, Bool_t corr) const 
{
  // Return covariance matrix from data for given list of observables

  RooArgList varList ;
  TIterator* iter = vars.createIterator() ;
  RooRealVar* var ;
  while((var=(RooRealVar*)iter->Next())) {
    RooRealVar* datavar = dataRealVar("covarianceMatrix",*var) ;
    if (!datavar) {
      delete iter ;
      return 0 ;
    } 
    varList.add(*datavar) ;
  }
  delete iter ;


  // Check if dataset is not empty
  if(sumEntries(cutSpec, cutRange) == 0.) {
    coutW(InputArguments) << "RooDataSet::covariance(" << GetName() << ") WARNING: empty dataset, returning zero" << endl ;
    return 0;
  }

  // Setup RooFormulaVar for cutSpec if it is present
  RooFormula* select = cutSpec ? new RooFormula("select",cutSpec,*get()) : 0 ;

  iter = varList.createIterator() ;
  TIterator* iter2 = varList.createIterator() ;

  TMatrixDSym xysum(varList.getSize()) ;
  vector<double> xsum(varList.getSize()) ;
  vector<double> x2sum(varList.getSize()) ;

  // Calculate <x_i> and <x_i y_j>
  for(Int_t index= 0; index < numEntries(); index++) {
    const RooArgSet* dvars = get(index) ;
    if (select && select->eval()==0) continue ;
    if (cutRange && dvars->allInRange(cutRange)) continue ;

    RooRealVar* varx, *vary ;
    iter->Reset() ;
    Int_t ix=0,iy=0 ;
    while((varx=(RooRealVar*)iter->Next())) {
      xsum[ix] += weight()*varx->getVal() ;
      if (corr) {
	x2sum[ix] += weight()*varx->getVal()*varx->getVal() ;
      }	

      *iter2=*iter ; iy=ix ;
      vary=varx ;
      while(vary) {
	xysum(ix,iy) += weight()*varx->getVal()*vary->getVal() ;
	xysum(iy,ix) = xysum(ix,iy) ;
	iy++ ;
	vary=(RooRealVar*)iter2->Next() ;
      }
      ix++ ;
    }
    
  }

  // Normalize sums 
  for (Int_t ix=0 ; ix<varList.getSize() ; ix++) {
    xsum[ix] /= sumEntries(cutSpec, cutRange) ;
    if (corr) {
      x2sum[ix] /= sumEntries(cutSpec, cutRange) ;
    }
    for (Int_t iy=0 ; iy<varList.getSize() ; iy++) {      
      xysum(ix,iy) /= sumEntries(cutSpec, cutRange) ;
    }
  }    

  // Calculate covariance matrix
  TMatrixDSym* C = new TMatrixDSym(varList.getSize()) ;
  for (Int_t ix=0 ; ix<varList.getSize() ; ix++) {
    for (Int_t iy=0 ; iy<varList.getSize() ; iy++) {      
      (*C)(ix,iy) = xysum(ix,iy)-xsum[ix]*xsum[iy] ;
      if (corr) {
	(*C)(ix,iy) /= sqrt((x2sum[ix]-(xsum[ix]*xsum[ix]))*(x2sum[iy]-(xsum[iy]*xsum[iy]))) ;
      }
    }    
  }

  if (select) delete select ;
  delete iter ;
  delete iter2 ;

  return C ;
}



//_____________________________________________________________________________
RooRealVar* RooAbsData::meanVar(RooRealVar &var, const char* cutSpec, const char* cutRange) const
{
  // Create a RooRealVar containing the mean of observable 'var' in
  // this dataset.  If cutSpec and/or cutRange are specified the
  // moment is calculated on the subset of the data which pass the C++
  // cut specification expression 'cutSpec' and/or are inside the
  // range named 'cutRange'
  
  // Create a new variable with appropriate strings. The error is calculated as
  // RMS/Sqrt(N) which is generally valid.

  // Create holder variable for mean
  TString name(var.GetName()),title("Mean of ") ;
  name.Append("Mean");
  title.Append(var.GetTitle());
  RooRealVar *meanv= new RooRealVar(name,title,0) ;
  meanv->setConstant(kFALSE) ;

  // Adjust plot label
  TString label("<") ;
  label.Append(var.getPlotLabel());
  label.Append(">");
  meanv->setPlotLabel(label.Data());

  // fill in this variable's value and error
  Double_t meanVal=moment(var,1,0,cutSpec,cutRange) ;
  Double_t N(sumEntries(cutSpec,cutRange)) ;

  Double_t rmsVal= sqrt(moment(var,2,meanVal,cutSpec,cutRange)*N/(N-1));
  meanv->setVal(meanVal) ;
  meanv->setError(N > 0 ? rmsVal/sqrt(N) : 0);

  return meanv;
}



//_____________________________________________________________________________
RooRealVar* RooAbsData::rmsVar(RooRealVar &var, const char* cutSpec, const char* cutRange) const
{
  // Create a RooRealVar containing the RMS of observable 'var' in
  // this dataset.  If cutSpec and/or cutRange are specified the
  // moment is calculated on the subset of the data which pass the C++
  // cut specification expression 'cutSpec' and/or are inside the
  // range named 'cutRange'

  // Create a new variable with appropriate strings. The error is calculated as
  // RMS/(2*Sqrt(N)) which is only valid if the variable has a Gaussian distribution.

  // Create RMS value holder
  TString name(var.GetName()),title("RMS of ") ;
  name.Append("RMS");
  title.Append(var.GetTitle());
  RooRealVar *rms= new RooRealVar(name,title,0) ;
  rms->setConstant(kFALSE) ;

  // Adjust plot label
  TString label(var.getPlotLabel());
  label.Append("_{RMS}");
  rms->setPlotLabel(label);

  // Fill in this variable's value and error
  Double_t meanVal(moment(var,1,0,cutSpec,cutRange)) ;
  Double_t N(sumEntries(cutSpec, cutRange));
  Double_t rmsVal= sqrt(moment(var,2,meanVal,cutSpec,cutRange)*N/(N-1));
  rms->setVal(rmsVal) ;
  rms->setError(rmsVal/sqrt(2*N));

  return rms;
}


//_____________________________________________________________________________
RooPlot* RooAbsData::statOn(RooPlot* frame, const RooCmdArg& arg1, const RooCmdArg& arg2, 
			    const RooCmdArg& arg3, const RooCmdArg& arg4, const RooCmdArg& arg5, 
			    const RooCmdArg& arg6, const RooCmdArg& arg7, const RooCmdArg& arg8)
{
  // Add a box with statistics information to the specified frame. By default a box with the
  // event count, mean and rms of the plotted variable is added.
  //
  // The following optional named arguments are accepted
  //
  //   What(const char* whatstr)          -- Controls what is printed: "N" = count, "M" is mean, "R" is RMS.
  //   Format(const char* optStr)         -- Classing [arameter formatting options, provided for backward compatibility
  //   Format(const char* what,...)       -- Parameter formatting options, details given below
  //   Label(const chat* label)           -- Add header label to parameter box
  //   Layout(Double_t xmin,              -- Specify relative position of left,right side of box and top of box. Position of 
  //       Double_t xmax, Double_t ymax)     bottom of box is calculated automatically from number lines in box
  //   Cut(const char* expression)        -- Apply given cut expression to data when calculating statistics
  //   CutRange(const char* rangeName)    -- Only consider events within given range when calculating statistics. Multiple
  //                                         CutRange() argument may be specified to combine ranges
  //
  // The Format(const char* what,...) has the following structure
  //
  //   const char* what          -- Controls what is shown. "N" adds name, "E" adds error, 
  //                                "A" shows asymmetric error, "U" shows unit, "H" hides the value
  //   FixedPrecision(int n)     -- Controls precision, set fixed number of digits
  //   AutoPrecision(int n)      -- Controls precision. Number of shown digits is calculated from error 
  //                                + n specified additional digits (1 is sensible default)
  //   VerbatimName(Bool_t flag) -- Put variable name in a \verb+   + clause.
  //

  // Stuff all arguments in a list
  RooLinkedList cmdList;
  cmdList.Add(const_cast<RooCmdArg*>(&arg1)) ;  cmdList.Add(const_cast<RooCmdArg*>(&arg2)) ;
  cmdList.Add(const_cast<RooCmdArg*>(&arg3)) ;  cmdList.Add(const_cast<RooCmdArg*>(&arg4)) ;
  cmdList.Add(const_cast<RooCmdArg*>(&arg5)) ;  cmdList.Add(const_cast<RooCmdArg*>(&arg6)) ;
  cmdList.Add(const_cast<RooCmdArg*>(&arg7)) ;  cmdList.Add(const_cast<RooCmdArg*>(&arg8)) ;

  // Select the pdf-specific commands 
  RooCmdConfig pc(Form("RooTreeData::statOn(%s)",GetName())) ;
  pc.defineString("what","What",0,"MNR") ;
  pc.defineString("label","Label",0,"") ;
  pc.defineDouble("xmin","Layout",0,0.65) ;
  pc.defineDouble("xmax","Layout",1,0.99) ;
  pc.defineInt("ymaxi","Layout",0,Int_t(0.95*10000)) ;
  pc.defineString("formatStr","Format",0,"NELU") ;
  pc.defineInt("sigDigit","Format",0,2) ;
  pc.defineInt("dummy","FormatArgs",0,0) ;
  pc.defineString("cutRange","CutRange",0,"",kTRUE) ;
  pc.defineString("cutString","CutSpec",0,"") ;
  pc.defineMutex("Format","FormatArgs") ;

  // Process and check varargs 
  pc.process(cmdList) ;
  if (!pc.ok(kTRUE)) {
    return frame ;
  }

  const char* label = pc.getString("label") ;
  Double_t xmin = pc.getDouble("xmin") ;
  Double_t xmax = pc.getDouble("xmax") ;
  Double_t ymax = pc.getInt("ymaxi") / 10000. ;
  const char* formatStr = pc.getString("formatStr") ;
  Int_t sigDigit = pc.getInt("sigDigit") ;  
  const char* what = pc.getString("what") ;

  const char* cutSpec = pc.getString("cutString",0,kTRUE) ;
  const char* cutRange = pc.getString("cutRange",0,kTRUE) ;

  if (pc.hasProcessed("FormatArgs")) {
    RooCmdArg* formatCmd = static_cast<RooCmdArg*>(cmdList.FindObject("FormatArgs")) ;
    return statOn(frame,what,label,0,0,xmin,xmax,ymax,cutSpec,cutRange,formatCmd) ;
  } else {
    return statOn(frame,what,label,sigDigit,formatStr,xmin,xmax,ymax,cutSpec,cutRange) ;
  }
}



//_____________________________________________________________________________
RooPlot* RooAbsData::statOn(RooPlot* frame, const char* what, const char *label, Int_t sigDigits,
			     Option_t *options, Double_t xmin, Double_t xmax, Double_t ymax, 
			     const char* cutSpec, const char* cutRange, const RooCmdArg* formatCmd) 
{
  // Implementation back-end of statOn() mehtod with named arguments

  Bool_t showLabel= (label != 0 && strlen(label) > 0);

  TString whatStr(what) ;
  whatStr.ToUpper() ;
  Bool_t showN = whatStr.Contains("N") ;
  Bool_t showR = whatStr.Contains("R") ;
  Bool_t showM = whatStr.Contains("M") ;
  Int_t nPar= 0;
  if (showN) nPar++ ;
  if (showR) nPar++ ;
  if (showM) nPar++ ;

  // calculate the box's size
  Double_t dy(0.06), ymin(ymax-nPar*dy);
  if(showLabel) ymin-= dy;

  // create the box and set its options
  TPaveText *box= new TPaveText(xmin,ymax,xmax,ymin,"BRNDC");
  if(!box) return 0;
  box->SetName(Form("%s_statBox",GetName())) ;
  box->SetFillColor(0);
  box->SetBorderSize(1);
  box->SetTextAlign(12);
  box->SetTextSize(0.04F);
  box->SetFillStyle(1001);

  // add formatted text for each statistic
  RooRealVar N("N","Number of Events",sumEntries(cutSpec,cutRange));
  N.setPlotLabel("Entries") ;
  RooRealVar *meanv= meanVar(*(RooRealVar*)frame->getPlotVar(),cutSpec,cutRange);
  meanv->setPlotLabel("Mean") ;
  RooRealVar *rms= rmsVar(*(RooRealVar*)frame->getPlotVar(),cutSpec,cutRange);
  rms->setPlotLabel("RMS") ;
  TString *rmsText, *meanText, *NText ;
  if (options) {
    rmsText= rms->format(sigDigits,options);
    meanText= meanv->format(sigDigits,options);
    NText= N.format(sigDigits,options);
  } else {
    rmsText= rms->format(*formatCmd);
    meanText= meanv->format(*formatCmd);
    NText= N.format(*formatCmd);
  }
  if (showR) box->AddText(rmsText->Data());
  if (showM) box->AddText(meanText->Data());
  if (showN) box->AddText(NText->Data());

  // cleanup heap memory
  delete NText;
  delete meanText;
  delete rmsText;
  delete meanv;
  delete rms;

  // add the optional label if specified
  if(showLabel) box->AddText(label);

  frame->addObject(box) ;
  return frame ;
}




//_____________________________________________________________________________
TH1 *RooAbsData::fillHistogram(TH1 *hist, const RooArgList &plotVars, const char *cuts, const char* cutRange) const
{
  // Loop over columns of our tree data and fill the input histogram. Returns a pointer to the
  // input histogram, or zero in case of an error. The input histogram can be any TH1 subclass, and
  // therefore of arbitrary dimension. Variables are matched with the (x,y,...) dimensions of the input
  // histogram according to the order in which they appear in the input plotVars list.

  // Do we have a valid histogram to use?
  if(0 == hist) {
    coutE(InputArguments) << ClassName() << "::" << GetName() << ":fillHistogram: no valid histogram to fill" << endl;
    return 0;
  }

  // Check that the number of plotVars matches the input histogram's dimension
  Int_t hdim= hist->GetDimension();
  if(hdim != plotVars.getSize()) {
    coutE(InputArguments) << ClassName() << "::" << GetName() << ":fillHistogram: plotVars has the wrong dimension" << endl;
    return 0;
  }

  // Check that the plot variables are all actually RooAbsReal's and print a warning if we do not
  // explicitly depend on one of them. Clone any variables that we do not contain directly and
  // redirect them to use our event data.
  RooArgSet plotClones,localVars;
  for(Int_t index= 0; index < plotVars.getSize(); index++) {
    const RooAbsArg *var= plotVars.at(index);
    const RooAbsReal *realVar= dynamic_cast<const RooAbsReal*>(var);
    if(0 == realVar) {
      coutE(InputArguments) << ClassName() << "::" << GetName() << ":fillHistogram: cannot plot variable \"" << var->GetName()
	   << "\" of type " << var->ClassName() << endl;
      return 0;
    }
    RooAbsArg *found= _vars.find(realVar->GetName());
    if(!found) {
      RooAbsArg *clone= plotClones.addClone(*realVar,kTRUE); // do not complain about duplicates
      assert(0 != clone);
      if(!clone->dependsOn(_vars)) {
	coutW(InputArguments) << ClassName() << "::" << GetName()
	     << ":fillHistogram: WARNING: data does not contain variable: " << realVar->GetName() << endl;
      }
      else {
	clone->recursiveRedirectServers(_vars);
      }
      localVars.add(*clone);
    }
    else {
      localVars.add(*found);
    }
  }

  // Create selection formula if selection cuts are specified
  RooFormula* select = 0;
  if(0 != cuts && strlen(cuts)) {
    select=new RooFormula(cuts,cuts,_vars);
    if (!select || !select->ok()) {
      coutE(InputArguments) << ClassName() << "::" << GetName() << ":fillHistogram: invalid cuts \"" << cuts << "\"" << endl;
      delete select;
      return 0 ;
    }
  }
  
  // Lookup each of the variables we are binning in our tree variables
  const RooAbsReal *xvar = 0;
  const RooAbsReal *yvar = 0;
  const RooAbsReal *zvar = 0;
  switch(hdim) {
  case 3:
    zvar= dynamic_cast<RooAbsReal*>(localVars.find(plotVars.at(2)->GetName()));
    assert(0 != zvar);
    // fall through to next case...
  case 2:
    yvar= dynamic_cast<RooAbsReal*>(localVars.find(plotVars.at(1)->GetName()));
    assert(0 != yvar);
    // fall through to next case...
  case 1:
    xvar= dynamic_cast<RooAbsReal*>(localVars.find(plotVars.at(0)->GetName()));
    assert(0 != xvar);
    break;
  default:
    coutE(InputArguments) << ClassName() << "::" << GetName() << ":fillHistogram: cannot fill histogram with "
	 << hdim << " dimensions" << endl;
    break;
  }

  // Parse cutRange specification
  vector<string> cutVec ;
  if (cutRange && strlen(cutRange)>0) {
    if (strchr(cutRange,',')==0) {
      cutVec.push_back(cutRange) ;
    } else {
      const size_t bufSize = strlen(cutRange)+1;
      char* buf = new char[bufSize] ;
      strlcpy(buf,cutRange,bufSize) ;
      const char* oneRange = strtok(buf,",") ;
      while(oneRange) {
	cutVec.push_back(oneRange) ;
	oneRange = strtok(0,",") ;
      }
      delete[] buf ;
    }
  }

  // Loop over events and fill the histogram  
  if (hist->GetSumw2()->fN==0) {    
    hist->Sumw2() ;
  }
  Int_t nevent= numEntries() ; //(Int_t)_tree->GetEntries();
  for(Int_t i=0; i < nevent; ++i) {

    //Int_t entryNumber= _tree->GetEntryNumber(i);
    //if (entryNumber<0) break;
    get(i);

    // Apply expression based selection criteria
    if (select && select->eval()==0) {
      continue ;
    }


    // Apply range based selection criteria
    Bool_t selectByRange = kTRUE ;
    if (cutRange) {
      _iterator->Reset() ;
      RooAbsArg* arg ;
      while((arg=(RooAbsArg*)_iterator->Next())) {
	Bool_t selectThisArg = kFALSE ;
	UInt_t icut ;
	for (icut=0 ; icut<cutVec.size() ; icut++) {
	  if (arg->inRange(cutVec[icut].c_str())) {
	    selectThisArg = kTRUE ;
	    break ;
	  }
	}
	if (!selectThisArg) {
	  selectByRange = kFALSE ;
	  break ;
	}
      }
    }

    if (!selectByRange) {
      // Go to next event in loop over events
      continue ;
    }

    Int_t bin(0);
    switch(hdim) {
    case 1:
      bin= hist->FindBin(xvar->getVal());
      hist->Fill(xvar->getVal(),weight()) ;
      break;
    case 2:
      bin= hist->FindBin(xvar->getVal(),yvar->getVal());
      static_cast<TH2*>(hist)->Fill(xvar->getVal(),yvar->getVal(),weight()) ;
      break;
    case 3:
      bin= hist->FindBin(xvar->getVal(),yvar->getVal(),zvar->getVal());
      static_cast<TH3*>(hist)->Fill(xvar->getVal(),yvar->getVal(),zvar->getVal(),weight()) ;
      break;
    default:
      assert(hdim < 3);
      break;
    }


    Double_t error2 = TMath::Power(hist->GetBinError(bin),2)-TMath::Power(weight(),2)  ;
    Double_t we = weightError(RooAbsData::SumW2) ;    
    if (we==0) we = weight() ;
    error2 += TMath::Power(we,2) ;
    

//     Double_t we = weightError(RooAbsData::SumW2) ;    
//     Double_t error2(0) ;
//     if (we==0) {      
//       we = weight() ; //sqrt(weight()) ;
//       error2 = TMath::Power(hist->GetBinError(bin),2)-TMath::Power(weight(),2) + TMath::Power(we,2) ;
//     } else {
//       error2 = TMath::Power(hist->GetBinError(bin),2)-TMath::Power(weight(),2) + TMath::Power(we,2) ;
//     }
    //hist->AddBinContent(bin,weight());
    hist->SetBinError(bin,sqrt(error2)) ;

    //cout << "RooTreeData::fillHistogram() bin = " << bin << " weight() = " << weight() << " we = " << we << endl ;

  }

  if(0 != select) delete select;

  return hist;
}



//_____________________________________________________________________________
TList* RooAbsData::split(const RooAbsCategory& splitCat, Bool_t createEmptyDataSets) const
{
  // Split dataset into subsets based on states of given splitCat in this dataset.
  // A TList of RooDataSets is returned in which each RooDataSet is named
  // after the state name of splitCat of which it contains the dataset subset.
  // The observables splitCat itself is no longer present in the sub datasets.
  // If createEmptyDataSets is kFALSE (default) this method only creates datasets for states 
  // which have at least one entry The caller takes ownership of the returned list and its contents

  // Sanity check
  if (!splitCat.dependsOn(*get())) {
    coutE(InputArguments) << "RooTreeData::split(" << GetName() << ") ERROR category " << splitCat.GetName() 
	 << " doesn't depend on any variable in this dataset" << endl ;
    return 0 ;
  }

  // Clone splitting category and attach to self
  RooAbsCategory* cloneCat =0;
  RooArgSet* cloneSet = 0;
  if (splitCat.isDerived()) {
    cloneSet = (RooArgSet*) RooArgSet(splitCat).snapshot(kTRUE) ;
    if (!cloneSet) {
      coutE(InputArguments) << "RooTreeData::split(" << GetName() << ") Couldn't deep-clone splitting category, abort." << endl ;
      return 0 ;
    }
    cloneCat = (RooAbsCategory*) cloneSet->find(splitCat.GetName()) ;
    cloneCat->attachDataSet(*this) ;
  } else {
    cloneCat = dynamic_cast<RooAbsCategory*>(get()->find(splitCat.GetName())) ;
    if (!cloneCat) {
      coutE(InputArguments) << "RooTreeData::split(" << GetName() << ") ERROR category " << splitCat.GetName() 
	   << " is fundamental and does not appear in this dataset" << endl ;
      return 0 ;      
    }
  }

  // Split a dataset in a series of subsets, each corresponding
  // to a state of splitCat
  TList* dsetList = new TList ;

  // Construct set of variables to be included in split sets = full set - split category
  RooArgSet subsetVars(*get()) ;
  if (splitCat.isDerived()) {
    RooArgSet* vars = splitCat.getVariables() ;
    subsetVars.remove(*vars,kTRUE,kTRUE) ;
    delete vars ;
  } else {
    subsetVars.remove(splitCat,kTRUE,kTRUE) ;
  }

  // Add weight variable explicitly if dataset has weights, but no top-level weight
  // variable exists (can happen with composite datastores)
  Bool_t addWV(kFALSE) ;
  RooRealVar newweight("weight","weight",-1e9,1e9) ;
  if (isWeighted() && !IsA()->InheritsFrom(RooDataHist::Class())) {
    subsetVars.add(newweight) ;
    addWV = kTRUE ;
  }

  // If createEmptyDataSets is true, prepopulate with empty sets corresponding to all states
  if (createEmptyDataSets) {
    TIterator* stateIter = cloneCat->typeIterator() ;
    RooCatType* state ;
    while ((state=(RooCatType*)stateIter->Next())) {
      RooAbsData* subset = emptyClone(state->GetName(),state->GetName(),&subsetVars,(addWV?"weight":0)) ;
      dsetList->Add((RooAbsArg*)subset) ;    
    }
    delete stateIter ;
  }

  
  // Loop over dataset and copy event to matching subset
  const bool propWeightSquared = isWeighted();
  for (Int_t i = 0; i < numEntries(); ++i) {
    const RooArgSet* row =  get(i);
    RooAbsData* subset = (RooAbsData*) dsetList->FindObject(cloneCat->getLabel());
    if (!subset) {
      subset = emptyClone(cloneCat->getLabel(),cloneCat->getLabel(),&subsetVars,(addWV?"weight":0));
      dsetList->Add((RooAbsArg*)subset);
    }
    if (!propWeightSquared) {
	subset->add(*row, weight());
    } else {
	subset->add(*row, weight(), weightSquared());
    }
  }

  delete cloneSet;
  return dsetList;
}



//_____________________________________________________________________________
RooPlot* RooAbsData::plotOn(RooPlot* frame, const RooLinkedList& argList) const
{
  // Plot dataset on specified frame. By default an unbinned dataset will use the default binning of
  // the target frame. A binned dataset will by default retain its intrinsic binning.
  //
  // The following optional named arguments can be used to modify the default behavior
  //
  // Data representation options
  // ---------------------------
  // Asymmetry(const RooCategory& c) -- Show the asymmetry of the data in given two-state category [F(+)-F(-)] / [F(+)+F(-)]. 
  //                                    Category must have two states with indices -1 and +1 or three states with indeces -1,0 and +1.
  // Efficiency(const RooCategory& c)-- Show the efficiency F(acc)/[F(acc)+F(rej)]. Category must have two states with indices 0 and 1
  // DataError(RooAbsData::EType)    -- Select the type of error drawn: 
  //                                     - Auto(default) results in Poisson for unweighted data and SumW2 for weighted data
  //                                     - Poisson draws asymmetric Poisson confidence intervals. 
  //                                     - SumW2 draws symmetric sum-of-weights error ( sum(w)^2/sum(w^2) )
  //                                     - None draws no error bars
  // Binning(int nbins, double xlo, double xhi) -- Use specified binning to draw dataset
  // Binning(const RooAbsBinning&)   -- Use specified binning to draw dataset
  // Binning(const char* name)       -- Use binning with specified name to draw dataset
  // RefreshNorm(Bool_t flag)        -- Force refreshing for PDF normalization information in frame.
  //                                    If set, any subsequent PDF will normalize to this dataset, even if it is
  //                                    not the first one added to the frame. By default only the 1st dataset
  //                                    added to a frame will update the normalization information
  // Rescale(Double_t f)             -- Rescale drawn histogram by given factor
  //
  // Histogram drawing options
  // -------------------------
  // DrawOption(const char* opt)     -- Select ROOT draw option for resulting TGraph object
  // LineStyle(Int_t style)          -- Select line style by ROOT line style code, default is solid
  // LineColor(Int_t color)          -- Select line color by ROOT color code, default is black
  // LineWidth(Int_t width)          -- Select line with in pixels, default is 3
  // MarkerStyle(Int_t style)        -- Select the ROOT marker style, default is 21
  // MarkerColor(Int_t color)        -- Select the ROOT marker color, default is black
  // MarkerSize(Double_t size)       -- Select the ROOT marker size
  // FillStyle(Int_t style)          -- Select fill style, default is filled. 
  // FillColor(Int_t color)          -- Select fill color by ROOT color code
  // XErrorSize(Double_t frac)       -- Select size of X error bar as fraction of the bin width, default is 1
  //
  //
  // Misc. other options
  // -------------------
  // Name(const chat* name)          -- Give curve specified name in frame. Useful if curve is to be referenced later
  // Invisble()                      -- Add curve to frame, but do not display. Useful in combination AddTo()
  // AddTo(const char* name,         -- Add constructed histogram to already existing histogram with given name and relative weight factors
  // double_t wgtSelf, double_t wgtOther)
  // 
  //                                    
  //

  // New experimental plotOn() with varargs...

  // Define configuration for this method
  RooCmdConfig pc(Form("RooTreeData::plotOn(%s)",GetName())) ;
  pc.defineString("drawOption","DrawOption",0,"P") ;
  pc.defineString("cutRange","CutRange",0,"",kTRUE) ;
  pc.defineString("cutString","CutSpec",0,"") ;
  pc.defineString("histName","Name",0,"") ;
  pc.defineObject("cutVar","CutVar",0) ;
  pc.defineObject("binning","Binning",0) ;
  pc.defineString("binningName","BinningName",0,"") ;
  pc.defineInt("nbins","BinningSpec",0,100) ;
  pc.defineDouble("xlo","BinningSpec",0,0) ;
  pc.defineDouble("xhi","BinningSpec",1,1) ;
  pc.defineObject("asymCat","Asymmetry",0) ;
  pc.defineObject("effCat","Efficiency",0) ;
  pc.defineInt("lineColor","LineColor",0,-999) ;
  pc.defineInt("lineStyle","LineStyle",0,-999) ;
  pc.defineInt("lineWidth","LineWidth",0,-999) ;
  pc.defineInt("markerColor","MarkerColor",0,-999) ;
  pc.defineInt("markerStyle","MarkerStyle",0,-999) ;
  pc.defineDouble("markerSize","MarkerSize",0,-999) ;
  pc.defineInt("fillColor","FillColor",0,-999) ;
  pc.defineInt("fillStyle","FillStyle",0,-999) ;
  pc.defineInt("errorType","DataError",0,(Int_t)RooAbsData::Auto) ;
  pc.defineInt("histInvisible","Invisible",0,0) ;
  pc.defineInt("refreshFrameNorm","RefreshNorm",0,1) ;
  pc.defineString("addToHistName","AddTo",0,"") ;
  pc.defineDouble("addToWgtSelf","AddTo",0,1.) ;
  pc.defineDouble("addToWgtOther","AddTo",1,1.) ;
  pc.defineDouble("xErrorSize","XErrorSize",0,1.) ;
  pc.defineDouble("scaleFactor","Rescale",0,1.) ;
  pc.defineMutex("DataError","Asymmetry","Efficiency") ;
  pc.defineMutex("Binning","BinningName","BinningSpec") ;

  // Process & check varargs 
  pc.process(argList) ;
  if (!pc.ok(kTRUE)) {
    return frame ;
  }

  PlotOpt o ;

  // Extract values from named arguments
  o.drawOptions = pc.getString("drawOption") ;
  o.cuts = pc.getString("cutString") ;
  if (pc.hasProcessed("Binning")) {
    o.bins = (RooAbsBinning*) pc.getObject("binning") ;
  } else if (pc.hasProcessed("BinningName")) {
    o.bins = &frame->getPlotVar()->getBinning(pc.getString("binningName")) ;
  } else if (pc.hasProcessed("BinningSpec")) {
    Double_t xlo = pc.getDouble("xlo") ;
    Double_t xhi = pc.getDouble("xhi") ;
    o.bins = new RooUniformBinning((xlo==xhi)?frame->getPlotVar()->getMin():xlo,
				   (xlo==xhi)?frame->getPlotVar()->getMax():xhi,pc.getInt("nbins")) ;
  }
  const RooAbsCategoryLValue* asymCat = (const RooAbsCategoryLValue*) pc.getObject("asymCat") ;
  const RooAbsCategoryLValue* effCat = (const RooAbsCategoryLValue*) pc.getObject("effCat") ;
  o.etype = (RooAbsData::ErrorType) pc.getInt("errorType") ;
  o.histInvisible = pc.getInt("histInvisible") ;
  o.xErrorSize = pc.getDouble("xErrorSize") ;
  o.cutRange = pc.getString("cutRange",0,kTRUE) ;
  o.histName = pc.getString("histName",0,kTRUE) ;
  o.addToHistName = pc.getString("addToHistName",0,kTRUE) ;
  o.addToWgtSelf = pc.getDouble("addToWgtSelf") ;
  o.addToWgtOther = pc.getDouble("addToWgtOther") ;
  o.refreshFrameNorm = pc.getInt("refreshFrameNorm") ;
  o.scaleFactor = pc.getDouble("scaleFactor") ;

  // Map auto error type to actual type
  if (o.etype == Auto) {
    o.etype = isNonPoissonWeighted() ? SumW2 : Poisson ;    
    if (o.etype == SumW2) {
      coutI(InputArguments) << "RooAbsData::plotOn(" << GetName() 
			    << ") INFO: dataset has non-integer weights, auto-selecting SumW2 errors instead of Poisson errors" << endl ;
    }
  }
  
  if (o.addToHistName && !frame->findObject(o.addToHistName,RooHist::Class())) {
    coutE(InputArguments) << "RooAbsData::plotOn(" << GetName() << ") cannot find existing histogram " << o.addToHistName 
			  << " to add to in RooPlot" << endl ;
    return frame ;
  }

  RooPlot* ret ;
  if (!asymCat && !effCat) {
    ret = plotOn(frame,o) ;
  } else if (asymCat) {
    ret = plotAsymOn(frame,*asymCat,o) ;    
  } else {
    ret = plotEffOn(frame,*effCat,o) ;    
  }

  Int_t lineColor   = pc.getInt("lineColor") ;
  Int_t lineStyle   = pc.getInt("lineStyle") ;
  Int_t lineWidth   = pc.getInt("lineWidth") ;
  Int_t markerColor = pc.getInt("markerColor") ;
  Int_t markerStyle = pc.getInt("markerStyle") ;
  Size_t markerSize  = pc.getDouble("markerSize") ;
  Int_t fillColor = pc.getInt("fillColor") ;
  Int_t fillStyle = pc.getInt("fillStyle") ;
  if (lineColor!=-999) ret->getAttLine()->SetLineColor(lineColor) ;
  if (lineStyle!=-999) ret->getAttLine()->SetLineStyle(lineStyle) ;
  if (lineWidth!=-999) ret->getAttLine()->SetLineWidth(lineWidth) ;
  if (markerColor!=-999) ret->getAttMarker()->SetMarkerColor(markerColor) ;
  if (markerStyle!=-999) ret->getAttMarker()->SetMarkerStyle(markerStyle) ;
  if (markerSize!=-999) ret->getAttMarker()->SetMarkerSize(markerSize) ;
  if (fillColor!=-999) ret->getAttFill()->SetFillColor(fillColor) ;
  if (fillStyle!=-999) ret->getAttFill()->SetFillStyle(fillStyle) ;

  if (pc.hasProcessed("BinningSpec")) {
    delete o.bins ;
  }

  return ret ;
}



//_____________________________________________________________________________
RooPlot *RooAbsData::plotOn(RooPlot *frame, PlotOpt o) const 
{
  // Create and fill a histogram of the frame's variable and append it to the frame.
  // The frame variable must be one of the data sets dimensions.
  //
  // The plot range and the number of plot bins is determined by the parameters
  // of the plot variable of the frame (RooAbsReal::setPlotRange(), RooAbsReal::setPlotBins())
  // 
  // The optional cut string expression can be used to select the events to be plotted.
  // The cut specification may refer to any variable contained in the data set
  //
  // The drawOptions are passed to the TH1::Draw() method

  if(0 == frame) {
    coutE(Plotting) << ClassName() << "::" << GetName() << ":plotOn: frame is null" << endl;
    return 0;
  }
  RooAbsRealLValue *var= (RooAbsRealLValue*) frame->getPlotVar();
  if(0 == var) {
    coutE(Plotting) << ClassName() << "::" << GetName()
	 << ":plotOn: frame does not specify a plot variable" << endl;
    return 0;
  }

  // create and fill a temporary histogram of this variable
  TString histName(GetName());
  histName.Append("_plot");
  TH1F *hist ;
    if (o.bins) {
    hist= static_cast<TH1F*>(var->createHistogram(histName.Data(), RooFit::AxisLabel("Events"), RooFit::Binning(*o.bins))) ;
  } else {
    hist= var->createHistogram(histName.Data(), "Events", 
			       frame->GetXaxis()->GetXmin(), frame->GetXaxis()->GetXmax(), frame->GetNbinsX());
  }

  // Keep track of sum-of-weights error
  hist->Sumw2() ;

  if(0 == fillHistogram(hist,RooArgList(*var),o.cuts,o.cutRange)) {
    coutE(Plotting) << ClassName() << "::" << GetName()
	 << ":plotOn: fillHistogram() failed" << endl;
    return 0;
  }

  // If frame has no predefined bin width (event density) it will be adjusted to 
  // our histograms bin width so we should force that bin width here
  Double_t nomBinWidth ;
  if (frame->getFitRangeNEvt()==0 && o.bins) {
    nomBinWidth = o.bins->averageBinWidth() ;
  } else {
    nomBinWidth = o.bins ? frame->getFitRangeBinW() : 0 ;
  }

  // convert this histogram to a RooHist object on the heap
  RooHist *graph= new RooHist(*hist,nomBinWidth,1,o.etype,o.xErrorSize,o.correctForBinWidth,o.scaleFactor); 
  if(0 == graph) {
    coutE(Plotting) << ClassName() << "::" << GetName()
	 << ":plotOn: unable to create a RooHist object" << endl;
    delete hist;
    return 0;
  }  

  // If the dataset variable has a wide range than the plot variable,
  // calculate the number of entries in the dataset in the plot variable fit range
  RooAbsRealLValue* dataVar = (RooAbsRealLValue*) _vars.find(var->GetName()) ;
  Double_t nEnt(sumEntries()) ;
  if (dataVar->getMin()<var->getMin() || dataVar->getMax()>var->getMax()) {
    RooAbsData* tmp = ((RooAbsData*)this)->reduce(*var) ;
    nEnt = tmp->sumEntries() ;
    delete tmp ;
  }

  // Store the number of entries before the cut, if any was made
  if ((o.cuts && strlen(o.cuts)) || o.cutRange) {
    coutI(Plotting) << "RooTreeData::plotOn: plotting " << hist->GetSum() << " events out of " << nEnt << " total events" << endl ;
    graph->setRawEntries(nEnt) ;
  }

  // Add self to other hist if requested
  if (o.addToHistName) {
    RooHist* otherGraph = static_cast<RooHist*>(frame->findObject(o.addToHistName,RooHist::Class())) ;

    if (!graph->hasIdenticalBinning(*otherGraph)) {
      coutE(Plotting) << "RooTreeData::plotOn: ERROR Histogram to be added to, '" << o.addToHistName << "',has different binning" << endl ;
      delete graph ;
      return frame ;
    }

    RooHist* sumGraph = new RooHist(*graph,*otherGraph,o.addToWgtSelf,o.addToWgtOther,o.etype) ;
    delete graph ;
    graph = sumGraph ;
  }  

  // Rename graph if requested
  if (o.histName) {
    graph->SetName(o.histName) ;
  } else {
    TString hname(Form("h_%s",GetName())) ;
    if (o.cutRange && strlen(o.cutRange)>0) {
      hname.Append(Form("_CutRange[%s]",o.cutRange)) ;
    } 
    if (o.cuts && strlen(o.cuts)>0) {
      hname.Append(Form("_Cut[%s]",o.cuts)) ;
    } 
    graph->SetName(hname.Data()) ;
  }
  
  // initialize the frame's normalization setup, if necessary
  frame->updateNormVars(_vars);


  // add the RooHist to the specified plot
  frame->addPlotable(graph,o.drawOptions,o.histInvisible,o.refreshFrameNorm);



  // cleanup
  delete hist;

  return frame;  
}




//_____________________________________________________________________________
RooPlot* RooAbsData::plotAsymOn(RooPlot* frame, const RooAbsCategoryLValue& asymCat, PlotOpt o) const 
{
  // Create and fill a histogram with the asymmetry N[+] - N[-] / ( N[+] + N[-] ),
  // where N(+/-) is the number of data points with asymCat=+1 and asymCat=-1 
  // as function of the frames variable. The asymmetry category 'asymCat' must
  // have exactly 2 (or 3) states defined with index values +1,-1 (and 0)
  // 
  // The plot range and the number of plot bins is determined by the parameters
  // of the plot variable of the frame (RooAbsReal::setPlotRange(), RooAbsReal::setPlotBins())
  // 
  // The optional cut string expression can be used to select the events to be plotted.
  // The cut specification may refer to any variable contained in the data set
  //
  // The drawOptions are passed to the TH1::Draw() method

  if(0 == frame) {
    coutE(Plotting) << ClassName() << "::" << GetName() << ":plotAsymOn: frame is null" << endl;
    return 0;
  }
  RooAbsRealLValue *var= (RooAbsRealLValue*) frame->getPlotVar();
  if(0 == var) {
    coutE(Plotting) << ClassName() << "::" << GetName()
	 << ":plotAsymOn: frame does not specify a plot variable" << endl;
    return 0;
  }

  // create and fill temporary histograms of this variable for each state
  TString hist1Name(GetName()),hist2Name(GetName());
  hist1Name.Append("_plot1");
  TH1F *hist1, *hist2 ;
  hist2Name.Append("_plot2");

  if (o.bins) {
    hist1= var->createHistogram(hist1Name.Data(), "Events", *o.bins) ;
    hist2= var->createHistogram(hist2Name.Data(), "Events", *o.bins) ;
  } else {
    hist1= var->createHistogram(hist1Name.Data(), "Events", 
				frame->GetXaxis()->GetXmin(), frame->GetXaxis()->GetXmax(),
				frame->GetNbinsX());
    hist2= var->createHistogram(hist2Name.Data(), "Events", 
				frame->GetXaxis()->GetXmin(), frame->GetXaxis()->GetXmax(),
				frame->GetNbinsX());
  }

  assert(0 != hist1 && 0 != hist2);

  TString cuts1,cuts2 ;
  if (o.cuts && strlen(o.cuts)) {
    cuts1 = Form("(%s)&&(%s>0)",o.cuts,asymCat.GetName());
    cuts2 = Form("(%s)&&(%s<0)",o.cuts,asymCat.GetName());
  } else {
    cuts1 = Form("(%s>0)",asymCat.GetName());
    cuts2 = Form("(%s<0)",asymCat.GetName());
  }

  if(0 == fillHistogram(hist1,RooArgList(*var),cuts1.Data(),o.cutRange) ||
     0 == fillHistogram(hist2,RooArgList(*var),cuts2.Data(),o.cutRange)) {
    coutE(Plotting) << ClassName() << "::" << GetName()
	 << ":plotAsymOn: createHistogram() failed" << endl;
    return 0;
  }

  // convert this histogram to a RooHist object on the heap
  RooHist *graph= new RooHist(*hist1,*hist2,0,1,o.etype,o.xErrorSize,kFALSE,o.scaleFactor);
  graph->setYAxisLabel(Form("Asymmetry in %s",asymCat.GetName())) ;

  // initialize the frame's normalization setup, if necessary
  frame->updateNormVars(_vars);

  // Rename graph if requested
  if (o.histName) {
    graph->SetName(o.histName) ;
  } else {
    TString hname(Form("h_%s_Asym[%s]",GetName(),asymCat.GetName())) ;
    if (o.cutRange && strlen(o.cutRange)>0) {
      hname.Append(Form("_CutRange[%s]",o.cutRange)) ;
    } 
    if (o.cuts && strlen(o.cuts)>0) {
      hname.Append(Form("_Cut[%s]",o.cuts)) ;
    } 
    graph->SetName(hname.Data()) ;
  }

  // add the RooHist to the specified plot
  frame->addPlotable(graph,o.drawOptions,o.histInvisible,o.refreshFrameNorm);

  // cleanup
  delete hist1;
  delete hist2;

  return frame;  
}



//_____________________________________________________________________________
RooPlot* RooAbsData::plotEffOn(RooPlot* frame, const RooAbsCategoryLValue& effCat, PlotOpt o) const 
{
  // Create and fill a histogram with the effiency N[1] / ( N[1] + N[0] ),
  // where N(1/0) is the number of data points with effCat=1 and effCat=0
  // as function of the frames variable. The efficiency category 'effCat' must
  // have exactly 2 +1 and 0.
  // 
  // The plot range and the number of plot bins is determined by the parameters
  // of the plot variable of the frame (RooAbsReal::setPlotRange(), RooAbsReal::setPlotBins())
  // 
  // The optional cut string expression can be used to select the events to be plotted.
  // The cut specification may refer to any variable contained in the data set
  //
  // The drawOptions are passed to the TH1::Draw() method

  if(0 == frame) {
    coutE(Plotting) << ClassName() << "::" << GetName() << ":plotEffOn: frame is null" << endl;
    return 0;
  }
  RooAbsRealLValue *var= (RooAbsRealLValue*) frame->getPlotVar();
  if(0 == var) {
    coutE(Plotting) << ClassName() << "::" << GetName()
	 << ":plotEffOn: frame does not specify a plot variable" << endl;
    return 0;
  }

  // create and fill temporary histograms of this variable for each state
  TString hist1Name(GetName()),hist2Name(GetName());
  hist1Name.Append("_plot1");
  TH1F *hist1, *hist2 ;
  hist2Name.Append("_plot2");

  if (o.bins) {
    hist1= var->createHistogram(hist1Name.Data(), "Events", *o.bins) ;
    hist2= var->createHistogram(hist2Name.Data(), "Events", *o.bins) ;
  } else {
    hist1= var->createHistogram(hist1Name.Data(), "Events", 
				frame->GetXaxis()->GetXmin(), frame->GetXaxis()->GetXmax(),
				frame->GetNbinsX());
    hist2= var->createHistogram(hist2Name.Data(), "Events", 
				frame->GetXaxis()->GetXmin(), frame->GetXaxis()->GetXmax(),
				frame->GetNbinsX());
  }

  assert(0 != hist1 && 0 != hist2);

  TString cuts1,cuts2 ;
  if (o.cuts && strlen(o.cuts)) {
    cuts1 = Form("(%s)&&(%s==1)",o.cuts,effCat.GetName());
    cuts2 = Form("(%s)&&(%s==0)",o.cuts,effCat.GetName());
  } else {
    cuts1 = Form("(%s==1)",effCat.GetName());
    cuts2 = Form("(%s==0)",effCat.GetName());
  }

  if(0 == fillHistogram(hist1,RooArgList(*var),cuts1.Data(),o.cutRange) ||
     0 == fillHistogram(hist2,RooArgList(*var),cuts2.Data(),o.cutRange)) {
    coutE(Plotting) << ClassName() << "::" << GetName()
	 << ":plotEffOn: createHistogram() failed" << endl;
    return 0;
  }

  // convert this histogram to a RooHist object on the heap
  RooHist *graph= new RooHist(*hist1,*hist2,0,1,o.etype,o.xErrorSize,kTRUE);
  graph->setYAxisLabel(Form("Efficiency of %s=%s",effCat.GetName(),effCat.lookupType(1)->GetName())) ;

  // initialize the frame's normalization setup, if necessary
  frame->updateNormVars(_vars);

  // Rename graph if requested
  if (o.histName) {
    graph->SetName(o.histName) ;
  } else {
    TString hname(Form("h_%s_Eff[%s]",GetName(),effCat.GetName())) ;
    if (o.cutRange && strlen(o.cutRange)>0) {
      hname.Append(Form("_CutRange[%s]",o.cutRange)) ;
    } 
    if (o.cuts && strlen(o.cuts)>0) {
      hname.Append(Form("_Cut[%s]",o.cuts)) ;
    } 
    graph->SetName(hname.Data()) ;
  }

  // add the RooHist to the specified plot
  frame->addPlotable(graph,o.drawOptions,o.histInvisible,o.refreshFrameNorm);

  // cleanup
  delete hist1;
  delete hist2;

  return frame;  
}


//_____________________________________________________________________________
Roo1DTable* RooAbsData::table(const RooAbsCategory& cat, const char* cuts, const char* /*opts*/) const
{
  // Create and fill a 1-dimensional table for given category column
  // This functions is the equivalent of plotOn() for category dimensions. 
  //
  // The optional cut string expression can be used to select the events to be tabulated
  // The cut specification may refer to any variable contained in the data set
  //
  // The option string is currently not used

  // First see if var is in data set 
  RooAbsCategory* tableVar = (RooAbsCategory*) _vars.find(cat.GetName()) ;
  RooArgSet *tableSet = 0;
  Bool_t ownPlotVar(kFALSE) ;
  if (!tableVar) {
    if (!cat.dependsOn(_vars)) {
      coutE(Plotting) << "RooTreeData::Table(" << GetName() << "): Argument " << cat.GetName() 
	   << " is not in dataset and is also not dependent on data set" << endl ;
      return 0 ; 
    }

    // Clone derived variable 
    tableSet = (RooArgSet*) RooArgSet(cat).snapshot(kTRUE) ;
    if (!tableSet) {
      coutE(Plotting) << "RooTreeData::table(" << GetName() << ") Couldn't deep-clone table category, abort." << endl ;
      return 0 ;
    }
    tableVar = (RooAbsCategory*) tableSet->find(cat.GetName()) ;
    ownPlotVar = kTRUE ;    

    //Redirect servers of derived clone to internal ArgSet representing the data in this set
    tableVar->recursiveRedirectServers(_vars) ;
  }

  TString tableName(GetName()) ;
  if (cuts && strlen(cuts)) {
    tableName.Append("(") ;
    tableName.Append(cuts) ;
    tableName.Append(")") ;    
  }
  Roo1DTable* table2 = tableVar->createTable(tableName) ;

  // Make cut selector if cut is specified
  RooFormulaVar* cutVar = 0;
  if (cuts && strlen(cuts)) {
    cutVar = new RooFormulaVar("cutVar",cuts,_vars) ;
  }

  // Dump contents   
  Int_t nevent= numEntries() ;
  for(Int_t i=0; i < nevent; ++i) {
    get(i);

    if (cutVar && cutVar->getVal()==0) continue ;
    
    table2->fill(*tableVar,weight()) ;
  }

  if (ownPlotVar) delete tableSet ;
  if (cutVar) delete cutVar ;

  return table2 ;
}


//_____________________________________________________________________________
Bool_t RooAbsData::getRange(RooRealVar& var, Double_t& lowest, Double_t& highest, Double_t marginFrac, Bool_t symMode) const 
{
  // Fill Doubles 'lowest' and 'highest' with the lowest and highest value of
  // observable 'var' in this dataset. If the return value is kTRUE and error
  // occurred

  // Lookup variable in dataset
  RooRealVar *varPtr= (RooRealVar*) _vars.find(var.GetName());
  if(0 == varPtr) {
    coutE(InputArguments) << "RooDataSet::getRange(" << GetName() << ") ERROR: unknown variable: " << var.GetName() << endl ;
    return kTRUE;
  }

  // Check if found variable is of type RooRealVar
  if (!dynamic_cast<RooRealVar*>(varPtr)) {
    coutE(InputArguments) << "RooDataSet::getRange(" << GetName() << ") ERROR: variable " << var.GetName() << " is not of type RooRealVar" << endl ;
    return kTRUE;
  }

  // Check if dataset is not empty
  if(sumEntries() == 0.) {
    coutE(InputArguments) << "RooDataSet::getRange(" << GetName() << ") WARNING: empty dataset" << endl ;
    return kTRUE;
  }

  // Look for highest and lowest value 
  lowest = RooNumber::infinity() ;
  highest = -RooNumber::infinity() ;
  for (Int_t i=0 ; i<numEntries() ; i++) {
    get(i) ;
    if (varPtr->getVal()<lowest) {
      lowest = varPtr->getVal() ;
    }
    if (varPtr->getVal()>highest) {
      highest = varPtr->getVal() ;
    }
  }  

  if (marginFrac>0) {
    if (symMode==kFALSE) {

      Double_t margin = marginFrac*(highest-lowest) ;    
      lowest -= margin ;
      highest += margin ; 
      if (lowest<var.getMin()) lowest = var.getMin() ;
      if (highest>var.getMax()) highest = var.getMax() ;

    } else {

      Double_t mom1 = moment(var,1) ;
      Double_t delta = ((highest-mom1)>(mom1-lowest)?(highest-mom1):(mom1-lowest))*(1+marginFrac) ;
      lowest = mom1-delta ;
      highest = mom1+delta ;
      if (lowest<var.getMin()) lowest = var.getMin() ;
      if (highest>var.getMax()) highest = var.getMax() ;

    }
  }
  
  return kFALSE ;
}




//_____________________________________________________________________________
void RooAbsData::optimizeReadingWithCaching(RooAbsArg& arg, const RooArgSet& cacheList, const RooArgSet& keepObsList)
{
  // Prepare dataset for use with cached constant terms listed in
  // 'cacheList' of expression 'arg'. Deactivate tree branches
  // for any dataset observable that is either not used at all,
  // or is used exclusively by cached branch nodes.

  RooArgSet pruneSet ;

  // Add unused observables in this dataset to pruneSet
  pruneSet.add(*get()) ;
  RooArgSet* usedObs = arg.getObservables(*this) ;
  pruneSet.remove(*usedObs,kTRUE,kTRUE) ;

  // Add observables exclusively used to calculate cached observables to pruneSet
  TIterator* vIter = get()->createIterator() ;
  RooAbsArg *var ;
  while ((var=(RooAbsArg*) vIter->Next())) {
    if (allClientsCached(var,cacheList)) {
      pruneSet.add(*var) ;
    }
  }
  delete vIter ;


  if (pruneSet.getSize()!=0) {

    // Go over all used observables and check if any of them have parameterized
    // ranges in terms of pruned observables. If so, remove those observable
    // from the pruning list
    TIterator* uIter = usedObs->createIterator() ;
    RooAbsArg* obs ;
    while((obs=(RooAbsArg*)uIter->Next())) {
      RooRealVar* rrv = dynamic_cast<RooRealVar*>(obs) ;
      if (rrv && !rrv->getBinning().isShareable()) {
	RooArgSet depObs ;
	RooAbsReal* loFunc = rrv->getBinning().lowBoundFunc() ;
	RooAbsReal* hiFunc = rrv->getBinning().highBoundFunc() ;
	if (loFunc) {
	  loFunc->leafNodeServerList(&depObs,0,kTRUE) ;
	}
	if (hiFunc) {
	  hiFunc->leafNodeServerList(&depObs,0,kTRUE) ;
	}
	if (depObs.getSize()>0) {
	  pruneSet.remove(depObs,kTRUE,kTRUE) ;
	}
      }
    }
    delete uIter ;
  }


  // Remove all observables in keep list from prune list
  pruneSet.remove(keepObsList,kTRUE,kTRUE) ;

  if (pruneSet.getSize()!=0) {
    
    // Deactivate tree branches here
    cxcoutI(Optimization) << "RooTreeData::optimizeReadingForTestStatistic(" << GetName() << "): Observables " << pruneSet
			    << " in dataset are either not used at all, orserving exclusively p.d.f nodes that are now cached, disabling reading of these observables for TTree" << endl ;
    setArgStatus(pruneSet,kFALSE) ;
  }

  delete usedObs ;
  
}


//_____________________________________________________________________________
Bool_t RooAbsData::allClientsCached(RooAbsArg* var, const RooArgSet& cacheList)
{
  // Utility function that determines if all clients of object 'var'
  // appear in given list of cached nodes.

  Bool_t ret(kTRUE), anyClient(kFALSE) ;

  TIterator* cIter = var->valueClientIterator() ;    
  RooAbsArg* client ;
  while ((client=(RooAbsArg*) cIter->Next())) {
    anyClient = kTRUE ;
    if (!cacheList.find(client->GetName())) {
      // If client is not cached recurse
      ret &= allClientsCached(client,cacheList) ;
    }
  }
  delete cIter ;
  
  return anyClient?ret:kFALSE ;
}



//_____________________________________________________________________________
void RooAbsData::attachBuffers(const RooArgSet& extObs) 
{ 
  _dstore->attachBuffers(extObs) ; 
}



//_____________________________________________________________________________
void RooAbsData::resetBuffers() 
{ 
  _dstore->resetBuffers() ; 
}
 



//_____________________________________________________________________________
Bool_t RooAbsData::canSplitFast() const 
{
  
  if (_ownedComponents.size()>0) {
    return kTRUE ;
  }
  return kFALSE ;
}



//_____________________________________________________________________________
RooAbsData* RooAbsData::getSimData(const char* name)
{
  map<string,RooAbsData*>::iterator i = _ownedComponents.find(name) ;
  if (i==_ownedComponents.end()) return 0 ;
  return i->second ;
}



//_____________________________________________________________________________
void RooAbsData::addOwnedComponent(const char* idxlabel, RooAbsData& data) 
{ 
  _ownedComponents[idxlabel]= &data ;
}


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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RooAbsData::Class(),this);

      // Convert on the fly to vector storage if that the current working default
      if (defaultStorageType==RooAbsData::Vector) {
	convertToVectorStore() ;
      }

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



//_____________________________________________________________________________
void RooAbsData::checkInit() const
{ 
  _dstore->checkInit() ; 
}


//_____________________________________________________________________________
void RooAbsData::Draw(Option_t* option) 
{ 
  // Forward draw command to data store
  if (_dstore) _dstore->Draw(option) ; 
}



//_____________________________________________________________________________
Bool_t RooAbsData::hasFilledCache() const 
{ 
  return _dstore->hasFilledCache() ; 
}


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