ROOT logo
/*****************************************************************************
 * Project: RooFit                                                           *
 * Package: RooFitCore                                                       *
 * @(#)root/roofitcore:$Id: RooAbsPdf.cxx 42241 2011-11-25 13:55:30Z wouter $
 * 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)             *
 *****************************************************************************/

//////////////////////////////////////////////////////////////////////////////
// 
// RooAbsPdf is the abstract interface for all probability density
// functions The class provides hybrid analytical/numerical
// normalization for its implementations, error tracing and a MC
// generator interface.
//
// A minimal implementation of a PDF class derived from RooAbsPdf
// should overload the evaluate() function. This functions should
// return PDFs value.
//
//
// [Normalization/Integration]
//
// Although the normalization of a PDF is an integral part of a
// probability density function, normalization is treated separately
// in RooAbsPdf. The reason is that a RooAbsPdf object is more than a
// PDF: it can be a building block for a more complex, composite PDF
// if any of its variables are functions instead of variables. In
// such cases the normalization of the composite may not be simply the
// integral over the dependents of the top level PDF as these are
// functions with potentially non-trivial Jacobian terms themselves.
// Therefore 
//
// --> No explicit attempt should be made to normalize 
//     the functions output in evaluate(). 
//
// In addition, RooAbsPdf objects do not have a static concept of what
// variables are parameters and what variables are dependents (which
// need to be integrated over for a correct PDF normalization). 
// Instead the choice of normalization is always specified each time a
// normalized values is requested from the PDF via the getVal()
// method.
//
// RooAbsPdf manages the entire normalization logic of each PDF with
// help of a RooRealIntegral object, which coordinates the integration
// of a given choice of normalization. By default, RooRealIntegral will
// perform a fully numeric integration of all dependents. However,
// PDFs can advertise one or more (partial) analytical integrals of
// their function, and these will be used by RooRealIntegral, if it
// determines that this is safe (i.e. no hidden Jacobian terms,
// multiplication with other PDFs that have one or more dependents in
// commen etc)
//
// To implement analytical integrals, two functions must be implemented. First,
//
// Int_t getAnalyticalIntegral(const RooArgSet& integSet, RooArgSet& anaIntSet)
// 
// advertises the analytical integrals that are supported. 'integSet'
// is the set of dependents for which integration is requested. The
// function should copy the subset of dependents it can analytically
// integrate to anaIntSet and return a unique identification code for
// this integration configuration.  If no integration can be
// performed, zero should be returned.  Second,
//
// Double_t analyticalIntegral(Int_t code)
//
// Implements the actual analytical integral(s) advertised by
// getAnalyticalIntegral.  This functions will only be called with
// codes returned by getAnalyticalIntegral, except code zero.
//
// The integration range for real each dependent to be integrated can
// be obtained from the dependents' proxy functions min() and
// max(). Never call these proxy functions for any proxy not known to
// be a dependent via the integration code.  Doing so may be
// ill-defined, e.g. in case the proxy holds a function, and will
// trigger an assert. Integrated category dependents should always be
// summed over all of their states.
//
//
//
// [Direct generation of observables]
//
// Any PDF dependent can be generated with the accept/reject method,
// but for certain PDFs more efficient methods may be implemented. To
// implement direct generation of one or more observables, two
// functions need to be implemented, similar to those for analytical
// integrals:
//
// Int_t getGenerator(const RooArgSet& generateVars, RooArgSet& directVars) and
// void generateEvent(Int_t code)
//
// The first function advertises observables that can be generated,
// similar to the way analytical integrals are advertised. The second
// function implements the generator for the advertised observables
//
// The generated dependent values should be store in the proxy
// objects. For this the assignment operator can be used (i.e. xProxy
// = 3.0 ). Never call assign to any proxy not known to be a dependent
// via the generation code.  Doing so may be ill-defined, e.g. in case
// the proxy holds a function, and will trigger an assert


#include "RooFit.h"
#include "RooMsgService.h" 

#include "TClass.h"
#include "Riostream.h"
#include "TMath.h"
#include "TObjString.h"
#include "TPaveText.h"
#include "TList.h"
#include "TH1.h"
#include "TH2.h"
#include "TMatrixD.h"
#include "TMatrixDSym.h"
#include "RooAbsPdf.h"
#include "RooDataSet.h"
#include "RooArgSet.h"
#include "RooArgProxy.h"
#include "RooRealProxy.h"
#include "RooRealVar.h"
#include "RooGenContext.h"
#include "RooBinnedGenContext.h"
#include "RooPlot.h"
#include "RooCurve.h"
#include "RooNLLVar.h"
#include "RooMinuit.h"
#include "RooCategory.h"
#include "RooNameReg.h"
#include "RooCmdConfig.h"
#include "RooGlobalFunc.h"
#include "RooAddition.h"
#include "RooRandom.h"
#include "RooNumIntConfig.h"
#include "RooProjectedPdf.h"
#include "RooInt.h"
#include "RooCustomizer.h"
#include "RooConstraintSum.h"
#include "RooParamBinning.h"
#include "RooNumCdf.h"
#include "RooFitResult.h"
#include "RooNumGenConfig.h"
#include "RooCachedReal.h"
#include "RooXYChi2Var.h"
#include "RooChi2Var.h"
#include "RooMinimizer.h"
#include "RooRealIntegral.h"
#include <string>

ClassImp(RooAbsPdf) 
;
ClassImp(RooAbsPdf::GenSpec)
;

Int_t RooAbsPdf::_verboseEval = 0;
Bool_t RooAbsPdf::_evalError = kFALSE ;
TString RooAbsPdf::_normRangeOverride ;

//_____________________________________________________________________________
RooAbsPdf::RooAbsPdf() : _norm(0), _normSet(0), _minDimNormValueCache(999), _valueCacheIntOrder(2), _specGeneratorConfig(0)
{
  // Default constructor
  _errorCount = 0 ;
  _negCount = 0 ;
  _rawValue = 0 ;
  _selectComp = kFALSE ;
  _traceCount = 0 ;
}



//_____________________________________________________________________________
RooAbsPdf::RooAbsPdf(const char *name, const char *title) : 
  RooAbsReal(name,title), _norm(0), _normSet(0), _minDimNormValueCache(999), _valueCacheIntOrder(2), _normMgr(this,10), _selectComp(kTRUE), _specGeneratorConfig(0)
{
  // Constructor with name and title only
  resetErrorCounters() ;
  setTraceCounter(0) ;
}



//_____________________________________________________________________________
RooAbsPdf::RooAbsPdf(const char *name, const char *title, 
		     Double_t plotMin, Double_t plotMax) :
  RooAbsReal(name,title,plotMin,plotMax), _norm(0), _normSet(0), _minDimNormValueCache(999), _valueCacheIntOrder(2), _normMgr(this,10), _selectComp(kTRUE), _specGeneratorConfig(0)
{
  // Constructor with name, title, and plot range
  resetErrorCounters() ;
  setTraceCounter(0) ;
}



//_____________________________________________________________________________
RooAbsPdf::RooAbsPdf(const RooAbsPdf& other, const char* name) : 
  RooAbsReal(other,name), _norm(0), _normSet(0), _minDimNormValueCache(other._minDimNormValueCache), _valueCacheIntOrder(other._valueCacheIntOrder),
  _normMgr(other._normMgr,this), _selectComp(other._selectComp), _normRange(other._normRange)
{
  // Copy constructor
  resetErrorCounters() ;
  setTraceCounter(other._traceCount) ;

  if (other._specGeneratorConfig) {
    _specGeneratorConfig = new RooNumGenConfig(*other._specGeneratorConfig) ;
  } else {
    _specGeneratorConfig = 0 ;
  }
}



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

  if (_specGeneratorConfig) delete _specGeneratorConfig ;
}



//_____________________________________________________________________________
Double_t RooAbsPdf::getValV(const RooArgSet* nset) const
{
  // Return current value, normalizated by integrating over
  // the observables in 'nset'. If 'nset' is 0, the unnormalized value. 
  // is returned. All elements of 'nset' must be lvalues
  //
  // Unnormalized values are not cached
  // Doing so would be complicated as _norm->getVal() could
  // spoil the cache and interfere with returning the cached
  // return value. Since unnormalized calls are typically
  // done in integration calls, there is no performance hit.

  // Fast-track processing of clean-cache objects
  //   if (_operMode==AClean) {
  //     cout << "RooAbsPdf::getValV(" << this << "," << GetName() << ") CLEAN  value = " << _value << endl ;
  //     return _value ;
  //   }

  // Special handling of case without normalization set (used in numeric integration of pdfs)
  if (!nset) {
    RooArgSet* tmp = _normSet ;
    _normSet = 0 ;
    Double_t val = evaluate() ;
    _normSet = tmp ;
    Bool_t error = traceEvalPdf(val) ;

    if (error) {
//       raiseEvalError() ;
      return 0 ;
    }
    return val ;
  }


  // Process change in last data set used
  Bool_t nsetChanged(kFALSE) ;
  if (nset!=_normSet || _norm==0) {
    nsetChanged = syncNormalization(nset) ;
  }

  // Return value of object. Calculated if dirty, otherwise cached value is returned.
  if (isValueDirty() || nsetChanged || _norm->isValueDirty()) {

    // Evaluate numerator
    Double_t rawVal = evaluate() ;
    Bool_t error = traceEvalPdf(rawVal) ; // Error checking and printing

    // Evaluate denominator
    Double_t normVal(_norm->getVal()) ;
    
    if (normVal<=0.) {
      error=kTRUE ;
      logEvalError("p.d.f normalization integral is zero or negative") ;  
    }

    // Raise global error flag if problems occur
    if (error) {
//       raiseEvalError() ;
      _value = 0 ;
    } else {
      _value = rawVal / normVal ;
//       cout << "RooAbsPdf::getValV(" << GetName() << ") writing _value = " << _value << endl ;
    }

    clearValueAndShapeDirty() ; //setValueDirty(kFALSE) ;
  } 

  return _value ;
}



//_____________________________________________________________________________
Double_t RooAbsPdf::analyticalIntegralWN(Int_t code, const RooArgSet* normSet, const char* rangeName) const
{
  // Analytical integral with normalization (see RooAbsReal::analyticalIntegralWN() for further information)
  //
  // This function applies the normalization specified by 'normSet' to the integral returned
  // by RooAbsReal::analyticalIntegral(). The passthrough scenario (code=0) is also changed
  // to return a normalized answer

  cxcoutD(Eval) << "RooAbsPdf::analyticalIntegralWN(" << GetName() << ") code = " << code << " normset = " << (normSet?*normSet:RooArgSet()) << endl ;


  if (code==0) return getVal(normSet) ;
  if (normSet) {
    return analyticalIntegral(code,rangeName) / getNorm(normSet) ;
  } else {
    return analyticalIntegral(code,rangeName) ;
  }
}



//_____________________________________________________________________________
Bool_t RooAbsPdf::traceEvalPdf(Double_t value) const
{
  // Check that passed value is positive and not 'not-a-number'.  If
  // not, print an error, until the error counter reaches its set
  // maximum.

  // check for a math error or negative value
  Bool_t error(kFALSE) ;
  if (isnan(value)) {
    logEvalError(Form("p.d.f value is Not-a-Number (%f), forcing value to zero",value)) ;
    error=kTRUE ;
  }
  if (value<0) {
    logEvalError(Form("p.d.f value is less than zero (%f), forcing value to zero",value)) ;
    error=kTRUE ;
  }
  
  // do nothing if we are no longer tracing evaluations and there was no error
  if(!error) return error ;

  // otherwise, print out this evaluations input values and result
  if(++_errorCount <= 10) {
    cxcoutD(Tracing) << "*** Evaluation Error " << _errorCount << " ";
    if(_errorCount == 10) cxcoutD(Tracing) << "(no more will be printed) ";
  }
  else {
    return error  ;
  }

  Print() ;
  return error ;
}




//_____________________________________________________________________________
Double_t RooAbsPdf::getNorm(const RooArgSet* nset) const
{
  // Return the integral of this PDF over all observables listed in 'nset'. 

  if (!nset) return 1 ;

  syncNormalization(nset,kTRUE) ;
  if (_verboseEval>1) cxcoutD(Tracing) << IsA()->GetName() << "::getNorm(" << GetName() << "): norm(" << _norm << ") = " << _norm->getVal() << endl ;

  Double_t ret = _norm->getVal() ;
  if (ret==0.) {
    if(++_errorCount <= 10) {
      coutW(Eval) << "RooAbsPdf::getNorm(" << GetName() << ":: WARNING normalization is zero, nset = " ;  nset->Print("1") ;
      if(_errorCount == 10) coutW(Eval) << "RooAbsPdf::getNorm(" << GetName() << ") INFO: no more messages will be printed " << endl ;
    }
  }

  return ret ;
}



//_____________________________________________________________________________
const RooAbsReal* RooAbsPdf::getNormObj(const RooArgSet* nset, const RooArgSet* iset, const TNamed* rangeName) const 
{
  // Return pointer to RooAbsReal object that implements calculation of integral over observables iset in range
  // rangeName, optionally taking the integrand normalized over observables nset


  // Check normalization is already stored
  CacheElem* cache = (CacheElem*) _normMgr.getObj(nset,iset,0,rangeName) ;
  if (cache) {
    return cache->_norm ;
  }

  // If not create it now
  RooArgSet* depList = getObservables(iset) ;
  RooAbsReal* norm = createIntegral(*depList,*nset, *getIntegratorConfig(), RooNameReg::str(rangeName)) ;
  delete depList ;

  // Store it in the cache
  cache = new CacheElem(*norm) ;
  _normMgr.setObj(nset,iset,cache,rangeName) ;

  // And return the newly created integral
  return norm ;
}



//_____________________________________________________________________________
Bool_t RooAbsPdf::syncNormalization(const RooArgSet* nset, Bool_t adjustProxies) const
{
  // Verify that the normalization integral cached with this PDF
  // is valid for given set of normalization observables
  //
  // If not, the cached normalization integral (if any) is deleted
  // and a new integral is constructed for use with 'nset'
  // Elements in 'nset' can be discrete and real, but must be lvalues
  //
  // For functions that declare to be self-normalized by overloading the
  // selfNormalized() function, a unit normalization is always constructed


//   cout << IsA()->GetName() << "::syncNormalization(" << GetName() << ") nset = " << nset << " = " << (nset?*nset:RooArgSet()) << endl ;

  _normSet = (RooArgSet*) nset ;

  // Check if data sets are identical
  CacheElem* cache = (CacheElem*) _normMgr.getObj(nset) ;
  if (cache) {

    Bool_t nsetChanged = (_norm!=cache->_norm) ;
    _norm = cache->_norm ;


//      cout << "returning existing object " << _norm->GetName() << endl ;

    if (nsetChanged && adjustProxies) {
      // Update dataset pointers of proxies
      ((RooAbsPdf*) this)->setProxyNormSet(nset) ;
    }
  
    return nsetChanged ;
  }
    
  // Update dataset pointers of proxies
  if (adjustProxies) {
    ((RooAbsPdf*) this)->setProxyNormSet(nset) ;
  }
  
  RooArgSet* depList = getObservables(nset) ;

  if (_verboseEval>0) {
    if (!selfNormalized()) {
      cxcoutD(Tracing) << IsA()->GetName() << "::syncNormalization(" << GetName() 
	   << ") recreating normalization integral " << endl ;
      if (depList) depList->printStream(ccoutD(Tracing),kName|kValue|kArgs,kSingleLine) ; else ccoutD(Tracing) << "<none>" << endl ;
    } else {
      cxcoutD(Tracing) << IsA()->GetName() << "::syncNormalization(" << GetName() << ") selfNormalized, creating unit norm" << endl;
    }
  }

  // Destroy old normalization & create new
  if (selfNormalized() || !dependsOn(*depList)) {    
    TString ntitle(GetTitle()) ; ntitle.Append(" Unit Normalization") ;
    TString nname(GetName()) ; nname.Append("_UnitNorm") ;
    _norm = new RooRealVar(nname.Data(),ntitle.Data(),1) ;
  } else {    
    const char* nr = (_normRangeOverride.Length()>0 ? _normRangeOverride.Data() : (_normRange.Length()>0 ? _normRange.Data() : 0)) ;

//     cout << "RooAbsPdf::syncNormalization(" << GetName() << ") rangeName for normalization is " << (nr?nr:"<null>") << endl ;
    RooRealIntegral* normInt = (RooRealIntegral*) createIntegral(*depList,*getIntegratorConfig(),nr) ;
    normInt->getVal() ;
//     cout << "resulting normInt = " << normInt->GetName() << endl ;

    RooArgSet* normParams = normInt->getVariables() ;
    if (normParams->getSize()>0 && normParams->getSize()<3 && normInt->numIntRealVars().getSize()>=_minDimNormValueCache) {
      coutI(Caching) << "RooAbsPdf::syncNormalization(" << GetName() << ") INFO: constructing " << normParams->getSize() 
		     << "-dim value cache for normalization integral over " << *depList << endl ;
      string name = Form("%s_CACHE_[%s]",normInt->GetName(),normParams->contentsString().c_str()) ;
      RooCachedReal* cachedNorm = new RooCachedReal(name.c_str(),name.c_str(),*normInt,*normParams) ;     
      cachedNorm->setInterpolationOrder(_valueCacheIntOrder) ;
      cachedNorm->addOwnedComponents(*normInt) ;
      _norm = cachedNorm ;
    } else {
      _norm = normInt ;
    } 
    delete normParams ;
  }



  // Register new normalization with manager (takes ownership)
  cache = new CacheElem(*_norm) ;
  _normMgr.setObj(nset,cache) ;

//   cout << "making new object " << _norm->GetName() << endl ;

  delete depList ;
  return kTRUE ;
}



//_____________________________________________________________________________
void RooAbsPdf::setNormValueCaching(Int_t minNumIntDim, Int_t ipOrder) 
{ 
  // Activate caching of normalization integral values in a interpolated histogram 
  // for integrals that exceed the specified minimum number of numerically integrated
  // dimensions, _and_ of which the integral has at most 2 parameters. 
  //
  // The cache is scanned with a granularity defined by a binning named "cache" in the 
  // scanned integral parameters and is interpolated to given order.
  // The cache values are kept for the livetime of the ROOT session/application
  // and are persisted along with the object in case the p.d.f. is persisted
  // in a RooWorkspace
  // 
  // This feature can substantially speed up fits and improve convergence with slow 
  // multi-dimensional integrals whose value varies slowly with the parameters so that the
  // an interpolated histogram is a good approximation of the true integral value.
  // The improved convergence behavior is a result of making the value of the normalization
  // integral deterministic for each value of the parameters. If (multi-dimensional) numeric
  // integrals are calculated at insufficient precision (>=1e-7) MINUIT convergence may
  // be impaired by the effects numerical noise that can cause that subsequent evaluations
  // of an integral at the same point in parameter space can give slightly different answers.

  _minDimNormValueCache = minNumIntDim ; 
  _valueCacheIntOrder = ipOrder ; 
}




//_____________________________________________________________________________
Bool_t RooAbsPdf::traceEvalHook(Double_t value) const 
{
  // WVE 08/21/01 Probably obsolete now.

  // Floating point error checking and tracing for given float value

  // check for a math error or negative value
  Bool_t error= isnan(value) || (value < 0);

  // do nothing if we are no longer tracing evaluations and there was no error
  if(!error && _traceCount <= 0) return error ;

  // otherwise, print out this evaluations input values and result
  if(error && ++_errorCount <= 10) {
    cxcoutD(Tracing) << "*** Evaluation Error " << _errorCount << " ";
    if(_errorCount == 10) ccoutD(Tracing) << "(no more will be printed) ";
  }
  else if(_traceCount > 0) {
    ccoutD(Tracing) << '[' << _traceCount-- << "] ";
  }
  else {
    return error ;
  }

  Print() ;

  return error ;
}




//_____________________________________________________________________________
void RooAbsPdf::resetErrorCounters(Int_t resetValue)
{
  // Reset error counter to given value, limiting the number
  // of future error messages for this pdf to 'resetValue'

  _errorCount = resetValue ;
  _negCount   = resetValue ;
}



//_____________________________________________________________________________
void RooAbsPdf::setTraceCounter(Int_t value, Bool_t allNodes)
{
  // Reset trace counter to given value, limiting the
  // number of future trace messages for this pdf to 'value'

  if (!allNodes) {
    _traceCount = value ;
    return ; 
  } else {
    RooArgList branchList ;
    branchNodeServerList(&branchList) ;
    TIterator* iter = branchList.createIterator() ;
    RooAbsArg* arg ;
    while((arg=(RooAbsArg*)iter->Next())) {
      RooAbsPdf* pdf = dynamic_cast<RooAbsPdf*>(arg) ;
      if (pdf) pdf->setTraceCounter(value,kFALSE) ;
    }
    delete iter ;
  }

}




//_____________________________________________________________________________
Double_t RooAbsPdf::getLogVal(const RooArgSet* nset) const 
{
  // Return the log of the current value with given normalization
  // An error message is printed if the argument of the log is negative.

  Double_t prob = getVal(nset) ;
  if(prob < 0) {

    logEvalError("getLogVal() top-level p.d.f evaluates to a negative number") ;

    return 0;
  }
  if(prob == 0) {

    logEvalError("getLogVal() top-level p.d.f evaluates to zero") ;

    return log((double)0);
  }
  return log(prob);
}



//_____________________________________________________________________________
Double_t RooAbsPdf::extendedTerm(Double_t observed, const RooArgSet* nset) const 
{
  // Returned the extended likelihood term (Nexpect - Nobserved*log(NExpected)
  // of this PDF for the given number of observed events
  //
  // For successfull operation the PDF implementation must indicate
  // it is extendable by overloading canBeExtended() and must
  // implemented the expectedEvents() function.

  // check if this PDF supports extended maximum likelihood fits
  if(!canBeExtended()) {
    coutE(InputArguments) << fName << ": this PDF does not support extended maximum likelihood"
         << endl;
    return 0;
  }

  Double_t expected= expectedEvents(nset);
  if(expected < 0) {
    coutE(InputArguments) << fName << ": calculated negative expected events: " << expected
         << endl;
    return 0;
  }

  // calculate and return the negative log-likelihood of the Poisson
  // factor for this dataset, dropping the constant log(observed!)
  Double_t extra= expected - observed*log(expected);

//   cout << "RooAbsPdf::extendedTerm(" << GetName() << ") observed = " << observed << " expected = " << expected << endl ;

  Bool_t trace(kFALSE) ;
  if(trace) {
    cxcoutD(Tracing) << fName << "::extendedTerm: expected " << expected << " events, got "
		     << observed << " events. extendedTerm = " << extra << endl;
  }

//   cout << "RooAbsPdf::extendedTerm(" << GetName() << ") nExp = " << expected << " nObs = " << observed << endl ;
  return extra;
}



//_____________________________________________________________________________
RooAbsReal* RooAbsPdf::createNLL(RooAbsData& data, const RooCmdArg& arg1, const RooCmdArg& arg2, const RooCmdArg& arg3, const RooCmdArg& arg4, 
                                             const RooCmdArg& arg5, const RooCmdArg& arg6, const RooCmdArg& arg7, const RooCmdArg& arg8) 
{
  // Construct representation of -log(L) of PDFwith given dataset. If dataset is unbinned, an unbinned likelihood is constructed. If the dataset
  // is binned, a binned likelihood is constructed. 
  //
  // The following named arguments are supported
  //
  // ConditionalObservables(const RooArgSet& set) -- Do not normalize PDF over listed observables
  // Extended(Bool_t flag)           -- Add extended likelihood term, off by default
  // Range(const char* name)         -- Fit only data inside range with given name
  // Range(Double_t lo, Double_t hi) -- Fit only data inside given range. A range named "fit" is created on the fly on all observables.
  //                                    Multiple comma separated range names can be specified.
  // SumCoefRange(const char* name)  -- Set the range in which to interpret the coefficients of RooAddPdf components 
  // NumCPU(int num)                 -- Parallelize NLL calculation on num CPUs
  // Optimize(Bool_t flag)           -- Activate constant term optimization (on by default)
  // SplitRange(Bool_t flag)         -- Use separate fit ranges in a simultaneous fit. Actual range name for each
  //                                    subsample is assumed to by rangeName_{indexState} where indexState
  //                                    is the state of the master index category of the simultaneous fit
  // Constrain(const RooArgSet&pars) -- For p.d.f.s that contain internal parameter constraint terms, only apply constraints to given subset of parameters
  // ExternalConstraints(const RooArgSet& ) -- Include given external constraints to likelihood
  // Verbose(Bool_t flag)           -- Constrols RooFit informational messages in likelihood construction
  // CloneData(Bool flag)           -- Use clone of dataset in NLL (default is true)
  // 
  // 
  
  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 createNLL(data,l) ;
}




//_____________________________________________________________________________
RooAbsReal* RooAbsPdf::createNLL(RooAbsData& data, const RooLinkedList& cmdList) 
{
  // Construct representation of -log(L) of PDFwith given dataset. If dataset is unbinned, an unbinned likelihood is constructed. If the dataset
  // is binned, a binned likelihood is constructed. 
  //
  // See RooAbsPdf::createNLL(RooAbsData& data, RooCmdArg arg1, RooCmdArg arg2, RooCmdArg arg3, RooCmdArg arg4, 
  //                                    RooCmdArg arg5, RooCmdArg arg6, RooCmdArg arg7, RooCmdArg arg8) 
  //
  // for documentation of options


  // Select the pdf-specific commands 
  RooCmdConfig pc(Form("RooAbsPdf::createNLL(%s)",GetName())) ;

  pc.defineString("rangeName","RangeWithName",0,"",kTRUE) ;
  pc.defineString("addCoefRange","SumCoefRange",0,"") ;
  pc.defineDouble("rangeLo","Range",0,-999.) ;
  pc.defineDouble("rangeHi","Range",1,-999.) ;
  pc.defineInt("splitRange","SplitRange",0,0) ;
  pc.defineInt("ext","Extended",0,2) ;
  pc.defineInt("numcpu","NumCPU",0,1) ;
  pc.defineInt("verbose","Verbose",0,0) ;
  pc.defineInt("optConst","Optimize",0,0) ;
  pc.defineInt("cloneData","CloneData",2,0) ;
  pc.defineSet("projDepSet","ProjectedObservables",0,0) ;
  pc.defineSet("cPars","Constrain",0,0) ;
  pc.defineInt("constrAll","Constrained",0,0) ;
  pc.defineSet("extCons","ExternalConstraints",0,0) ;
  pc.defineMutex("Range","RangeWithName") ;
  pc.defineMutex("Constrain","Constrained") ;
  
  // Process and check varargs 
  pc.process(cmdList) ;
  if (!pc.ok(kTRUE)) {
    return 0 ;
  }

  // Decode command line arguments
  const char* rangeName = pc.getString("rangeName",0,kTRUE) ;
  const char* addCoefRangeName = pc.getString("addCoefRange",0,kTRUE) ;
  Int_t ext      = pc.getInt("ext") ;
  Int_t numcpu   = pc.getInt("numcpu") ;
  Int_t splitr   = pc.getInt("splitRange") ;
  Bool_t verbose = pc.getInt("verbose") ;
  Int_t optConst = pc.getInt("optConst") ;
  Int_t cloneData = pc.getInt("cloneData") ;
  
  // If no explicit cloneData command is specified, cloneData is set to true if optimization is activated
  if (cloneData==2) {
    cloneData = optConst ;
  }
  RooArgSet* cPars = pc.getSet("cPars") ;
  Bool_t doStripDisconnected=kFALSE ;

  // If no explicit list of parameters to be constrained is specified apply default algorithm
  // All terms of RooProdPdfs that do not contain observables and share a parameters with one or more
  // terms that do contain observables are added as constraints.
  if (!cPars) {    
    cPars = getParameters(data,kFALSE) ;
    doStripDisconnected=kTRUE ;
  }
  const RooArgSet* extCons = pc.getSet("extCons") ;

  // Process automatic extended option
  if (ext==2) {
    ext = ((extendMode()==CanBeExtended || extendMode()==MustBeExtended)) ? 1 : 0 ;
    if (ext) {
      coutI(Minimization) << "p.d.f. provides expected number of events, including extended term in likelihood." << endl ;
    }
  }

  if (pc.hasProcessed("Range")) {
    Double_t rangeLo = pc.getDouble("rangeLo") ;
    Double_t rangeHi = pc.getDouble("rangeHi") ;
   
    // Create range with name 'fit' with above limits on all observables
    RooArgSet* obs = getObservables(&data) ;
    TIterator* iter = obs->createIterator() ;
    RooAbsArg* arg ;
    while((arg=(RooAbsArg*)iter->Next())) {
      RooRealVar* rrv =  dynamic_cast<RooRealVar*>(arg) ;
      if (rrv) rrv->setRange("fit",rangeLo,rangeHi) ;
    }
    // Set range name to be fitted to "fit"
    rangeName = "fit" ;
  }

  RooArgSet projDeps ;
  RooArgSet* tmp = pc.getSet("projDepSet") ;  
  if (tmp) {
    projDeps.add(*tmp) ;
  }

  // Construct NLL
  RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::CollectErrors) ;
  RooAbsReal* nll ;
  string baseName = Form("nll_%s_%s",GetName(),data.GetName()) ;
  if (!rangeName || strchr(rangeName,',')==0) {
    // Simple case: default range, or single restricted range
    //cout<<"FK: Data test 1: "<<data.sumEntries()<<endl;

    nll = new RooNLLVar(baseName.c_str(),"-log(likelihood)",*this,data,projDeps,ext,rangeName,addCoefRangeName,numcpu,kFALSE,verbose,splitr,cloneData) ;

  } else {
    // Composite case: multiple ranges
    RooArgList nllList ;
    char* buf = new char[strlen(rangeName)+1] ;
    strlcpy(buf,rangeName,strlen(rangeName)+1) ;
    char* token = strtok(buf,",") ;
    while(token) {
      RooAbsReal* nllComp = new RooNLLVar(Form("%s_%s",baseName.c_str(),token),"-log(likelihood)",*this,data,projDeps,ext,token,addCoefRangeName,numcpu,kFALSE,verbose,splitr,cloneData) ;
      nllList.add(*nllComp) ;
      token = strtok(0,",") ;
    }
    delete[] buf ;
    nll = new RooAddition(baseName.c_str(),"-log(likelihood)",nllList,kTRUE) ;
  }
  RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::PrintErrors) ;
  
  // Collect internal and external constraint specifications
  RooArgSet allConstraints ;
  if (cPars && cPars->getSize()>0) {
    RooArgSet* constraints = getAllConstraints(*data.get(),*cPars,doStripDisconnected) ;
    allConstraints.add(*constraints) ;
    delete constraints ;
    
  }
  if (extCons) {
    allConstraints.add(*extCons) ;
  }

  // Include constraints, if any, in likelihood
  RooAbsReal* nllCons(0) ;
  if (allConstraints.getSize()>0 && cPars) {   

    coutI(Minimization) << " Including the following contraint terms in minimization: " << allConstraints << endl ;
    
    nllCons = new RooConstraintSum(Form("%s_constr",baseName.c_str()),"nllCons",allConstraints,*cPars) ;
    nllCons->setOperMode(ADirty) ;
    RooAbsReal* orignll = nll ;

    nll = new RooAddition(Form("%s_with_constr",baseName.c_str()),"nllWithCons",RooArgSet(*nll,*nllCons)) ;
    nll->addOwnedComponents(RooArgSet(*orignll,*nllCons)) ;
  }

  
  if (optConst) {
    nll->constOptimizeTestStatistic(RooAbsArg::Activate,optConst>1) ;
  }

  if (doStripDisconnected) {
    delete cPars ;
  }
  return nll ;
}






//_____________________________________________________________________________
RooFitResult* RooAbsPdf::fitTo(RooAbsData& data, const RooCmdArg& arg1, const RooCmdArg& arg2, const RooCmdArg& arg3, const RooCmdArg& arg4, 
                                                 const RooCmdArg& arg5, const RooCmdArg& arg6, const RooCmdArg& arg7, const RooCmdArg& arg8) 
{
  // Fit PDF to given dataset. If dataset is unbinned, an unbinned maximum likelihood is performed. If the dataset
  // is binned, a binned maximum likelihood is performed. By default the fit is executed through the MINUIT
  // commands MIGRAD, HESSE and MINOS in succession.
  //
  // The following named arguments are supported
  //
  // Options to control construction of -log(L)
  // ------------------------------------------
  // ConditionalObservables(const RooArgSet& set) -- Do not normalize PDF over listed observables
  // Extended(Bool_t flag)           -- Add extended likelihood term, off by default
  // Range(const char* name)         -- Fit only data inside range with given name
  // Range(Double_t lo, Double_t hi) -- Fit only data inside given range. A range named "fit" is created on the fly on all observables.
  //                                    Multiple comma separated range names can be specified.
  // SumCoefRange(const char* name)  -- Set the range in which to interpret the coefficients of RooAddPdf components 
  // NumCPU(int num)                 -- Parallelize NLL calculation on num CPUs
  // SplitRange(Bool_t flag)         -- Use separate fit ranges in a simultaneous fit. Actual range name for each
  //                                    subsample is assumed to by rangeName_{indexState} where indexState
  //                                    is the state of the master index category of the simultaneous fit
  // Constrained()                   -- Apply all constrained contained in the p.d.f. in the likelihood 
  // Contrain(const RooArgSet&pars)  -- Apply constraints to listed parameters in likelihood using internal constrains in p.d.f
  // ExternalConstraints(const RooArgSet& ) -- Include given external constraints to likelihood
  //
  // Options to control flow of fit procedure
  // ----------------------------------------
  //
  // Minimizer(type,algo)           -- Choose minimization package and algorithm to use. Default is MINUIT/MIGRAD through the RooMinimizer
  //                                   interface, but others can be specified (through RooMinimizer interface). Select OldMinuit to use
  //                                   MINUIT through the old RooMinuit interface
  //
  //                                          Type         Algorithm
  //                                          ------       ---------
  //                                          OldMinuit    migrad, simplex, minimize (=migrad+simplex), migradimproved (=migrad+improve)
  //                                          Minuit       migrad, simplex, minimize (=migrad+simplex), migradimproved (=migrad+improve)
  //                                          Minuit2      migrad, simplex, minimize, scan
  //                                          GSLMultiMin  conjugatefr, conjugatepr, bfgs, bfgs2, steepestdescent
  //                                          GSLSimAn     -
  //
  // 
  // InitialHesse(Bool_t flag)      -- Flag controls if HESSE before MIGRAD as well, off by default
  // Optimize(Bool_t flag)          -- Activate constant term optimization of test statistic during minimization (on by default)
  // Hesse(Bool_t flag)             -- Flag controls if HESSE is run after MIGRAD, on by default
  // Minos(Bool_t flag)             -- Flag controls if MINOS is run after HESSE, on by default
  // Minos(const RooArgSet& set)    -- Only run MINOS on given subset of arguments
  // Save(Bool_t flag)              -- Flac controls if RooFitResult object is produced and returned, off by default
  // Strategy(Int_t flag)           -- Set Minuit strategy (0 through 2, default is 1)
  // FitOptions(const char* optStr) -- Steer fit with classic options string (for backward compatibility). Use of this option
  //                                   excludes use of any of the new style steering options.
  //
  // SumW2Error(Bool_t flag)        -- Apply correaction to errors and covariance matrix using sum-of-weights covariance matrix
  //                                   to obtain correct error for weighted likelihood fits. If this option is activated the
  //                                   corrected covariance matrix is calculated as Vcorr = V C-1 V, where V is the original 
  //                                   covariance matrix and C is the inverse of the covariance matrix calculated using the
  //                                   weights squared
  //
  // Options to control informational output
  // ---------------------------------------
  // Verbose(Bool_t flag)           -- Flag controls if verbose output is printed (NLL, parameter changes during fit
  // Timer(Bool_t flag)             -- Time CPU and wall clock consumption of fit steps, off by default
  // PrintLevel(Int_t level)        -- Set Minuit print level (-1 through 3, default is 1). At -1 all RooFit informational 
  //                                   messages are suppressed as well
  // Warnings(Bool_t flag)          -- Enable or disable MINUIT warnings (enabled by default)
  // PrintEvalErrors(Int_t numErr)  -- Control number of p.d.f evaluation errors printed per likelihood evaluation. A negative
  //                                   value suppress output completely, a zero value will only print the error count per p.d.f component,
  //                                   a positive value is will print details of each error up to numErr messages per p.d.f component.
  // 
  // 
  
  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 fitTo(data,l) ;
}



//_____________________________________________________________________________
RooFitResult* RooAbsPdf::fitTo(RooAbsData& data, const RooLinkedList& cmdList) 
{
  // Fit PDF to given dataset. If dataset is unbinned, an unbinned maximum likelihood is performed. If the dataset
  // is binned, a binned maximum likelihood is performed. By default the fit is executed through the MINUIT
  // commands MIGRAD, HESSE and MINOS in succession.
  //
  // See RooAbsPdf::fitTo(RooAbsData& data, RooCmdArg arg1, RooCmdArg arg2, RooCmdArg arg3, RooCmdArg arg4, 
  //                                         RooCmdArg arg5, RooCmdArg arg6, RooCmdArg arg7, RooCmdArg arg8) 
  //
  // for documentation of options


  // Select the pdf-specific commands 
  RooCmdConfig pc(Form("RooAbsPdf::fitTo(%s)",GetName())) ;

  RooLinkedList fitCmdList(cmdList) ;
  RooLinkedList nllCmdList = pc.filterCmdList(fitCmdList,"ProjectedObservables,Extended,Range,RangeWithName,SumCoefRange,NumCPU,SplitRange,Constrained,Constrain,ExternalConstraints,CloneData") ;

  pc.defineString("fitOpt","FitOptions",0,"") ;
  pc.defineInt("optConst","Optimize",0,2) ;
  pc.defineInt("verbose","Verbose",0,0) ;
  pc.defineInt("doSave","Save",0,0) ;
  pc.defineInt("doTimer","Timer",0,0) ;
  pc.defineInt("plevel","PrintLevel",0,1) ;
  pc.defineInt("strat","Strategy",0,1) ;
  pc.defineInt("initHesse","InitialHesse",0,0) ;
  pc.defineInt("hesse","Hesse",0,1) ;
  pc.defineInt("minos","Minos",0,0) ;
  pc.defineInt("ext","Extended",0,2) ;
  pc.defineInt("numcpu","NumCPU",0,1) ;
  pc.defineInt("numee","PrintEvalErrors",0,10) ;
  pc.defineInt("doEEWall","EvalErrorWall",0,1) ;
  pc.defineInt("doWarn","Warnings",0,1) ;
  pc.defineInt("doSumW2","SumW2Error",0,-1) ;
  pc.defineString("mintype","Minimizer",0,"OldMinuit") ;
  pc.defineString("minalg","Minimizer",1,"minuit") ;
  pc.defineObject("minosSet","Minos",0,0) ;
  pc.defineSet("cPars","Constrain",0,0) ;
  pc.defineSet("extCons","ExternalConstraints",0,0) ;
  pc.defineMutex("FitOptions","Verbose") ;
  pc.defineMutex("FitOptions","Save") ;
  pc.defineMutex("FitOptions","Timer") ;
  pc.defineMutex("FitOptions","Strategy") ;
  pc.defineMutex("FitOptions","InitialHesse") ;
  pc.defineMutex("FitOptions","Hesse") ;
  pc.defineMutex("FitOptions","Minos") ;
  pc.defineMutex("Range","RangeWithName") ;
  pc.defineMutex("InitialHesse","Minimizer") ;
  
  // Process and check varargs 
  pc.process(fitCmdList) ;
  if (!pc.ok(kTRUE)) {
    return 0 ;
  }

  // Decode command line arguments
  const char* fitOpt = pc.getString("fitOpt",0,kTRUE) ;
  Int_t optConst = pc.getInt("optConst") ;
  Int_t verbose  = pc.getInt("verbose") ;
  Int_t doSave   = pc.getInt("doSave") ;
  Int_t doTimer  = pc.getInt("doTimer") ;
  Int_t plevel    = pc.getInt("plevel") ;
  Int_t strat    = pc.getInt("strat") ;
  Int_t initHesse= pc.getInt("initHesse") ;
  Int_t hesse    = pc.getInt("hesse") ;
  Int_t minos    = pc.getInt("minos") ;
  Int_t numee    = pc.getInt("numee") ;
  Int_t doEEWall = pc.getInt("doEEWall") ;
  Int_t doWarn   = pc.getInt("doWarn") ;
  Int_t doSumW2  = pc.getInt("doSumW2") ;
  const RooArgSet* minosSet = static_cast<RooArgSet*>(pc.getObject("minosSet")) ;
#ifdef __ROOFIT_NOROOMINIMIZER
  const char* minType =0 ;
#else
  const char* minType = pc.getString("mintype","OldMinuit") ;
  const char* minAlg = pc.getString("minalg","minuit") ;
#endif

  // Determine if the dataset has weights  
  Bool_t weightedData = data.isNonPoissonWeighted() ;

  // Warn user that a SumW2Error() argument should be provided if weighted data is offered
  if (weightedData && doSumW2==-1) {
    coutW(InputArguments) << "RooAbsPdf::fitTo(" << GetName() << ") WARNING: a likelihood fit is request of what appears to be weighted data. " << endl
                          << "       While the estimated values of the parameters will always be calculated taking the weights into account, " << endl 
			  << "       there are multiple ways to estimate the errors on these parameter values. You are advised to make an " << endl 
			  << "       explicit choice on the error calculation: " << endl
			  << "           - Either provide SumW2Error(kTRUE), to calculate a sum-of-weights corrected HESSE error matrix " << endl
			  << "             (error will be proportional to the number of events)" << endl 
			  << "           - Or provide SumW2Error(kFALSE), to return errors from original HESSE error matrix" << endl 
			  << "             (which will be proportional to the sum of the weights)" << endl 
			  << "       If you want the errors to reflect the information contained in the provided dataset, choose kTRUE. " << endl
			  << "       If you want the errors to reflect the precision you would be able to obtain with an unweighted dataset " << endl 
			  << "       with 'sum-of-weights' events, choose kFALSE." << endl ;
  }


  // Warn user that sum-of-weights correction does not apply to MINOS errrors
  if (doSumW2==1 && minos) {
    coutW(InputArguments) << "RooAbsPdf::fitTo(" << GetName() << ") WARNING: sum-of-weights correction does not apply to MINOS errors" << endl ;
  }
    
  RooAbsReal* nll = createNLL(data,nllCmdList) ;  

  RooFitResult *ret = 0 ;    

  // Instantiate MINUIT

  if (string(minType)!="OldMinuit") {
    
#ifndef __ROOFIT_NOROOMINIMIZER
    RooMinimizer m(*nll) ;

    m.setMinimizerType(minType) ;
    
    m.setEvalErrorWall(doEEWall) ;
    if (doWarn==0) {
      // m.setNoWarn() ; WVE FIX THIS
    }
    
    m.setPrintEvalErrors(numee) ;
    if (plevel!=1) {
      m.setPrintLevel(plevel) ;
    }
    
    if (optConst) {
      // Activate constant term optimization
      m.optimizeConst(optConst) ;
    }
    
    if (fitOpt) {
      
      // Play fit options as historically defined
      ret = m.fit(fitOpt) ;
      
    } else {
      
      if (verbose) {
	// Activate verbose options
	m.setVerbose(1) ;
      }
      if (doTimer) {
	// Activate timer options
	m.setProfile(1) ;
      }
      
      if (strat!=1) {
	// Modify fit strategy
	m.setStrategy(strat) ;
      }
      
      if (initHesse) {
	// Initialize errors with hesse
	m.hesse() ;
      }
      
      // Minimize using chosen algorithm
      m.minimize(minType,minAlg) ;
      
      if (hesse) {
	// Evaluate errors with Hesse
	m.hesse() ;
      }
      
      if (doSumW2==1) {
	
	// Make list of RooNLLVar components of FCN
	list<RooNLLVar*> nllComponents ;
	RooArgSet* comps = nll->getComponents() ;
	RooAbsArg* arg ;
	TIterator* citer = comps->createIterator() ;
	while((arg=(RooAbsArg*)citer->Next())) {
	  RooNLLVar* nllComp = dynamic_cast<RooNLLVar*>(arg) ;
	  if (nllComp) {
	    nllComponents.push_back(nllComp) ;
	  }
	}
	delete citer ;
	delete comps ;  
	
	// Calculated corrected errors for weighted likelihood fits
	RooFitResult* rw = m.save() ;
	for (list<RooNLLVar*>::iterator iter1=nllComponents.begin() ; iter1!=nllComponents.end() ; iter1++) {
	  (*iter1)->applyWeightSquared(kTRUE) ;
	}
	coutI(Fitting) << "RooAbsPdf::fitTo(" << GetName() << ") Calculating sum-of-weights-squared correction matrix for covariance matrix" << endl ;
	m.hesse() ;
	RooFitResult* rw2 = m.save() ;
	for (list<RooNLLVar*>::iterator iter2=nllComponents.begin() ; iter2!=nllComponents.end() ; iter2++) {
	  (*iter2)->applyWeightSquared(kFALSE) ;
	}
	
	// Apply correction matrix
	const TMatrixDSym& V = rw->covarianceMatrix() ;
	TMatrixDSym  C = rw2->covarianceMatrix() ;
	
	// Invert C
	Double_t det(0) ;
	C.Invert(&det) ;
	if (det==0) {
	  coutE(Fitting) << "RooAbsPdf::fitTo(" << GetName() 
			 << ") ERROR: Cannot apply sum-of-weights correction to covariance matrix: correction matrix calculated with weight-squared is singular" <<endl ;
	} else {
	  
	  // Calculate corrected covariance matrix = V C-1 V
	  TMatrixD VCV(V,TMatrixD::kMult,TMatrixD(C,TMatrixD::kMult,V)) ; 
	  
	  // Make matrix explicitly symmetric
	  Int_t n = VCV.GetNrows() ;
	  TMatrixDSym VCVsym(n) ;
	  for (Int_t i=0 ; i<n ; i++) {
	    for (Int_t j=i ; j<n ; j++) {
	      if (i==j) {
		VCVsym(i,j) = VCV(i,j) ;
	      }
	      if (i!=j) {
		Double_t deltaRel = (VCV(i,j)-VCV(j,i))/sqrt(VCV(i,i)*VCV(j,j)) ;
		if (fabs(deltaRel)>1e-3) {
		  coutW(Fitting) << "RooAbsPdf::fitTo(" << GetName() << ") WARNING: Corrected covariance matrix is not (completely) symmetric: V[" << i << "," << j << "] = " 
				 << VCV(i,j) << " V[" << j << "," << i << "] = " << VCV(j,i) << " explicitly restoring symmetry by inserting average value" << endl ;
		}
		VCVsym(i,j) = (VCV(i,j)+VCV(j,i))/2 ;
	      }
	    }
	  }
	  
	  // Propagate corrected errors to parameters objects
	  m.applyCovarianceMatrix(VCVsym) ;
	}
	
	delete rw ;
	delete rw2 ;
      }
      
      if (minos) {
	// Evaluate errs with Minos
	if (minosSet) {
	  m.minos(*minosSet) ;
	} else {
	  m.minos() ;
	}
      }
      
      // Optionally return fit result
      if (doSave) {
	string name = Form("fitresult_%s_%s",GetName(),data.GetName()) ;
	string title = Form("Result of fit of p.d.f. %s to dataset %s",GetName(),data.GetName()) ;
	ret = m.save(name.c_str(),title.c_str()) ;
      } 
      
    }
    if (optConst) {
      m.optimizeConst(0) ;
    }

#endif

  } else {

    RooMinuit m(*nll) ;
    
    m.setEvalErrorWall(doEEWall) ;
    if (doWarn==0) {
      m.setNoWarn() ;
    }
    
    m.setPrintEvalErrors(numee) ;
    if (plevel!=1) {
      m.setPrintLevel(plevel) ;
    }
    
    if (optConst) {
      // Activate constant term optimization
      m.optimizeConst(optConst) ;
    }
    
    if (fitOpt) {
      
      // Play fit options as historically defined
      ret = m.fit(fitOpt) ;
      
    } else {
      
      if (verbose) {
	// Activate verbose options
	m.setVerbose(1) ;
      }
      if (doTimer) {
	// Activate timer options
	m.setProfile(1) ;
      }
      
      if (strat!=1) {
	// Modify fit strategy
	m.setStrategy(strat) ;
      }
      
      if (initHesse) {
	// Initialize errors with hesse
	m.hesse() ;
      }
      
      // Minimize using migrad
      m.migrad() ;
      
      if (hesse) {
	// Evaluate errors with Hesse
	m.hesse() ;
      }
      
      if (doSumW2==1) {
	
	// Make list of RooNLLVar components of FCN
	list<RooNLLVar*> nllComponents ;
	RooArgSet* comps = nll->getComponents() ;
	RooAbsArg* arg ;
	TIterator* citer = comps->createIterator() ;
	while((arg=(RooAbsArg*)citer->Next())) {
	  RooNLLVar* nllComp = dynamic_cast<RooNLLVar*>(arg) ;
	  if (nllComp) {
	    nllComponents.push_back(nllComp) ;
	  }
	}
	delete citer ;
	delete comps ;  
	
	// Calculated corrected errors for weighted likelihood fits
	RooFitResult* rw = m.save() ;
	for (list<RooNLLVar*>::iterator iter1=nllComponents.begin() ; iter1!=nllComponents.end() ; iter1++) {
	  (*iter1)->applyWeightSquared(kTRUE) ;
	}
	coutI(Fitting) << "RooAbsPdf::fitTo(" << GetName() << ") Calculating sum-of-weights-squared correction matrix for covariance matrix" << endl ;
	m.hesse() ;
	RooFitResult* rw2 = m.save() ;
	for (list<RooNLLVar*>::iterator iter2=nllComponents.begin() ; iter2!=nllComponents.end() ; iter2++) {
	  (*iter2)->applyWeightSquared(kFALSE) ;
	}
	
	// Apply correction matrix
	const TMatrixDSym& V = rw->covarianceMatrix() ;
	TMatrixDSym  C = rw2->covarianceMatrix() ;
	
	// Invert C
	Double_t det(0) ;
	C.Invert(&det) ;
	if (det==0) {
	  coutE(Fitting) << "RooAbsPdf::fitTo(" << GetName() 
			 << ") ERROR: Cannot apply sum-of-weights correction to covariance matrix: correction matrix calculated with weight-squared is singular" <<endl ;
	} else {
	  
	  // Calculate corrected covariance matrix = V C-1 V
	  TMatrixD VCV(V,TMatrixD::kMult,TMatrixD(C,TMatrixD::kMult,V)) ; 
	  
	  // Make matrix explicitly symmetric
	  Int_t n = VCV.GetNrows() ;
	  TMatrixDSym VCVsym(n) ;
	  for (Int_t i=0 ; i<n ; i++) {
	    for (Int_t j=i ; j<n ; j++) {
	      if (i==j) {
		VCVsym(i,j) = VCV(i,j) ;
	      }
	      if (i!=j) {
		Double_t deltaRel = (VCV(i,j)-VCV(j,i))/sqrt(VCV(i,i)*VCV(j,j)) ;
		if (fabs(deltaRel)>1e-3) {
		  coutW(Fitting) << "RooAbsPdf::fitTo(" << GetName() << ") WARNING: Corrected covariance matrix is not (completely) symmetric: V[" << i << "," << j << "] = " 
				 << VCV(i,j) << " V[" << j << "," << i << "] = " << VCV(j,i) << " explicitly restoring symmetry by inserting average value" << endl ;
		}
		VCVsym(i,j) = (VCV(i,j)+VCV(j,i))/2 ;
	      }
	    }
	  }
	  
	  // Propagate corrected errors to parameters objects
	  m.applyCovarianceMatrix(VCVsym) ;
	}
	
	delete rw ;
	delete rw2 ;
      }
      
      if (minos) {
	// Evaluate errs with Minos
	if (minosSet) {
	  m.minos(*minosSet) ;
	} else {
	  m.minos() ;
	}
      }
      
      // Optionally return fit result
      if (doSave) {
	string name = Form("fitresult_%s_%s",GetName(),data.GetName()) ;
	string title = Form("Result of fit of p.d.f. %s to dataset %s",GetName(),data.GetName()) ;
	ret = m.save(name.c_str(),title.c_str()) ;
      } 
      
    }

    if (optConst) {
      m.optimizeConst(0) ;
    }
    
  }


  
  // Cleanup
  delete nll ;
  return ret ;
}



//_____________________________________________________________________________
RooFitResult* RooAbsPdf::chi2FitTo(RooDataHist& data, const RooLinkedList& cmdList) 
{
  // Internal back-end function to steer chi2 fits

  // Select the pdf-specific commands 
  RooCmdConfig pc(Form("RooAbsPdf::chi2FitTo(%s)",GetName())) ;

  // Pull arguments to be passed to chi2 construction from list
  RooLinkedList fitCmdList(cmdList) ;
  RooLinkedList chi2CmdList = pc.filterCmdList(fitCmdList,"Range,RangeWithName,NumCPU,Optimize,ProjectedObservables,AddCoefRange,SplitRange") ;

  RooAbsReal* chi2 = createChi2(data,chi2CmdList) ;
  RooFitResult* ret = chi2FitDriver(*chi2,fitCmdList) ;
  
  // Cleanup
  delete chi2 ;
  return ret ;
}




//_____________________________________________________________________________
RooAbsReal* RooAbsPdf::createChi2(RooDataHist& data, 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 chi-2 from a histogram and this function.
  //
  // The following named arguments are supported
  //
  //  Options to control construction of the chi^2
  //  ------------------------------------------
  //  Extended()   -- Use expected number of events of an extended p.d.f as normalization 
  //  DataError()  -- Choose between Poisson errors and Sum-of-weights errors
  //  NumCPU()     -- Activate parallel processing feature
  //  Range()      -- Fit only selected region
  //  SumCoefRange() -- Set the range in which to interpret the coefficients of RooAddPdf components 
  //  SplitRange() -- Fit range is split by index catory of simultaneous PDF
  //  ConditionalObservables() -- Define projected observables 

  string name = Form("chi2_%s_%s",GetName(),data.GetName()) ;
 
  return new RooChi2Var(name.c_str(),name.c_str(),*this,data,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8) ;
}




//_____________________________________________________________________________
RooAbsReal* RooAbsPdf::createChi2(RooDataSet& data, const RooLinkedList& cmdList) 
{
  // Internal back-end function to create a chi^2 from a p.d.f. and a dataset

  // Select the pdf-specific commands 
  RooCmdConfig pc(Form("RooAbsPdf::fitTo(%s)",GetName())) ;

  pc.defineInt("integrate","Integrate",0,0) ;
  pc.defineObject("yvar","YVar",0,0) ;
  
  // Process and check varargs 
  pc.process(cmdList) ;
  if (!pc.ok(kTRUE)) {
    return 0 ;
  }

  // Decode command line arguments 
  Bool_t integrate = pc.getInt("integrate") ;
  RooRealVar* yvar = (RooRealVar*) pc.getObject("yvar") ;

  string name = Form("chi2_%s_%s",GetName(),data.GetName()) ;
 
  if (yvar) {
    return new RooXYChi2Var(name.c_str(),name.c_str(),*this,data,*yvar,integrate) ;
  } else {
    return new RooXYChi2Var(name.c_str(),name.c_str(),*this,data,integrate) ;
  }  
}




//_____________________________________________________________________________
void RooAbsPdf::printValue(ostream& os) const
{
  // Print value of p.d.f, also print normalization integral that was last used, if any

  getVal() ;

  if (_norm) {
    os << evaluate() << "/" << _norm->getVal() ;
  } else {
    os << evaluate() ;
  }
}



//_____________________________________________________________________________
void RooAbsPdf::printMultiline(ostream& os, Int_t contents, Bool_t verbose, TString indent) const
{
  // Print multi line detailed information of this RooAbsPdf

  RooAbsReal::printMultiline(os,contents,verbose,indent);
  os << indent << "--- RooAbsPdf ---" << endl;
  os << indent << "Cached value = " << _value << endl ;
  if (_norm) {
    os << indent << " Normalization integral: " << endl ;
    TString moreIndent(indent) ; moreIndent.Append("   ") ;
    _norm->printStream(os,kName|kAddress|kTitle|kValue|kArgs,kSingleLine,moreIndent.Data()) ;
  }
}



//_____________________________________________________________________________
RooAbsGenContext* RooAbsPdf::binnedGenContext(const RooArgSet &vars, Bool_t verbose) const 
{
  // Return a binned generator context
  return new RooBinnedGenContext(*this,vars,0,0,verbose) ;
}


//_____________________________________________________________________________
RooAbsGenContext* RooAbsPdf::genContext(const RooArgSet &vars, const RooDataSet *prototype, 
					const RooArgSet* auxProto, Bool_t verbose) const 
{
  // Interface function to create a generator context from a p.d.f. This default
  // implementation returns a 'standard' context that works for any p.d.f
  return new RooGenContext(*this,vars,prototype,auxProto,verbose) ;
}


//_____________________________________________________________________________
RooAbsGenContext* RooAbsPdf::autoGenContext(const RooArgSet &vars, const RooDataSet* prototype, const RooArgSet* auxProto, 
					    Bool_t verbose, Bool_t autoBinned, const char* binnedTag) const 
{
  
  if (prototype || (auxProto && auxProto->getSize()>0)) {
    return genContext(vars,prototype,auxProto,verbose);
  }

  RooAbsGenContext *context(0) ;
  if ( (autoBinned & isBinnedDistribution(vars)) || ( binnedTag && strlen(binnedTag) && (getAttribute(binnedTag)||string(binnedTag)=="*"))) {
    context = binnedGenContext(vars,verbose) ;
  } else {
    context= genContext(vars,0,0,verbose);
  }
  return context ;
}



//_____________________________________________________________________________
RooDataSet *RooAbsPdf::generate(const RooArgSet& whatVars, Int_t nEvents, const RooCmdArg& arg1,
				const RooCmdArg& arg2, const RooCmdArg& arg3,const RooCmdArg& arg4, const RooCmdArg& arg5) 
{
  // Generate a new dataset containing the specified variables with events sampled from our distribution. 
  // Generate the specified number of events or expectedEvents() if not specified.
  //
  // Any variables of this PDF that are not in whatVars will use their
  // current values and be treated as fixed parameters. Returns zero
  // in case of an error. The caller takes ownership of the returned
  // dataset.
  //
  // The following named arguments are supported
  //
  // Name(const char* name)             -- Name of the output dataset
  // Verbose(Bool_t flag)               -- Print informational messages during event generation
  // Extended()                         -- The actual number of events generated will be sampled from a Poisson distribution
  //                                       with mu=nevt. For use with extended maximum likelihood fits
  // AutoBinned(Bool_t flag)            -- Automatically deploy binned generation for binned distributions (e.g. RooHistPdf, sums and products of RooHistPdfs etc)
  //                                       NB: Datasets that are generated in binned mode are returned as weighted unbinned datasets
  //
  // GenBinned(const char* tag)         -- Use binned generation for all component pdfs that have 'setAttribute(tag)' set
  // AllBinned()                        -- As above, but for all components. 
  //
  //                                       Note that the notion of components is only meaningful for simultaneous pdf
  //                                       as binned generation is always executed at the top-level node for a regular
  //                                       pdf, so for those it only mattes that the top-level node is tagged.
  //
  // ProtoData(const RooDataSet& data,  -- Use specified dataset as prototype dataset. If randOrder is set to true
  //                 Bool_t randOrder)     the order of the events in the dataset will be read in a random order
  //                                       if the requested number of events to be generated does not match the
  //                                       number of events in the prototype dataset
  //                                        
  // If ProtoData() is used, the specified existing dataset as a prototype: the new dataset will contain 
  // the same number of events as the prototype (unless otherwise specified), and any prototype variables not in
  // whatVars will be copied into the new dataset for each generated event and also used to set our PDF parameters. 
  // The user can specify a  number of events to generate that will override the default. The result is a
  // copy of the prototype dataset with only variables in whatVars randomized. Variables in whatVars that 
  // are not in the prototype will be added as new columns to the generated dataset.  

  return generate(whatVars,RooFit::NumEvents(nEvents),arg1,arg2,arg3,arg4,arg5) ;
}



//_____________________________________________________________________________
RooDataSet *RooAbsPdf::generate(const RooArgSet& whatVars, const RooCmdArg& arg1,const RooCmdArg& arg2,
				const RooCmdArg& arg3,const RooCmdArg& arg4, const RooCmdArg& arg5,const RooCmdArg& arg6) 
{
  // Generate a new dataset containing the specified variables with events sampled from our distribution. 
  // Generate the specified number of events or expectedEvents() if not specified.
  //
  // Any variables of this PDF that are not in whatVars will use their
  // current values and be treated as fixed parameters. Returns zero
  // in case of an error. The caller takes ownership of the returned
  // dataset.
  //
  // The following named arguments are supported
  //
  // Name(const char* name)             -- Name of the output dataset
  // Verbose(Bool_t flag)               -- Print informational messages during event generation
  // NumEvent(int nevt)                 -- Generate specified number of events
  //
  // AutoBinned(Bool_t flag)            -- Automatically deploy binned generation for binned distributions (e.g. RooHistPdf, sums and products of RooHistPdfs etc)
  //                                       NB: Datasets that are generated in binned mode are returned as weighted unbinned datasets
  //
  // GenBinned(const char* tag)         -- Use binned generation for all component pdfs that have 'setAttribute(tag)' set
  // AllBinned()                        -- As above, but for all components. 
  //
  //                                       Note that the notion of components is only meaningful for simultaneous pdf
  //                                       as binned generation is always executed at the top-level node for a regular
  //                                       pdf, so for those it only mattes that the top-level node is tagged.
  //
  //                                       Binned generation cannot be used when prototype data is supplied
  // Extended()                         -- The actual number of events generated will be sampled from a Poisson distribution
  //                                       with mu=nevt. For use with extended maximum likelihood fits
  // ProtoData(const RooDataSet& data,  -- Use specified dataset as prototype dataset. If randOrder is set to true
  //                 Bool_t randOrder,     the order of the events in the dataset will be read in a random order
  //                 Bool_t resample)      if the requested number of events to be generated does not match the
  //                                       number of events in the prototype dataset. If resample is also set to 
  //                                       true, the prototype dataset will be resampled rather than be strictly
  //                                       reshuffled. In this mode events of the protodata may be used more than
  //                                       once.
  //
  // If ProtoData() is used, the specified existing dataset as a prototype: the new dataset will contain 
  // the same number of events as the prototype (unless otherwise specified), and any prototype variables not in
  // whatVars will be copied into the new dataset for each generated event and also used to set our PDF parameters. 
  // The user can specify a  number of events to generate that will override the default. The result is a
  // copy of the prototype dataset with only variables in whatVars randomized. Variables in whatVars that 
  // are not in the prototype will be added as new columns to the generated dataset.  

  // Select the pdf-specific commands 
  RooCmdConfig pc(Form("RooAbsPdf::generate(%s)",GetName())) ;
  pc.defineObject("proto","PrototypeData",0,0) ;
  pc.defineString("dsetName","Name",0,"") ;
  pc.defineInt("randProto","PrototypeData",0,0) ;
  pc.defineInt("resampleProto","PrototypeData",1,0) ;
  pc.defineInt("verbose","Verbose",0,0) ;
  pc.defineInt("extended","Extended",0,0) ;
  pc.defineInt("nEvents","NumEvents",0,0) ;
  pc.defineInt("autoBinned","AutoBinned",0,1) ;
  pc.defineInt("expectedData","ExpectedData",0,0) ;
  pc.defineDouble("nEventsD","NumEventsD",0,-1.) ;
  pc.defineString("binnedTag","GenBinned",0,"") ;
  pc.defineMutex("GenBinned","ProtoData") ;
    
  // Process and check varargs 
  pc.process(arg1,arg2,arg3,arg4,arg5,arg6) ;
  if (!pc.ok(kTRUE)) {
    return 0 ;
  }

  // Decode command line arguments
  RooDataSet* protoData = static_cast<RooDataSet*>(pc.getObject("proto",0)) ;
  const char* dsetName = pc.getString("dsetName") ;
  Bool_t verbose = pc.getInt("verbose") ;
  Bool_t randProto = pc.getInt("randProto") ;
  Bool_t resampleProto = pc.getInt("resampleProto") ;
  Bool_t extended = pc.getInt("extended") ;
  Bool_t autoBinned = pc.getInt("autoBinned") ;
  const char* binnedTag = pc.getString("binnedTag") ;
  Int_t nEvents = pc.getInt("nEvents") ;
  //Bool_t verbose = pc.getInt("verbose") ;
  Bool_t expectedData = pc.getInt("expectedData") ;

  // Force binned mode for expected data mode
  if (expectedData) {
    binnedTag="*" ;
  }

  if (extended) {
    nEvents = RooRandom::randomGenerator()->Poisson(nEvents==0?expectedEvents(&whatVars):nEvents) ;
    cxcoutI(Generation) << " Extended mode active, number of events generated (" << nEvents << ") is Poisson fluctuation on " 
			  << GetName() << "::expectedEvents() = " << nEvents << endl ;
    // If Poisson fluctuation results in zero events, stop here
    if (nEvents==0) {
      return new RooDataSet("emptyData","emptyData",whatVars) ;
    }
  } else if (nEvents==0) {
    cxcoutI(Generation) << "No number of events specified , number of events generated is " 
			  << GetName() << "::expectedEvents() = " << expectedEvents(&whatVars)<< endl ;
  }

  if (extended && protoData && !randProto) {
    cxcoutI(Generation) << "WARNING Using generator option Extended() (Poisson distribution of #events) together "
			  << "with a prototype dataset implies incomplete sampling or oversampling of proto data. " 
			  << "Set randomize flag in ProtoData() option to randomize prototype dataset order and thus "
			  << "to randomize the set of over/undersampled prototype events for each generation cycle." << endl ;
  }


  // Forward to appropiate implementation
  RooDataSet* data ;
  if (protoData) {
    data = generate(whatVars,*protoData,nEvents,verbose,randProto,resampleProto) ;
  } else {
    data = generate(whatVars,nEvents,verbose,autoBinned,binnedTag,expectedData) ;
  }

  // Rename dataset to given name if supplied
  if (dsetName && strlen(dsetName)>0) {
    data->SetName(dsetName) ;
  }

  return data ;
}





//_____________________________________________________________________________
RooAbsPdf::GenSpec* RooAbsPdf::prepareMultiGen(const RooArgSet &whatVars,  
					       const RooCmdArg& arg1,const RooCmdArg& arg2,
					       const RooCmdArg& arg3,const RooCmdArg& arg4,
					       const RooCmdArg& arg5,const RooCmdArg& arg6) 
{
  // Prepare GenSpec configuration object for efficient generation of multiple datasets from idetical specification
  // This method does not perform any generation. To generate according to generations specification call RooAbsPdf::generate(RooAbsPdf::GenSpec&)
  //
  // Generate the specified number of events or expectedEvents() if not specified.
  //
  // Any variables of this PDF that are not in whatVars will use their
  // current values and be treated as fixed parameters. Returns zero
  // in case of an error. The caller takes ownership of the returned
  // dataset.
  //
  // The following named arguments are supported
  //
  // Name(const char* name)             -- Name of the output dataset
  // Verbose(Bool_t flag)               -- Print informational messages during event generation
  // NumEvent(int nevt)                 -- Generate specified number of events

  // AutoBinned(Bool_t flag)            -- Automatically deploy binned generation for binned distributions (e.g. RooHistPdf, sums and products of RooHistPdfs etc)
  //                                       NB: Datasets that are generated in binned mode are returned as weighted unbinned datasets
  //
  //
  // GenBinned(const char* tag)         -- Use binned generation for all component pdfs that have 'setAttribute(tag)' set
  // AllBinned()                        -- As above, but for all components. 
  //
  //                                       Note that the notion of components is only meaningful for simultaneous pdf
  //                                       as binned generation is always executed at the top-level node for a regular
  //                                       pdf, so for those it only mattes that the top-level node is tagged.
  //
  // Extended()                         -- The actual number of events generated will be sampled from a Poisson distribution
  //                                       with mu=nevt. For use with extended maximum likelihood fits
  // ProtoData(const RooDataSet& data,  -- Use specified dataset as prototype dataset. If randOrder is set to true
  //                 Bool_t randOrder,     the order of the events in the dataset will be read in a random order
  //                 Bool_t resample)      if the requested number of events to be generated does not match the
  //                                       number of events in the prototype dataset. If resample is also set to 
  //                                       true, the prototype dataset will be resampled rather than be strictly
  //                                       reshuffled. In this mode events of the protodata may be used more than
  //                                       once.
  //
  // If ProtoData() is used, the specified existing dataset as a prototype: the new dataset will contain 
  // the same number of events as the prototype (unless otherwise specified), and any prototype variables not in
  // whatVars will be copied into the new dataset for each generated event and also used to set our PDF parameters. 
  // The user can specify a  number of events to generate that will override the default. The result is a
  // copy of the prototype dataset with only variables in whatVars randomized. Variables in whatVars that 
  // are not in the prototype will be added as new columns to the generated dataset.  

  // Select the pdf-specific commands 
  RooCmdConfig pc(Form("RooAbsPdf::generate(%s)",GetName())) ;
  pc.defineObject("proto","PrototypeData",0,0) ;
  pc.defineString("dsetName","Name",0,"") ;
  pc.defineInt("randProto","PrototypeData",0,0) ;
  pc.defineInt("resampleProto","PrototypeData",1,0) ;
  pc.defineInt("verbose","Verbose",0,0) ;
  pc.defineInt("extended","Extended",0,0) ;
  pc.defineInt("nEvents","NumEvents",0,0) ;
  pc.defineInt("autoBinned","AutoBinned",0,1) ;
  pc.defineString("binnedTag","GenBinned",0,"") ;
  pc.defineMutex("GenBinned","ProtoData") ;
  
  
  // Process and check varargs 
  pc.process(arg1,arg2,arg3,arg4,arg5,arg6) ;
  if (!pc.ok(kTRUE)) {
    return 0 ;
  }

  // Decode command line arguments
  RooDataSet* protoData = static_cast<RooDataSet*>(pc.getObject("proto",0)) ;
  const char* dsetName = pc.getString("dsetName") ;
  Int_t nEvents = pc.getInt("nEvents") ;
  Bool_t verbose = pc.getInt("verbose") ;
  Bool_t randProto = pc.getInt("randProto") ;
  Bool_t resampleProto = pc.getInt("resampleProto") ;
  Bool_t extended = pc.getInt("extended") ;
  Bool_t autoBinned = pc.getInt("autoBinned") ;
  const char* binnedTag = pc.getString("binnedTag") ;

  RooAbsGenContext* cx = autoGenContext(whatVars,protoData,0,verbose,autoBinned,binnedTag) ;
  
  return new GenSpec(cx,whatVars,protoData,nEvents,extended,randProto,resampleProto,dsetName) ;  
}


//_____________________________________________________________________________
RooDataSet *RooAbsPdf::generate(RooAbsPdf::GenSpec& spec) const
{
  // Generate data according to a pre-configured specification created by
  // RooAbsPdf::prepareMultiGen(). If many identical generation requests
  // are needed, e.g. in toy MC studies, it is more efficient to use the prepareMultiGen()/generate()
  // combination than calling the standard generate() multiple times as 
  // initialization overhead is only incurred once.

  //Int_t nEvt = spec._extended ? RooRandom::randomGenerator()->Poisson(spec._nGen) : spec._nGen ;
  //Int_t nEvt = spec._extended ? RooRandom::randomGenerator()->Poisson(spec._nGen==0?expectedEvents(spec._whatVars):spec._nGen) : spec._nGen ;
  Int_t nEvt = spec._nGen==0? Int_t(expectedEvents(spec._whatVars)+0.5) : spec._nGen ;
  
  
  RooDataSet* ret = generate(*spec._genContext,spec._whatVars,spec._protoData, nEvt,kFALSE,spec._randProto,spec._resampleProto,
			     spec._init,spec._extended) ;
  spec._init = kTRUE ;
  return ret ;
}





//_____________________________________________________________________________
RooDataSet *RooAbsPdf::generate(const RooArgSet &whatVars, Int_t nEvents, Bool_t verbose, Bool_t autoBinned, const char* binnedTag, Bool_t expectedData) const 
{
  // Generate a new dataset containing the specified variables with
  // events sampled from our distribution. Generate the specified
  // number of events or else try to use expectedEvents() if nEvents <= 0.
  // Any variables of this PDF that are not in whatVars will use their
  // current values and be treated as fixed parameters. Returns zero
  // in case of an error. The caller takes ownership of the returned
  // dataset.

  if (nEvents==0 && extendMode()==CanNotBeExtended) {
    return new RooDataSet("emptyData","emptyData",whatVars) ;
  }

  // Request for binned generation
  RooAbsGenContext *context = autoGenContext(whatVars,0,0,verbose,autoBinned,binnedTag) ;
  if (expectedData) {
    context->setExpectedData(kTRUE) ;
  }
  
  RooDataSet *generated = 0;
  if(0 != context && context->isValid()) {
    generated= context->generate(nEvents);
  }
  else {
    coutE(Generation)  << "RooAbsPdf::generate(" << GetName() << ") cannot create a valid context" << endl;
  }
  if(0 != context) delete context;
  return generated;
}




//_____________________________________________________________________________
RooDataSet *RooAbsPdf::generate(RooAbsGenContext& context, const RooArgSet &whatVars, const RooDataSet *prototype,
				Int_t nEvents, Bool_t /*verbose*/, Bool_t randProtoOrder, Bool_t resampleProto, 
				Bool_t skipInit, Bool_t extended) const 
{
  // Internal method  
  if (nEvents==0 && (prototype==0 || prototype->numEntries()==0)) {
    return new RooDataSet("emptyData","emptyData",whatVars) ;
  }

  RooDataSet *generated = 0;

  // Resampling implies reshuffling in the implementation
  if (resampleProto) {
    randProtoOrder=kTRUE ;
  }

  if (randProtoOrder && prototype && prototype->numEntries()!=nEvents) {
    coutI(Generation) << "RooAbsPdf::generate (Re)randomizing event order in prototype dataset (Nevt=" << nEvents << ")" << endl ;
    Int_t* newOrder = randomizeProtoOrder(prototype->numEntries(),nEvents,resampleProto) ;
    context.setProtoDataOrder(newOrder) ;
    delete[] newOrder ;
  }

  if(context.isValid()) {
    generated= context.generate(nEvents,skipInit,extended);
  }
  else {
    coutE(Generation) << "RooAbsPdf::generate(" << GetName() << ") do not have a valid generator context" << endl;
  }
  return generated;
}




//_____________________________________________________________________________
RooDataSet *RooAbsPdf::generate(const RooArgSet &whatVars, const RooDataSet& prototype,
				Int_t nEvents, Bool_t verbose, Bool_t randProtoOrder, Bool_t resampleProto) const 
{
  // Generate a new dataset with values of the whatVars variables
  // sampled from our distribution. Use the specified existing dataset
  // as a prototype: the new dataset will contain the same number of
  // events as the prototype (by default), and any prototype variables not in
  // whatVars will be copied into the new dataset for each generated
  // event and also used to set our PDF parameters. The user can specify a
  // number of events to generate that will override the default. The result is a
  // copy of the prototype dataset with only variables in whatVars
  // randomized. Variables in whatVars that are not in the prototype
  // will be added as new columns to the generated dataset.  Returns
  // zero in case of an error. The caller takes ownership of the
  // returned dataset.

  RooAbsGenContext *context= genContext(whatVars,&prototype,0,verbose);
  if (context) {
    RooDataSet* data =  generate(*context,whatVars,&prototype,nEvents,verbose,randProtoOrder,resampleProto) ;
    delete context ;
    return data ;
  } else {
    coutE(Generation) << "RooAbsPdf::generate(" << GetName() << ") ERROR creating generator context" << endl ;
    return 0 ;
  }
}



//_____________________________________________________________________________
Int_t* RooAbsPdf::randomizeProtoOrder(Int_t nProto, Int_t, Bool_t resampleProto) const
{
  // Return lookup table with randomized access order for prototype events,
  // given nProto prototype data events and nGen events that will actually
  // be accessed

  // Make unsorted linked list of indeces
  RooLinkedList l ;
  Int_t i ;
  for (i=0 ; i<nProto ; i++) {
    l.Add(new RooInt(i)) ;
  }

  // Make output list
  Int_t* lut = new Int_t[nProto] ;

  // Randomly samply input list into output list
  if (!resampleProto) {
    // In this mode, randomization is a strict reshuffle of the order
    for (i=0 ; i<nProto ; i++) {
      Int_t iran = RooRandom::integer(nProto-i) ;
      RooInt* sample = (RooInt*) l.At(iran) ;
      lut[i] = *sample ;
      l.Remove(sample) ;
      delete sample ;
    }
  } else {
    // In this mode, we resample, i.e. events can be used more than once
    for (i=0 ; i<nProto ; i++) {
      lut[i] = RooRandom::integer(nProto);
    }
  }


  return lut ;
}



//_____________________________________________________________________________
Int_t RooAbsPdf::getGenerator(const RooArgSet &/*directVars*/, RooArgSet &/*generatedVars*/, Bool_t /*staticInitOK*/) const 
{
  // Load generatedVars with the subset of directVars that we can generate events for,
  // and return a code that specifies the generator algorithm we will use. A code of
  // zero indicates that we cannot generate any of the directVars (in this case, nothing
  // should be added to generatedVars). Any non-zero codes will be passed to our generateEvent()
  // implementation, but otherwise its value is arbitrary. The default implemetation of
  // this method returns zero. Subclasses will usually implement this method using the
  // matchArgs() methods to advertise the algorithms they provide.

  return 0 ;
}



//_____________________________________________________________________________
void RooAbsPdf::initGenerator(Int_t /*code*/) 
{  
  // Interface for one-time initialization to setup the generator for the specified code.
}



//_____________________________________________________________________________
void RooAbsPdf::generateEvent(Int_t /*code*/) 
{
  // Interface for generation of anan event using the algorithm
  // corresponding to the specified code. The meaning of each code is
  // defined by the getGenerator() implementation. The default
  // implementation does nothing.
}



//_____________________________________________________________________________
Bool_t RooAbsPdf::isDirectGenSafe(const RooAbsArg& arg) const 
{
  // Check if given observable can be safely generated using the
  // pdfs internal generator mechanism (if that existsP). Observables
  // on which a PDF depends via more than route are not safe
  // for use with internal generators because they introduce
  // correlations not known to the internal generator

  // Arg must be direct server of self
  if (!findServer(arg.GetName())) return kFALSE ;

  // There must be no other dependency routes
  TIterator* sIter = serverIterator() ;
  const RooAbsArg *server = 0;
  while((server=(const RooAbsArg*)sIter->Next())) {
    if(server == &arg) continue;
    if(server->dependsOn(arg)) {
      delete sIter ;
      return kFALSE ;
    }
  }
  delete sIter ;
  return kTRUE ;
}




//_____________________________________________________________________________
RooDataHist *RooAbsPdf::generateBinned(const RooArgSet& whatVars, Double_t nEvents, const RooCmdArg& arg1,
				       const RooCmdArg& arg2, const RooCmdArg& arg3,const RooCmdArg& arg4, const RooCmdArg& arg5) 
{
  // Generate a new dataset containing the specified variables with events sampled from our distribution. 
  // Generate the specified number of events or expectedEvents() if not specified.
  //
  // Any variables of this PDF that are not in whatVars will use their
  // current values and be treated as fixed parameters. Returns zero
  // in case of an error. The caller takes ownership of the returned
  // dataset.
  //
  // The following named arguments are supported
  //
  // Name(const char* name)             -- Name of the output dataset
  // Verbose(Bool_t flag)               -- Print informational messages during event generation
  // Extended()                         -- The actual number of events generated will be sampled from a Poisson distribution
  //                                       with mu=nevt. For use with extended maximum likelihood fits
  // ExpectedData()                     -- Return a binned dataset _without_ statistical fluctuations (also aliased as Asimov())
  return generateBinned(whatVars,RooFit::NumEvents(nEvents),arg1,arg2,arg3,arg4,arg5) ;
}



//_____________________________________________________________________________
RooDataHist *RooAbsPdf::generateBinned(const RooArgSet& whatVars, const RooCmdArg& arg1,const RooCmdArg& arg2,
				       const RooCmdArg& arg3,const RooCmdArg& arg4, const RooCmdArg& arg5,const RooCmdArg& arg6) 
{
  // Generate a new dataset containing the specified variables with events sampled from our distribution. 
  // Generate the specified number of events or expectedEvents() if not specified.
  //
  // Any variables of this PDF that are not in whatVars will use their
  // current values and be treated as fixed parameters. Returns zero
  // in case of an error. The caller takes ownership of the returned
  // dataset.
  //
  // The following named arguments are supported
  //
  // Name(const char* name)             -- Name of the output dataset
  // Verbose(Bool_t flag)               -- Print informational messages during event generation
  // NumEvent(int nevt)                 -- Generate specified number of events
  // Extended()                         -- The actual number of events generated will be sampled from a Poisson distribution
  //                                       with mu=nevt. For use with extended maximum likelihood fits
  // ExpectedData()                     -- Return a binned dataset _without_ statistical fluctuations (also aliased as Asimov())
  

  // Select the pdf-specific commands 
  RooCmdConfig pc(Form("RooAbsPdf::generate(%s)",GetName())) ;
  pc.defineString("dsetName","Name",0,"") ;
  pc.defineInt("verbose","Verbose",0,0) ;
  pc.defineInt("extended","Extended",0,0) ;
  pc.defineInt("nEvents","NumEvents",0,0) ;
  pc.defineDouble("nEventsD","NumEventsD",0,-1.) ;
  pc.defineInt("expectedData","ExpectedData",0,0) ;
  
  // Process and check varargs 
  pc.process(arg1,arg2,arg3,arg4,arg5,arg6) ;
  if (!pc.ok(kTRUE)) {
    return 0 ;
  }

  // Decode command line arguments
  Double_t nEvents = pc.getDouble("nEventsD") ;
  if (nEvents<0) {
    nEvents = pc.getInt("nEvents") ;
  }
  //Bool_t verbose = pc.getInt("verbose") ;
  Bool_t extended = pc.getInt("extended") ;
  Bool_t expectedData = pc.getInt("expectedData") ;
  const char* dsetName = pc.getString("dsetName") ;

  if (extended) {
    nEvents = (nEvents==0?Int_t(expectedEvents(&whatVars)+0.5):nEvents) ;
    cxcoutI(Generation) << " Extended mode active, number of events generated (" << nEvents << ") is Poisson fluctuation on " 
			<< GetName() << "::expectedEvents() = " << nEvents << endl ;
    // If Poisson fluctuation results in zero events, stop here
    if (nEvents==0) {
      return 0 ;
    }
  } else if (nEvents==0) {
    cxcoutI(Generation) << "No number of events specified , number of events generated is " 
			<< GetName() << "::expectedEvents() = " << expectedEvents(&whatVars)<< endl ;
  }

  // Forward to appropiate implementation
  RooDataHist* data = generateBinned(whatVars,nEvents,expectedData,extended) ;

  // Rename dataset to given name if supplied
  if (dsetName && strlen(dsetName)>0) {
    data->SetName(dsetName) ;
  }

  return data ;
}




//_____________________________________________________________________________
RooDataHist *RooAbsPdf::generateBinned(const RooArgSet &whatVars, Double_t nEvents, Bool_t expectedData, Bool_t extended) const 
{
  // Generate a new dataset containing the specified variables with
  // events sampled from our distribution. Generate the specified
  // number of events or else try to use expectedEvents() if nEvents <= 0.
  //
  // If expectedData is kTRUE (it is kFALSE by default), the returned histogram returns the 'expected'
  // data sample, i.e. no statistical fluctuations are present.
  //
  // Any variables of this PDF that are not in whatVars will use their
  // current values and be treated as fixed parameters. Returns zero
  // in case of an error. The caller takes ownership of the returned
  // dataset.

  // Create empty RooDataHist
  RooDataHist* hist = new RooDataHist("genData","genData",whatVars) ;

  // Scale to number of events and introduce Poisson fluctuations
  if (nEvents<=0) {
    if (!canBeExtended()) {
      coutE(InputArguments) << "RooAbsPdf::generateBinned(" << GetName() << ") ERROR: No event count provided and p.d.f does not provide expected number of events" << endl ;
      delete hist ;
      return 0 ;
    } else {
      // Don't round in expectedData mode
      if (expectedData) {
	nEvents = expectedEvents(&whatVars) ;
      } else {
	nEvents = Int_t(expectedEvents(&whatVars)+0.5) ;
      }
    }
  } 

  // Sample p.d.f. distribution
  fillDataHist(hist,&whatVars,1,kTRUE) ;  

  vector<int> histOut(hist->numEntries()) ;
  Double_t histMax(-1) ;
  Int_t histOutSum(0) ;
  for (int i=0 ; i<hist->numEntries() ; i++) {
    hist->get(i) ;
    if (expectedData) {

      // Expected data, multiply p.d.f by nEvents
      Double_t w=hist->weight()*nEvents ;
      hist->set(w,sqrt(w)) ;

    } else if (extended) {

      // Extended mode, set contents to Poisson(pdf*nEvents)
      Double_t w = RooRandom::randomGenerator()->Poisson(hist->weight()*nEvents) ;
      hist->set(w,sqrt(w)) ;
      
    } else {

      // Regular mode, fill array of weights with Poisson(pdf*nEvents), but to not fill
      // histogram yet.
      if (hist->weight()>histMax) {
	histMax = hist->weight() ;
      }
      histOut[i] = RooRandom::randomGenerator()->Poisson(hist->weight()*nEvents) ;
      histOutSum += histOut[i] ;
    }
  }


  if (!expectedData && !extended) {

    // Second pass for regular mode - Trim/Extend dataset to exact number of entries

    // Calculate difference between what is generated so far and what is requested
    Int_t nEvtExtra = abs(Int_t(nEvents)-histOutSum) ;
    Int_t wgt = (histOutSum>nEvents) ? -1 : 1 ;

    // Perform simple binned accept/reject procedure to get to exact event count
    while(nEvtExtra>0) {

      Int_t ibinRand = RooRandom::randomGenerator()->Integer(hist->numEntries()) ;
      hist->get(ibinRand) ;
      Double_t ranY = RooRandom::randomGenerator()->Uniform(histMax) ;

      if (ranY<hist->weight()) {
	if (wgt==1) {
	  histOut[ibinRand]++ ;
	} else {
	  // If weight is negative, prior bin content must be at least 1
	  if (histOut[ibinRand]>0) {
	    histOut[ibinRand]-- ;
	  } else {
	    continue ;
	  }
	}
	nEvtExtra-- ;
      }
    }

    // Transfer working array to histogram
    for (int i=0 ; i<hist->numEntries() ; i++) {
      hist->get(i) ;
      hist->set(histOut[i],sqrt(1.0*histOut[i])) ;
    }    

  } else if (expectedData) {

    // Second pass for expectedData mode -- Normalize to exact number of requested events
    // Minor difference may be present in first round due to difference between 
    // bin average and bin integral in sampling bins
    Double_t corr = nEvents/hist->sumEntries() ;
    for (int i=0 ; i<hist->numEntries() ; i++) {
      hist->get(i) ;
      hist->set(hist->weight()*corr,sqrt(hist->weight()*corr)) ;
    }

  }

  return hist;
}



//_____________________________________________________________________________
RooDataSet* RooAbsPdf::generateSimGlobal(const RooArgSet& whatVars, Int_t nEvents) 
{
  // Special generator interface for generation of 'global observables' -- for RooStats tools

  return generate(whatVars,nEvents) ;
}



//_____________________________________________________________________________
RooPlot* RooAbsPdf::plotOn(RooPlot* frame, RooLinkedList& cmdList) const
{
  // Plot (project) PDF on specified frame. If a PDF is plotted in an empty frame, it
  // will show a unit normalized curve in the frame variable, taken at the present value 
  // of other observables defined for this PDF
  //
  // If a PDF is plotted in a frame in which a dataset has already been plotted, it will
  // show a projected curve integrated over all variables that were present in the shown
  // dataset except for the one on the x-axis. The normalization of the curve will also
  // be adjusted to the event count of the plotted dataset. An informational message
  // will be printed for each projection step that is performed
  //
  // This function takes the following named arguments
  //
  // Projection control
  // ------------------
  // Slice(const RooArgSet& set)     -- Override default projection behaviour by omittting observables listed 
  //                                    in set from the projection, resulting a 'slice' plot. Slicing is usually
  //                                    only sensible in discrete observables
  // Project(const RooArgSet& set)   -- Override default projection behaviour by projecting over observables
  //                                    given in set and complete ignoring the default projection behavior. Advanced use only.
  // ProjWData(const RooAbsData& d)  -- Override default projection _technique_ (integration). For observables present in given dataset
  //                                    projection of PDF is achieved by constructing an average over all observable values in given set.
  //                                    Consult RooFit plotting tutorial for further explanation of meaning & use of this technique
  // ProjWData(const RooArgSet& s,   -- As above but only consider subset 's' of observables in dataset 'd' for projection through data averaging
  //           const RooAbsData& d)
  // ProjectionRange(const char* rn) -- Override default range of projection integrals to a different range speficied by given range name.
  //                                    This technique allows you to project a finite width slice in a real-valued observable
  // NormRange(const char* name)     -- Calculate curve normalization w.r.t. only in specified ranges. NB: A Range() by default implies a NormRange()
  //                                    on the same range, but this option allows to override the default, or specify a normalization ranges
  //                                    when the full curve is to be drawn
  // 
  // Misc content control
  // --------------------
  // Normalization(Double_t scale,   -- Adjust normalization by given scale factor. Interpretation of number depends on code: Relative:
  //                ScaleType code)     relative adjustment factor, NumEvent: scale to match given number of events.
  // Name(const chat* name)          -- Give curve specified name in frame. Useful if curve is to be referenced later
  // Asymmetry(const RooCategory& c) -- Show the asymmetry of the PDF in given two-state category [F(+)-F(-)] / [F(+)+F(-)] rather than
  //                                    the PDF projection. Category must have two states with indices -1 and +1 or three states with
  //                                    indeces -1,0 and +1.
  // ShiftToZero(Bool_t flag)        -- Shift entire curve such that lowest visible point is at exactly zero. Mostly useful when
  //                                    plotting -log(L) or chi^2 distributions
  // AddTo(const char* name,         -- Add constructed projection to already existing curve with given name and relative weight factors
  //       double_t wgtSelf, double_t wgtOther)
  //
  // Plotting control 
  // ----------------
  // 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 blue
  // LineWidth(Int_t width)          -- Select line with in pixels, default is 3
  // FillStyle(Int_t style)          -- Select fill style, default is not filled. If a filled style is selected, also use VLines()
  //                                    to add vertical downward lines at end of curve to ensure proper closure
  // FillColor(Int_t color)          -- Select fill color by ROOT color code
  // Range(const char* name)         -- Only draw curve in range defined by given name
  // Range(double lo, double hi)     -- Only draw curve in specified range
  // VLines()                        -- Add vertical lines to y=0 at end points of curve
  // Precision(Double_t eps)         -- Control precision of drawn curve w.r.t to scale of plot, default is 1e-3. Higher precision
  //                                    will result in more and more densely spaced curve points
  // Invisble(Bool_t flag)           -- Add curve to frame, but do not display. Useful in combination AddTo()


  // Pre-processing if p.d.f. contains a fit range and there is no command specifying one,
  // add a fit range as default range
  RooCmdArg* plotRange(0) ;
  RooCmdArg* normRange2(0) ;  
  if (getStringAttribute("fitrange") && !cmdList.FindObject("Range") && 
      !cmdList.FindObject("RangeWithName")) {
    plotRange = (RooCmdArg*) RooFit::Range(getStringAttribute("fitrange")).Clone() ;    
    cmdList.Add(plotRange) ;
  }

  if (getStringAttribute("fitrange") && !cmdList.FindObject("NormRange")) {
    normRange2 = (RooCmdArg*) RooFit::NormRange(getStringAttribute("fitrange")).Clone() ;    
    cmdList.Add(normRange2) ;
  }

  if (plotRange || normRange2) {
    coutI(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") p.d.f was fitted in range and no explicit " 
		    << (plotRange?"plot":"") << ((plotRange&&normRange2)?",":"")
		    << (normRange2?"norm":"") << " range was specified, using fit range as default" << endl ;
  }

  // Sanity checks
  if (plotSanityChecks(frame)) return frame ;

  // Select the pdf-specific commands 
  RooCmdConfig pc(Form("RooAbsPdf::plotOn(%s)",GetName())) ;
  pc.defineDouble("scaleFactor","Normalization",0,1.0) ;
  pc.defineInt("scaleType","Normalization",0,Relative) ;  
  pc.defineObject("compSet","SelectCompSet",0) ;
  pc.defineString("compSpec","SelectCompSpec",0) ;
  pc.defineObject("asymCat","Asymmetry",0) ;
  pc.defineDouble("rangeLo","Range",0,-999.) ;
  pc.defineDouble("rangeHi","Range",1,-999.) ;
  pc.defineString("rangeName","RangeWithName",0,"") ;
  pc.defineString("normRangeName","NormRange",0,"") ;
  pc.defineInt("rangeAdjustNorm","Range",0,0) ;
  pc.defineInt("rangeWNAdjustNorm","RangeWithName",0,0) ;
  pc.defineMutex("SelectCompSet","SelectCompSpec") ;
  pc.defineMutex("Range","RangeWithName") ;
  pc.allowUndefined() ; // unknowns may be handled by RooAbsReal

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

  // Decode command line arguments
  ScaleType stype = (ScaleType) pc.getInt("scaleType") ;
  Double_t scaleFactor = pc.getDouble("scaleFactor") ;
  const RooAbsCategoryLValue* asymCat = (const RooAbsCategoryLValue*) pc.getObject("asymCat") ;
  const char* compSpec = pc.getString("compSpec") ;
  const RooArgSet* compSet = (const RooArgSet*) pc.getObject("compSet") ;
  Bool_t haveCompSel = ( (compSpec && strlen(compSpec)>0) || compSet) ;

  // Suffix for curve name
  TString nameSuffix ;
  if (compSpec && strlen(compSpec)>0) {
    nameSuffix.Append("_Comp[") ;
    nameSuffix.Append(compSpec) ;
    nameSuffix.Append("]") ;    
  } else if (compSet) {
    nameSuffix.Append("_Comp[") ;
    nameSuffix.Append(compSet->contentsString().c_str()) ;
    nameSuffix.Append("]") ;    
  }

  // Remove PDF-only commands from command list
  pc.stripCmdList(cmdList,"SelectCompSet,SelectCompSpec") ;
  
  // Adjust normalization, if so requested
  if (asymCat) {
    RooCmdArg cnsuffix("CurveNameSuffix",0,0,0,0,nameSuffix.Data(),0,0,0) ;
    cmdList.Add(&cnsuffix);
    return  RooAbsReal::plotOn(frame,cmdList) ;
  }

  // More sanity checks
  Double_t nExpected(1) ;
  if (stype==RelativeExpected) {
    if (!canBeExtended()) {
      coutE(Plotting) << "RooAbsPdf::plotOn(" << GetName() 
		      << "): ERROR the 'Expected' scale option can only be used on extendable PDFs" << endl ;
      return frame ;
    }
    nExpected = expectedEvents(frame->getNormVars()) ;
  }

  if (stype != Raw) {    

    if (frame->getFitRangeNEvt() && stype==Relative) {

      Bool_t hasCustomRange(kFALSE), adjustNorm(kFALSE) ;

      list<pair<Double_t,Double_t> > rangeLim ;

      // Retrieve plot range to be able to adjust normalization to data
      if (pc.hasProcessed("Range")) {

	Double_t rangeLo = pc.getDouble("rangeLo") ;
	Double_t rangeHi = pc.getDouble("rangeHi") ;
	rangeLim.push_back(make_pair(rangeLo,rangeHi)) ;
	adjustNorm = pc.getInt("rangeAdjustNorm") ;
	hasCustomRange = kTRUE ;

	coutI(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") only plotting range [" 
			<< rangeLo << "," << rangeHi << "]" ;
	if (!pc.hasProcessed("NormRange")) {	  
	  ccoutI(Plotting) << ", curve is normalized to data in " << (adjustNorm?"given":"full") << " given range" << endl ;
	} else {
	  ccoutI(Plotting) << endl ;
	}

	nameSuffix.Append(Form("_Range[%f_%f]",rangeLo,rangeHi)) ;

      } else if (pc.hasProcessed("RangeWithName")) {    

	char tmp[1024] ;
	strlcpy(tmp,pc.getString("rangeName",0,kTRUE),1024) ;
	char* rangeNameToken = strtok(tmp,",") ;
	while(rangeNameToken) {
	  Double_t rangeLo = frame->getPlotVar()->getMin(rangeNameToken) ;
	  Double_t rangeHi = frame->getPlotVar()->getMax(rangeNameToken) ;
	  rangeLim.push_back(make_pair(rangeLo,rangeHi)) ;
	  rangeNameToken = strtok(0,",") ;
	}
	adjustNorm = pc.getInt("rangeWNAdjustNorm") ;
	hasCustomRange = kTRUE ;

	coutI(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") only plotting range '" << pc.getString("rangeName",0,kTRUE) << "'" ;
	if (!pc.hasProcessed("NormRange")) {	  
	  ccoutI(Plotting) << ", curve is normalized to data in " << (adjustNorm?"given":"full") << " given range" << endl ;
	} else {
	  ccoutI(Plotting) << endl ;
	}

	nameSuffix.Append(Form("_Range[%s]",pc.getString("rangeName"))) ;
      } 
      // Specification of a normalization range override those in a regular ranage
      if (pc.hasProcessed("NormRange")) {    
	char tmp[1024] ;
	strlcpy(tmp,pc.getString("normRangeName",0,kTRUE),1024) ;
	char* rangeNameToken = strtok(tmp,",") ;
	rangeLim.clear() ;
	while(rangeNameToken) {
	  Double_t rangeLo = frame->getPlotVar()->getMin(rangeNameToken) ;
	  Double_t rangeHi = frame->getPlotVar()->getMax(rangeNameToken) ;
	  rangeLim.push_back(make_pair(rangeLo,rangeHi)) ;
	  rangeNameToken = strtok(0,",") ;
	}
	adjustNorm = kTRUE ;
	hasCustomRange = kTRUE ;	
	coutI(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") p.d.f. curve is normalized using explicit choice of ranges '" << pc.getString("normRangeName",0,kTRUE) << "'" << endl ;

	nameSuffix.Append(Form("_NormRange[%s]",pc.getString("rangeName"))) ;

      }

      if (hasCustomRange && adjustNorm) {	

	Double_t rangeNevt(0) ;
	list<pair<Double_t,Double_t> >::iterator riter = rangeLim.begin() ;
	for (;riter!=rangeLim.end() ; ++riter) {
	  Double_t nevt= frame->getFitRangeNEvt(riter->first,riter->second) ;
	  rangeNevt += nevt ;
	}
	scaleFactor *= rangeNevt/nExpected ;

      } else {
	scaleFactor *= frame->getFitRangeNEvt()/nExpected ;
      }
    } else if (stype==RelativeExpected) {
      scaleFactor *= nExpected ; 
    } else if (stype==NumEvent) {
      scaleFactor /= nExpected ;
    }
    scaleFactor *= frame->getFitRangeBinW() ;
  } 
  frame->updateNormVars(*frame->getPlotVar()) ;

  // Append overriding scale factor command at end of original command list
  RooCmdArg tmp = RooFit::Normalization(scaleFactor,Raw) ;
  cmdList.Add(&tmp) ;

  // Was a component selected requested
  if (haveCompSel) {
    
    // Get complete set of tree branch nodes
    RooArgSet branchNodeSet ;
    branchNodeServerList(&branchNodeSet) ;
    
    // Discard any non-RooAbsReal nodes
    TIterator* iter = branchNodeSet.createIterator() ;
    RooAbsArg* arg ;
    while((arg=(RooAbsArg*)iter->Next())) {
      if (!dynamic_cast<RooAbsReal*>(arg)) {
	branchNodeSet.remove(*arg) ;
      }
    }
    delete iter ;
    
    // Obtain direct selection
    RooArgSet* dirSelNodes ;
    if (compSet) {
      dirSelNodes = (RooArgSet*) branchNodeSet.selectCommon(*compSet) ;
    } else {
      dirSelNodes = (RooArgSet*) branchNodeSet.selectByName(compSpec) ;
    }
    if (dirSelNodes->getSize()>0) {
      coutI(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") directly selected PDF components: " << *dirSelNodes << endl ;
      
      // Do indirect selection and activate both
      plotOnCompSelect(dirSelNodes) ;
    } else {
      if (compSet) {
	coutE(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") ERROR: component selection set " << *compSet << " does not match any components of p.d.f." << endl ;
      } else {
	coutE(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") ERROR: component selection expression '" << compSpec << "' does not select any components of p.d.f." << endl ;
      }
      return 0 ;
    }

    delete dirSelNodes ;
  }


  RooCmdArg cnsuffix("CurveNameSuffix",0,0,0,0,nameSuffix.Data(),0,0,0) ;
  cmdList.Add(&cnsuffix);

  RooPlot* ret =  RooAbsReal::plotOn(frame,cmdList) ;
  
  // Restore selection status ;
  if (haveCompSel) plotOnCompSelect(0) ;

  if (plotRange) {
    delete plotRange ;
  }
  if (normRange2) {
    delete normRange2 ;
  }  

  return ret ;
}



//_____________________________________________________________________________
void RooAbsPdf::plotOnCompSelect(RooArgSet* selNodes) const
{
  // Helper function for plotting of composite p.d.fs. Given
  // a set of selected components that should be plotted,
  // find all nodes that (in)directly depend on these selected
  // nodes. Mark all directly and indirecty selected nodes
  // as 'selected' using the selectComp() method

  // Get complete set of tree branch nodes
  RooArgSet branchNodeSet ;
  branchNodeServerList(&branchNodeSet) ;

  // Discard any non-PDF nodes
  TIterator* iter = branchNodeSet.createIterator() ;
  RooAbsArg* arg ;
  while((arg=(RooAbsArg*)iter->Next())) {
    if (!dynamic_cast<RooAbsReal*>(arg)) {
      branchNodeSet.remove(*arg) ;
    }
  }

  // If no set is specified, restored all selection bits to kTRUE
  if (!selNodes) {
    // Reset PDF selection bits to kTRUE
    iter->Reset() ;
    while((arg=(RooAbsArg*)iter->Next())) {
      ((RooAbsReal*)arg)->selectComp(kTRUE) ;
    }
    delete iter ;
    return ;
  }


  // Add all nodes below selected nodes
  iter->Reset() ;
  TIterator* sIter = selNodes->createIterator() ;
  RooArgSet tmp ;
  while((arg=(RooAbsArg*)iter->Next())) {
    sIter->Reset() ;
    RooAbsArg* selNode ;
    while((selNode=(RooAbsArg*)sIter->Next())) {
      if (selNode->dependsOn(*arg)) {
	tmp.add(*arg,kTRUE) ;
      }      
    }      
  }
  delete sIter ;

  // Add all nodes that depend on selected nodes
  iter->Reset() ;
  while((arg=(RooAbsArg*)iter->Next())) {
    if (arg->dependsOn(*selNodes)) {
      tmp.add(*arg,kTRUE) ;
    }
  }

  tmp.remove(*selNodes,kTRUE) ;
  tmp.remove(*this) ;
  selNodes->add(tmp) ;
  coutI(Plotting) << "RooAbsPdf::plotOn(" << GetName() << ") indirectly selected PDF components: " << tmp << endl ;

  // Set PDF selection bits according to selNodes
  iter->Reset() ;
  while((arg=(RooAbsArg*)iter->Next())) {
    Bool_t select = selNodes->find(arg->GetName()) ? kTRUE : kFALSE ;
    ((RooAbsReal*)arg)->selectComp(select) ;
  }
  
  delete iter ;
} 




//_____________________________________________________________________________
// coverity[PASS_BY_VALUE]
RooPlot* RooAbsPdf::plotOn(RooPlot *frame, PlotOpt o) const
{
  // Plot oneself on 'frame'. In addition to features detailed in  RooAbsReal::plotOn(),
  // the scale factor for a PDF can be interpreted in three different ways. The interpretation
  // is controlled by ScaleType
  //
  //  Relative  -  Scale factor is applied on top of PDF normalization scale factor 
  //  NumEvent  -  Scale factor is interpreted as a number of events. The surface area
  //               under the PDF curve will match that of a histogram containing the specified
  //               number of event
  //  Raw       -  Scale factor is applied to the raw (projected) probability density.
  //               Not too useful, option provided for completeness.

  // Sanity checks
  if (plotSanityChecks(frame)) return frame ;

  // More sanity checks
  Double_t nExpected(1) ;
  if (o.stype==RelativeExpected) {
    if (!canBeExtended()) {
      coutE(Plotting) << "RooAbsPdf::plotOn(" << GetName() 
		      << "): ERROR the 'Expected' scale option can only be used on extendable PDFs" << endl ;
      return frame ;
    }
    nExpected = expectedEvents(frame->getNormVars()) ;
  }

  // Adjust normalization, if so requested
  if (o.stype != Raw) {    

    if (frame->getFitRangeNEvt() && o.stype==Relative) {
      // If non-default plotting range is specified, adjust number of events in fit range
      o.scaleFactor *= frame->getFitRangeNEvt()/nExpected ;
    } else if (o.stype==RelativeExpected) {
      o.scaleFactor *= nExpected ;
    } else if (o.stype==NumEvent) {
      o.scaleFactor /= nExpected ;
    }
    o.scaleFactor *= frame->getFitRangeBinW() ;
  }
  frame->updateNormVars(*frame->getPlotVar()) ;

  return RooAbsReal::plotOn(frame,o) ;
}




//_____________________________________________________________________________
RooPlot* RooAbsPdf::paramOn(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 parameter values (and errors) to the specified frame
  //
  // The following named arguments are supported
  //
  //   Parameters(const RooArgSet& param) -- Only the specified subset of parameters will be shown. 
  //                                         By default all non-contant parameters are shown
  //   ShowConstants(Bool_t flag)         -- Also display constant parameters
  //   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
  //                                 
  //
  // 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)
  //
  // Example use: pdf.paramOn(frame, Label("fit result"), Format("NEU",AutoPrecision(1)) ) ;
  //

  // 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("RooAbsPdf::paramOn(%s)",GetName())) ;
  pc.defineString("label","Label",0,"") ;
  pc.defineDouble("xmin","Layout",0,0.50) ;
  pc.defineDouble("xmax","Layout",1,0.99) ;
  pc.defineInt("ymaxi","Layout",0,Int_t(0.95*10000)) ;
  pc.defineInt("showc","ShowConstants",0,0) ;
  pc.defineObject("params","Parameters",0,0) ;
  pc.defineString("formatStr","Format",0,"NELU") ;
  pc.defineInt("sigDigit","Format",0,2) ;
  pc.defineInt("dummy","FormatArgs",0,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. ;
  Int_t showc = pc.getInt("showc") ;


  const char* formatStr = pc.getString("formatStr") ;
  Int_t sigDigit = pc.getInt("sigDigit") ;  

  // Decode command line arguments
  RooArgSet* params = static_cast<RooArgSet*>(pc.getObject("params")) ;
  if (!params) {
    params = getParameters(frame->getNormVars()) ;
    if (pc.hasProcessed("FormatArgs")) {
      const RooCmdArg* formatCmd = static_cast<RooCmdArg*>(cmdList.FindObject("FormatArgs")) ;
      paramOn(frame,*params,showc,label,0,0,xmin,xmax,ymax,formatCmd) ;
    } else {
      paramOn(frame,*params,showc,label,sigDigit,formatStr,xmin,xmax,ymax) ;
    }
    delete params ;
  } else {
    RooArgSet* pdfParams = getParameters(frame->getNormVars()) ;    
    RooArgSet* selParams = static_cast<RooArgSet*>(pdfParams->selectCommon(*params)) ;
    if (pc.hasProcessed("FormatArgs")) {
      const RooCmdArg* formatCmd = static_cast<RooCmdArg*>(cmdList.FindObject("FormatArgs")) ;
      paramOn(frame,*selParams,showc,label,0,0,xmin,xmax,ymax,formatCmd) ;
    } else {
      paramOn(frame,*selParams,showc,label,sigDigit,formatStr,xmin,xmax,ymax) ;
    }
    delete selParams ;
    delete pdfParams ;
  }
  
  return frame ;
}




//_____________________________________________________________________________
RooPlot* RooAbsPdf::paramOn(RooPlot* frame, const RooAbsData* data, const char *label,
			    Int_t sigDigits, Option_t *options, Double_t xmin,
			    Double_t xmax ,Double_t ymax) 
{
  // OBSOLETE FUNCTION PROVIDED FOR BACKWARD COMPATIBILITY

  RooArgSet* params = getParameters(data) ;
  TString opts(options) ;  
  paramOn(frame,*params,opts.Contains("c"),label,sigDigits,options,xmin,xmax,ymax) ;
  delete params ;
  return frame ;
}



//_____________________________________________________________________________
RooPlot* RooAbsPdf::paramOn(RooPlot* frame, const RooArgSet& params, Bool_t showConstants, const char *label,
			    Int_t sigDigits, Option_t *options, Double_t xmin,
			    Double_t xmax ,Double_t ymax, const RooCmdArg* formatCmd) 
{
  // Add a text box with the current parameter values and their errors to the frame.
  // Observables of this PDF appearing in the 'data' dataset will be omitted.
  //
  // Optional label will be inserted as first line of the text box. Use 'sigDigits'
  // to modify the default number of significant digits printed. The 'xmin,xmax,ymax'
  // values specify the inital relative position of the text box in the plot frame  


  // parse the options
  TString opts = options;
  opts.ToLower();
  Bool_t showLabel= (label != 0 && strlen(label) > 0);
  
  // calculate the box's size, adjusting for constant parameters
  TIterator* pIter = params.createIterator() ;

  Double_t ymin(ymax), dy(0.06);
  RooRealVar *var = 0;
  while((var=(RooRealVar*)pIter->Next())) {
    if(showConstants || !var->isConstant()) ymin-= 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_paramBox",GetName())) ;
  box->SetFillColor(0);
  box->SetBorderSize(1);
  box->SetTextAlign(12);
  box->SetTextSize(0.04F);
  box->SetFillStyle(1001);
  box->SetFillColor(0);
  //char buffer[512];
  pIter->Reset() ;
  while((var=(RooRealVar*)pIter->Next())) {
    if(var->isConstant() && !showConstants) continue;
    
    TString *formatted= options ? var->format(sigDigits, options) : var->format(*formatCmd) ;
    box->AddText(formatted->Data());
    delete formatted;
  }
  // add the optional label if specified
  if(showLabel) box->AddText(label);

  // Add box to frame 
  frame->addObject(box) ;

  delete pIter ;
  return frame ;
}




//_____________________________________________________________________________
Double_t RooAbsPdf::expectedEvents(const RooArgSet*) const 
{ 
  // Return expected number of events from this p.d.f for use in extended
  // likelihood calculations. This default implementation returns zero
  return 0 ; 
} 



//_____________________________________________________________________________
void RooAbsPdf::verboseEval(Int_t stat) 
{ 
  // Change global level of verbosity for p.d.f. evaluations

  _verboseEval = stat ; 
}



//_____________________________________________________________________________
Int_t RooAbsPdf::verboseEval() 
{ 
  // Return global level of verbosity for p.d.f. evaluations

  return _verboseEval ;
}



//_____________________________________________________________________________
void RooAbsPdf::CacheElem::operModeHook(RooAbsArg::OperMode) 
{
  // Dummy implementation
}



//_____________________________________________________________________________
RooAbsPdf::CacheElem::~CacheElem() 
{ 
  // Destructor of normalization cache element. If this element 
  // provides the 'current' normalization stored in RooAbsPdf::_norm
  // zero _norm pointer here before object pointed to is deleted here

  // Zero _norm pointer in RooAbsPdf if it is points to our cache payload
  if (_owner) {
    RooAbsPdf* pdfOwner = static_cast<RooAbsPdf*>(_owner) ;
    if (pdfOwner->_norm == _norm) {
      pdfOwner->_norm = 0 ;
    }
  }

  delete _norm ; 
} 



//_____________________________________________________________________________
RooAbsPdf* RooAbsPdf::createProjection(const RooArgSet& iset) 
{
  // Return a p.d.f that represent a projection of this p.d.f integrated over given observables

  // Construct name for new object
  TString name(GetName()) ;
  name.Append("_Proj[") ;
  if (iset.getSize()>0) {
    TIterator* iter = iset.createIterator() ;
    RooAbsArg* arg ;
    Bool_t first(kTRUE) ;
    while((arg=(RooAbsArg*)iter->Next())) {
      if (first) {
	first=kFALSE ;
      } else {
	name.Append(",") ;
      }
      name.Append(arg->GetName()) ;
    }
    delete iter ;
  }
  name.Append("]") ;
  
  // Return projected p.d.f.
  return new RooProjectedPdf(name.Data(),name.Data(),*this,iset) ;
}



//_____________________________________________________________________________
RooAbsReal* RooAbsPdf::createCdf(const RooArgSet& iset, const RooArgSet& nset) 
{
  // Create a cumulative distribution function of this p.d.f in terms
  // of the observables listed in iset. If no nset argument is given
  // the c.d.f normalization is constructed over the integrated
  // observables, so that its maximum value is precisely 1. It is also
  // possible to choose a different normalization for
  // multi-dimensional p.d.f.s: eg. for a pdf f(x,y,z) one can
  // construct a partial cdf c(x,y) that only when integrated itself
  // over z results in a maximum value of 1. To construct such a cdf pass
  // z as argument to the optional nset argument

  return createCdf(iset,RooFit::SupNormSet(nset)) ;
}



//_____________________________________________________________________________
RooAbsReal* RooAbsPdf::createCdf(const RooArgSet& iset, 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 an object that represents the integral of the function over one or more observables listed in iset
  // The actual integration calculation is only performed when the return object is evaluated. The name
  // of the integral object is automatically constructed from the name of the input function, the variables
  // it integrates and the range integrates over
  //
  // The following named arguments are accepted
  //
  // SupNormSet(const RooArgSet&)         -- Observables over which should be normalized _in_addition_ to the
  //                                         integration observables
  // ScanNumCdf()                         -- Apply scanning technique if cdf integral involves numeric integration [ default ] 
  // ScanAllCdf()                         -- Always apply scanning technique 
  // ScanNoCdf()                          -- Never apply scanning technique                  
  // ScanParameters(Int_t nbins,          -- Parameters for scanning technique of making CDF: number
  //                Int_t intOrder)          of sampled bins and order of interpolation applied on numeric cdf

  // Define configuration for this method
  RooCmdConfig pc(Form("RooAbsReal::createCdf(%s)",GetName())) ;
  pc.defineObject("supNormSet","SupNormSet",0,0) ;
  pc.defineInt("numScanBins","ScanParameters",0,1000) ;
  pc.defineInt("intOrder","ScanParameters",1,2) ;
  pc.defineInt("doScanNum","ScanNumCdf",0,1) ;
  pc.defineInt("doScanAll","ScanAllCdf",0,0) ;
  pc.defineInt("doScanNon","ScanNoCdf",0,0) ;
  pc.defineMutex("ScanNumCdf","ScanAllCdf","ScanNoCdf") ;

  // 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 RooArgSet* snset = static_cast<const RooArgSet*>(pc.getObject("supNormSet",0)) ;
  RooArgSet nset ;
  if (snset) {
    nset.add(*snset) ;
  }
  Int_t numScanBins = pc.getInt("numScanBins") ;
  Int_t intOrder = pc.getInt("intOrder") ;
  Int_t doScanNum = pc.getInt("doScanNum") ;
  Int_t doScanAll = pc.getInt("doScanAll") ;
  Int_t doScanNon = pc.getInt("doScanNon") ;

  // If scanning technique is not requested make integral-based cdf and return
  if (doScanNon) {
    return createIntRI(iset,nset) ;
  }
  if (doScanAll) {
    return createScanCdf(iset,nset,numScanBins,intOrder) ;
  }
  if (doScanNum) {
    RooRealIntegral* tmp = (RooRealIntegral*) createIntegral(iset) ;
    Int_t isNum= (tmp->numIntRealVars().getSize()>0) ;
    delete tmp ;

    if (isNum) {
      coutI(NumIntegration) << "RooAbsPdf::createCdf(" << GetName() << ") integration over observable(s) " << iset << " involves numeric integration," << endl 
			    << "      constructing cdf though numeric integration of sampled pdf in " << numScanBins << " bins and applying order " 
			    << intOrder << " interpolation on integrated histogram." << endl 
			    << "      To override this choice of technique use argument ScanNone(), to change scan parameters use ScanParameters(nbins,order) argument" << endl ;
    }
    
    return isNum ? createScanCdf(iset,nset,numScanBins,intOrder) : createIntRI(iset,nset) ;
  }
  return 0 ;
}

RooAbsReal* RooAbsPdf::createScanCdf(const RooArgSet& iset, const RooArgSet& nset, Int_t numScanBins, Int_t intOrder) 
{
  string name = string(GetName()) + "_NUMCDF_" + integralNameSuffix(iset,&nset).Data() ;  
  RooRealVar* ivar = (RooRealVar*) iset.first() ;
  ivar->setBins(numScanBins,"numcdf") ;
  RooNumCdf* ret = new RooNumCdf(name.c_str(),name.c_str(),*this,*ivar,"numcdf") ;
  ret->setInterpolationOrder(intOrder) ;
  return ret ;
}




//_____________________________________________________________________________
RooArgSet* RooAbsPdf::getAllConstraints(const RooArgSet& observables, RooArgSet& constrainedParams, Bool_t stripDisconnected) const 
{
  // This helper function finds and collects all constraints terms of all coponent p.d.f.s
  // and returns a RooArgSet with all those terms

  RooArgSet* ret = new RooArgSet("AllConstraints") ;

  RooArgSet* comps = getComponents() ;
  TIterator* iter = comps->createIterator() ;
  RooAbsArg *arg ;
  while((arg=(RooAbsArg*)iter->Next())) {
    RooAbsPdf* pdf = dynamic_cast<RooAbsPdf*>(arg) ;
    if (pdf && !ret->find(pdf->GetName())) {
      RooArgSet* compRet = pdf->getConstraints(observables,constrainedParams,stripDisconnected) ;
      if (compRet) {
	ret->add(*compRet,kFALSE) ;
	delete compRet ;
      }
    }
  }
  delete iter ;
  delete comps ;

  return ret ;
}


//_____________________________________________________________________________
void RooAbsPdf::clearEvalError() 
{ 
  // Clear the evaluation error flag
  _evalError = kFALSE ; 
}



//_____________________________________________________________________________
Bool_t RooAbsPdf::evalError() 
{ 
  // Return the evaluation error flag
  return _evalError ; 
}



//_____________________________________________________________________________
void RooAbsPdf::raiseEvalError() 
{ 
  // Raise the evaluation error flag
  _evalError = kTRUE ; 
}



//_____________________________________________________________________________
RooNumGenConfig* RooAbsPdf::defaultGeneratorConfig() 
{
  // Returns the default numeric MC generator configuration for all RooAbsReals
  return &RooNumGenConfig::defaultConfig() ;
}


//_____________________________________________________________________________
RooNumGenConfig* RooAbsPdf::specialGeneratorConfig() const 
{
  // Returns the specialized integrator configuration for _this_ RooAbsReal.
  // If this object has no specialized configuration, a null pointer is returned
  return _specGeneratorConfig ;
}



//_____________________________________________________________________________
RooNumGenConfig* RooAbsPdf::specialGeneratorConfig(Bool_t createOnTheFly) 
{
  // Returns the specialized integrator configuration for _this_ RooAbsReal.
  // If this object has no specialized configuration, a null pointer is returned,
  // unless createOnTheFly is kTRUE in which case a clone of the default integrator
  // configuration is created, installed as specialized configuration, and returned

  if (!_specGeneratorConfig && createOnTheFly) {
    _specGeneratorConfig = new RooNumGenConfig(*defaultGeneratorConfig()) ;
  }
  return _specGeneratorConfig ;
}



//_____________________________________________________________________________
const RooNumGenConfig* RooAbsPdf::getGeneratorConfig() const 
{
  // Return the numeric MC generator configuration used for this object. If
  // a specialized configuration was associated with this object, that configuration
  // is returned, otherwise the default configuration for all RooAbsReals is returned

  const RooNumGenConfig* config = specialGeneratorConfig() ;
  if (config) return config ;
  return defaultGeneratorConfig() ;
}



//_____________________________________________________________________________
void RooAbsPdf::setGeneratorConfig(const RooNumGenConfig& config) 
{
  // Set the given configuration as default numeric MC generator
  // configuration for this object
  if (_specGeneratorConfig) {
    delete _specGeneratorConfig ;
  }
  _specGeneratorConfig = new RooNumGenConfig(config) ;  
}



//_____________________________________________________________________________
void RooAbsPdf::setGeneratorConfig() 
{
  // Remove the specialized numeric MC generator configuration associated
  // with this object
  if (_specGeneratorConfig) {
    delete _specGeneratorConfig ;
  }
  _specGeneratorConfig = 0 ;
}



//_____________________________________________________________________________
RooAbsPdf::GenSpec::~GenSpec() 
{
  delete _genContext ;
}


//_____________________________________________________________________________
RooAbsPdf::GenSpec::GenSpec(RooAbsGenContext* context, const RooArgSet& whatVars, RooDataSet* protoData, Int_t nGen, 
			    Bool_t extended, Bool_t randProto, Bool_t resampleProto, TString dsetName, Bool_t init) :
  _genContext(context), _whatVars(whatVars), _protoData(protoData), _nGen(nGen), _extended(extended), 
  _randProto(randProto), _resampleProto(resampleProto), _dsetName(dsetName), _init(init)
{
}



//_____________________________________________________________________________
void RooAbsPdf::setNormRange(const char* rangeName) 
{ 
  if (rangeName) {
    _normRange = rangeName ; 
  } else {
    _normRange.Clear() ; 
  }

  if (_norm) { 
    _normMgr.sterilize() ;
    _norm = 0 ; 
  }
}


//_____________________________________________________________________________
void RooAbsPdf::setNormRangeOverride(const char* rangeName) 
{
  if (rangeName) {
    _normRangeOverride = rangeName ; 
  } else {
    _normRangeOverride.Clear() ; 
  }

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