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

//////////////////////////////////////////////////////////////////////////////
// 
// BEGIN_HTML
// RooAbsReal is the common abstract base class for objects that represent a
// real value and implements functionality common to all real-valued objects
// such as the ability to plot them, to construct integrals of them, the
// ability to advertise (partial) analytical integrals etc..

// Implementation of RooAbsReal may be derived, thus no interface
// is provided to modify the contents.
// 
// 
// END_HTML
//

#include <sys/types.h>


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

#include "RooAbsReal.h"
#include "RooAbsReal.h"
#include "RooArgSet.h"
#include "RooArgList.h"
#include "RooBinning.h"
#include "RooPlot.h"
#include "RooCurve.h"
#include "RooRealVar.h"
#include "RooArgProxy.h"
#include "RooFormulaVar.h"
#include "RooRealBinding.h"
#include "RooRealIntegral.h"
#include "RooAbsCategoryLValue.h"
#include "RooCustomizer.h"
#include "RooAbsData.h"
#include "RooScaledFunc.h"
#include "RooAddPdf.h"
#include "RooCmdConfig.h"
#include "RooCategory.h"
#include "RooNumIntConfig.h"
#include "RooAddition.h"
#include "RooDataSet.h"
#include "RooDataHist.h"
#include "RooDataWeightedAverage.h"
#include "RooNumRunningInt.h"
#include "RooGlobalFunc.h"
#include "RooParamBinning.h"
#include "RooProfileLL.h"
#include "RooFunctor.h"
#include "RooDerivative.h"
#include "RooGenFunction.h"
#include "RooMultiGenFunction.h"
#include "RooCmdConfig.h"
#include "RooXYChi2Var.h"
#include "RooMinuit.h"
#ifndef __ROOFIT_NOROOMINIMIZER
#include "RooMinimizer.h"
#endif
#include "RooChi2Var.h"
#include "RooFitResult.h"
#include "RooAbsMoment.h"
#include "RooMoment.h"
#include "RooFirstMoment.h"
#include "RooSecondMoment.h"
#include "RooBrentRootFinder.h"
#include "RooVectorDataStore.h"
#include "RooCachedReal.h"

#include "Riostream.h"

#include "Math/IFunction.h"
#include "TMath.h"
#include "TObjString.h"
#include "TTree.h"
#include "TH1.h"
#include "TH2.h"
#include "TH3.h"
#include "TBranch.h"
#include "TLeaf.h"
#include "TAttLine.h"
#include "TF1.h"
#include "TF2.h"
#include "TF3.h"
#include "TMatrixD.h"
#include "TVector.h"

#include <sstream>

using namespace std ;
 
ClassImp(RooAbsReal)
;

Bool_t RooAbsReal::_cacheCheck(kFALSE) ;
Bool_t RooAbsReal::_globalSelectComp = kFALSE ;
Bool_t RooAbsReal::_hideOffset = kTRUE ;

void RooAbsReal::setHideOffset(Bool_t flag) { _hideOffset = flag ; }
Bool_t RooAbsReal::hideOffset() { return _hideOffset ; }

RooAbsReal::ErrorLoggingMode RooAbsReal::_evalErrorMode = RooAbsReal::PrintErrors ;
Int_t RooAbsReal::_evalErrorCount = 0 ;
map<const RooAbsArg*,pair<string,list<RooAbsReal::EvalError> > > RooAbsReal::_evalErrorList ;


//_____________________________________________________________________________
RooAbsReal::RooAbsReal() : _specIntegratorConfig(0), _treeVar(kFALSE), _selectComp(kTRUE), _lastNSet(0)
{
  // coverity[UNINIT_CTOR]
  // Default constructor
}



//_____________________________________________________________________________
RooAbsReal::RooAbsReal(const char *name, const char *title, const char *unit) : 
  RooAbsArg(name,title), _plotMin(0), _plotMax(0), _plotBins(100), 
  _value(0),  _unit(unit), _forceNumInt(kFALSE), _specIntegratorConfig(0), _treeVar(kFALSE), _selectComp(kTRUE), _lastNSet(0)
{
  // Constructor with unit label
  setValueDirty() ;
  setShapeDirty() ;

}



//_____________________________________________________________________________
RooAbsReal::RooAbsReal(const char *name, const char *title, Double_t inMinVal,
		       Double_t inMaxVal, const char *unit) :
  RooAbsArg(name,title), _plotMin(inMinVal), _plotMax(inMaxVal), _plotBins(100),
  _value(0), _unit(unit), _forceNumInt(kFALSE), _specIntegratorConfig(0), _treeVar(kFALSE), _selectComp(kTRUE), _lastNSet(0)
{
  // Constructor with plot range and unit label
  setValueDirty() ;
  setShapeDirty() ;

}



//_____________________________________________________________________________
RooAbsReal::RooAbsReal(const RooAbsReal& other, const char* name) : 
  RooAbsArg(other,name), _plotMin(other._plotMin), _plotMax(other._plotMax), 
  _plotBins(other._plotBins), _value(other._value), _unit(other._unit), _label(other._label), 
  _forceNumInt(other._forceNumInt), _treeVar(other._treeVar), _selectComp(other._selectComp), _lastNSet(0)
{
  // coverity[UNINIT_CTOR]
  // Copy constructor

  if (other._specIntegratorConfig) {
    _specIntegratorConfig = new RooNumIntConfig(*other._specIntegratorConfig) ;
  } else {
    _specIntegratorConfig = 0 ;
  }
}



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

  if (_specIntegratorConfig) delete _specIntegratorConfig ;
}



//_____________________________________________________________________________
Bool_t RooAbsReal::operator==(Double_t value) const
{
  // Equality operator comparing to a Double_t
  return (getVal()==value) ;
}



//_____________________________________________________________________________
Bool_t RooAbsReal::operator==(const RooAbsArg& other) 
{
  // Equality operator when comparing to another RooAbsArg.
  // Only functional when the other arg is a RooAbsReal

  const RooAbsReal* otherReal = dynamic_cast<const RooAbsReal*>(&other) ;
  return otherReal ? operator==(otherReal->getVal()) : kFALSE ;
}


//_____________________________________________________________________________
Bool_t RooAbsReal::isIdentical(const RooAbsArg& other, Bool_t assumeSameType)  
{
  if (!assumeSameType) {
    const RooAbsReal* otherReal = dynamic_cast<const RooAbsReal*>(&other) ;
    return otherReal ? operator==(otherReal->getVal()) : kFALSE ;
  } else {
    return getVal()==((RooAbsReal&)other).getVal() ;
  }
}


//_____________________________________________________________________________
TString RooAbsReal::getTitle(Bool_t appendUnit) const 
{
  // Return this variable's title string. If appendUnit is true and
  // this variable has units, also append a string " (<unit>)".
  
  TString title(GetTitle());
  if(appendUnit && 0 != strlen(getUnit())) {
    title.Append(" (");
    title.Append(getUnit());
    title.Append(")");
  }
  return title;
}



//_____________________________________________________________________________
Double_t RooAbsReal::getValV(const RooArgSet* nset) const
{
  // Return value of object. If the cache is clean, return the
  // cached value, otherwise recalculate on the fly and refill
  // the cache

  if (nset && nset!=_lastNSet) {
    ((RooAbsReal*) this)->setProxyNormSet(nset) ;    
    _lastNSet = (RooArgSet*) nset ;
  }

  if (isValueDirtyAndClear()) {
    _value = traceEval(nset) ;
    //     clearValueDirty() ; 
  } 
  //   cout << "RooAbsReal::getValV(" << GetName() << ") writing _value = " << _value << endl ;

  Double_t ret(_value) ;
  if (hideOffset()) ret += offset() ;    

  return ret ;
}


//_____________________________________________________________________________
Int_t RooAbsReal::numEvalErrorItems() 
{ 
  return _evalErrorList.size() ; 
}


//_____________________________________________________________________________
RooAbsReal::EvalErrorIter RooAbsReal::evalErrorIter() 
{ 
  return _evalErrorList.begin() ; 
} 


//_____________________________________________________________________________
Double_t RooAbsReal::traceEval(const RooArgSet* /*nset*/) const
{
  // Calculate current value of object, with error tracing wrapper

  Double_t value = evaluate() ;

  if (TMath::IsNaN(value)) {
    logEvalError("function value is NAN") ;
  }

  //cxcoutD(Tracing) << "RooAbsReal::getValF(" << GetName() << ") operMode = " << _operMode << " recalculated, new value = " << value << endl ;
  
  //Standard tracing code goes here
  if (!isValidReal(value)) {
    coutW(Tracing) << "RooAbsReal::traceEval(" << GetName() 
		   << "): validation failed: " << value << endl ;
  }

  //Call optional subclass tracing code
  //   traceEvalHook(value) ;

  return value ;
}



//_____________________________________________________________________________
Int_t RooAbsReal::getAnalyticalIntegralWN(RooArgSet& allDeps, RooArgSet& analDeps, 
					  const RooArgSet* /*normSet*/, const char* rangeName) const
{
  // Variant of getAnalyticalIntegral that is also passed the normalization set
  // that should be applied to the integrand of which the integral is request.
  // For certain operator p.d.f it is useful to overload this function rather
  // than analyticalIntegralWN() as the additional normalization information
  // may be useful in determining a more efficient decomposition of the
  // requested integral

  return _forceNumInt ? 0 : getAnalyticalIntegral(allDeps,analDeps,rangeName) ;
}



//_____________________________________________________________________________
Int_t RooAbsReal::getAnalyticalIntegral(RooArgSet& /*integSet*/, RooArgSet& /*anaIntSet*/, const char* /*rangeName*/) const
{
  // Interface function getAnalyticalIntergral 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.
  
  return 0 ;
}



//_____________________________________________________________________________
Double_t RooAbsReal::analyticalIntegralWN(Int_t code, const RooArgSet* normSet, const char* rangeName) const
{
  // Implements the actual analytical integral(s) advertised by
  // getAnalyticalIntegral.  This functions will only be called with
  // codes returned by getAnalyticalIntegral, except code zero.

//   cout << "RooAbsReal::analyticalIntegralWN(" << GetName() << ") code = " << code << " normSet = " << (normSet?*normSet:RooArgSet()) << endl ;
  if (code==0) return getVal(normSet) ;
  return analyticalIntegral(code,rangeName) ;
}



//_____________________________________________________________________________
Double_t RooAbsReal::analyticalIntegral(Int_t code, const char* /*rangeName*/) const
{
  // Implements the actual analytical integral(s) advertised by
  // getAnalyticalIntegral.  This functions will only be called with
  // codes returned by getAnalyticalIntegral, except code zero.

  // By default no analytical integrals are implemented
  coutF(Eval)  << "RooAbsReal::analyticalIntegral(" << GetName() << ") code " << code << " not implemented" << endl ;
  return 0 ;
}



//_____________________________________________________________________________
const char *RooAbsReal::getPlotLabel() const 
{
  // Get the label associated with the variable

  return _label.IsNull() ? fName.Data() : _label.Data();
}



//_____________________________________________________________________________
void RooAbsReal::setPlotLabel(const char *label) 
{
  // Set the label associated with this variable

  _label= label;
}



//_____________________________________________________________________________
Bool_t RooAbsReal::readFromStream(istream& /*is*/, Bool_t /*compact*/, Bool_t /*verbose*/) 
{
  //Read object contents from stream (dummy for now)

  return kFALSE ;
} 



//_____________________________________________________________________________
void RooAbsReal::writeToStream(ostream& /*os*/, Bool_t /*compact*/) const
{
  //Write object contents to stream (dummy for now)
}



//_____________________________________________________________________________
void RooAbsReal::printValue(ostream& os) const
{
  // Print object value 
  os << getVal() ;
}



//_____________________________________________________________________________
void RooAbsReal::printMultiline(ostream& os, Int_t contents, Bool_t verbose, TString indent) const
{
  // Structure printing

  RooAbsArg::printMultiline(os,contents,verbose,indent) ;
  os << indent << "--- RooAbsReal ---" << endl;
  TString unit(_unit);
  if(!unit.IsNull()) unit.Prepend(' ');
  //os << indent << "  Value = " << getVal() << unit << endl;
  os << endl << indent << "  Plot label is \"" << getPlotLabel() << "\"" << endl;

}


//_____________________________________________________________________________
Bool_t RooAbsReal::isValid() const 
{
  // Check if current value is valid

  return isValidReal(_value) ;
}



//_____________________________________________________________________________
Bool_t RooAbsReal::isValidReal(Double_t /*value*/, Bool_t /*printError*/) const 
{
  // Interface function to check if given value is a valid value for this object.
  // This default implementation considers all values valid

  return kTRUE ;
}




//_____________________________________________________________________________
RooAbsReal* RooAbsReal::createProfile(const RooArgSet& paramsOfInterest) 
{
  // Create a RooProfileLL object that eliminates all nuisance parameters in the
  // present function. The nuisance parameters are defined as all parameters
  // of the function except the stated paramsOfInterest

  // Construct name of profile object
  TString name(Form("%s_Profile[",GetName())) ;
  TIterator* iter = paramsOfInterest.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("]") ;
  
  // Create and return profile object
  return new RooProfileLL(name.Data(),Form("Profile of %s",GetTitle()),*this,paramsOfInterest) ;
}
       





//_____________________________________________________________________________
RooAbsReal* RooAbsReal::createIntegral(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) const 
{
  // 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
  //
  // NormSet(const RooArgSet&)            -- Specify normalization set, mostly useful when working with PDFS
  // NumIntConfig(const RooNumIntConfig&) -- Use given configuration for any numeric integration, if necessary
  // Range(const char* name)              -- Integrate only over given range. Multiple ranges may be specified
  //                                         by passing multiple Range() arguments  



  // Define configuration for this method
  RooCmdConfig pc(Form("RooAbsReal::createIntegral(%s)",GetName())) ;
  pc.defineString("rangeName","RangeWithName",0,"",kTRUE) ;
  pc.defineObject("normSet","NormSet",0,0) ;
  pc.defineObject("numIntConfig","NumIntConfig",0,0) ;

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

  // Extract values from named arguments
  const char* rangeName = pc.getString("rangeName",0,kTRUE) ;
  const RooArgSet* nset = static_cast<const RooArgSet*>(pc.getObject("normSet",0)) ;
  const RooNumIntConfig* cfg = static_cast<const RooNumIntConfig*>(pc.getObject("numIntConfig",0)) ;

  return createIntegral(iset,nset,cfg,rangeName) ;
}





//_____________________________________________________________________________
RooAbsReal* RooAbsReal::createIntegral(const RooArgSet& iset, const RooArgSet* nset, 
				       const RooNumIntConfig* cfg, const char* rangeName) const 
{
  // 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. If nset is specified the integrand is request
  // to be normalized over nset (only meaningful when the integrand is a pdf). If rangename is specified
  // the integral is performed over the named range, otherwise it is performed over the domain of each
  // integrated observable. If cfg is specified it will be used to configure any numeric integration
  // aspect of the integral. It will not force the integral to be performed numerically, which is
  // decided automatically by RooRealIntegral

  if (!rangeName || strchr(rangeName,',')==0) {
    // Simple case: integral over full range or single limited range
    return createIntObj(iset,nset,cfg,rangeName) ;
  } 

  // Integral over multiple ranges
  RooArgSet components ;
  
  TObjArray* oa = TString(rangeName).Tokenize(",");
  
  for( Int_t i=0; i < oa->GetEntries(); ++i) {
    TObjString* os = (TObjString*) (*oa)[i];
    if(!os) break;
    RooAbsReal* compIntegral = createIntObj(iset,nset,cfg,os->GetString().Data()) ;
    components.add(*compIntegral) ;
  }
  delete oa;

  TString title(GetTitle()) ;
  title.Prepend("Integral of ") ;
  TString fullName(GetName()) ;
  fullName.Append(integralNameSuffix(iset,nset,rangeName)) ;

  return new RooAddition(fullName.Data(),title.Data(),components,kTRUE) ;
}



//_____________________________________________________________________________
RooAbsReal* RooAbsReal::createIntObj(const RooArgSet& iset2, const RooArgSet* nset2, 
				     const RooNumIntConfig* cfg, const char* rangeName) const 
{
  // Utility function for createIntegral that creates the actual integreal object

  // Make internal use copies of iset and nset
  RooArgSet iset(iset2) ;
  const RooArgSet* nset = nset2 ;


  // Initialize local variables perparing for recursive loop
  Bool_t error = kFALSE ;
  const RooAbsReal* integrand = this ;
  RooAbsReal* integral = 0 ;

  // Handle trivial case of no integration here explicitly
  if (iset.getSize()==0) {

    TString title(GetTitle()) ;
    title.Prepend("Integral of ") ;
    
    TString name(GetName()) ;
    name.Append(integralNameSuffix(iset,nset,rangeName)) ;

    return new RooRealIntegral(name,title,*this,iset,nset,cfg,rangeName) ;
  }

  // Process integration over remaining integration variables
  while(iset.getSize()>0) {


    // Find largest set of observables that can be integrated in one go
    RooArgSet innerSet ;
    findInnerMostIntegration(iset,innerSet,rangeName) ;

    // If largest set of observables that can be integrated is empty set, problem was ill defined
    // Postpone error messaging and handling to end of function, exit loop here
    if (innerSet.getSize()==0) {
      error = kTRUE ; 
      break ;
    }

    // Prepare name and title of integral to be created
    TString title(integrand->GetTitle()) ;
    title.Prepend("Integral of ") ;

    TString name(integrand->GetName()) ;
    name.Append(integrand->integralNameSuffix(innerSet,nset,rangeName)) ;

    // Construct innermost integral
    integral = new RooRealIntegral(name,title,*integrand,innerSet,nset,cfg,rangeName) ;

    // Integral of integral takes ownership of innermost integral
    if (integrand != this) {
      integral->addOwnedComponents(*integrand) ;
    }

    // Remove already integrated observables from to-do list
    iset.remove(innerSet) ;

    // Send info message on recursion if needed
    if (integrand == this && iset.getSize()>0) {
      coutI(Integration) << GetName() << " : multidimensional integration over observables with parameterized ranges in terms of other integrated observables detected, using recursive integration strategy to construct final integral" << endl ;
    }

    // Prepare for recursion, next integral should integrate last integrand
    integrand = integral ;


    // Only need normalization set in innermost integration
    nset = 0 ; 
  }

  if (error) {
    coutE(Integration) << GetName() << " : ERROR while defining recursive integral over observables with parameterized integration ranges, please check that integration rangs specify uniquely defined integral " << endl; 
    delete integral ;
    integral = 0 ;
    return integral ;
  }


  // After-burner: apply interpolating cache on (numeric) integral if requested by user
  const char* cacheParamsStr = getStringAttribute("CACHEPARAMINT") ;
  if (cacheParamsStr && strlen(cacheParamsStr)) {

    RooArgSet* intParams = integral->getVariables() ;
    
    RooNameSet cacheParamNames ;
    cacheParamNames.setNameList(cacheParamsStr) ;
    RooArgSet* cacheParams = cacheParamNames.select(*intParams) ;

    if (cacheParams->getSize()>0) {
      cxcoutD(Caching) << "RooAbsReal::createIntObj(" << GetName() << ") INFO: constructing " << cacheParams->getSize()
		     << "-dim value cache for integral over " << iset2 << " as a function of " << *cacheParams << " in range " << (rangeName?rangeName:"<none>") <<  endl ;
      string name = Form("%s_CACHE_[%s]",integral->GetName(),cacheParams->contentsString().c_str()) ;
      RooCachedReal* cachedIntegral = new RooCachedReal(name.c_str(),name.c_str(),*integral,*cacheParams) ;
      cachedIntegral->setInterpolationOrder(2) ;
      cachedIntegral->addOwnedComponents(*integral) ;
      cachedIntegral->setCacheSource(kTRUE) ;
      if (integral->operMode()==ADirty) {
	cachedIntegral->setOperMode(ADirty) ;
      }
      //cachedIntegral->disableCache(kTRUE) ;
      integral = cachedIntegral ;
    }

    delete cacheParams ;
    delete intParams ;
  }

  return integral ;
}



//_____________________________________________________________________________
void RooAbsReal::findInnerMostIntegration(const RooArgSet& allObs, RooArgSet& innerObs, const char* rangeName) const
{
  // Utility function for createIntObj() that aids in the construct of recursive integrals
  // over functions with multiple observables with parameterized ranges. This function
  // finds in a given set allObs over which integration is requested the largeset subset
  // of observables that can be integrated simultaneously. This subset consists of
  // observables with fixed ranges and observables with parameterized ranges whose
  // parameterization does not depend on any observable that is also integrated.

  // Make lists of 
  // a) integrated observables with fixed ranges, 
  // b) integrated observables with parameterized ranges depending on other integrated observables
  // c) integrated observables used in definition of any parameterized ranges of integrated observables
  RooArgSet obsWithFixedRange(allObs) ;
  RooArgSet obsWithParamRange ;
  RooArgSet obsServingAsRangeParams ;

  // Loop over all integrated observables
  TIterator* oiter = allObs.createIterator() ;
  RooAbsArg* aarg ;
  while((aarg=(RooAbsArg*)oiter->Next())) {
    // Check if observable is real-valued lvalue
    RooAbsRealLValue* arglv = dynamic_cast<RooAbsRealLValue*>(aarg) ;
    if (arglv) {

      // Check if range is parameterized
      RooAbsBinning& binning = arglv->getBinning(rangeName,kFALSE,kTRUE) ;
      if (binning.isParameterized()) { 
	RooArgSet* loBoundObs = binning.lowBoundFunc()->getObservables(allObs) ;
	RooArgSet* hiBoundObs = binning.highBoundFunc()->getObservables(allObs) ;

	// Check if range parameterization depends on other integrated observables
	if (loBoundObs->overlaps(allObs) || hiBoundObs->overlaps(allObs)) {
	  obsWithParamRange.add(*aarg) ;
	  obsWithFixedRange.remove(*aarg) ;
	  obsServingAsRangeParams.add(*loBoundObs,kFALSE) ;
	  obsServingAsRangeParams.add(*hiBoundObs,kFALSE) ;
	}
	delete loBoundObs ;
	delete hiBoundObs ;
      }
    }
  }
  delete oiter ;

  // Make list of fixed-range observables that are _not_ involved in the parameterization of ranges of other observables
  RooArgSet obsWithFixedRangeNP(obsWithFixedRange) ;
  obsWithFixedRangeNP.remove(obsServingAsRangeParams) ; 
  
  // Make list of param-range observables that are _not_ involved in the parameterization of ranges of other observables
  RooArgSet obsWithParamRangeNP(obsWithParamRange) ;
  obsWithParamRangeNP.remove(obsServingAsRangeParams) ; 
  
  // Construct inner-most integration: over observables (with fixed or param range) not used in any other param range definitions
  innerObs.removeAll() ;
  innerObs.add(obsWithFixedRangeNP) ;
  innerObs.add(obsWithParamRangeNP) ;

}


//_____________________________________________________________________________
TString RooAbsReal::integralNameSuffix(const RooArgSet& iset, const RooArgSet* nset, const char* rangeName, Bool_t omitEmpty) const 
{
  // Construct string with unique suffix name to give to integral object that encodes
  // integrated observables, normalization observables and the integration range name
  
  TString name ;
  if (iset.getSize()>0) {

    RooArgSet isetTmp(iset) ;
    isetTmp.sort() ;  

    name.Append("_Int[") ;
    TIterator* iter = isetTmp.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 ;
    if (rangeName) {
      name.Append("|") ;
      name.Append(rangeName) ;
    }
    name.Append("]");
  } else if (!omitEmpty) {
    name.Append("_Int[]") ;
  }

  if (nset && nset->getSize()>0 ) {

    RooArgSet nsetTmp(*nset) ;
    nsetTmp.sort() ;

    name.Append("_Norm[") ;
    Bool_t first(kTRUE); 
    TIterator* iter  = nsetTmp.createIterator() ;
    RooAbsArg* arg ;
    while((arg=(RooAbsArg*)iter->Next())) {
      if (first) {
	first=kFALSE ;
      } else {
	name.Append(",") ;
      }
      name.Append(arg->GetName()) ;
    }
    delete iter ;
    const RooAbsPdf* thisPdf = dynamic_cast<const RooAbsPdf*>(this) ;    
    if (thisPdf && thisPdf->normRange()) {
      name.Append("|") ;
      name.Append(thisPdf->normRange()) ;
    }
    name.Append("]") ;
  }

  return name ;
}



//_____________________________________________________________________________
const RooAbsReal* RooAbsReal::createPlotProjection(const RooArgSet& depVars, const RooArgSet& projVars, 
                                               RooArgSet*& cloneSet) const 
{
  // Utility function for plotOn() that creates a projection of a function or p.d.f 
  // to be plotted on a RooPlot. 
  return createPlotProjection(depVars,&projVars,cloneSet) ; 
}



//_____________________________________________________________________________
const RooAbsReal* RooAbsReal::createPlotProjection(const RooArgSet& depVars, const RooArgSet& projVars) const 
{
  // Utility function for plotOn() that creates a projection of a function or p.d.f 
  // to be plotted on a RooPlot. 
  RooArgSet* cloneSet = new RooArgSet() ;
  return createPlotProjection(depVars,&projVars,cloneSet) ; 
}



//_____________________________________________________________________________
const RooAbsReal *RooAbsReal::createPlotProjection(const RooArgSet &dependentVars, const RooArgSet *projectedVars,
						   RooArgSet *&cloneSet, const char* rangeName, const RooArgSet* condObs) const 
{
  // Utility function for plotOn() that creates a projection of a function or p.d.f 
  // to be plotted on a RooPlot. 
  //
  // Create a new object G that represents the normalized projection:
  //
  //             Integral [ F[x,y,p] , { y } ]
  //  G[x,p] = ---------------------------------
  //            Integral [ F[x,y,p] , { x,y } ]
  //
  // where F[x,y,p] is the function we represent, "x" are the
  // specified dependentVars, "y" are the specified projectedVars, and
  // "p" are our remaining variables ("parameters"). Return a
  // pointer to the newly created object, or else zero in case of an
  // error.  The caller is responsible for deleting the contents of
  // cloneSet (which includes the returned projection object) 

  // Get the set of our leaf nodes
  RooArgSet leafNodes;
  RooArgSet treeNodes;
  leafNodeServerList(&leafNodes,this);
  treeNodeServerList(&treeNodes,this) ;


  // Check that the dependents are all fundamental. Filter out any that we
  // do not depend on, and make substitutions by name in our leaf list.
  // Check for overlaps with the projection variables.

  TIterator *dependentIterator= dependentVars.createIterator();
  assert(0 != dependentIterator);
  const RooAbsArg *arg = 0;
  while((arg= (const RooAbsArg*)dependentIterator->Next())) {
    if(!arg->isFundamental() && !dynamic_cast<const RooAbsLValue*>(arg)) {
      coutE(Plotting) << ClassName() << "::" << GetName() << ":createPlotProjection: variable \"" << arg->GetName()
	   << "\" of wrong type: " << arg->ClassName() << endl;
      delete dependentIterator;
      return 0;
    }

    RooAbsArg *found= treeNodes.find(arg->GetName()); 
    if(!found) {
      coutE(Plotting) << ClassName() << "::" << GetName() << ":createPlotProjection: \"" << arg->GetName()
		      << "\" is not a dependent and will be ignored." << endl;
      continue;
    }
    if(found != arg) {
      if (leafNodes.find(found->GetName())) {
	leafNodes.replace(*found,*arg);
      } else {
	leafNodes.add(*arg) ;

	// Remove any dependents of found, replace by dependents of LV node
	RooArgSet* lvDep = arg->getObservables(&leafNodes) ;
	RooAbsArg* lvs ;
	TIterator* iter = lvDep->createIterator() ;
	while((lvs=(RooAbsArg*)iter->Next())) {
	  RooAbsArg* tmp = leafNodes.find(lvs->GetName()) ;
	  if (tmp) {
	    leafNodes.remove(*tmp) ;
	    leafNodes.add(*lvs) ;
	  }
	}
	delete iter ;
	
      }
    }

    // check if this arg is also in the projection set
    if(0 != projectedVars && projectedVars->find(arg->GetName())) {
      coutE(Plotting) << ClassName() << "::" << GetName() << ":createPlotProjection: \"" << arg->GetName()
		      << "\" cannot be both a dependent and a projected variable." << endl;
      delete dependentIterator;
      return 0;
    }
  }

  // Remove the projected variables from the list of leaf nodes, if necessary.
  if(0 != projectedVars) leafNodes.remove(*projectedVars,kTRUE);

  // Make a deep-clone of ourself so later operations do not disturb our original state
  cloneSet= (RooArgSet*)RooArgSet(*this).snapshot(kTRUE);
  if (!cloneSet) {
    coutE(Plotting) << "RooAbsPdf::createPlotProjection(" << GetName() << ") Couldn't deep-clone PDF, abort," << endl ;
    return 0 ;
  }
  RooAbsReal *theClone= (RooAbsReal*)cloneSet->find(GetName());

  // The remaining entries in our list of leaf nodes are the the external
  // dependents (x) and parameters (p) of the projection. Patch them back
  // into the theClone. This orphans the nodes they replace, but the orphans
  // are still in the cloneList and so will be cleaned up eventually.
  //cout << "redirection leafNodes : " ; leafNodes.Print("1") ;

  RooArgSet* plotLeafNodes = (RooArgSet*) leafNodes.selectCommon(dependentVars) ;
  theClone->recursiveRedirectServers(*plotLeafNodes,kFALSE,kFALSE,kFALSE);
  delete plotLeafNodes ;

  // Create the set of normalization variables to use in the projection integrand
  RooArgSet normSet(dependentVars);
  if(0 != projectedVars) normSet.add(*projectedVars);
  if(0 != condObs) {
    normSet.remove(*condObs,kTRUE,kTRUE) ;
  }
  
  // Try to create a valid projection integral. If no variables are to be projected,
  // create a null projection anyway to bind our normalization over the dependents
  // consistently with the way they would be bound with a non-trivial projection.
  RooArgSet empty;
  if(0 == projectedVars) projectedVars= &empty;

  TString name = GetName() ;
  name += integralNameSuffix(*projectedVars,&normSet,rangeName,kTRUE) ;

  TString title(GetTitle());  
  title.Prepend("Projection of ");


  RooAbsReal* projected= theClone->createIntegral(*projectedVars,normSet,rangeName) ;

  if(0 == projected || !projected->isValid()) {
    coutE(Plotting) << ClassName() << "::" << GetName() << ":createPlotProjection: cannot integrate out ";
    projectedVars->printStream(cout,kName|kArgs,kSingleLine);
    // cleanup and exit
    if(0 != projected) delete projected;
    delete dependentIterator;
    return 0;
  }

  projected->SetName(name.Data()) ;
  projected->SetTitle(title.Data()) ;

  // Add the projection integral to the cloneSet so that it eventually gets cleaned up by the caller.
  cloneSet->addOwned(*projected);

  // cleanup
  delete dependentIterator;

  // return a const pointer to remind the caller that they do not delete the returned object
  // directly (it is contained in the cloneSet instead).
  return projected;
}




//_____________________________________________________________________________
TH1 *RooAbsReal::fillHistogram(TH1 *hist, const RooArgList &plotVars,
			       Double_t scaleFactor, const RooArgSet *projectedVars, Bool_t scaleForDensity,
			       const RooArgSet* condObs, Bool_t setError) const 
{
  // Fill the ROOT histogram 'hist' with values sampled from this
  // function at the bin centers.  Our value is calculated by first
  // integrating out any variables in projectedVars and then scaling
  // the result by scaleFactor. Returns a pointer to the input
  // histogram, or zero in case of an error. The input histogram can
  // be any TH1 subclass, and therefore of arbitrary
  // dimension. Variables are matched with the (x,y,...) dimensions of
  // the input histogram according to the order in which they appear
  // in the input plotVars list. If scaleForDensity is true the
  // histogram is filled with a the functions density rather than
  // the functions value (i.e. the value at the bin center is multiplied
  // with bin volume)

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

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


  // Check that the plot variables are all actually RooRealVars and print a warning if we do not
  // explicitly depend on one of them. Fill a set (not list!) of cloned plot variables.
  RooArgSet plotClones;
  for(Int_t index= 0; index < plotVars.getSize(); index++) {
    const RooAbsArg *var= plotVars.at(index);
    const RooRealVar *realVar= dynamic_cast<const RooRealVar*>(var);
    if(0 == realVar) {
      coutE(InputArguments) << ClassName() << "::" << GetName() << ":fillHistogram: cannot plot variable \"" << var->GetName()
	   << "\" of type " << var->ClassName() << endl;
      return 0;
    }
    if(!this->dependsOn(*realVar)) {
      coutE(InputArguments) << ClassName() << "::" << GetName()
	   << ":fillHistogram: WARNING: variable is not an explicit dependent: " << realVar->GetName() << endl;
    }
    plotClones.addClone(*realVar,kTRUE); // do not complain about duplicates
  }

  // Reconnect all plotClones to each other, imported when plotting N-dim integrals with entangled parameterized ranges
  TIterator* pciter= plotClones.createIterator() ;
  RooAbsArg* pc ;
  while((pc=(RooAbsArg*)pciter->Next())) {
    pc->recursiveRedirectServers(plotClones,kFALSE,kFALSE,kTRUE) ;
  }

  delete pciter ;
  
  // Call checkObservables
  RooArgSet allDeps(plotClones) ;
  if (projectedVars) {
    allDeps.add(*projectedVars) ;
  }
  if (checkObservables(&allDeps)) {
    coutE(InputArguments) << "RooAbsReal::fillHistogram(" << GetName() << ") error in checkObservables, abort" << endl ;
    return hist ;
  }

  // Create a standalone projection object to use for calculating bin contents
  RooArgSet *cloneSet = 0;
  const RooAbsReal *projected= createPlotProjection(plotClones,projectedVars,cloneSet,0,condObs);

  cxcoutD(Plotting) << "RooAbsReal::fillHistogram(" << GetName() << ") plot projection object is " << projected->GetName() << endl ;

  // Prepare to loop over the histogram bins
  Int_t xbins(0),ybins(1),zbins(1);
  RooRealVar *xvar = 0;
  RooRealVar *yvar = 0;
  RooRealVar *zvar = 0;
  TAxis *xaxis = 0;
  TAxis *yaxis = 0;
  TAxis *zaxis = 0;
  switch(hdim) {
  case 3:
    zbins= hist->GetNbinsZ();
    zvar= dynamic_cast<RooRealVar*>(plotClones.find(plotVars.at(2)->GetName()));
    zaxis= hist->GetZaxis();
    assert(0 != zvar && 0 != zaxis);
    if (scaleForDensity) {
      scaleFactor*= (zaxis->GetXmax() - zaxis->GetXmin())/zbins;
    }
    // fall through to next case...
  case 2:
    ybins= hist->GetNbinsY(); 
    yvar= dynamic_cast<RooRealVar*>(plotClones.find(plotVars.at(1)->GetName()));
    yaxis= hist->GetYaxis();
    assert(0 != yvar && 0 != yaxis);
    if (scaleForDensity) {
      scaleFactor*= (yaxis->GetXmax() - yaxis->GetXmin())/ybins;
    }
    // fall through to next case...
  case 1:
    xbins= hist->GetNbinsX();
    xvar= dynamic_cast<RooRealVar*>(plotClones.find(plotVars.at(0)->GetName()));
    xaxis= hist->GetXaxis();
    assert(0 != xvar && 0 != xaxis);
    if (scaleForDensity) {
      scaleFactor*= (xaxis->GetXmax() - xaxis->GetXmin())/xbins;
    }
    break;
  default:
    coutE(InputArguments) << ClassName() << "::" << GetName() << ":fillHistogram: cannot fill histogram with "
			  << hdim << " dimensions" << endl;
    break;
  }

  // Loop over the input histogram's bins and fill each one with our projection's
  // value, calculated at the center.
  RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::CollectErrors) ;
  Int_t xbin(0),ybin(0),zbin(0);
  Int_t bins= xbins*ybins*zbins;
  for(Int_t bin= 0; bin < bins; bin++) {
    switch(hdim) {
    case 3:
      if(bin % (xbins*ybins) == 0) {
	zbin++;
	zvar->setVal(zaxis->GetBinCenter(zbin));
      }
      // fall through to next case...
    case 2:
      if(bin % xbins == 0) {
	ybin= (ybin%ybins) + 1;
	yvar->setVal(yaxis->GetBinCenter(ybin));
      }
      // fall through to next case...
    case 1:
      xbin= (xbin%xbins) + 1;
      xvar->setVal(xaxis->GetBinCenter(xbin));
      break;
    default:
      coutE(InputArguments) << "RooAbsReal::fillHistogram: Internal Error!" << endl;
      break;
    }

    Double_t result= scaleFactor*projected->getVal();
    if (RooAbsReal::numEvalErrors()>0) {
      coutW(Plotting) << "WARNING: Function evaluation error(s) at coordinates [x]=" << xvar->getVal() ;
      if (hdim==2) ccoutW(Plotting) << " [y]=" << yvar->getVal() ;
      if (hdim==3) ccoutW(Plotting) << " [z]=" << zvar->getVal() ;
      ccoutW(Plotting) << endl ;
      // RooAbsReal::printEvalErrors(ccoutW(Plotting),10) ;
      result = 0 ;
    }
    RooAbsReal::clearEvalErrorLog() ;
    
    hist->SetBinContent(hist->GetBin(xbin,ybin,zbin),result);
    if (setError) {
      hist->SetBinError(hist->GetBin(xbin,ybin,zbin),sqrt(result)) ;
    }

    //cout << "bin " << bin << " -> (" << xbin << "," << ybin << "," << zbin << ") = " << result << endl;
  }
  RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::PrintErrors) ;

  // cleanup
  delete cloneSet;

  return hist;
}



//_____________________________________________________________________________
RooDataHist* RooAbsReal::fillDataHist(RooDataHist *hist, const RooArgSet* normSet, Double_t scaleFactor, 
				      Bool_t correctForBinSize, Bool_t showProgress) const 
{
  // Fill a RooDataHist with values sampled from this function at the
  // bin centers.  If extendedMode is true, the p.d.f. values is multiplied
  // by the number of expected events in each bin
  // 
  // An optional scaling by a given scaleFactor can be performed. 
  // Returns a pointer to the input RooDataHist, or zero
  // in case of an error. 
  //
  // If correctForBinSize is true the RooDataHist
  // is filled with the functions density (function value times the
  // bin volume) rather than function value.  
  //
  // If showProgress is true
  // a process indicator is printed on stdout in steps of one percent,
  // which is mostly useful for the sampling of expensive functions
  // such as likelihoods

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

  // Call checkObservables
  RooArgSet allDeps(*hist->get()) ;
  if (checkObservables(&allDeps)) {
    coutE(InputArguments) << "RooAbsReal::fillDataHist(" << GetName() << ") error in checkObservables, abort" << endl ;
    return hist ;
  }
  
  // Make deep clone of self and attach to dataset observables
  //RooArgSet* origObs = getObservables(hist) ;  
  RooArgSet* cloneSet = (RooArgSet*) RooArgSet(*this).snapshot(kTRUE) ;
  RooAbsReal* theClone = (RooAbsReal*) cloneSet->find(GetName()) ;
  theClone->recursiveRedirectServers(*hist->get()) ;
  //const_cast<RooAbsReal*>(this)->recursiveRedirectServers(*hist->get()) ;

  // Iterator over all bins of RooDataHist and fill weights
  Int_t onePct = hist->numEntries()/100 ;
  if (onePct==0) {
    onePct++ ;
  }
  for (Int_t i=0 ; i<hist->numEntries() ; i++) {    
    if (showProgress && (i%onePct==0)) {
      ccoutP(Eval) << "." << flush ;
    }
    const RooArgSet* obs = hist->get(i) ;
    Double_t binVal = theClone->getVal(normSet?normSet:obs)*scaleFactor ;
    if (correctForBinSize) {
      binVal*= hist->binVolume() ;
    }
    hist->set(binVal) ;
  }

  delete cloneSet ;
  //const_cast<RooAbsReal*>(this)->recursiveRedirectServers(*origObs) ;
  //delete origObs ;

  return hist;
}




//_____________________________________________________________________________
TH1* RooAbsReal::createHistogram(const char* varNameList, Int_t xbins, Int_t ybins, Int_t zbins) const 
{
  // Create and fill a ROOT histogram TH1,TH2 or TH3 with the values of this function for the variables with given names
  // The number of bins can be controlled using the [xyz]bins parameters. For a greater degree of control
  // use the createHistogram() method below with named arguments
  //
  // The caller takes ownership of the returned histogram

  // Parse list of variable names
  char buf[1024] ;
  strlcpy(buf,varNameList,1024) ;
  char* varName = strtok(buf,",:") ;

  RooArgSet* vars = getVariables() ;
  
  RooRealVar* xvar = (RooRealVar*) vars->find(varName) ;
  varName = strtok(0,",") ;
  RooRealVar* yvar = varName ? (RooRealVar*) vars->find(varName) : 0 ;
  varName = strtok(0,",") ;
  RooRealVar* zvar = varName ? (RooRealVar*) vars->find(varName) : 0 ;

  delete vars ;

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

  RooLinkedList argList ; 
  if (xbins>0) {
    argList.Add(RooFit::Binning(xbins).Clone()) ;
  }
 
  if (yvar) {        
    if (ybins>0) {
      argList.Add(RooFit::YVar(*yvar,RooFit::Binning(ybins)).Clone()) ;
    } else {
      argList.Add(RooFit::YVar(*yvar).Clone()) ;
    }
  }


  if (zvar) {        
    if (zbins>0) {
      argList.Add(RooFit::ZVar(*zvar,RooFit::Binning(zbins)).Clone()) ;
    } else {
      argList.Add(RooFit::ZVar(*zvar).Clone()) ;
    }
  }


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

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

  return result ;
}



//_____________________________________________________________________________
TH1 *RooAbsReal::createHistogram(const char *name, const RooAbsRealLValue& xvar,
				 const RooCmdArg& arg1, const RooCmdArg& arg2, const RooCmdArg& arg3, const RooCmdArg& arg4, 
				 const RooCmdArg& arg5, const RooCmdArg& arg6, const RooCmdArg& arg7, const RooCmdArg& arg8) const 
{
  // Create and fill a ROOT histogram TH1,TH2 or TH3 with the values of this function. 
  //
  // This function accepts the following arguments
  //
  // name -- Name of the ROOT histogram
  // xvar -- Observable to be mapped on x axis of ROOT histogram
  //
  // IntrinsicBinning()                           -- Apply binning defined by function or pdf (as advertised via binBoundaries() method)
  // Binning(const char* name)                    -- Apply binning with given name to x axis of histogram
  // Binning(RooAbsBinning& binning)              -- Apply specified binning to x axis of histogram
  // Binning(int nbins, [double lo, double hi])   -- Apply specified binning to x axis of histogram
  // ConditionalObservables(const RooArgSet& set) -- Do not normalized PDF over following observables when projecting PDF into histogram
  // Scaling(Bool_t)                              -- Apply density-correction scaling (multiply by bin volume), default is kTRUE
  // Extended(Bool_t)                             -- Plot event yield instead of probability density (for extended pdfs only)
  //
  // YVar(const RooAbsRealLValue& var,...)    -- Observable to be mapped on y axis of ROOT histogram
  // ZVar(const RooAbsRealLValue& var,...)    -- Observable to be mapped on z axis of ROOT histogram
  //
  // The YVar() and ZVar() arguments can be supplied with optional Binning() arguments to control the binning of the Y and Z axes, e.g.
  // createHistogram("histo",x,Binning(-1,1,20), YVar(y,Binning(-1,1,30)), ZVar(z,Binning("zbinning")))
  //
  // The caller takes ownership of the returned histogram


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

  return createHistogram(name,xvar,l) ;
}


//_____________________________________________________________________________
TH1* RooAbsReal::createHistogram(const char *name, const RooAbsRealLValue& xvar, RooLinkedList& argList) const 
{
  // Internal method implementing createHistogram


  // Define configuration for this method
  RooCmdConfig pc(Form("RooAbsReal::createHistogram(%s)",GetName())) ;
  pc.defineInt("scaling","Scaling",0,1) ;
  pc.defineInt("intBinning","IntrinsicBinning",0,2) ;
  pc.defineInt("extended","Extended",0,2) ;

  pc.defineObject("compSet","SelectCompSet",0) ;
  pc.defineString("compSpec","SelectCompSpec",0) ;
  pc.defineSet("projObs","ProjectedObservables",0,0) ;
  pc.defineObject("yvar","YVar",0,0) ;
  pc.defineObject("zvar","ZVar",0,0) ;  
  pc.defineMutex("SelectCompSet","SelectCompSpec") ;
  pc.defineMutex("IntrinsicBinning","Binning") ;
  pc.defineMutex("IntrinsicBinning","BinningName") ;
  pc.defineMutex("IntrinsicBinning","BinningSpec") ;
  pc.allowUndefined() ;

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

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

  RooArgSet* projObs = pc.getSet("projObs") ;
  RooArgSet* intObs = 0 ;

  Bool_t doScaling = pc.getInt("scaling") ;
  Int_t doIntBinning = pc.getInt("intBinning") ;
  Int_t doExtended = pc.getInt("extended") ;

  // If doExtended is two, selection is automatic, set to 1 of pdf is extended, to zero otherwise
  const RooAbsPdf* pdfSelf = dynamic_cast<const RooAbsPdf*>(this) ;
  if (!pdfSelf && doExtended>0) {
    coutW(InputArguments) << "RooAbsReal::createHistogram(" << GetName() << ") WARNING extended mode requested for a non-pdf object, ignored" << endl ;
    doExtended=0 ;
  }
  if (pdfSelf && doExtended==1 && pdfSelf->extendMode()==RooAbsPdf::CanNotBeExtended) {
    coutW(InputArguments) << "RooAbsReal::createHistogram(" << GetName() << ") WARNING extended mode requested for a non-extendable pdf, ignored" << endl ;
    doExtended=0 ;
  }
  if (pdfSelf && doExtended==2) {
    doExtended = pdfSelf->extendMode()==RooAbsPdf::CanNotBeExtended ? 0 : 1 ; 
  }
  
  const char* compSpec = pc.getString("compSpec") ;
  const RooArgSet* compSet = (const RooArgSet*) pc.getObject("compSet") ;
  Bool_t haveCompSel = ( (compSpec && strlen(compSpec)>0) || compSet) ;

  RooBinning* intBinning(0) ;
  if (doIntBinning>0) {
    // Given RooAbsPdf* pdf and RooRealVar* obs
    list<Double_t>* bl = binBoundaries((RooRealVar&)xvar,xvar.getMin(),xvar.getMax()) ;
    if (!bl) {
      // Only emit warning when intrinsic binning is explicitly requested 
      if (doIntBinning==1) {
	coutW(InputArguments) << "RooAbsReal::createHistogram(" << GetName() 
			      << ") WARNING, intrinsic model binning requested for histogram, but model does not define bin boundaries, reverting to default binning"<< endl ;
      }
    } else {
      if (doIntBinning==2) {
	coutI(InputArguments) << "RooAbsReal::createHistogram(" << GetName() 
			      << ") INFO: Model has intrinsic binning definition, selecting that binning for the histogram"<< endl ;
      }
      Double_t* ba = new Double_t[bl->size()] ; int i=0 ;
      for (list<double>::iterator it=bl->begin() ; it!=bl->end() ; ++it) { ba[i++] = *it ; }
      intBinning = new RooBinning(bl->size()-1,ba) ;
      delete[] ba ;
    }    
  }

  RooLinkedList argListCreate(argList) ;
  pc.stripCmdList(argListCreate,"Scaling,ProjectedObservables,IntrinsicBinning,SelectCompSet,SelectCompSpec,Extended") ;

  TH1* histo(0) ;
  if (intBinning) {
    RooCmdArg tmp = RooFit::Binning(*intBinning) ;
    argListCreate.Add(&tmp) ;
    histo = xvar.createHistogram(name,argListCreate) ;
    delete intBinning ;
  } else {
    histo = xvar.createHistogram(name,argListCreate) ;
  }

  // Do component selection here
  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 ;

    RooArgSet* dirSelNodes ;
    if (compSet) {
      dirSelNodes = (RooArgSet*) branchNodeSet.selectCommon(*compSet) ;
    } else {
      dirSelNodes = (RooArgSet*) branchNodeSet.selectByName(compSpec) ;
    }
    if (dirSelNodes->getSize()>0) {
      coutI(Plotting) << "RooAbsPdf::createHistogram(" << GetName() << ") directly selected PDF components: " << *dirSelNodes << endl ;
      
      // Do indirect selection and activate both
      plotOnCompSelect(dirSelNodes) ;
    } else {
      if (compSet) {
	coutE(Plotting) << "RooAbsPdf::createHistogram(" << GetName() << ") ERROR: component selection set " << *compSet << " does not match any components of p.d.f." << endl ;
      } else {
	coutE(Plotting) << "RooAbsPdf::createHistogram(" << GetName() << ") ERROR: component selection expression '" << compSpec << "' does not select any components of p.d.f." << endl ;
      }
      return 0 ;
    }  
    delete dirSelNodes ;
  }
  
  Double_t scaleFactor(1.0) ;
  if (doExtended) {
    scaleFactor = pdfSelf->expectedEvents(vars) ;
    doScaling=kFALSE ;
  }
  
  fillHistogram(histo,vars,scaleFactor,intObs,doScaling,projObs,kFALSE) ;

  // Deactivate component selection
  if (haveCompSel) {
      plotOnCompSelect(0) ;
  }


  return histo ;
}


//_____________________________________________________________________________
void RooAbsReal::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 ;
} 



//_____________________________________________________________________________
RooPlot* RooAbsReal::plotOn(RooPlot* frame, const RooCmdArg& arg1, const RooCmdArg& arg2,
			    const RooCmdArg& arg3, const RooCmdArg& arg4,
			    const RooCmdArg& arg5, const RooCmdArg& arg6,
			    const RooCmdArg& arg7, const RooCmdArg& arg8,
			    const RooCmdArg& arg9, const RooCmdArg& arg10) 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. The slice is position at the 'current'
  //                                    value of the observable objects
  //
  // Slice(RooCategory& cat,         -- Override default projection behaviour by omittting specified category 
  //       const char* label)           observable from the projection, resulting in a 'slice' plot. The slice is positioned
  //                                    at the given label value. Multiple Slice() commands can be given to specify slices
  //                                    in multiple 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
  //
  // NumCPU(Int_t ncpu)              -- Number of CPUs to use simultaneously to calculate data-weighted projections (only in combination with ProjWData)
  //
  //
  // Misc content control
  // --------------------
  // PrintEvalErrors(Int_t numErr)   -- Control number of p.d.f evaluation errors printed per curve. 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.
  // 
  // EvalErrorValue(Double_t value)  -- Set curve points at which (pdf) evaluation error occur to specified value. By default the 
  //                                    function value is plotted.
  //
  // 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 
  // ----------------
  // DrawOption(const char* opt)     -- Select ROOT draw option for resulting TGraph object
  //
  // LineStyle(Int_t style)          -- Select line style by ROOT line style code, default is solid
  //
  // LineColor(Int_t color)          -- Select line color by ROOT color code, default is 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
  //
  // Invisible(Bool_t flag)           -- Add curve to frame, but do not display. Useful in combination AddTo()
  //
  // VisualizeError(const RooFitResult& fitres, Double_t Z=1, Bool_t linearMethod=kTRUE) 
  //                                  -- Visualize the uncertainty on the parameters, as given in fitres, at 'Z' sigma'
  //
  // VisualizeError(const RooFitResult& fitres, const RooArgSet& param, Double_t Z=1, Bool_t linearMethod=kTRUE) ;
  //                                  -- Visualize the uncertainty on the subset of parameters 'param', as given in fitres, at 'Z' sigma'
  //
  //
  // Details on error band visualization
  // -----------------------------------
  //
  // By default (linMethod=kTRUE) a linearized error is shown which is calculated as follows
  //                                    T            
  // error(x) = Z* F_a(x) * Corr(a,a') F_a'(x)
  //
  // where     F_a(x) = [ f(x,a+da) - f(x,a-da) ] / 2, with f(x) the plotted curve and 'da' taken from the fit result
  //       Corr(a,a') = the correlation matrix from the fit result
  //                Z = requested significance 'Z sigma band'
  //
  // The linear method is fast (required 2*N evaluations of the curve, where N is the number of parameters), but may
  // not be accurate in the presence of strong correlations (~>0.9) and at Z>2 due to linear and Gaussian approximations made
  //
  // Alternatively (linMethod=kFALSE), a more robust error is calculated using a sampling method. In this method a number of curves
  // is calculated with variations of the parameter values, as drawn from a multi-variate Gaussian p.d.f. that is constructed
  // from the fit results covariance matrix. The error(x) is determined by calculating a central interval that capture N% of the variations 
  // for each valye of x, where N% is controlled by Z (i.e. Z=1 gives N=68%). The number of sampling curves is chosen to be such
  // that at least 30 curves are expected to be outside the N% interval, and is minimally 100 (e.g. Z=1->Ncurve=100, Z=2->Ncurve=659, Z=3->Ncurve=11111)
  // Intervals from the sampling method can be asymmetric, and may perform better in the presence of strong correlations, but may take (much)
  // longer to calculate

  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) ;
  l.Add((TObject*)&arg9) ;  l.Add((TObject*)&arg10) ;
  return plotOn(frame,l) ;
}



//_____________________________________________________________________________
RooPlot* RooAbsReal::plotOn(RooPlot* frame, RooLinkedList& argList) const
{
  // Internal back-end function of plotOn() with named arguments

  // Special handling here if argList contains RangeWithName argument with multiple
  // range names -- Need to translate this call into multiple calls

  RooCmdArg* rcmd = (RooCmdArg*) argList.FindObject("RangeWithName") ;
  if (rcmd && TString(rcmd->getString(0)).Contains(",")) {

    // List joint ranges as choice of normalization for all later processing
    RooCmdArg rnorm = RooFit::NormRange(rcmd->getString(0)) ;
    argList.Add(&rnorm) ;

    list<string> rlist ;

    // Separate named ranges using strtok
    char buf[1024] ;
    strlcpy(buf,rcmd->getString(0),1024) ;
    char* oneRange = strtok(buf,",") ;
    while(oneRange) {
      rlist.push_back(oneRange) ;
      oneRange = strtok(0,",") ;      
    }

    for (list<string>::iterator riter=rlist.begin() ; riter!=rlist.end() ; ++riter) {
      // Process each range with a separate command with a single range to be plotted
      rcmd->setString(0,riter->c_str()) ;
      RooAbsReal::plotOn(frame,argList) ;
    }
    return frame ;
    
  }

  // Define configuration for this method
  RooCmdConfig pc(Form("RooAbsReal::plotOn(%s)",GetName())) ;
  pc.defineString("drawOption","DrawOption",0,"L") ;
  pc.defineString("projectionRangeName","ProjectionRange",0,"",kTRUE) ;
  pc.defineString("curveNameSuffix","CurveNameSuffix",0,"") ;
  pc.defineString("sliceCatState","SliceCat",0,"",kTRUE) ;
  pc.defineDouble("scaleFactor","Normalization",0,1.0) ;
  pc.defineObject("sliceSet","SliceVars",0) ;
  pc.defineObject("sliceCatList","SliceCat",0,0,kTRUE) ;
  pc.defineObject("projSet","Project",0) ;
  pc.defineObject("asymCat","Asymmetry",0) ;
  pc.defineDouble("precision","Precision",0,1e-3) ;
  pc.defineDouble("evalErrorVal","EvalErrorValue",0,0) ;
  pc.defineInt("doEvalError","EvalErrorValue",0,0) ;
  pc.defineInt("shiftToZero","ShiftToZero",0,0) ;  
  pc.defineObject("projDataSet","ProjData",0) ;
  pc.defineObject("projData","ProjData",1) ;
  pc.defineObject("errorFR","VisualizeError",0) ;
  pc.defineDouble("errorZ","VisualizeError",0,1.) ;
  pc.defineSet("errorPars","VisualizeError",0) ;
  pc.defineInt("linearMethod","VisualizeError",0,0) ;
  pc.defineInt("binProjData","ProjData",0,0) ;
  pc.defineDouble("rangeLo","Range",0,-999.) ;
  pc.defineDouble("rangeHi","Range",1,-999.) ;
  pc.defineInt("numee","PrintEvalErrors",0,10) ;
  pc.defineInt("rangeAdjustNorm","Range",0,0) ;
  pc.defineInt("rangeWNAdjustNorm","RangeWithName",0,0) ;
  pc.defineInt("VLines","VLines",0,2) ; // 2==ExtendedWings
  pc.defineString("rangeName","RangeWithName",0,"") ;
  pc.defineString("normRangeName","NormRange",0,"") ;
  pc.defineInt("lineColor","LineColor",0,-999) ;
  pc.defineInt("lineStyle","LineStyle",0,-999) ;
  pc.defineInt("lineWidth","LineWidth",0,-999) ;
  pc.defineInt("fillColor","FillColor",0,-999) ;
  pc.defineInt("fillStyle","FillStyle",0,-999) ;
  pc.defineString("curveName","Name",0,"") ;
  pc.defineInt("curveInvisible","Invisible",0,0) ;
  pc.defineInt("showProg","ShowProgress",0,0) ;
  pc.defineInt("numCPU","NumCPU",0,1) ;
  pc.defineInt("interleave","NumCPU",1,0) ; 
  pc.defineString("addToCurveName","AddTo",0,"") ;
  pc.defineDouble("addToWgtSelf","AddTo",0,1.) ;
  pc.defineDouble("addToWgtOther","AddTo",1,1.) ;
  pc.defineInt("moveToBack","MoveToBack",0,0) ;
  pc.defineMutex("SliceVars","Project") ;
  pc.defineMutex("AddTo","Asymmetry") ;
  pc.defineMutex("Range","RangeWithName") ;
  pc.defineMutex("VisualizeError","VisualizeErrorData") ;

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

  PlotOpt o ;

  RooFitResult* errFR = (RooFitResult*) pc.getObject("errorFR") ;
  Double_t errZ = pc.getDouble("errorZ") ;
  RooArgSet* errPars = pc.getSet("errorPars") ;
  Bool_t linMethod = pc.getInt("linearMethod") ;
  if (errFR) {
    return plotOnWithErrorBand(frame,*errFR,errZ,errPars,argList,linMethod) ;
  }

  // Extract values from named arguments
  o.numee       = pc.getInt("numee") ;
  o.drawOptions = pc.getString("drawOption") ;
  o.curveNameSuffix = pc.getString("curveNameSuffix") ;
  o.scaleFactor = pc.getDouble("scaleFactor") ;
  o.projData = (const RooAbsData*) pc.getObject("projData") ;
  o.binProjData = pc.getInt("binProjData") ;
  o.projDataSet = (const RooArgSet*) pc.getObject("projDataSet") ;
  o.numCPU = pc.getInt("numCPU") ;
  o.interleave = (RooFit::MPSplit) pc.getInt("interleave") ;
  o.eeval      = pc.getDouble("evalErrorVal") ;
  o.doeeval   = pc.getInt("doEvalError") ;

  const RooArgSet* sliceSetTmp = (const RooArgSet*) pc.getObject("sliceSet") ;
  RooArgSet* sliceSet = sliceSetTmp ? ((RooArgSet*) sliceSetTmp->Clone()) : 0 ;
  const RooArgSet* projSet = (const RooArgSet*) pc.getObject("projSet") ;
  const RooAbsCategoryLValue* asymCat = (const RooAbsCategoryLValue*) pc.getObject("asymCat") ;


  // Look for category slice arguments and add them to the master slice list if found
  const char* sliceCatState = pc.getString("sliceCatState",0,kTRUE) ;
  const RooLinkedList& sliceCatList = pc.getObjectList("sliceCatList") ;
  if (sliceCatState) {

    // Make the master slice set if it doesnt exist
    if (!sliceSet) {
      sliceSet = new RooArgSet ;
    }

    // Prepare comma separated label list for parsing
    char buf[1024] ;
    strlcpy(buf,sliceCatState,1024) ;
    const char* slabel = strtok(buf,",") ;

    // Loop over all categories provided by (multiple) Slice() arguments
    TIterator* iter = sliceCatList.MakeIterator() ;
    RooCategory* scat ;
    while((scat=(RooCategory*)iter->Next())) {
      if (slabel) {
	// Set the slice position to the value indicate by slabel
	scat->setLabel(slabel) ;
	// Add the slice category to the master slice set
	sliceSet->add(*scat,kFALSE) ;
      }
      slabel = strtok(0,",") ;
    }
    delete iter ;
  }

  o.precision = pc.getDouble("precision") ;
  o.shiftToZero = (pc.getInt("shiftToZero")!=0) ;
  Int_t vlines = pc.getInt("VLines");
  if (pc.hasProcessed("Range")) {
    o.rangeLo = pc.getDouble("rangeLo") ;
    o.rangeHi = pc.getDouble("rangeHi") ;
    o.postRangeFracScale = pc.getInt("rangeAdjustNorm") ;
    if (vlines==2) vlines=0 ; // Default is NoWings if range was specified
  } else if (pc.hasProcessed("RangeWithName")) {    
    o.normRangeName = pc.getString("rangeName",0,kTRUE) ;
    o.rangeLo = frame->getPlotVar()->getMin(pc.getString("rangeName",0,kTRUE)) ;
    o.rangeHi = frame->getPlotVar()->getMax(pc.getString("rangeName",0,kTRUE)) ;
    o.postRangeFracScale = pc.getInt("rangeWNAdjustNorm") ;
    if (vlines==2) vlines=0 ; // Default is NoWings if range was specified
  } 


  // If separate normalization range was specified this overrides previous settings
  if (pc.hasProcessed("NormRange")) {
    o.normRangeName = pc.getString("normRangeName") ;
    o.postRangeFracScale = kTRUE ;    
  }

  o.wmode = (vlines==2)?RooCurve::Extended:(vlines==1?RooCurve::Straight:RooCurve::NoWings) ;
  o.projectionRangeName = pc.getString("projectionRangeName",0,kTRUE) ;
  o.curveName = pc.getString("curveName",0,kTRUE) ;
  o.curveInvisible = pc.getInt("curveInvisible") ;
  o.progress = pc.getInt("showProg") ;
  o.addToCurveName = pc.getString("addToCurveName",0,kTRUE) ;
  o.addToWgtSelf = pc.getDouble("addToWgtSelf") ;
  o.addToWgtOther = pc.getDouble("addToWgtOther") ;  

  if (o.addToCurveName && !frame->findObject(o.addToCurveName,RooCurve::Class())) {
    coutE(InputArguments) << "RooAbsReal::plotOn(" << GetName() << ") cannot find existing curve " << o.addToCurveName << " to add to in RooPlot" << endl ;
    return frame ;
  }
  
  RooArgSet projectedVars ;
  if (sliceSet) {
    cxcoutD(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") Preprocessing: have slice " << *sliceSet << endl ;

    makeProjectionSet(frame->getPlotVar(),frame->getNormVars(),projectedVars,kTRUE) ;
    
    // Take out the sliced variables
    TIterator* iter = sliceSet->createIterator() ;
    RooAbsArg* sliceArg ;
    while((sliceArg=(RooAbsArg*)iter->Next())) {
      RooAbsArg* arg = projectedVars.find(sliceArg->GetName()) ;
      if (arg) {
	projectedVars.remove(*arg) ;
      } else {
	coutI(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") slice variable " 
			<< sliceArg->GetName() << " was not projected anyway" << endl ;
      }
    }
    delete iter ;
  } else if (projSet) {
    cxcoutD(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") Preprocessing: have projSet " << *projSet << endl ;
    makeProjectionSet(frame->getPlotVar(),projSet,projectedVars,kFALSE) ;
  } else {
    cxcoutD(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") Preprocessing: have neither sliceSet nor projSet " << endl ;
    makeProjectionSet(frame->getPlotVar(),frame->getNormVars(),projectedVars,kTRUE) ;
  }
  o.projSet = &projectedVars ;

  cxcoutD(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") Preprocessing: projectedVars = " << projectedVars << endl ;


  RooPlot* ret ;
  if (!asymCat) {
    // Forward to actual calculation
    ret = RooAbsReal::plotOn(frame,o) ;
  } else {        
    // Forward to actual calculation
    ret = RooAbsReal::plotAsymOn(frame,*asymCat,o) ;
  }

  delete sliceSet ;

  // Optionally adjust line/fill attributes
  Int_t lineColor = pc.getInt("lineColor") ;
  Int_t lineStyle = pc.getInt("lineStyle") ;
  Int_t lineWidth = pc.getInt("lineWidth") ;
  Int_t fillColor = pc.getInt("fillColor") ;
  Int_t fillStyle = pc.getInt("fillStyle") ;
  if (lineColor!=-999) ret->getAttLine()->SetLineColor(lineColor) ;
  if (lineStyle!=-999) ret->getAttLine()->SetLineStyle(lineStyle) ;
  if (lineWidth!=-999) ret->getAttLine()->SetLineWidth(lineWidth) ;
  if (fillColor!=-999) ret->getAttFill()->SetFillColor(fillColor) ;
  if (fillStyle!=-999) ret->getAttFill()->SetFillStyle(fillStyle) ;

  // Move last inserted object to back to drawing stack if requested
  if (pc.getInt("moveToBack") && frame->numItems()>1) {   
    frame->drawBefore(frame->getObject(0)->GetName(), frame->getCurve()->GetName());    
  }
  
  return ret ;
}




//_____________________________________________________________________________
// coverity[PASS_BY_VALUE]
RooPlot* RooAbsReal::plotOn(RooPlot *frame, PlotOpt o) const
{
  // Plotting engine function for internal use
  // 
  // Plot ourselves on given frame. If frame contains a histogram, all dimensions of the plotted
  // function that occur in the previously plotted dataset are projected via partial integration,
  // otherwise no projections are performed. Optionally, certain projections can be performed
  // by summing over the values present in a provided dataset ('projData'), to correctly
  // project out data dependents that are not properly described by the PDF (e.g. per-event errors).
  //
  // The functions value can be multiplied with an optional scale factor. The interpretation
  // of the scale factor is unique for generic real functions, for PDFs there are various interpretations
  // possible, which can be selection with 'stype' (see RooAbsPdf::plotOn() for details).
  //
  // The default projection behaviour can be overriden by supplying an optional set of dependents
  // to project. For most cases, plotSliceOn() and plotProjOn() provide a more intuitive interface
  // to modify the default projection behavour.

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

  // ProjDataVars is either all projData observables, or the user indicated subset of it
  RooArgSet projDataVars ;
  if (o.projData) {
    cxcoutD(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") have ProjData with observables = " << *o.projData->get() << endl ;
    if (o.projDataSet) {
      RooArgSet* tmp = (RooArgSet*) o.projData->get()->selectCommon(*o.projDataSet) ;
      projDataVars.add(*tmp) ;
      cxcoutD(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") have ProjDataSet = " << *o.projDataSet << " will only use this subset of projData" << endl ;
      delete tmp ;
    } else {
      cxcoutD(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") using full ProjData" << endl ;
      projDataVars.add(*o.projData->get()) ;
    }
  }

  cxcoutD(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") ProjDataVars = " << projDataVars << endl ;

  // Make list of variables to be projected
  RooArgSet projectedVars ;
  RooArgSet sliceSet ;
  if (o.projSet) {
    cxcoutD(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") have input projSet = " << *o.projSet << endl ;
    makeProjectionSet(frame->getPlotVar(),o.projSet,projectedVars,kFALSE) ;
    cxcoutD(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") calculated projectedVars = " << *o.projSet << endl ;

    // Print list of non-projected variables
    if (frame->getNormVars()) {
      RooArgSet *sliceSetTmp = getObservables(*frame->getNormVars()) ;

      cxcoutD(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") frame->getNormVars() that are also observables = " << *sliceSetTmp << endl ;

      sliceSetTmp->remove(projectedVars,kTRUE,kTRUE) ;
      sliceSetTmp->remove(*frame->getPlotVar(),kTRUE,kTRUE) ;

      if (o.projData) {
	RooArgSet* tmp = (RooArgSet*) projDataVars.selectCommon(*o.projSet) ;
	sliceSetTmp->remove(*tmp,kTRUE,kTRUE) ;
	delete tmp ;
      }

      if (sliceSetTmp->getSize()) {
	coutI(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") plot on " 
			<< frame->getPlotVar()->GetName() << " represents a slice in " << *sliceSetTmp << endl ;
      }
      sliceSet.add(*sliceSetTmp) ;
      delete sliceSetTmp ;
    }
  } else {
    makeProjectionSet(frame->getPlotVar(),frame->getNormVars(),projectedVars,kTRUE) ;
  }

  cxcoutD(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") projectedVars = " << projectedVars << " sliceSet = " << sliceSet << endl ;


  RooArgSet* projDataNeededVars = 0 ;
  // Take out data-projected dependents from projectedVars
  if (o.projData) {
    projDataNeededVars = (RooArgSet*) projectedVars.selectCommon(projDataVars) ;
    projectedVars.remove(projDataVars,kTRUE,kTRUE) ;
  }

  // Clone the plot variable
  RooAbsReal* realVar = (RooRealVar*) frame->getPlotVar() ;
  RooArgSet* plotCloneSet = (RooArgSet*) RooArgSet(*realVar).snapshot(kTRUE) ;
  if (!plotCloneSet) {
    coutE(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") Couldn't deep-clone self, abort," << endl ;
    return frame ;
  }
  RooRealVar* plotVar = (RooRealVar*) plotCloneSet->find(realVar->GetName());

  // Inform user about projections
  if (projectedVars.getSize()) {
    coutI(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") plot on " << plotVar->GetName() 
		    << " integrates over variables " << projectedVars 
		    << (o.projectionRangeName?Form(" in range %s",o.projectionRangeName):"") << endl;
  }  
  if (projDataNeededVars && projDataNeededVars->getSize()>0) {
    coutI(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") plot on " << plotVar->GetName() 
		    << " averages using data variables " << *projDataNeededVars << endl ;
  }

  // Create projection integral
  RooArgSet* projectionCompList ;

  RooArgSet* deps = getObservables(frame->getNormVars()) ;
  deps->remove(projectedVars,kTRUE,kTRUE) ;
  if (projDataNeededVars) {
    deps->remove(*projDataNeededVars,kTRUE,kTRUE) ;
  }
  deps->remove(*plotVar,kTRUE,kTRUE) ;
  deps->add(*plotVar) ;

  // Now that we have the final set of dependents, call checkObservables()

  // WVE take out conditional observables
  if (checkObservables(deps)) {
    coutE(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") error in checkObservables, abort" << endl ;
    delete deps ;
    delete plotCloneSet ;
    if (projDataNeededVars) delete projDataNeededVars ;
    return frame ;
  }

  RooArgSet normSet(*deps) ;
  //normSet.add(projDataVars) ;

  RooAbsReal *projection = (RooAbsReal*) createPlotProjection(normSet, &projectedVars, projectionCompList, o.projectionRangeName) ;
  cxcoutD(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") plot projection object is " << projection->GetName() << endl ;
  if (dologD(Plotting)) {
    projection->printStream(ccoutD(Plotting),0,kVerbose) ;
  }

  // Always fix RooAddPdf normalizations
  RooArgSet fullNormSet(*deps) ;
  fullNormSet.add(projectedVars) ;
  if (projDataNeededVars && projDataNeededVars->getSize()>0) {
    fullNormSet.add(*projDataNeededVars) ;
  }
  RooArgSet* compSet = projection->getComponents() ;
  TIterator* iter = compSet->createIterator() ;
  RooAbsArg* arg ;
  while((arg=(RooAbsArg*)iter->Next())) {
    RooAbsPdf* pdf = dynamic_cast<RooAbsPdf*>(arg) ;
    if (pdf) {
      pdf->selectNormalization(&fullNormSet) ;
    } 
  }
  delete iter ;
  delete compSet ;
  
  
  // Apply data projection, if requested
  if (o.projData && projDataNeededVars && projDataNeededVars->getSize()>0) {

    // If data set contains more rows than needed, make reduced copy first
    RooAbsData* projDataSel = (RooAbsData*)o.projData;

    if (projDataNeededVars->getSize()<o.projData->get()->getSize()) {
      
      // Determine if there are any slice variables in the projection set
      RooArgSet* sliceDataSet = (RooArgSet*) sliceSet.selectCommon(*o.projData->get()) ;
      TString cutString ;
      if (sliceDataSet->getSize()>0) {
	TIterator* iter2 = sliceDataSet->createIterator() ;
	RooAbsArg* sliceVar ; 
	Bool_t first(kTRUE) ;
	while((sliceVar=(RooAbsArg*)iter2->Next())) {
	  if (!first) {
	    cutString.Append("&&") ;
	  } else {
	    first=kFALSE ;	    
	  }

	  RooAbsRealLValue* real ;
	  RooAbsCategoryLValue* cat ;	  
	  if ((real = dynamic_cast<RooAbsRealLValue*>(sliceVar))) {
	    cutString.Append(Form("%s==%f",real->GetName(),real->getVal())) ;
	  } else if ((cat = dynamic_cast<RooAbsCategoryLValue*>(sliceVar))) {
	    cutString.Append(Form("%s==%d",cat->GetName(),cat->getIndex())) ;	    
	  }
	}
	delete iter2 ;
      }
      delete sliceDataSet ;

      if (!cutString.IsNull()) {
	projDataSel = ((RooAbsData*)o.projData)->reduce(*projDataNeededVars,cutString) ;
	coutI(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") reducing given projection dataset to entries with " << cutString << endl ;
      } else {
	projDataSel = ((RooAbsData*)o.projData)->reduce(*projDataNeededVars) ;
      }
      coutI(Plotting) << "RooAbsReal::plotOn(" << GetName() 
		      << ") only the following components of the projection data will be used: " << *projDataNeededVars << endl ;
    }

    // Request binning of unbinned projection dataset that consists exclusively of category observables
    if (!o.binProjData && dynamic_cast<RooDataSet*>(projDataSel)!=0) {
      
      // Determine if dataset contains only categories
      TIterator* iter2 = projDataSel->get()->createIterator() ;
      Bool_t allCat(kTRUE) ;
      RooAbsArg* arg2 ;
      while((arg2=(RooAbsArg*)iter2->Next())) {
	if (!dynamic_cast<RooCategory*>(arg2)) allCat = kFALSE ;
      }
      delete iter2 ;
      if (allCat) {
	o.binProjData = kTRUE ;
	coutI(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") unbinned projection dataset consist only of discrete variables,"
			<< " performing projection with binned copy for optimization." << endl ;
	
      }
    }

    // Bin projection dataset if requested
    if (o.binProjData) {
      RooAbsData* tmp = new RooDataHist(Form("%s_binned",projDataSel->GetName()),"Binned projection data",*projDataSel->get(),*projDataSel) ;
      if (projDataSel!=o.projData) delete projDataSel ;
      projDataSel = tmp ;
    }
    


    // Attach dataset
    projection->getVal(projDataSel->get()) ;
    projection->attachDataSet(*projDataSel) ;

    // Construct optimized data weighted average
    RooDataWeightedAverage dwa(Form("%sDataWgtAvg",GetName()),"Data Weighted average",*projection,*projDataSel,RooArgSet()/**projDataSel->get()*/,o.numCPU,o.interleave,kTRUE) ;
    //RooDataWeightedAverage dwa(Form("%sDataWgtAvg",GetName()),"Data Weighted average",*projection,*projDataSel,*projDataSel->get(),o.numCPU,o.interleave,kTRUE) ;

    // Do _not_ activate cache-and-track as necessary information to define normalization observables are not present in the underlying dataset
    dwa.constOptimizeTestStatistic(Activate,kFALSE) ;

    RooRealBinding projBind(dwa,*plotVar) ;
    RooScaledFunc scaleBind(projBind,o.scaleFactor);

    // Set default range, if not specified
    if (o.rangeLo==0 && o.rangeHi==0) {
      o.rangeLo = frame->GetXaxis()->GetXmin() ;
      o.rangeHi = frame->GetXaxis()->GetXmax() ;
    }
    
    // Construct name of curve for data weighed average
    TString curveName(projection->GetName()) ;
    curveName.Append(Form("_DataAvg[%s]",projDataSel->get()->contentsString().c_str())) ;
    // Append slice set specification if any
    if (sliceSet.getSize()>0) {
      curveName.Append(Form("_Slice[%s]",sliceSet.contentsString().c_str())) ;      
    }
    // Append any suffixes imported from RooAbsPdf::plotOn
    if (o.curveNameSuffix) {
      curveName.Append(o.curveNameSuffix) ;
    }

    // Curve constructor for data weighted average    
    RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::CollectErrors) ;
    RooCurve *curve = new RooCurve(projection->GetName(),projection->GetTitle(),scaleBind,
				   o.rangeLo,o.rangeHi,frame->GetNbinsX(),o.precision,o.precision,o.shiftToZero,o.wmode,o.numee,o.doeeval,o.eeval) ;
    RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::PrintErrors) ;

    curve->SetName(curveName.Data()) ;

    // Add self to other curve if requested
    if (o.addToCurveName) {
      RooCurve* otherCurve = static_cast<RooCurve*>(frame->findObject(o.addToCurveName,RooCurve::Class())) ;

      // Curve constructor for sum of curves
      RooCurve* sumCurve = new RooCurve(projection->GetName(),projection->GetTitle(),*curve,*otherCurve,o.addToWgtSelf,o.addToWgtOther) ;
      sumCurve->SetName(Form("%s_PLUS_%s",curve->GetName(),otherCurve->GetName())) ;
      delete curve ;
      curve = sumCurve ;
      
    }

    if (o.curveName) {
      curve->SetName(o.curveName) ;
    }

    // add this new curve to the specified plot frame
    frame->addPlotable(curve, o.drawOptions);

    if (projDataSel!=o.projData) delete projDataSel ;
       
  } else {
    
    // Set default range, if not specified
    if (o.rangeLo==0 && o.rangeHi==0) {
      o.rangeLo = frame->GetXaxis()->GetXmin() ;
      o.rangeHi = frame->GetXaxis()->GetXmax() ;
    }

    // Calculate a posteriori range fraction scaling if requested (2nd part of normalization correction for
    // result fit on subrange of data)
    if (o.postRangeFracScale) {
      if (!o.normRangeName) {
	o.normRangeName = "plotRange" ;
	plotVar->setRange("plotRange",o.rangeLo,o.rangeHi) ;
      }

      // Evaluate fractional correction integral always on full p.d.f, not component.
      Bool_t tmp = _globalSelectComp ;
      globalSelectComp(kTRUE) ;
      RooAbsReal* intFrac = projection->createIntegral(*plotVar,*plotVar,o.normRangeName) ;
      globalSelectComp(kTRUE) ;
      o.scaleFactor /= intFrac->getVal() ;
      globalSelectComp(tmp) ;
      delete intFrac ;

    }

    // create a new curve of our function using the clone to do the evaluations
    // Curve constructor for regular projections

    RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::CollectErrors) ;
    RooCurve *curve = new RooCurve(*projection,*plotVar,o.rangeLo,o.rangeHi,frame->GetNbinsX(),
				   o.scaleFactor,0,o.precision,o.precision,o.shiftToZero,o.wmode,o.numee,o.doeeval,o.eeval,o.progress);
    RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::PrintErrors) ;



    // Set default name of curve
    TString curveName(projection->GetName()) ;
    if (sliceSet.getSize()>0) {
      curveName.Append(Form("_Slice[%s]",sliceSet.contentsString().c_str())) ;      
    }
    if (o.curveNameSuffix) {
      // Append any suffixes imported from RooAbsPdf::plotOn
      curveName.Append(o.curveNameSuffix) ;
    }
    curve->SetName(curveName.Data()) ;


    // Add self to other curve if requested
    if (o.addToCurveName) {
      RooCurve* otherCurve = static_cast<RooCurve*>(frame->findObject(o.addToCurveName,RooCurve::Class())) ;
      RooCurve* sumCurve = new RooCurve(projection->GetName(),projection->GetTitle(),*curve,*otherCurve,o.addToWgtSelf,o.addToWgtOther) ;
      sumCurve->SetName(Form("%s_PLUS_%s",curve->GetName(),otherCurve->GetName())) ;
      delete curve ;
      curve = sumCurve ;
    }

    // Override name of curve by user name, if specified
    if (o.curveName) {
      curve->SetName(o.curveName) ;
    }

    // add this new curve to the specified plot frame
    frame->addPlotable(curve, o.drawOptions, o.curveInvisible);
  }

  if (projDataNeededVars) delete projDataNeededVars ;
  delete deps ;
  delete projectionCompList ;
  delete plotCloneSet ;
  return frame;
}




//_____________________________________________________________________________
RooPlot* RooAbsReal::plotSliceOn(RooPlot *frame, const RooArgSet& sliceSet, Option_t* drawOptions, 
				 Double_t scaleFactor, ScaleType stype, const RooAbsData* projData) const
{
  // OBSOLETE -- RETAINED FOR BACKWARD COMPATIBILITY. Use the plotOn(frame,Slice(...)) instead

  RooArgSet projectedVars ;
  makeProjectionSet(frame->getPlotVar(),frame->getNormVars(),projectedVars,kTRUE) ;
  
  // Take out the sliced variables
  TIterator* iter = sliceSet.createIterator() ;
  RooAbsArg* sliceArg ;
  while((sliceArg=(RooAbsArg*)iter->Next())) {
    RooAbsArg* arg = projectedVars.find(sliceArg->GetName()) ;
    if (arg) {
      projectedVars.remove(*arg) ;
    } else {
      coutI(Plotting) << "RooAbsReal::plotSliceOn(" << GetName() << ") slice variable " 
		      << sliceArg->GetName() << " was not projected anyway" << endl ;
    }
  }
  delete iter ;

  PlotOpt o ;
  o.drawOptions = drawOptions ;
  o.scaleFactor = scaleFactor ;
  o.stype = stype ;
  o.projData = projData ;
  o.projSet = &projectedVars ;
  return plotOn(frame,o) ;
}




//_____________________________________________________________________________
// coverity[PASS_BY_VALUE]
RooPlot* RooAbsReal::plotAsymOn(RooPlot *frame, const RooAbsCategoryLValue& asymCat, PlotOpt o) const

{
  // Plotting engine for asymmetries. Implements the functionality if plotOn(frame,Asymmetry(...))) 
  //
  // Plot asymmetry of ourselves, defined as
  //
  //   asym = f(asymCat=-1) - f(asymCat=+1) / ( f(asymCat=-1) + f(asymCat=+1) )
  //
  // on frame. If frame contains a histogram, all dimensions of the plotted
  // asymmetry function that occur in the previously plotted dataset are projected via partial integration.
  // Otherwise no projections are performed,
  //
  // The asymmetry function can be multiplied with an optional scale factor. The default projection 
  // behaviour can be overriden by supplying an optional set of dependents to project. 

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

  // ProjDataVars is either all projData observables, or the user indicated subset of it
  RooArgSet projDataVars ;
  if (o.projData) {
    if (o.projDataSet) {
      RooArgSet* tmp = (RooArgSet*) o.projData->get()->selectCommon(*o.projDataSet) ;
      projDataVars.add(*tmp) ;
      delete tmp ;
    } else {
      projDataVars.add(*o.projData->get()) ;
    }
  }

  // Must depend on asymCat
  if (!dependsOn(asymCat)) {
    coutE(Plotting) << "RooAbsReal::plotAsymOn(" << GetName() 
		    << ") function doesn't depend on asymmetry category " << asymCat.GetName() << endl ;
    return frame ;
  }

  // asymCat must be a signCat
  if (!asymCat.isSignType()) {
    coutE(Plotting) << "RooAbsReal::plotAsymOn(" << GetName()
		    << ") asymmetry category must have 2 or 3 states with index values -1,0,1" << endl ;
    return frame ;
  }
  
  // Make list of variables to be projected
  RooArgSet projectedVars ;
  RooArgSet sliceSet ;
  if (o.projSet) {
    makeProjectionSet(frame->getPlotVar(),o.projSet,projectedVars,kFALSE) ;

    // Print list of non-projected variables
    if (frame->getNormVars()) {
      RooArgSet *sliceSetTmp = getObservables(*frame->getNormVars()) ;
      sliceSetTmp->remove(projectedVars,kTRUE,kTRUE) ;
      sliceSetTmp->remove(*frame->getPlotVar(),kTRUE,kTRUE) ;

      if (o.projData) {
	RooArgSet* tmp = (RooArgSet*) projDataVars.selectCommon(*o.projSet) ;
	sliceSetTmp->remove(*tmp,kTRUE,kTRUE) ;
	delete tmp ;
      }

      if (sliceSetTmp->getSize()) {
	coutI(Plotting) << "RooAbsReal::plotAsymOn(" << GetName() << ") plot on " 
			<< frame->getPlotVar()->GetName() << " represents a slice in " << *sliceSetTmp << endl ;
      }
      sliceSet.add(*sliceSetTmp) ;
      delete sliceSetTmp ;
    }
  } else {
    makeProjectionSet(frame->getPlotVar(),frame->getNormVars(),projectedVars,kTRUE) ;
  }


  // Take out data-projected dependens from projectedVars
  RooArgSet* projDataNeededVars = 0 ;
  if (o.projData) {
    projDataNeededVars = (RooArgSet*) projectedVars.selectCommon(projDataVars) ;
    projectedVars.remove(projDataVars,kTRUE,kTRUE) ;
  }

  // Take out plotted asymmetry from projection
  if (projectedVars.find(asymCat.GetName())) {
    projectedVars.remove(*projectedVars.find(asymCat.GetName())) ;
  }

  // Clone the plot variable
  RooAbsReal* realVar = (RooRealVar*) frame->getPlotVar() ;
  RooRealVar* plotVar = (RooRealVar*) realVar->Clone() ;

  // Inform user about projections
  if (projectedVars.getSize()) {
    coutI(Plotting) << "RooAbsReal::plotAsymOn(" << GetName() << ") plot on " << plotVar->GetName() 
		    << " projects variables " << projectedVars << endl ;
  }  
  if (projDataNeededVars && projDataNeededVars->getSize()>0) {
    coutI(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") plot on " << plotVar->GetName() 
		    << " averages using data variables "<<  *projDataNeededVars << endl ;
  }


  // Customize two copies of projection with fixed negative and positive asymmetry
  RooAbsCategoryLValue* asymPos = (RooAbsCategoryLValue*) asymCat.Clone("asym_pos") ;
  RooAbsCategoryLValue* asymNeg = (RooAbsCategoryLValue*) asymCat.Clone("asym_neg") ;
  asymPos->setIndex(1) ;
  asymNeg->setIndex(-1) ;
  RooCustomizer* custPos = new RooCustomizer(*this,"pos") ;
  RooCustomizer* custNeg = new RooCustomizer(*this,"neg") ;
  //custPos->setOwning(kTRUE) ;
  //custNeg->setOwning(kTRUE) ;
  custPos->replaceArg(asymCat,*asymPos) ;
  custNeg->replaceArg(asymCat,*asymNeg) ;
  RooAbsReal* funcPos = (RooAbsReal*) custPos->build() ;
  RooAbsReal* funcNeg = (RooAbsReal*) custNeg->build() ;

  // Create projection integral 
  RooArgSet *posProjCompList, *negProjCompList ;

  // Add projDataVars to normalized dependents of projection
  // This is needed only for asymmetries (why?)
  RooArgSet depPos(*plotVar,*asymPos) ;
  RooArgSet depNeg(*plotVar,*asymNeg) ;
  depPos.add(projDataVars) ;
  depNeg.add(projDataVars) ;

  const RooAbsReal *posProj = funcPos->createPlotProjection(depPos, &projectedVars, posProjCompList, o.projectionRangeName) ;
  const RooAbsReal *negProj = funcNeg->createPlotProjection(depNeg, &projectedVars, negProjCompList, o.projectionRangeName) ;
  if (!posProj || !negProj) {
    coutE(Plotting) << "RooAbsReal::plotAsymOn(" << GetName() << ") Unable to create projections, abort" << endl ;
    return frame ; 
  }

  // Create a RooFormulaVar representing the asymmetry
  TString asymName(GetName()) ;
  asymName.Append("_Asym[") ;
  asymName.Append(asymCat.GetName()) ;
  asymName.Append("]") ;
  TString asymTitle(asymCat.GetName()) ;
  asymTitle.Append(" Asymmetry of ") ;
  asymTitle.Append(GetTitle()) ;
  RooFormulaVar* funcAsym = new RooFormulaVar(asymName,asymTitle,"(@0-@1)/(@0+@1)",RooArgSet(*posProj,*negProj)) ;

  if (o.projData) {
    
    // If data set contains more rows than needed, make reduced copy first
    RooAbsData* projDataSel = (RooAbsData*)o.projData;
    if (projDataNeededVars && projDataNeededVars->getSize()<o.projData->get()->getSize()) {
      
      // Determine if there are any slice variables in the projection set
      RooArgSet* sliceDataSet = (RooArgSet*) sliceSet.selectCommon(*o.projData->get()) ;
      TString cutString ;
      if (sliceDataSet->getSize()>0) {
	TIterator* iter = sliceDataSet->createIterator() ;
	RooAbsArg* sliceVar ; 
	Bool_t first(kTRUE) ;
 	while((sliceVar=(RooAbsArg*)iter->Next())) {
	  if (!first) {
	    cutString.Append("&&") ;
 	  } else {
	    first=kFALSE ;	    
 	  }

 	  RooAbsRealLValue* real ;
	  RooAbsCategoryLValue* cat ;	  
 	  if ((real = dynamic_cast<RooAbsRealLValue*>(sliceVar))) {
	    cutString.Append(Form("%s==%f",real->GetName(),real->getVal())) ;
	  } else if ((cat = dynamic_cast<RooAbsCategoryLValue*>(sliceVar))) {
	    cutString.Append(Form("%s==%d",cat->GetName(),cat->getIndex())) ;	    
	  }
 	}
	delete iter ;
      }
      delete sliceDataSet ;

      if (!cutString.IsNull()) {
	projDataSel = ((RooAbsData*)o.projData)->reduce(*projDataNeededVars,cutString) ;
 	coutI(Plotting) << "RooAbsReal::plotAsymOn(" << GetName() 
			<< ") reducing given projection dataset to entries with " << cutString << endl ;
      } else {
	projDataSel = ((RooAbsData*)o.projData)->reduce(*projDataNeededVars) ;
      }
      coutI(Plotting) << "RooAbsReal::plotAsymOn(" << GetName() 
		      << ") only the following components of the projection data will be used: " << *projDataNeededVars << endl ;
    }    
    

    RooDataWeightedAverage dwa(Form("%sDataWgtAvg",GetName()),"Data Weighted average",*funcAsym,*projDataSel,RooArgSet()/**projDataSel->get()*/,o.numCPU,o.interleave,kTRUE) ;
    //RooDataWeightedAverage dwa(Form("%sDataWgtAvg",GetName()),"Data Weighted average",*funcAsym,*projDataSel,*projDataSel->get(),o.numCPU,o.interleave,kTRUE) ;
    dwa.constOptimizeTestStatistic(Activate) ;

    RooRealBinding projBind(dwa,*plotVar) ;

    ((RooAbsReal*)posProj)->attachDataSet(*projDataSel) ;
    ((RooAbsReal*)negProj)->attachDataSet(*projDataSel) ;

    RooScaledFunc scaleBind(projBind,o.scaleFactor);

    // Set default range, if not specified
    if (o.rangeLo==0 && o.rangeHi==0) {
      o.rangeLo = frame->GetXaxis()->GetXmin() ;
      o.rangeHi = frame->GetXaxis()->GetXmax() ;
    }

    // Construct name of curve for data weighed average
    TString curveName(funcAsym->GetName()) ;
    curveName.Append(Form("_DataAvg[%s]",projDataSel->get()->contentsString().c_str())) ;
    // Append slice set specification if any
    if (sliceSet.getSize()>0) {
      curveName.Append(Form("_Slice[%s]",sliceSet.contentsString().c_str())) ;      
    }
    // Append any suffixes imported from RooAbsPdf::plotOn
    if (o.curveNameSuffix) {
      curveName.Append(o.curveNameSuffix) ;
    }


    RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::CollectErrors) ;
    RooCurve *curve = new RooCurve(funcAsym->GetName(),funcAsym->GetTitle(),scaleBind,
				   o.rangeLo,o.rangeHi,frame->GetNbinsX(),o.precision,o.precision,kFALSE,o.wmode,o.numee,o.doeeval,o.eeval) ;
    RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::PrintErrors) ;

    dynamic_cast<TAttLine*>(curve)->SetLineColor(2) ;
    // add this new curve to the specified plot frame
    frame->addPlotable(curve, o.drawOptions);

    ccoutW(Eval) << endl ;

    if (projDataSel!=o.projData) delete projDataSel ;
       
  } else {

    // Set default range, if not specified
    if (o.rangeLo==0 && o.rangeHi==0) {
      o.rangeLo = frame->GetXaxis()->GetXmin() ;
      o.rangeHi = frame->GetXaxis()->GetXmax() ;
    }

    RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::CollectErrors) ;
    RooCurve* curve= new RooCurve(*funcAsym,*plotVar,o.rangeLo,o.rangeHi,frame->GetNbinsX(),
				  o.scaleFactor,0,o.precision,o.precision,kFALSE,o.wmode,o.numee,o.doeeval,o.eeval);
    RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::PrintErrors) ;

    dynamic_cast<TAttLine*>(curve)->SetLineColor(2) ;


    // Set default name of curve
    TString curveName(funcAsym->GetName()) ;
    if (sliceSet.getSize()>0) {
      curveName.Append(Form("_Slice[%s]",sliceSet.contentsString().c_str())) ;      
    }
    if (o.curveNameSuffix) {
      // Append any suffixes imported from RooAbsPdf::plotOn
      curveName.Append(o.curveNameSuffix) ;
    }
    curve->SetName(curveName.Data()) ;
    
    // add this new curve to the specified plot frame
    frame->addPlotable(curve, o.drawOptions);

  }

  // Cleanup
  delete custPos ;
  delete custNeg ;
  delete funcPos ;
  delete funcNeg ;
  delete posProjCompList ;
  delete negProjCompList ;
  delete asymPos ;
  delete asymNeg ;
  delete funcAsym ;

  delete plotVar ;

  return frame;
}



//_____________________________________________________________________________
Double_t RooAbsReal::getPropagatedError(const RooFitResult& fr) 
{
  // Calculate error on self by propagated errors on parameters with correlations as given by fit result
  // The linearly propagated error is calculated as follows
  //                                    T            
  // error(x) = F_a(x) * Corr(a,a') F_a'(x)
  //
  // where     F_a(x) = [ f(x,a+da) - f(x,a-da) ] / 2, with f(x) this function and 'da' taken from the fit result
  //       Corr(a,a') = the correlation matrix from the fit result
  //


  // Clone self for internal use
  RooAbsReal* cloneFunc = (RooAbsReal*) cloneTree() ;
  RooArgSet* errorParams = cloneFunc->getObservables(fr.floatParsFinal()) ;
  RooArgSet* nset = cloneFunc->getParameters(*errorParams) ;
    
  // Make list of parameter instances of cloneFunc in order of error matrix
  RooArgList paramList ;
  const RooArgList& fpf = fr.floatParsFinal() ;
  vector<int> fpf_idx ;
  for (Int_t i=0 ; i<fpf.getSize() ; i++) {
    RooAbsArg* par = errorParams->find(fpf[i].GetName()) ;
    if (par) {
      paramList.add(*par) ;
      fpf_idx.push_back(i) ;
    }
  }

  vector<Double_t> plusVar, minusVar ;    
  
  // Create vector of plus,minus variations for each parameter  
  TMatrixDSym V(paramList.getSize()==fr.floatParsFinal().getSize()?
		fr.covarianceMatrix():
		fr.reducedCovarianceMatrix(paramList)) ;
  
  for (Int_t ivar=0 ; ivar<paramList.getSize() ; ivar++) {
    
    RooRealVar& rrv = (RooRealVar&)fpf[fpf_idx[ivar]] ;
    
    Double_t cenVal = rrv.getVal() ;
    Double_t errVal = sqrt(V(ivar,ivar)) ;
    
    // Make Plus variation
    ((RooRealVar*)paramList.at(ivar))->setVal(cenVal+errVal) ;
    plusVar.push_back(cloneFunc->getVal(nset)) ;
    
    // Make Minus variation
    ((RooRealVar*)paramList.at(ivar))->setVal(cenVal-errVal) ;
    minusVar.push_back(cloneFunc->getVal(nset)) ;
    
    ((RooRealVar*)paramList.at(ivar))->setVal(cenVal) ;
  }
  
  TMatrixDSym C(paramList.getSize()) ;      
  vector<double> errVec(paramList.getSize()) ;
  for (int i=0 ; i<paramList.getSize() ; i++) {
    errVec[i] = sqrt(V(i,i)) ;
    for (int j=i ; j<paramList.getSize() ; j++) {
      C(i,j) = V(i,j)/sqrt(V(i,i)*V(j,j)) ;
      C(j,i) = C(i,j) ;
    }
  }
  
  // Make vector of variations
  TVectorD F(plusVar.size()) ;
  for (unsigned int j=0 ; j<plusVar.size() ; j++) {
    F[j] = (plusVar[j]-minusVar[j])/2 ;
  }

  // Calculate error in linear approximation from variations and correlation coefficient
  Double_t sum = F*(C*F) ;

  delete cloneFunc ;
  delete errorParams ;
  delete nset ;

  return sqrt(sum) ;
}










//_____________________________________________________________________________
RooPlot* RooAbsReal::plotOnWithErrorBand(RooPlot* frame,const RooFitResult& fr, Double_t Z,const RooArgSet* params, const RooLinkedList& argList, Bool_t linMethod) const 
{
  // Plot function or p.d.f. on frame with support for visualization of the uncertainty encoded in the given fit result fr.
  // If params is non-zero, only the subset of the parameters in fr that occur in params is considered for the error evaluation
  // Argument argList can contain any RooCmdArg named argument that can be applied to a regular plotOn() operation
  //
  // By default (linMethod=kTRUE) a linearized error is shown which is calculated as follows
  //                                    T            
  // error(x) = Z* F_a(x) * Corr(a,a') F_a'(x)
  //
  // where     F_a(x) = [ f(x,a+da) - f(x,a-da) ] / 2, with f(x) the plotted curve and 'da' taken from the fit result
  //       Corr(a,a') = the correlation matrix from the fit result
  //                Z = requested signifance 'Z sigma band'
  //
  // The linear method is fast (required 2*N evaluations of the curve, where N is the number of parameters), but may
  // not be accurate in the presence of strong correlations (~>0.9) and at Z>2 due to linear and Gaussian approximations made
  //
  // Alternatively, a more robust error is calculated using a sampling method. In this method a number of curves
  // is calculated with variations of the parameter values, as drawn from a multi-variate Gaussian p.d.f. that is constructed
  // from the fit results covariance matrix. The error(x) is determined by calculating a central interval that capture N% of the variations 
  // for each valye of x, where N% is controlled by Z (i.e. Z=1 gives N=68%). The number of sampling curves is chosen to be such
  // that at least 30 curves are expected to be outside the N% interval, and is minimally 100 (e.g. Z=1->Ncurve=100, Z=2->Ncurve=659, Z=3->Ncurve=11111)
  // Intervals from the sampling method can be asymmetric, and may perform better in the presence of strong correlations

  RooLinkedList plotArgListTmp(argList) ;
  RooCmdConfig pc(Form("RooAbsPdf::plotOn(%s)",GetName())) ;
  pc.stripCmdList(plotArgListTmp,"VisualizeError,MoveToBack") ;  

  // Strip any 'internal normalization' arguments from list
  RooLinkedList plotArgList ;
  RooFIter iter = plotArgListTmp.fwdIterator() ;
  RooCmdArg* cmd ;
  while ((cmd=(RooCmdArg*)iter.next())) {
    if (std::string("Normalization")==cmd->GetName()) {
      if (((RooCmdArg*)cmd)->getInt(1)!=0) {
      } else {
	plotArgList.Add(cmd) ;
      }
    } else {
      plotArgList.Add(cmd) ;
    }
  }

  // Generate central value curve
  RooLinkedList tmp(plotArgList) ;
  plotOn(frame,tmp) ;
  RooCurve* cenCurve = frame->getCurve() ;
  frame->remove(0,kFALSE) ;

  RooCurve* band(0) ;
  if (!linMethod) {

    // *** Interval method ***
    //
    // Make N variations of parameters samples from V and visualize N% central interval where N% is defined from Z

    // Clone self for internal use
    RooAbsReal* cloneFunc = (RooAbsReal*) cloneTree() ;
    RooArgSet* cloneParams = cloneFunc->getObservables(fr.floatParsFinal()) ;
    RooArgSet* errorParams = params?((RooArgSet*)cloneParams->selectCommon(*params)):cloneParams ;
    
    // Generate 100 random parameter points distributed according to fit result covariance matrix
    RooAbsPdf* paramPdf = fr.createHessePdf(*errorParams) ;
    Int_t n = Int_t(100./TMath::Erfc(Z/sqrt(2.))) ;
    if (n<100) n=100 ;
    
    coutI(Plotting) << "RooAbsReal::plotOn(" << GetName() << ") INFO: visualizing " << Z << "-sigma uncertainties in parameters " 
		  << *errorParams << " from fit result " << fr.GetName() << " using " << n << " samplings." << endl ;
    
    // Generate variation curves with above set of parameter values
    Double_t ymin = frame->GetMinimum() ;
    Double_t ymax = frame->GetMaximum() ;
    RooDataSet* d = paramPdf->generate(*errorParams,n) ;
    vector<RooCurve*> cvec ;
    for (int i=0 ; i<d->numEntries() ; i++) {
      *cloneParams = (*d->get(i)) ;
      RooLinkedList tmp2(plotArgList) ;
      cloneFunc->plotOn(frame,tmp2) ;
      cvec.push_back(frame->getCurve()) ;
      frame->remove(0,kFALSE) ;
    }
    frame->SetMinimum(ymin) ;
    frame->SetMaximum(ymax) ;
    
    
    // Generate upper and lower curve points from 68% interval around each point of central curve
    band = cenCurve->makeErrorBand(cvec,Z) ;
    
    // Cleanup 
    delete paramPdf ;
    delete cloneFunc ;
    for (vector<RooCurve*>::iterator i=cvec.begin() ; i!=cvec.end() ; i++) {
      delete (*i) ;
    }

  } else {

    // *** Linear Method ***
    //
    // Make a one-sigma up- and down fluctation for each parameter and visualize
    // a from a linearized calculation as follows
    //
    //   error(x) = F(a) C_aa' F(a')
    //
    //   Where F(a) = (f(x,a+da) - f(x,a-da))/2
    //   and C_aa' is the correlation matrix

    // Clone self for internal use
    RooAbsReal* cloneFunc = (RooAbsReal*) cloneTree() ;
    RooArgSet* cloneParams = cloneFunc->getObservables(fr.floatParsFinal()) ;
    RooArgSet* errorParams = params?((RooArgSet*)cloneParams->selectCommon(*params)):cloneParams ;    
    

    // Make list of parameter instances of cloneFunc in order of error matrix
    RooArgList paramList ;
    const RooArgList& fpf = fr.floatParsFinal() ;
    vector<int> fpf_idx ;
    for (Int_t i=0 ; i<fpf.getSize() ; i++) {
      RooAbsArg* par = errorParams->find(fpf[i].GetName()) ;
      if (par) {
	paramList.add(*par) ;
	fpf_idx.push_back(i) ;
      }
    }

    vector<RooCurve*> plusVar, minusVar ;    

    // Create vector of plus,minus variations for each parameter
    
    TMatrixDSym V(paramList.getSize()==fr.floatParsFinal().getSize()?
		  fr.covarianceMatrix():
		  fr.reducedCovarianceMatrix(paramList)) ;
    

    for (Int_t ivar=0 ; ivar<paramList.getSize() ; ivar++) {

      RooRealVar& rrv = (RooRealVar&)fpf[fpf_idx[ivar]] ;
      
      Double_t cenVal = rrv.getVal() ;
      Double_t errVal = sqrt(V(ivar,ivar)) ;
      
      // Make Plus variation
      ((RooRealVar*)paramList.at(ivar))->setVal(cenVal+Z*errVal) ;


      RooLinkedList tmp2(plotArgList) ;
      cloneFunc->plotOn(frame,tmp2) ;
      plusVar.push_back(frame->getCurve()) ;
      frame->remove(0,kFALSE) ;
      

      // Make Minus variation
      ((RooRealVar*)paramList.at(ivar))->setVal(cenVal-Z*errVal) ;
      RooLinkedList tmp3(plotArgList) ;
      cloneFunc->plotOn(frame,tmp3) ;
      minusVar.push_back(frame->getCurve()) ;
      frame->remove(0,kFALSE) ;
      
      ((RooRealVar*)paramList.at(ivar))->setVal(cenVal) ;
    }
    
    TMatrixDSym C(paramList.getSize()) ;      
    vector<double> errVec(paramList.getSize()) ;
    for (int i=0 ; i<paramList.getSize() ; i++) {
      errVec[i] = sqrt(V(i,i)) ;
      for (int j=i ; j<paramList.getSize() ; j++) {
	C(i,j) = V(i,j)/sqrt(V(i,i)*V(j,j)) ;
	C(j,i) = C(i,j) ;
      }
    }
    
    band = cenCurve->makeErrorBand(plusVar,minusVar,C,Z) ;    
    
    
    // Cleanup 
    delete cloneFunc ;
    for (vector<RooCurve*>::iterator i=plusVar.begin() ; i!=plusVar.end() ; i++) {
      delete (*i) ;
    }
    for (vector<RooCurve*>::iterator i=minusVar.begin() ; i!=minusVar.end() ; i++) {
      delete (*i) ;
    }

  }

  delete cenCurve ;
  if (!band) return frame ;
  
  // Define configuration for this method
  pc.defineString("drawOption","DrawOption",0,"F") ;
  pc.defineString("curveNameSuffix","CurveNameSuffix",0,"") ;
  pc.defineInt("lineColor","LineColor",0,-999) ;
  pc.defineInt("lineStyle","LineStyle",0,-999) ;
  pc.defineInt("lineWidth","LineWidth",0,-999) ;
  pc.defineInt("fillColor","FillColor",0,-999) ;
  pc.defineInt("fillStyle","FillStyle",0,-999) ;
  pc.defineString("curveName","Name",0,"") ;
  pc.defineInt("curveInvisible","Invisible",0,0) ;
  pc.defineInt("moveToBack","MoveToBack",0,0) ;
  pc.allowUndefined() ;

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

  // Insert error band in plot frame
  frame->addPlotable(band,pc.getString("drawOption"),pc.getInt("curveInvisible")) ;


  // Optionally adjust line/fill attributes
  Int_t lineColor = pc.getInt("lineColor") ;
  Int_t lineStyle = pc.getInt("lineStyle") ;
  Int_t lineWidth = pc.getInt("lineWidth") ;
  Int_t fillColor = pc.getInt("fillColor") ;
  Int_t fillStyle = pc.getInt("fillStyle") ;
  if (lineColor!=-999) frame->getAttLine()->SetLineColor(lineColor) ;
  if (lineStyle!=-999) frame->getAttLine()->SetLineStyle(lineStyle) ;
  if (lineWidth!=-999) frame->getAttLine()->SetLineWidth(lineWidth) ;
  if (fillColor!=-999) frame->getAttFill()->SetFillColor(fillColor) ;
  if (fillStyle!=-999) frame->getAttFill()->SetFillStyle(fillStyle) ;

  // Adjust name if requested
  if (pc.getString("curveName",0,kTRUE)) {
    band->SetName(pc.getString("curveName",0,kTRUE)) ;
  } else if (pc.getString("curveNameSuffix",0,kTRUE)) {
    TString name(band->GetName()) ;
    name.Append(pc.getString("curveNameSuffix",0,kTRUE)) ;
    band->SetName(name.Data()) ;
  }

  // Move last inserted object to back to drawing stack if requested
  if (pc.getInt("moveToBack") && frame->numItems()>1) {   
    frame->drawBefore(frame->getObject(0)->GetName(), frame->getCurve()->GetName());    
  }
  
  
  return frame ;
}




//_____________________________________________________________________________
Bool_t RooAbsReal::plotSanityChecks(RooPlot* frame) const
{
  // Utility function for plotOn(), perform general sanity check on frame to ensure safe plotting operations

  // check that we are passed a valid plot frame to use
  if(0 == frame) {
    coutE(Plotting) << ClassName() << "::" << GetName() << ":plotOn: frame is null" << endl;
    return kTRUE;
  }

  // check that this frame knows what variable to plot
  RooAbsReal* var = frame->getPlotVar() ;
  if(!var) {
    coutE(Plotting) << ClassName() << "::" << GetName()
	 << ":plotOn: frame does not specify a plot variable" << endl;
    return kTRUE;
  }

  // check that the plot variable is not derived
  if(!dynamic_cast<RooAbsRealLValue*>(var)) {
    coutE(Plotting) << ClassName() << "::" << GetName() << ":plotOn: cannot plot variable \""
		    << var->GetName() << "\" of type " << var->ClassName() << endl;
    return kTRUE;
  }

  // check if we actually depend on the plot variable
  if(!this->dependsOn(*var)) {
    coutE(Plotting) << ClassName() << "::" << GetName() << ":plotOn: WARNING: variable is not an explicit dependent: "
		    << var->GetName() << endl;
  }
  
  return kFALSE ;
}




//_____________________________________________________________________________
void RooAbsReal::makeProjectionSet(const RooAbsArg* plotVar, const RooArgSet* allVars, 
				   RooArgSet& projectedVars, Bool_t silent) const
{
  // Utility function for plotOn() that constructs the set of
  // observables to project when plotting ourselves as function of
  // 'plotVar'. 'allVars' is the list of variables that must be
  // projected, but may contain variables that we do not depend on. If
  // 'silent' is cleared, warnings about inconsistent input parameters
  // will be printed.

  cxcoutD(Plotting) << "RooAbsReal::makeProjectionSet(" << GetName() << ") plotVar = " << plotVar->GetName() 
		    << " allVars = " << (allVars?(*allVars):RooArgSet()) << endl ;

  projectedVars.removeAll() ;
  if (!allVars) return ;

  // Start out with suggested list of variables  
  projectedVars.add(*allVars) ;

  // Take out plot variable
  RooAbsArg *found= projectedVars.find(plotVar->GetName());
  if(found) {
    projectedVars.remove(*found);

    // Take out eventual servers of plotVar
    RooArgSet* plotServers = plotVar->getObservables(&projectedVars) ;
    TIterator* psIter = plotServers->createIterator() ;
    RooAbsArg* ps ;
    while((ps=(RooAbsArg*)psIter->Next())) {
      RooAbsArg* tmp = projectedVars.find(ps->GetName()) ;
      if (tmp) {
	cxcoutD(Plotting) << "RooAbsReal::makeProjectionSet(" << GetName() << ") removing " << tmp->GetName() 
			  << " from projection set because it a server of " << plotVar->GetName() << endl ;
	projectedVars.remove(*tmp) ;
      }
    }
    delete psIter ;
    delete plotServers ;

    if (!silent) {
      coutW(Plotting) << "RooAbsReal::plotOn(" << GetName() 
		      << ") WARNING: cannot project out frame variable (" 
		      << found->GetName() << "), ignoring" << endl ; 
    }
  }

  // Take out all non-dependents of function
  TIterator* iter = allVars->createIterator() ;
  RooAbsArg* arg ;
  while((arg=(RooAbsArg*)iter->Next())) {
    if (!dependsOnValue(*arg)) {
      projectedVars.remove(*arg,kTRUE) ;

      cxcoutD(Plotting) << "RooAbsReal::plotOn(" << GetName() 
			<< ") function doesn't depend on projection variable " 
			<< arg->GetName() << ", ignoring" << endl ;
    }
  }
  delete iter ;
}




//_____________________________________________________________________________
Bool_t RooAbsReal::isSelectedComp() const 
{ 
  // If true, the current pdf is a selected component (for use in plotting)
  return _selectComp || _globalSelectComp ; 
}



//_____________________________________________________________________________
void RooAbsReal::globalSelectComp(Bool_t flag) 
{ 
  // Global switch controlling the activation of the selectComp() functionality
  _globalSelectComp = flag ; 
}




//_____________________________________________________________________________
RooAbsFunc *RooAbsReal::bindVars(const RooArgSet &vars, const RooArgSet* nset, Bool_t clipInvalid) const 
{
  // Create an interface adaptor f(vars) that binds us to the specified variables
  // (in arbitrary order). For example, calling bindVars({x1,x3}) on an object
  // F(x1,x2,x3,x4) returns an object f(x1,x3) that is evaluated using the
  // current values of x2 and x4. The caller takes ownership of the returned adaptor.

  RooAbsFunc *binding= new RooRealBinding(*this,vars,nset,clipInvalid);
  if(binding && !binding->isValid()) {
    coutE(InputArguments) << ClassName() << "::" << GetName() << ":bindVars: cannot bind to " << vars << endl ;
    delete binding;
    binding= 0;
  }
  return binding;
}



//_____________________________________________________________________________
void RooAbsReal::copyCache(const RooAbsArg* source, Bool_t /*valueOnly*/, Bool_t setValDirty) 
{
  // Copy the cached value of another RooAbsArg to our cache.
  // Warning: This function copies the cached values of source,
  // it is the callers responsibility to make sure the cache is clean

  RooAbsReal* other = static_cast<RooAbsReal*>(const_cast<RooAbsArg*>(source)) ;

  if (!other->_treeVar) {
    _value = other->_value ;
  } else {
    if (source->getAttribute("FLOAT_TREE_BRANCH")) {
      _value = other->_floatValue ;
    } else if (source->getAttribute("INTEGER_TREE_BRANCH")) {
      _value = other->_intValue ;
    } else if (source->getAttribute("BYTE_TREE_BRANCH")) {
      _value = other->_byteValue ;
    } else if (source->getAttribute("BOOL_TREE_BRANCH")) {
      _value = other->_boolValue ;
    } else if (source->getAttribute("SIGNEDBYTE_TREE_BRANCH")) {
      _value = other->_sbyteValue ;
    } else if (source->getAttribute("UNSIGNED_INTEGER_TREE_BRANCH")) {
      _value = other->_uintValue ;
    } 
  }
  if (setValDirty) {
    setValueDirty() ;
  }
}



//_____________________________________________________________________________
void RooAbsReal::attachToVStore(RooVectorDataStore& vstore) 
{
  RooVectorDataStore::RealVector* rv = vstore.addReal(this) ;
  rv->setBuffer(this,&_value) ;
}




//_____________________________________________________________________________
void RooAbsReal::attachToTree(TTree& t, Int_t bufSize)
{
  // Attach object to a branch of given TTree. By default it will
  // register the internal value cache RooAbsReal::_value as branch
  // buffer for a Double_t tree branch with the same name as this
  // object. If no Double_t branch is found with the name of this
  // object, this method looks for a Float_t Int_t, UChar_t and UInt_t
  // branch in that order. If any of these are found the buffer for
  // that branch is set to a correctly typed conversion buffer in this
  // RooRealVar.  A flag is set that will cause copyCache to copy the
  // object value from the appropriate conversion buffer instead of
  // the _value buffer.

  // First determine if branch is taken
  TString cleanName(cleanBranchName()) ;
  TBranch* branch = t.GetBranch(cleanName) ;
  if (branch) { 
    
    // Determine if existing branch is Float_t or Double_t
    TLeaf* leaf = (TLeaf*)branch->GetListOfLeaves()->At(0) ;

    // Check that leaf is _not_ an array
    Int_t dummy ;
    TLeaf* counterLeaf = leaf->GetLeafCounter(dummy) ;
    if (counterLeaf) {
      coutE(Eval) << "RooAbsReal::attachToTree(" << GetName() << ") ERROR: TTree branch " << GetName() 
		  << " is an array and cannot be attached to a RooAbsReal" << endl ;      
      return ;
    }
    
    TString typeName(leaf->GetTypeName()) ;

    if (!typeName.CompareTo("Float_t")) {
      coutI(Eval) << "RooAbsReal::attachToTree(" << GetName() << ") TTree Float_t branch " << GetName() 
		  << " will be converted to double precision" << endl ;
      setAttribute("FLOAT_TREE_BRANCH",kTRUE) ;
      _treeVar = kTRUE ;
      t.SetBranchAddress(cleanName,&_floatValue) ;
    } else if (!typeName.CompareTo("Int_t")) {
      coutI(Eval) << "RooAbsReal::attachToTree(" << GetName() << ") TTree Int_t branch " << GetName() 
		  << " will be converted to double precision" << endl ;
      setAttribute("INTEGER_TREE_BRANCH",kTRUE) ;
      _treeVar = kTRUE ;
      t.SetBranchAddress(cleanName,&_intValue) ;
    } else if (!typeName.CompareTo("UChar_t")) {
      coutI(Eval) << "RooAbsReal::attachToTree(" << GetName() << ") TTree UChar_t branch " << GetName() 
		  << " will be converted to double precision" << endl ;
      setAttribute("BYTE_TREE_BRANCH",kTRUE) ;
      _treeVar = kTRUE ;
      t.SetBranchAddress(cleanName,&_byteValue) ;
    } else if (!typeName.CompareTo("Bool_t")) {
      coutI(Eval) << "RooAbsReal::attachToTree(" << GetName() << ") TTree Bool_t branch " << GetName() 
		  << " will be converted to double precision" << endl ;
      setAttribute("BOOL_TREE_BRANCH",kTRUE) ;
      _treeVar = kTRUE ;
      t.SetBranchAddress(cleanName,&_boolValue) ;
    } else if (!typeName.CompareTo("Char_t")) {
      coutI(Eval) << "RooAbsReal::attachToTree(" << GetName() << ") TTree Char_t branch " << GetName() 
		  << " will be converted to double precision" << endl ;
      setAttribute("SIGNEDBYTE_TREE_BRANCH",kTRUE) ;
      _treeVar = kTRUE ;
      t.SetBranchAddress(cleanName,&_sbyteValue) ;
    }  else if (!typeName.CompareTo("UInt_t")) { 
      coutI(Eval) << "RooAbsReal::attachToTree(" << GetName() << ") TTree UInt_t branch " << GetName() 
		  << " will be converted to double precision" << endl ;
      setAttribute("UNSIGNED_INTEGER_TREE_BRANCH",kTRUE) ;
      _treeVar = kTRUE ;
      t.SetBranchAddress(cleanName,&_uintValue) ;
    } else if (!typeName.CompareTo("Double_t")) {
      t.SetBranchAddress(cleanName,&_value) ;
    } else {
      coutE(InputArguments) << "RooAbsReal::attachToTree(" << GetName() << ") data type " << typeName << " is not supported" << endl ;
    }   
    
    if (branch->GetCompressionLevel()<0) {
      // cout << "RooAbsReal::attachToTree(" << GetName() << ") Fixing compression level of branch " << cleanName << endl ;
      branch->SetCompressionLevel(1) ;
    }

//      cout << "RooAbsReal::attachToTree(" << cleanName << "): branch already exists in tree " << (void*)&t << ", changing address" << endl ;

  } else {

    TString format(cleanName);
    format.Append("/D");
    branch = t.Branch(cleanName, &_value, (const Text_t*)format, bufSize);
    branch->SetCompressionLevel(1) ;
    //      cout << "RooAbsReal::attachToTree(" << cleanName << "): creating new branch in tree " << (void*)&t << endl ;
  }

}



//_____________________________________________________________________________
void RooAbsReal::fillTreeBranch(TTree& t) 
{
  // Fill the tree branch that associated with this object with its current value

  // First determine if branch is taken
  TBranch* branch = t.GetBranch(cleanBranchName()) ;
  if (!branch) { 
    coutE(Eval) << "RooAbsReal::fillTreeBranch(" << GetName() << ") ERROR: not attached to tree: " << cleanBranchName() << endl ;
    assert(0) ;
  }
  branch->Fill() ;
  
}



//_____________________________________________________________________________
void RooAbsReal::setTreeBranchStatus(TTree& t, Bool_t active) 
{
  // (De)Activate associated tree branch

  TBranch* branch = t.GetBranch(cleanBranchName()) ;
  if (branch) { 
    t.SetBranchStatus(cleanBranchName(),active?1:0) ;
  }
}



//_____________________________________________________________________________
RooAbsArg *RooAbsReal::createFundamental(const char* newname) const 
{
  // Create a RooRealVar fundamental object with our properties. The new
  // object will be created without any fit limits.

  RooRealVar *fund= new RooRealVar(newname?newname:GetName(),GetTitle(),_value,getUnit());
  fund->removeRange();
  fund->setPlotLabel(getPlotLabel());
  fund->setAttribute("fundamentalCopy");
  return fund;
}



//_____________________________________________________________________________
Bool_t RooAbsReal::matchArgs(const RooArgSet& allDeps, RooArgSet& analDeps, 
			      const RooArgProxy& a) const
{
  // Utility function for use in getAnalyticalIntegral(). If the
  // content of proxy 'a' occurs in set 'allDeps' then the argument
  // held in 'a' is copied from allDeps to analDeps

  TList nameList ;
  nameList.Add(new TObjString(a.absArg()->GetName())) ;
  Bool_t result = matchArgsByName(allDeps,analDeps,nameList) ;
  nameList.Delete() ;
  return result ;
}



//_____________________________________________________________________________
Bool_t RooAbsReal::matchArgs(const RooArgSet& allDeps, RooArgSet& analDeps, 
			      const RooArgProxy& a, const RooArgProxy& b) const
{
  // Utility function for use in getAnalyticalIntegral(). If the
  // contents of proxies a,b occur in set 'allDeps' then the arguments
  // held in a,b are copied from allDeps to analDeps

  TList nameList ;
  nameList.Add(new TObjString(a.absArg()->GetName())) ;
  nameList.Add(new TObjString(b.absArg()->GetName())) ;  
  Bool_t result = matchArgsByName(allDeps,analDeps,nameList) ;
  nameList.Delete() ;
  return result ;
}



//_____________________________________________________________________________
Bool_t RooAbsReal::matchArgs(const RooArgSet& allDeps, RooArgSet& analDeps, 
			      const RooArgProxy& a, const RooArgProxy& b,
			      const RooArgProxy& c) const
{
  // Utility function for use in getAnalyticalIntegral(). If the
  // contents of proxies a,b,c occur in set 'allDeps' then the arguments
  // held in a,b,c are copied from allDeps to analDeps

  TList nameList ;
  nameList.Add(new TObjString(a.absArg()->GetName())) ;
  nameList.Add(new TObjString(b.absArg()->GetName())) ;
  nameList.Add(new TObjString(c.absArg()->GetName())) ;
  Bool_t result = matchArgsByName(allDeps,analDeps,nameList) ;
  nameList.Delete() ;
  return result ;
}



//_____________________________________________________________________________
Bool_t RooAbsReal::matchArgs(const RooArgSet& allDeps, RooArgSet& analDeps, 
			      const RooArgProxy& a, const RooArgProxy& b,
			      const RooArgProxy& c, const RooArgProxy& d) const
{
  // Utility function for use in getAnalyticalIntegral(). If the
  // contents of proxies a,b,c,d occur in set 'allDeps' then the arguments
  // held in a,b,c,d are copied from allDeps to analDeps

  TList nameList ;
  nameList.Add(new TObjString(a.absArg()->GetName())) ;
  nameList.Add(new TObjString(b.absArg()->GetName())) ;
  nameList.Add(new TObjString(c.absArg()->GetName())) ;
  nameList.Add(new TObjString(d.absArg()->GetName())) ;
  Bool_t result = matchArgsByName(allDeps,analDeps,nameList) ;
  nameList.Delete() ;
  return result ;
}


//_____________________________________________________________________________
Bool_t RooAbsReal::matchArgs(const RooArgSet& allDeps, RooArgSet& analDeps, 
			     const RooArgSet& refset) const 
{
  // Utility function for use in getAnalyticalIntegral(). If the
  // contents of 'refset' occur in set 'allDeps' then the arguments
  // held in 'refset' are copied from allDeps to analDeps.

  TList nameList ;
  TIterator* iter = refset.createIterator() ;
  RooAbsArg* arg ;
  while ((arg=(RooAbsArg*)iter->Next())) {
    nameList.Add(new TObjString(arg->GetName())) ;    
  }
  delete iter ;

  Bool_t result = matchArgsByName(allDeps,analDeps,nameList) ;
  nameList.Delete() ;
  return result ;
}



//_____________________________________________________________________________
Bool_t RooAbsReal::matchArgsByName(const RooArgSet &allArgs, RooArgSet &matchedArgs,
				  const TList &nameList) const 
{
  // Check if allArgs contains matching elements for each name in nameList. If it does,
  // add the corresponding args from allArgs to matchedArgs and return kTRUE. Otherwise
  // return kFALSE and do not change matchedArgs.
  
  RooArgSet matched("matched");
  TIterator *iterator= nameList.MakeIterator();
  TObjString *name = 0;
  Bool_t isMatched(kTRUE);
  while((isMatched && (name= (TObjString*)iterator->Next()))) {
    RooAbsArg *found= allArgs.find(name->String().Data());
    if(found) {
      matched.add(*found);
    }
    else {
      isMatched= kFALSE;
    }
  }

  // nameList may not contain multiple entries with the same name
  // that are both matched
  if (isMatched && (matched.getSize()!=nameList.GetSize())) {
    isMatched = kFALSE ;
  }

  delete iterator;
  if(isMatched) matchedArgs.add(matched);
  return isMatched;
}



//_____________________________________________________________________________
RooNumIntConfig* RooAbsReal::defaultIntegratorConfig() 
{
  // Returns the default numeric integration configuration for all RooAbsReals
  return &RooNumIntConfig::defaultConfig() ;
}


//_____________________________________________________________________________
RooNumIntConfig* RooAbsReal::specialIntegratorConfig() const
{
  // Returns the specialized integrator configuration for _this_ RooAbsReal.
  // If this object has no specialized configuration, a null pointer is returned.

  return _specIntegratorConfig ;
}
 

//_____________________________________________________________________________
RooNumIntConfig* RooAbsReal::specialIntegratorConfig(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 (!_specIntegratorConfig && createOnTheFly) {
    _specIntegratorConfig = new RooNumIntConfig(*defaultIntegratorConfig()) ;
  }
  return _specIntegratorConfig ;
}



//_____________________________________________________________________________
const RooNumIntConfig* RooAbsReal::getIntegratorConfig() const 
{
  // Return the numeric integration 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 RooNumIntConfig* config = specialIntegratorConfig() ;
  if (config) return config ;
  return defaultIntegratorConfig() ;
}


//_____________________________________________________________________________
RooNumIntConfig* RooAbsReal::getIntegratorConfig() 
{
  // Return the numeric integration 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

  RooNumIntConfig* config = specialIntegratorConfig() ;
  if (config) return config ;
  return defaultIntegratorConfig() ;
}



//_____________________________________________________________________________
void RooAbsReal::setIntegratorConfig(const RooNumIntConfig& config) 
{
  // Set the given integrator configuration as default numeric integration
  // configuration for this object
  if (_specIntegratorConfig) {
    delete _specIntegratorConfig ;
  }
  _specIntegratorConfig = new RooNumIntConfig(config) ;  
}



//_____________________________________________________________________________
void RooAbsReal::setIntegratorConfig() 
{
  // Remove the specialized numeric integration configuration associated
  // with this object
  if (_specIntegratorConfig) {
    delete _specIntegratorConfig ;
  }
  _specIntegratorConfig = 0 ;
}




//_____________________________________________________________________________
void RooAbsReal::selectNormalization(const RooArgSet*, Bool_t) 
{
  // Interface function to force use of a given set of observables
  // to interpret function value. Needed for functions or p.d.f.s
  // whose shape depends on the choice of normalization such as
  // RooAddPdf
}
 



//_____________________________________________________________________________
void RooAbsReal::selectNormalizationRange(const char*, Bool_t) 
{
  // Interface function to force use of a given normalization range
  // to interpret function value. Needed for functions or p.d.f.s
  // whose shape depends on the choice of normalization such as
  // RooAddPdf
}



//_____________________________________________________________________________
void RooAbsReal::setCacheCheck(Bool_t flag) 
{ 
  // Activate cache validation mode
  _cacheCheck = flag ; 
}



//_____________________________________________________________________________
Int_t RooAbsReal::getMaxVal(const RooArgSet& /*vars*/) const 
{
  // Advertise capability to determine maximum value of function for given set of 
  // observables. If no direct generator method is provided, this information
  // will assist the accept/reject generator to operate more efficiently as
  // it can skip the initial trial sampling phase to empirically find the function
  // maximum

  return 0 ;
}



//_____________________________________________________________________________
Double_t RooAbsReal::maxVal(Int_t /*code*/) const
{
  // Return maximum value for set of observables identified by code assigned
  // in getMaxVal

  assert(1) ;
  return 0 ;
}



//_____________________________________________________________________________
void RooAbsReal::logEvalError(const RooAbsReal* originator, const char* origName, const char* message, const char* serverValueString) 
{
  // Interface to insert remote error logging messages received by RooRealMPFE into current error loggin stream

  if (_evalErrorMode==Ignore) {
    return ;
  }

  if (_evalErrorMode==CountErrors) {
    _evalErrorCount++ ;
    return ;
  }

  static Bool_t inLogEvalError = kFALSE ;  

  if (inLogEvalError) {
    return ;
  }
  inLogEvalError = kTRUE ;

  EvalError ee ;
  ee.setMessage(message) ;

  if (serverValueString) {
    ee.setServerValues(serverValueString) ;
  } 

  if (_evalErrorMode==PrintErrors) {
   oocoutE((TObject*)0,Eval) << "RooAbsReal::logEvalError(" << "<STATIC>" << ") evaluation error, " << endl 
		   << " origin       : " << origName << endl 
		   << " message      : " << ee._msg << endl
		   << " server values: " << ee._srvval << endl ;
  } else if (_evalErrorMode==CollectErrors) {
    _evalErrorList[originator].first = origName ;
    _evalErrorList[originator].second.push_back(ee) ;
  }


  inLogEvalError = kFALSE ;
}



//_____________________________________________________________________________
void RooAbsReal::logEvalError(const char* message, const char* serverValueString) const
{
  // Log evaluation error message. Evaluation errors may be routed through a different
  // protocol than generic RooFit warning message (which go straight through RooMsgService)
  // because evaluation errors can occur in very large numbers in the use of likelihood
  // evaluations. In logEvalError mode, controlled by global method enableEvalErrorLogging()
  // messages reported through this function are not printed but all stored in a list,
  // along with server values at the time of reporting. Error messages logged in this
  // way can be printed in a structured way, eliminating duplicates and with the ability
  // to truncate the list by printEvalErrors. This is the standard mode of error logging
  // during MINUIT operations. If enableEvalErrorLogging() is false, all errors
  // reported through this method are passed for immediate printing through RooMsgService.
  // A string with server names and values is constructed automatically for error logging
  // purposes, unless a custom string with similar information is passed as argument.

  if (_evalErrorMode==Ignore) {
    return ;
  }

  if (_evalErrorMode==CountErrors) {
    _evalErrorCount++ ;
    return ;
  }

  static Bool_t inLogEvalError = kFALSE ;  

  if (inLogEvalError) {
    return ;
  }
  inLogEvalError = kTRUE ;

  EvalError ee ;
  ee.setMessage(message) ;

  if (serverValueString) {
    ee.setServerValues(serverValueString) ;
  } else {
    string srvval ;
    ostringstream oss ;
    Bool_t first(kTRUE) ;
    for (Int_t i=0 ; i<numProxies() ; i++) {
      RooAbsProxy* p = getProxy(i) ;
      if (!p) continue ;
      //if (p->name()[0]=='!') continue ;
      if (first) {
	first=kFALSE ;
      } else {
	oss << ", " ;
      }
      p->print(oss,kTRUE) ;
    }
    ee.setServerValues(oss.str().c_str()) ;
  }

  ostringstream oss2 ;
  printStream(oss2,kName|kClassName|kArgs,kInline)  ;

  if (_evalErrorMode==PrintErrors) {
   coutE(Eval) << "RooAbsReal::logEvalError(" << GetName() << ") evaluation error, " << endl 
	       << " origin       : " << oss2.str() << endl 
	       << " message      : " << ee._msg << endl
	       << " server values: " << ee._srvval << endl ;
  } else if (_evalErrorMode==CollectErrors) {
    _evalErrorList[this].first = oss2.str().c_str() ;
    _evalErrorList[this].second.push_back(ee) ;
  }

  inLogEvalError = kFALSE ;
  //coutE(Tracing) << "RooAbsReal::logEvalError(" << GetName() << ") message = " << message << endl ;
}




//_____________________________________________________________________________
void RooAbsReal::clearEvalErrorLog() 
{
  // Clear the stack of evaluation error messages
  if (_evalErrorMode==PrintErrors) {
    return ;
  } else if (_evalErrorMode==CollectErrors) {
    _evalErrorList.clear() ;
  } else {
    _evalErrorCount = 0 ;
  }
}



//_____________________________________________________________________________
void RooAbsReal::printEvalErrors(ostream& os, Int_t maxPerNode) 
{
  // Print all outstanding logged evaluation error on the given ostream. If maxPerNode
  // is zero, only the number of errors for each source (object with unique name) is listed.
  // If maxPerNode is greater than zero, up to maxPerNode detailed error messages are shown
  // per source of errors. A truncation message is shown if there were more errors logged
  // than shown.

  if (_evalErrorMode == CountErrors) {
    os << _evalErrorCount << " errors counted" << endl ;
  }

  if (maxPerNode<0) return ;

  map<const RooAbsArg*,pair<string,list<EvalError> > >::iterator iter = _evalErrorList.begin() ;

  for(;iter!=_evalErrorList.end() ; ++iter) {
    if (maxPerNode==0) {

      // Only print node name with total number of errors
      os << iter->second.first ;
      //iter->first->printStream(os,kName|kClassName|kArgs,kInline)  ;
      os << " has " << iter->second.second.size() << " errors" << endl ;      

    } else {

      // Print node name and details of 'maxPerNode' errors
      os << iter->second.first << endl ;
      //iter->first->printStream(os,kName|kClassName|kArgs,kSingleLine) ;

      Int_t i(0) ;
      std::list<EvalError>::iterator iter2 = iter->second.second.begin() ;
      for(;iter2!=iter->second.second.end() ; ++iter2, i++) {
	os << "     " << iter2->_msg << " @ " << iter2->_srvval << endl ;
	if (i>maxPerNode) {
	  os << "    ... (remaining " << iter->second.second.size() - maxPerNode << " messages suppressed)" << endl ;
	  break ;
	}
      } 
    }
  }
}



//_____________________________________________________________________________
Int_t RooAbsReal::numEvalErrors()
{
  // Return the number of logged evaluation errors since the last clearing.
  if (_evalErrorMode==CountErrors) {
    return _evalErrorCount ;
  }

  Int_t ntot(0) ;
  map<const RooAbsArg*,pair<string,list<EvalError> > >::iterator iter = _evalErrorList.begin() ;
  for(;iter!=_evalErrorList.end() ; ++iter) {
    ntot += iter->second.second.size() ;
  }
  return ntot ;
}



//_____________________________________________________________________________
void RooAbsReal::fixAddCoefNormalization(const RooArgSet& addNormSet, Bool_t force) 
{
  // Fix the interpretation of the coefficient of any RooAddPdf component in
  // the expression tree headed by this object to the given set of observables.
  //
  // If the force flag is false, the normalization choice is only fixed for those
  // RooAddPdf components that have the default 'automatic' interpretation of
  // coefficients (i.e. the interpretation is defined by the observables passed
  // to getVal()). If force is true, also RooAddPdf that already have a fixed
  // interpretation are changed to a new fixed interpretation.

  RooArgSet* compSet = getComponents() ;
  TIterator* iter = compSet->createIterator() ;
  RooAbsArg* arg ;
  while((arg=(RooAbsArg*)iter->Next())) {
    RooAbsPdf* pdf = dynamic_cast<RooAbsPdf*>(arg) ;
    if (pdf) {
      if (addNormSet.getSize()>0) {
	pdf->selectNormalization(&addNormSet,force) ;
      } else {
	pdf->selectNormalization(0,force) ;
      }
    } 
  }
  delete iter ;
  delete compSet ;  
}



//_____________________________________________________________________________
void RooAbsReal::fixAddCoefRange(const char* rangeName, Bool_t force) 
{
  // Fix the interpretation of the coefficient of any RooAddPdf component in
  // the expression tree headed by this object to the given set of observables.
  //
  // If the force flag is false, the normalization range choice is only fixed for those
  // RooAddPdf components that currently use the default full domain to interpret their
  // coefficients. If force is true, also RooAddPdf that already have a fixed
  // interpretation range are changed to a new fixed interpretation range.

  RooArgSet* compSet = getComponents() ;
  TIterator* iter = compSet->createIterator() ;
  RooAbsArg* arg ;
  while((arg=(RooAbsArg*)iter->Next())) {
    RooAbsPdf* pdf = dynamic_cast<RooAbsPdf*>(arg) ;
    if (pdf) {
      pdf->selectNormalizationRange(rangeName,force) ;
    }
  }
  delete iter ;
  delete compSet ;    
}



//_____________________________________________________________________________
void RooAbsReal::preferredObservableScanOrder(const RooArgSet& obs, RooArgSet& orderedObs) const
{
  // Interface method for function objects to indicate their prefferred order of observables
  // for scanning their values into a (multi-dimensional) histogram or RooDataSet. The observables
  // to be ordered are offered in argument 'obs' and should be copied in their preferred
  // order into argument 'orderdObs', This default implementation indicates no preference
  // and copies the original order of 'obs' into 'orderedObs'

  // Dummy implementation, do nothing 
  orderedObs.removeAll() ;
  orderedObs.add(obs) ;
}



//_____________________________________________________________________________
RooAbsReal* RooAbsReal::createRunningIntegral(const RooArgSet& iset, const RooArgSet& nset) 
{
  // Create a running integral over this function, i.e. given a f(x), create an object
  // representing 'int[x_lo,x] f(x_prime) dx_prime'

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



//_____________________________________________________________________________
RooAbsReal* RooAbsReal::createRunningIntegral(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 running integral of the function over one or more observables listed in iset, i.e.
  // 
  //   int[x_lo,x] f(x_prime) dx_prime
  // 
  // 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 default strategy to calculate the running integrals is
  //
  //   - If the integrand (this object) supports analytical integration, construct an integral object
  //     that calculate the running integrals value by calculating the analytical integral each
  //     time the running integral object is evaluated
  //
  //   - If the integrand (this object) requires numeric integration to construct the running integral
  //     create an object of class RooNumRunningInt which first samples the entire function and integrates
  //     the sampled function numerically. This method has superior performance as there is no need to
  //     perform a full (numeric) integration for each evaluation of the running integral object, but
  //     only when one of its parameters has changed.
  //
  // The choice of strategy can be changed with the ScanAll() argument, which forces the use of the
  // scanning technique implemented in RooNumRunningInt for all use cases, and with the ScanNone()
  // argument which forces the 'integrate each evaluation' technique for all use cases. The sampling
  // granularity for the scanning technique can be controlled with the ScanParameters technique
  // which allows to specify the number of samples to be taken, and to which order the resulting
  // running integral should be interpolated. The default values are 1000 samples and 2nd order
  // interpolation.
  //
  // The following named arguments are accepted
  //
  // SupNormSet(const RooArgSet&)         -- Observables over which should be normalized _in_addition_ to the
  //                                         integration observables
  // 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
  // ScanNum()                            -- Apply scanning technique if cdf integral involves numeric integration
  // ScanAll()                            -- Always apply scanning technique 
  // ScanNone()                           -- Never apply scanning technique                  

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

  // 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 createScanRI(iset,nset,numScanBins,intOrder) ;
  }
  if (doScanNum) {
    RooRealIntegral* tmp = (RooRealIntegral*) createIntegral(iset) ;
    Int_t isNum= (tmp->numIntRealVars().getSize()==1) ;
    delete tmp ;

    if (isNum) {
      coutI(NumIntegration) << "RooAbsPdf::createRunningIntegral(" << 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 ? createScanRI(iset,nset,numScanBins,intOrder) : createIntRI(iset,nset) ;
  }
  return 0 ;
}



//_____________________________________________________________________________
RooAbsReal* RooAbsReal::createScanRI(const RooArgSet& iset, const RooArgSet& nset, Int_t numScanBins, Int_t intOrder) 
{
  // Utility function for createRunningIntegral that construct an object
  // implementing the numeric scanning technique for calculating the running integral
  
  string name = string(GetName()) + "_NUMRUNINT_" + integralNameSuffix(iset,&nset).Data() ;  
  RooRealVar* ivar = (RooRealVar*) iset.first() ;
  ivar->setBins(numScanBins,"numcdf") ;
  RooNumRunningInt* ret = new RooNumRunningInt(name.c_str(),name.c_str(),*this,*ivar,"numrunint") ;
  ret->setInterpolationOrder(intOrder) ;
  return ret ;
}



//_____________________________________________________________________________
RooAbsReal* RooAbsReal::createIntRI(const RooArgSet& iset, const RooArgSet& nset) 
{
  // Utility function for createRunningIntegral that construct an
  // object implementing the standard (analytical) integration
  // technique for calculating the running integral

  // Make list of input arguments keeping only RooRealVars
  RooArgList ilist ;
  TIterator* iter2 = iset.createIterator() ;
  RooAbsArg* arg ;
  while((arg=(RooAbsArg*)iter2->Next())) {
    if (dynamic_cast<RooRealVar*>(arg)) {
      ilist.add(*arg) ;
    } else {
      coutW(InputArguments) << "RooAbsPdf::createRunningIntegral(" << GetName() << ") WARNING ignoring non-RooRealVar input argument " << arg->GetName() << endl ;      
    }
  }
  delete iter2 ;

  RooArgList cloneList ;
  RooArgList loList ;
  RooArgSet clonedBranchNodes ;

  // Setup customizer that stores all cloned branches in our non-owning list
  RooCustomizer cust(*this,"cdf") ;
  cust.setCloneBranchSet(clonedBranchNodes) ;
  cust.setOwning(kFALSE) ;

  // Make integration observable x_prime for each observable x as well as an x_lowbound 
  TIterator* iter = ilist.createIterator() ;
  RooRealVar* rrv ;
  while((rrv=(RooRealVar*)iter->Next())) {

    // Make clone x_prime of each c.d.f observable x represening running integral
    RooRealVar* cloneArg = (RooRealVar*) rrv->clone(Form("%s_prime",rrv->GetName())) ;
    cloneList.add(*cloneArg) ;
    cust.replaceArg(*rrv,*cloneArg) ;

    // Make clone x_lowbound of each c.d.f observable representing low bound of x
    RooRealVar* cloneLo = (RooRealVar*) rrv->clone(Form("%s_lowbound",rrv->GetName())) ;
    cloneLo->setVal(rrv->getMin()) ;
    loList.add(*cloneLo) ;

    // Make parameterized binning from [x_lowbound,x] for each x_prime
    RooParamBinning pb(*cloneLo,*rrv,100) ;
    cloneArg->setBinning(pb,"CDF") ;
    
  }
  delete iter ;

  RooAbsReal* tmp = (RooAbsReal*) cust.build() ;

  // Construct final normalization set for c.d.f = integrated observables + any extra specified by user
  RooArgSet finalNset(nset) ;
  finalNset.add(cloneList,kTRUE) ;
  RooAbsReal* cdf = tmp->createIntegral(cloneList,finalNset,"CDF") ;

  // Transfer ownership of cloned items to top-level c.d.f object
  cdf->addOwnedComponents(*tmp) ;
  cdf->addOwnedComponents(cloneList) ;
  cdf->addOwnedComponents(loList) ;

  return cdf ;
}


//_____________________________________________________________________________
RooFunctor* RooAbsReal::functor(const RooArgList& obs, const RooArgList& pars, const RooArgSet& nset) const 
{
  // Return a RooFunctor object bound to this RooAbsReal with given definition of observables
  // and parameters

  RooArgSet* realObs = getObservables(obs) ;
  if (realObs->getSize() != obs.getSize()) {
    coutE(InputArguments) << "RooAbsReal::functor(" << GetName() << ") ERROR: one or more specified observables are not variables of this p.d.f" << endl ;
    delete realObs ;
    return 0 ;
  }
  RooArgSet* realPars = getObservables(pars) ;
  if (realPars->getSize() != pars.getSize()) {
    coutE(InputArguments) << "RooAbsReal::functor(" << GetName() << ") ERROR: one or more specified parameters are not variables of this p.d.f" << endl ;
    delete realPars ;
    return 0 ;
  }
  delete realObs ;
  delete realPars ;

  return new RooFunctor(*this,obs,pars,nset) ;
}



//_____________________________________________________________________________
TF1* RooAbsReal::asTF(const RooArgList& obs, const RooArgList& pars, const RooArgSet& nset) const 
{
  // Return a ROOT TF1,2,3 object bound to this RooAbsReal with given definition of observables
  // and parameters

  // Check that specified input are indeed variables of this function
  RooArgSet* realObs = getObservables(obs) ;
  if (realObs->getSize() != obs.getSize()) {
    coutE(InputArguments) << "RooAbsReal::functor(" << GetName() << ") ERROR: one or more specified observables are not variables of this p.d.f" << endl ;
    delete realObs ;
    return 0 ;
  }
  RooArgSet* realPars = getObservables(pars) ;
  if (realPars->getSize() != pars.getSize()) {
    coutE(InputArguments) << "RooAbsReal::functor(" << GetName() << ") ERROR: one or more specified parameters are not variables of this p.d.f" << endl ;
    delete realPars ;
    return 0 ;
  }
  delete realObs ;
  delete realPars ;
  
  // Check that all obs and par are of type RooRealVar
  for (int i=0 ; i<obs.getSize() ; i++) {
    if (dynamic_cast<RooRealVar*>(obs.at(i))==0) {
      coutE(ObjectHandling) << "RooAbsReal::asTF(" << GetName() << ") ERROR: proposed observable " << obs.at(0)->GetName() << " is not of type RooRealVar" << endl ;
      return 0 ;
    }
  }
  for (int i=0 ; i<pars.getSize() ; i++) {
    if (dynamic_cast<RooRealVar*>(pars.at(i))==0) {
      coutE(ObjectHandling) << "RooAbsReal::asTF(" << GetName() << ") ERROR: proposed parameter " << pars.at(0)->GetName() << " is not of type RooRealVar" << endl ;
      return 0 ;
    }
  }
  
  // Create functor and TFx of matching dimension
  TF1* tf=0 ;
  RooFunctor* f ;
  switch(obs.getSize()) {
  case 1: {
    RooRealVar* x = (RooRealVar*)obs.at(0) ;
    f = functor(obs,pars,nset) ;
    tf = new TF1(GetName(),f,x->getMin(),x->getMax(),pars.getSize()) ;
    break ;
  }
  case 2: {
    RooRealVar* x = (RooRealVar*)obs.at(0) ;
    RooRealVar* y = (RooRealVar*)obs.at(1) ;
    f = functor(obs,pars,nset) ;
    tf = new TF2(GetName(),f,x->getMin(),x->getMax(),y->getMin(),y->getMax(),pars.getSize()) ;
    break ;
  }
  case 3: {
    RooRealVar* x = (RooRealVar*)obs.at(0) ;
    RooRealVar* y = (RooRealVar*)obs.at(1) ;
    RooRealVar* z = (RooRealVar*)obs.at(2) ;
    f = functor(obs,pars,nset) ;
    tf = new TF3(GetName(),f,x->getMin(),x->getMax(),y->getMin(),y->getMax(),z->getMin(),z->getMax(),pars.getSize()) ;
    break ;
  }
  default:
    coutE(InputArguments) << "RooAbsReal::asTF(" << GetName() << ") ERROR: " << obs.getSize() 
			  << " observables specified, but a ROOT TFx can only have  1,2 or 3 observables" << endl ;
    return 0 ;
  }

  // Set initial parameter values of TFx to those of RooRealVars
  for (int i=0 ; i<pars.getSize() ; i++) {
    RooRealVar* p = (RooRealVar*) pars.at(i) ;
    tf->SetParameter(i,p->getVal()) ;
    tf->SetParName(i,p->GetName()) ;
    //tf->SetParLimits(i,p->getMin(),p->getMax()) ;
  }

  return tf ;
}


//_____________________________________________________________________________
RooDerivative* RooAbsReal::derivative(RooRealVar& obs, Int_t order, Double_t eps) 
{
  // Return function representing first, second or third order derivative of this function
  string name=Form("%s_DERIV_%s",GetName(),obs.GetName()) ;
  string title=Form("Derivative of %s w.r.t %s ",GetName(),obs.GetName()) ;
  return new RooDerivative(name.c_str(),title.c_str(),*this,obs,order,eps) ;
}



//_____________________________________________________________________________
RooDerivative* RooAbsReal::derivative(RooRealVar& obs, const RooArgSet& normSet, Int_t order, Double_t eps) 
{
  // Return function representing first, second or third order derivative of this function
  string name=Form("%s_DERIV_%s",GetName(),obs.GetName()) ;
  string title=Form("Derivative of %s w.r.t %s ",GetName(),obs.GetName()) ;
  return new RooDerivative(name.c_str(),title.c_str(),*this,obs,normSet,order,eps) ;
}



//_____________________________________________________________________________
RooAbsMoment* RooAbsReal::moment(RooRealVar& obs, Int_t order, Bool_t central, Bool_t takeRoot) 
{
  // Return function representing moment of function of given order. If central is
  // true, the central moment is given <(x-<x>)^2>
  string name=Form("%s_MOMENT_%d%s_%s",GetName(),order,(central?"C":""),obs.GetName()) ;
  string title=Form("%sMoment of order %d of %s w.r.t %s ",(central?"Central ":""),order,GetName(),obs.GetName()) ;  
  if (order==1) return new RooFirstMoment(name.c_str(),title.c_str(),*this,obs) ;
  if (order==2) return new RooSecondMoment(name.c_str(),title.c_str(),*this,obs,central,takeRoot) ;
  return new RooMoment(name.c_str(),title.c_str(),*this,obs,order,central,takeRoot) ;
}


//_____________________________________________________________________________
RooAbsMoment* RooAbsReal::moment(RooRealVar& obs, const RooArgSet& normObs, Int_t order, Bool_t central, Bool_t takeRoot, Bool_t intNormObs) 
{
  // Return function representing moment of p.d.f (normalized w.r.t given observables) of given order. If central is
  // true, the central moment is given <(x-<x>)^2>. If intNormObs is true, the moment of the function integrated over
  // all normalization observables is returned.
  string name=Form("%s_MOMENT_%d%s_%s",GetName(),order,(central?"C":""),obs.GetName()) ;
  string title=Form("%sMoment of order %d of %s w.r.t %s ",(central?"Central ":""),order,GetName(),obs.GetName()) ;

  if (order==1) return new RooFirstMoment(name.c_str(),title.c_str(),*this,obs,normObs,intNormObs) ;
  if (order==2) return new RooSecondMoment(name.c_str(),title.c_str(),*this,obs,normObs,central,takeRoot,intNormObs) ;
  return new RooMoment(name.c_str(),title.c_str(),*this,obs,normObs,order,central,takeRoot,intNormObs) ;
}



//_____________________________________________________________________________
Double_t RooAbsReal::findRoot(RooRealVar& x, Double_t xmin, Double_t xmax, Double_t yval) 
{
  //
  // Return value of x (in range xmin,xmax) at which function equals yval.
  // (Calculation is performed with Brent root finding algorithm)
  
  Double_t result(0) ;
  RooBrentRootFinder(RooRealBinding(*this,x)).findRoot(result,xmin,xmax,yval) ;
  return result ;
}




//_____________________________________________________________________________
RooGenFunction* RooAbsReal::iGenFunction(RooRealVar& x, const RooArgSet& nset) 
{
  return new RooGenFunction(*this,x,RooArgList(),nset.getSize()>0?nset:RooArgSet(x)) ;
}



//_____________________________________________________________________________
RooMultiGenFunction* RooAbsReal::iGenFunction(const RooArgSet& observables, const RooArgSet& nset) 
{
  return new RooMultiGenFunction(*this,observables,RooArgList(),nset.getSize()>0?nset:observables) ;
}




//_____________________________________________________________________________
RooFitResult* RooAbsReal::chi2FitTo(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) 
{  
  // Perform a chi^2 fit to given histogram By default the fit is executed through the MINUIT
  // commands MIGRAD, HESSE in succession
  //
  // The following named arguments are supported
  //
  // Options to control construction of -log(L)
  // ------------------------------------------
  // 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.
  // NumCPU(int num)                 -- Parallelize NLL calculation on num CPUs
  // Optimize(Bool_t flag)           -- Activate constant term optimization (on by default)
  //
  // Options to control flow of fit procedure
  // ----------------------------------------
  // InitialHesse(Bool_t flag)      -- Flag controls if HESSE before MIGRAD as well, off 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.
  //
  // 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 chi2FitTo(data,l) ;
  
}



//_____________________________________________________________________________
RooFitResult* RooAbsReal::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") ;

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




//_____________________________________________________________________________
RooAbsReal* RooAbsReal::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
  //  ------------------------------------------
  //  DataError(RooAbsData::ErrorType)  -- Choose between Poisson errors and Sum-of-weights errors
  //  NumCPU(Int_t)                     -- Activate parallel processing feature on N processes
  //  Range()                           -- Calculate Chi2 only in selected region

  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* RooAbsReal::createChi2(RooDataHist& data, const RooLinkedList& cmdList) 
{
  // Internal back-end function to create a chi2

  // Fill array of commands
  const RooCmdArg* cmds[8] ;
  TIterator* iter = cmdList.MakeIterator() ;
  Int_t i(0) ;
  RooCmdArg* arg ;
  while((arg=(RooCmdArg*)iter->Next())) {
    cmds[i++] = arg ;
  }
  for (;i<8 ; i++) {
    cmds[i] = &RooCmdArg::none() ;
  }
  delete iter ;
  
  return createChi2(data,*cmds[0],*cmds[1],*cmds[2],*cmds[3],*cmds[4],*cmds[5],*cmds[6],*cmds[7]) ;
  
}





//_____________________________________________________________________________
RooFitResult* RooAbsReal::chi2FitTo(RooDataSet& xydata, 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 series of x and y value stored in a dataset.
  // The y values can either be the event weights, or can be another column designated
  // by the YVar() argument. The y value must have errors defined for the chi-2 to
  // be well defined.
  //
  // The following named arguments are supported
  //
  // Options to control construction of the chi^2
  // ------------------------------------------
  // YVar(RooRealVar& yvar)          -- Designate given column in dataset as Y value 
  // Integrate(Bool_t flag)          -- Integrate function over range specified by X errors
  //                                    rather than take value at bin center.
  //
  // Options to control flow of fit procedure
  // ----------------------------------------
  // InitialHesse(Bool_t flag)      -- Flag controls if HESSE before MIGRAD as well, off 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.
  //
  // 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 chi2FitTo(xydata,l) ;  
}




//_____________________________________________________________________________
RooFitResult* RooAbsReal::chi2FitTo(RooDataSet& xydata, 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,"YVar,Integrate") ;

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




//_____________________________________________________________________________
RooAbsReal* RooAbsReal::createChi2(RooDataSet& 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 series of x and y value stored in a dataset.
  // The y values can either be the event weights (default), or can be another column designated
  // by the YVar() argument. The y value must have errors defined for the chi-2 to
  // be well defined. 
  //
  // The following named arguments are supported
  //
  // Options to control construction of the chi^2
  // ------------------------------------------
  // YVar(RooRealVar& yvar)          -- Designate given column in dataset as Y value 
  // Integrate(Bool_t flag)          -- Integrate function over range specified by X errors
  //                                    rather than take value at bin center.
  // 
  
  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 createChi2(data,l) ;
}



//_____________________________________________________________________________
RooAbsReal* RooAbsReal::createChi2(RooDataSet& data, const RooLinkedList& cmdList) 
{
  // Internal back-end function to create a chi^2 from a function 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) ;
  }  
}






//_____________________________________________________________________________
RooFitResult* RooAbsReal::chi2FitDriver(RooAbsReal& fcn, RooLinkedList& cmdList) 
{
  // Internal driver function for chi2 fits

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

  pc.defineString("fitOpt","FitOptions",0,"") ;

  pc.defineInt("optConst","Optimize",0,1) ;
  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("numee","PrintEvalErrors",0,10) ;
  pc.defineInt("doWarn","Warnings",0,1) ;
  pc.defineString("mintype","Minimizer",0,"OldMinuit") ;
  pc.defineString("minalg","Minimizer",1,"minuit") ;
  pc.defineObject("minosSet","Minos",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") ;
  
  // Process and check varargs 
  pc.process(cmdList) ;
  if (!pc.ok(kTRUE)) {
    return 0 ;
  }

  // Decode command line arguments
  const char* fitOpt = pc.getString("fitOpt",0,kTRUE) ;
#ifdef __ROOFIT_NOROOMINIMIZER
  const char* minType =0 ;
#else
  const char* minType = pc.getString("mintype","OldMinuit") ;
  const char* minAlg = pc.getString("minalg","minuit") ;
#endif
  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 doWarn   = pc.getInt("doWarn") ;
  const RooArgSet* minosSet = static_cast<RooArgSet*>(pc.getObject("minosSet")) ;

  RooFitResult *ret = 0 ;

#ifdef __ROOFIT_NOROOMINIMIZER
  if (true) {
#else
  if ("OldMinuit" == string(minType)) {
#endif
    // Instantiate MINUIT
    RooMinuit m(fcn) ;

    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 (minos) {
	// Evaluate errs with Minos
	if (minosSet) {
	  m.minos(*minosSet) ;
	} else {
	  m.minos() ;
	}
      }

      // Optionally return fit result
      if (doSave) {
	string name = Form("fitresult_%s",fcn.GetName()) ;
	string title = Form("Result of fit of %s ",GetName()) ;
	ret = m.save(name.c_str(),title.c_str()) ;
      } 

    }
  } else {
#ifndef __ROOFIT_NOROOMINIMIZER
    // Instantiate MINUIT
    RooMinimizer m(fcn) ;
    m.setMinimizerType(minType);

    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 migrad
      m.minimize(minType, minAlg) ;

      if (hesse) {
	// Evaluate errors with Hesse
	m.hesse() ;
      }

      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",fcn.GetName()) ;
	string title = Form("Result of fit of %s ",GetName()) ;
	ret = m.save(name.c_str(),title.c_str()) ;
      } 
    }
#endif
  }

  // Cleanup
  return ret ;

}


//_____________________________________________________________________________
RooAbsReal::ErrorLoggingMode RooAbsReal::evalErrorLoggingMode() 
{ 
  // Return current evaluation error logging mode. 
  return _evalErrorMode ; 
}

//_____________________________________________________________________________
void RooAbsReal::setEvalErrorLoggingMode(RooAbsReal::ErrorLoggingMode m) 
{ 
  // Set evaluation error logging mode. Options are
  //
  // PrintErrors - Print each error through RooMsgService() as it occurs
  // CollectErrors - Accumulate errors, but do not print them. A subsequent call
  //                 to printEvalErrors() will print a summary
  // CountErrors - Accumulate error count, but do not print them. 
  //

  _evalErrorMode =  m; 
}


//_____________________________________________________________________________
void RooAbsReal::setParameterizeIntegral(const RooArgSet& paramVars) 
{
  RooFIter iter = paramVars.fwdIterator() ;
  RooAbsArg* arg ;
  string plist ;
  while((arg=iter.next())) {
    if (!dependsOnValue(*arg)) {
      coutW(InputArguments) << "RooAbsReal::setParameterizeIntegral(" << GetName() 
			    << ") function does not depend on listed parameter " << arg->GetName() << ", ignoring" << endl ;
      continue ;
    }
    if (plist.size()>0) plist += ":" ;
    plist += arg->GetName() ;    
  }
  setStringAttribute("CACHEPARAMINT",plist.c_str()) ;
}

 RooAbsReal.cxx:1
 RooAbsReal.cxx:2
 RooAbsReal.cxx:3
 RooAbsReal.cxx:4
 RooAbsReal.cxx:5
 RooAbsReal.cxx:6
 RooAbsReal.cxx:7
 RooAbsReal.cxx:8
 RooAbsReal.cxx:9
 RooAbsReal.cxx:10
 RooAbsReal.cxx:11
 RooAbsReal.cxx:12
 RooAbsReal.cxx:13
 RooAbsReal.cxx:14
 RooAbsReal.cxx:15
 RooAbsReal.cxx:16
 RooAbsReal.cxx:17
 RooAbsReal.cxx:18
 RooAbsReal.cxx:19
 RooAbsReal.cxx:20
 RooAbsReal.cxx:21
 RooAbsReal.cxx:22
 RooAbsReal.cxx:23
 RooAbsReal.cxx:24
 RooAbsReal.cxx:25
 RooAbsReal.cxx:26
 RooAbsReal.cxx:27
 RooAbsReal.cxx:28
 RooAbsReal.cxx:29
 RooAbsReal.cxx:30
 RooAbsReal.cxx:31
 RooAbsReal.cxx:32
 RooAbsReal.cxx:33
 RooAbsReal.cxx:34
 RooAbsReal.cxx:35
 RooAbsReal.cxx:36
 RooAbsReal.cxx:37
 RooAbsReal.cxx:38
 RooAbsReal.cxx:39
 RooAbsReal.cxx:40
 RooAbsReal.cxx:41
 RooAbsReal.cxx:42
 RooAbsReal.cxx:43
 RooAbsReal.cxx:44
 RooAbsReal.cxx:45
 RooAbsReal.cxx:46
 RooAbsReal.cxx:47
 RooAbsReal.cxx:48
 RooAbsReal.cxx:49
 RooAbsReal.cxx:50
 RooAbsReal.cxx:51
 RooAbsReal.cxx:52
 RooAbsReal.cxx:53
 RooAbsReal.cxx:54
 RooAbsReal.cxx:55
 RooAbsReal.cxx:56
 RooAbsReal.cxx:57
 RooAbsReal.cxx:58
 RooAbsReal.cxx:59
 RooAbsReal.cxx:60
 RooAbsReal.cxx:61
 RooAbsReal.cxx:62
 RooAbsReal.cxx:63
 RooAbsReal.cxx:64
 RooAbsReal.cxx:65
 RooAbsReal.cxx:66
 RooAbsReal.cxx:67
 RooAbsReal.cxx:68
 RooAbsReal.cxx:69
 RooAbsReal.cxx:70
 RooAbsReal.cxx:71
 RooAbsReal.cxx:72
 RooAbsReal.cxx:73
 RooAbsReal.cxx:74
 RooAbsReal.cxx:75
 RooAbsReal.cxx:76
 RooAbsReal.cxx:77
 RooAbsReal.cxx:78
 RooAbsReal.cxx:79
 RooAbsReal.cxx:80
 RooAbsReal.cxx:81
 RooAbsReal.cxx:82
 RooAbsReal.cxx:83
 RooAbsReal.cxx:84
 RooAbsReal.cxx:85
 RooAbsReal.cxx:86
 RooAbsReal.cxx:87
 RooAbsReal.cxx:88
 RooAbsReal.cxx:89
 RooAbsReal.cxx:90
 RooAbsReal.cxx:91
 RooAbsReal.cxx:92
 RooAbsReal.cxx:93
 RooAbsReal.cxx:94
 RooAbsReal.cxx:95
 RooAbsReal.cxx:96
 RooAbsReal.cxx:97
 RooAbsReal.cxx:98
 RooAbsReal.cxx:99
 RooAbsReal.cxx:100
 RooAbsReal.cxx:101
 RooAbsReal.cxx:102
 RooAbsReal.cxx:103
 RooAbsReal.cxx:104
 RooAbsReal.cxx:105
 RooAbsReal.cxx:106
 RooAbsReal.cxx:107
 RooAbsReal.cxx:108
 RooAbsReal.cxx:109
 RooAbsReal.cxx:110
 RooAbsReal.cxx:111
 RooAbsReal.cxx:112
 RooAbsReal.cxx:113
 RooAbsReal.cxx:114
 RooAbsReal.cxx:115
 RooAbsReal.cxx:116
 RooAbsReal.cxx:117
 RooAbsReal.cxx:118
 RooAbsReal.cxx:119
 RooAbsReal.cxx:120
 RooAbsReal.cxx:121
 RooAbsReal.cxx:122
 RooAbsReal.cxx:123
 RooAbsReal.cxx:124
 RooAbsReal.cxx:125
 RooAbsReal.cxx:126
 RooAbsReal.cxx:127
 RooAbsReal.cxx:128
 RooAbsReal.cxx:129
 RooAbsReal.cxx:130
 RooAbsReal.cxx:131
 RooAbsReal.cxx:132
 RooAbsReal.cxx:133
 RooAbsReal.cxx:134
 RooAbsReal.cxx:135
 RooAbsReal.cxx:136
 RooAbsReal.cxx:137
 RooAbsReal.cxx:138
 RooAbsReal.cxx:139
 RooAbsReal.cxx:140
 RooAbsReal.cxx:141
 RooAbsReal.cxx:142
 RooAbsReal.cxx:143
 RooAbsReal.cxx:144
 RooAbsReal.cxx:145
 RooAbsReal.cxx:146
 RooAbsReal.cxx:147
 RooAbsReal.cxx:148
 RooAbsReal.cxx:149
 RooAbsReal.cxx:150
 RooAbsReal.cxx:151
 RooAbsReal.cxx:152
 RooAbsReal.cxx:153
 RooAbsReal.cxx:154
 RooAbsReal.cxx:155
 RooAbsReal.cxx:156
 RooAbsReal.cxx:157
 RooAbsReal.cxx:158
 RooAbsReal.cxx:159
 RooAbsReal.cxx:160
 RooAbsReal.cxx:161
 RooAbsReal.cxx:162
 RooAbsReal.cxx:163
 RooAbsReal.cxx:164
 RooAbsReal.cxx:165
 RooAbsReal.cxx:166
 RooAbsReal.cxx:167
 RooAbsReal.cxx:168
 RooAbsReal.cxx:169
 RooAbsReal.cxx:170
 RooAbsReal.cxx:171
 RooAbsReal.cxx:172
 RooAbsReal.cxx:173
 RooAbsReal.cxx:174
 RooAbsReal.cxx:175
 RooAbsReal.cxx:176
 RooAbsReal.cxx:177
 RooAbsReal.cxx:178
 RooAbsReal.cxx:179
 RooAbsReal.cxx:180
 RooAbsReal.cxx:181
 RooAbsReal.cxx:182
 RooAbsReal.cxx:183
 RooAbsReal.cxx:184
 RooAbsReal.cxx:185
 RooAbsReal.cxx:186
 RooAbsReal.cxx:187
 RooAbsReal.cxx:188
 RooAbsReal.cxx:189
 RooAbsReal.cxx:190
 RooAbsReal.cxx:191
 RooAbsReal.cxx:192
 RooAbsReal.cxx:193
 RooAbsReal.cxx:194
 RooAbsReal.cxx:195
 RooAbsReal.cxx:196
 RooAbsReal.cxx:197
 RooAbsReal.cxx:198
 RooAbsReal.cxx:199
 RooAbsReal.cxx:200
 RooAbsReal.cxx:201
 RooAbsReal.cxx:202
 RooAbsReal.cxx:203
 RooAbsReal.cxx:204
 RooAbsReal.cxx:205
 RooAbsReal.cxx:206
 RooAbsReal.cxx:207
 RooAbsReal.cxx:208
 RooAbsReal.cxx:209
 RooAbsReal.cxx:210
 RooAbsReal.cxx:211
 RooAbsReal.cxx:212
 RooAbsReal.cxx:213
 RooAbsReal.cxx:214
 RooAbsReal.cxx:215
 RooAbsReal.cxx:216
 RooAbsReal.cxx:217
 RooAbsReal.cxx:218
 RooAbsReal.cxx:219
 RooAbsReal.cxx:220
 RooAbsReal.cxx:221
 RooAbsReal.cxx:222
 RooAbsReal.cxx:223
 RooAbsReal.cxx:224
 RooAbsReal.cxx:225
 RooAbsReal.cxx:226
 RooAbsReal.cxx:227
 RooAbsReal.cxx:228
 RooAbsReal.cxx:229
 RooAbsReal.cxx:230
 RooAbsReal.cxx:231
 RooAbsReal.cxx:232
 RooAbsReal.cxx:233
 RooAbsReal.cxx:234
 RooAbsReal.cxx:235
 RooAbsReal.cxx:236
 RooAbsReal.cxx:237
 RooAbsReal.cxx:238
 RooAbsReal.cxx:239
 RooAbsReal.cxx:240
 RooAbsReal.cxx:241
 RooAbsReal.cxx:242
 RooAbsReal.cxx:243
 RooAbsReal.cxx:244
 RooAbsReal.cxx:245
 RooAbsReal.cxx:246
 RooAbsReal.cxx:247
 RooAbsReal.cxx:248
 RooAbsReal.cxx:249
 RooAbsReal.cxx:250
 RooAbsReal.cxx:251
 RooAbsReal.cxx:252
 RooAbsReal.cxx:253
 RooAbsReal.cxx:254
 RooAbsReal.cxx:255
 RooAbsReal.cxx:256
 RooAbsReal.cxx:257
 RooAbsReal.cxx:258
 RooAbsReal.cxx:259
 RooAbsReal.cxx:260
 RooAbsReal.cxx:261
 RooAbsReal.cxx:262
 RooAbsReal.cxx:263
 RooAbsReal.cxx:264
 RooAbsReal.cxx:265
 RooAbsReal.cxx:266
 RooAbsReal.cxx:267
 RooAbsReal.cxx:268
 RooAbsReal.cxx:269
 RooAbsReal.cxx:270
 RooAbsReal.cxx:271
 RooAbsReal.cxx:272
 RooAbsReal.cxx:273
 RooAbsReal.cxx:274
 RooAbsReal.cxx:275
 RooAbsReal.cxx:276
 RooAbsReal.cxx:277
 RooAbsReal.cxx:278
 RooAbsReal.cxx:279
 RooAbsReal.cxx:280
 RooAbsReal.cxx:281
 RooAbsReal.cxx:282
 RooAbsReal.cxx:283
 RooAbsReal.cxx:284
 RooAbsReal.cxx:285
 RooAbsReal.cxx:286
 RooAbsReal.cxx:287
 RooAbsReal.cxx:288
 RooAbsReal.cxx:289
 RooAbsReal.cxx:290
 RooAbsReal.cxx:291
 RooAbsReal.cxx:292
 RooAbsReal.cxx:293
 RooAbsReal.cxx:294
 RooAbsReal.cxx:295
 RooAbsReal.cxx:296
 RooAbsReal.cxx:297
 RooAbsReal.cxx:298
 RooAbsReal.cxx:299
 RooAbsReal.cxx:300
 RooAbsReal.cxx:301
 RooAbsReal.cxx:302
 RooAbsReal.cxx:303
 RooAbsReal.cxx:304
 RooAbsReal.cxx:305
 RooAbsReal.cxx:306
 RooAbsReal.cxx:307
 RooAbsReal.cxx:308
 RooAbsReal.cxx:309
 RooAbsReal.cxx:310
 RooAbsReal.cxx:311
 RooAbsReal.cxx:312
 RooAbsReal.cxx:313
 RooAbsReal.cxx:314
 RooAbsReal.cxx:315
 RooAbsReal.cxx:316
 RooAbsReal.cxx:317
 RooAbsReal.cxx:318
 RooAbsReal.cxx:319
 RooAbsReal.cxx:320
 RooAbsReal.cxx:321
 RooAbsReal.cxx:322
 RooAbsReal.cxx:323
 RooAbsReal.cxx:324
 RooAbsReal.cxx:325
 RooAbsReal.cxx:326
 RooAbsReal.cxx:327
 RooAbsReal.cxx:328
 RooAbsReal.cxx:329
 RooAbsReal.cxx:330
 RooAbsReal.cxx:331
 RooAbsReal.cxx:332
 RooAbsReal.cxx:333
 RooAbsReal.cxx:334
 RooAbsReal.cxx:335
 RooAbsReal.cxx:336
 RooAbsReal.cxx:337
 RooAbsReal.cxx:338
 RooAbsReal.cxx:339
 RooAbsReal.cxx:340
 RooAbsReal.cxx:341
 RooAbsReal.cxx:342
 RooAbsReal.cxx:343
 RooAbsReal.cxx:344
 RooAbsReal.cxx:345
 RooAbsReal.cxx:346
 RooAbsReal.cxx:347
 RooAbsReal.cxx:348
 RooAbsReal.cxx:349
 RooAbsReal.cxx:350
 RooAbsReal.cxx:351
 RooAbsReal.cxx:352
 RooAbsReal.cxx:353
 RooAbsReal.cxx:354
 RooAbsReal.cxx:355
 RooAbsReal.cxx:356
 RooAbsReal.cxx:357
 RooAbsReal.cxx:358
 RooAbsReal.cxx:359
 RooAbsReal.cxx:360
 RooAbsReal.cxx:361
 RooAbsReal.cxx:362
 RooAbsReal.cxx:363
 RooAbsReal.cxx:364
 RooAbsReal.cxx:365
 RooAbsReal.cxx:366
 RooAbsReal.cxx:367
 RooAbsReal.cxx:368
 RooAbsReal.cxx:369
 RooAbsReal.cxx:370
 RooAbsReal.cxx:371
 RooAbsReal.cxx:372
 RooAbsReal.cxx:373
 RooAbsReal.cxx:374
 RooAbsReal.cxx:375
 RooAbsReal.cxx:376
 RooAbsReal.cxx:377
 RooAbsReal.cxx:378
 RooAbsReal.cxx:379
 RooAbsReal.cxx:380
 RooAbsReal.cxx:381
 RooAbsReal.cxx:382
 RooAbsReal.cxx:383
 RooAbsReal.cxx:384
 RooAbsReal.cxx:385
 RooAbsReal.cxx:386
 RooAbsReal.cxx:387
 RooAbsReal.cxx:388
 RooAbsReal.cxx:389
 RooAbsReal.cxx:390
 RooAbsReal.cxx:391
 RooAbsReal.cxx:392
 RooAbsReal.cxx:393
 RooAbsReal.cxx:394
 RooAbsReal.cxx:395
 RooAbsReal.cxx:396
 RooAbsReal.cxx:397
 RooAbsReal.cxx:398
 RooAbsReal.cxx:399
 RooAbsReal.cxx:400
 RooAbsReal.cxx:401
 RooAbsReal.cxx:402
 RooAbsReal.cxx:403
 RooAbsReal.cxx:404
 RooAbsReal.cxx:405
 RooAbsReal.cxx:406
 RooAbsReal.cxx:407
 RooAbsReal.cxx:408
 RooAbsReal.cxx:409
 RooAbsReal.cxx:410
 RooAbsReal.cxx:411
 RooAbsReal.cxx:412
 RooAbsReal.cxx:413
 RooAbsReal.cxx:414
 RooAbsReal.cxx:415
 RooAbsReal.cxx:416
 RooAbsReal.cxx:417
 RooAbsReal.cxx:418
 RooAbsReal.cxx:419
 RooAbsReal.cxx:420
 RooAbsReal.cxx:421
 RooAbsReal.cxx:422
 RooAbsReal.cxx:423
 RooAbsReal.cxx:424
 RooAbsReal.cxx:425
 RooAbsReal.cxx:426
 RooAbsReal.cxx:427
 RooAbsReal.cxx:428
 RooAbsReal.cxx:429
 RooAbsReal.cxx:430
 RooAbsReal.cxx:431
 RooAbsReal.cxx:432
 RooAbsReal.cxx:433
 RooAbsReal.cxx:434
 RooAbsReal.cxx:435
 RooAbsReal.cxx:436
 RooAbsReal.cxx:437
 RooAbsReal.cxx:438
 RooAbsReal.cxx:439
 RooAbsReal.cxx:440
 RooAbsReal.cxx:441
 RooAbsReal.cxx:442
 RooAbsReal.cxx:443
 RooAbsReal.cxx:444
 RooAbsReal.cxx:445
 RooAbsReal.cxx:446
 RooAbsReal.cxx:447
 RooAbsReal.cxx:448
 RooAbsReal.cxx:449
 RooAbsReal.cxx:450
 RooAbsReal.cxx:451
 RooAbsReal.cxx:452
 RooAbsReal.cxx:453
 RooAbsReal.cxx:454
 RooAbsReal.cxx:455
 RooAbsReal.cxx:456
 RooAbsReal.cxx:457
 RooAbsReal.cxx:458
 RooAbsReal.cxx:459
 RooAbsReal.cxx:460
 RooAbsReal.cxx:461
 RooAbsReal.cxx:462
 RooAbsReal.cxx:463
 RooAbsReal.cxx:464
 RooAbsReal.cxx:465
 RooAbsReal.cxx:466
 RooAbsReal.cxx:467
 RooAbsReal.cxx:468
 RooAbsReal.cxx:469
 RooAbsReal.cxx:470
 RooAbsReal.cxx:471
 RooAbsReal.cxx:472
 RooAbsReal.cxx:473
 RooAbsReal.cxx:474
 RooAbsReal.cxx:475
 RooAbsReal.cxx:476
 RooAbsReal.cxx:477
 RooAbsReal.cxx:478
 RooAbsReal.cxx:479
 RooAbsReal.cxx:480
 RooAbsReal.cxx:481
 RooAbsReal.cxx:482
 RooAbsReal.cxx:483
 RooAbsReal.cxx:484
 RooAbsReal.cxx:485
 RooAbsReal.cxx:486
 RooAbsReal.cxx:487
 RooAbsReal.cxx:488
 RooAbsReal.cxx:489
 RooAbsReal.cxx:490
 RooAbsReal.cxx:491
 RooAbsReal.cxx:492
 RooAbsReal.cxx:493
 RooAbsReal.cxx:494
 RooAbsReal.cxx:495
 RooAbsReal.cxx:496
 RooAbsReal.cxx:497
 RooAbsReal.cxx:498
 RooAbsReal.cxx:499
 RooAbsReal.cxx:500
 RooAbsReal.cxx:501
 RooAbsReal.cxx:502
 RooAbsReal.cxx:503
 RooAbsReal.cxx:504
 RooAbsReal.cxx:505
 RooAbsReal.cxx:506
 RooAbsReal.cxx:507
 RooAbsReal.cxx:508
 RooAbsReal.cxx:509
 RooAbsReal.cxx:510
 RooAbsReal.cxx:511
 RooAbsReal.cxx:512
 RooAbsReal.cxx:513
 RooAbsReal.cxx:514
 RooAbsReal.cxx:515
 RooAbsReal.cxx:516
 RooAbsReal.cxx:517
 RooAbsReal.cxx:518
 RooAbsReal.cxx:519
 RooAbsReal.cxx:520
 RooAbsReal.cxx:521
 RooAbsReal.cxx:522
 RooAbsReal.cxx:523
 RooAbsReal.cxx:524
 RooAbsReal.cxx:525
 RooAbsReal.cxx:526
 RooAbsReal.cxx:527
 RooAbsReal.cxx:528
 RooAbsReal.cxx:529
 RooAbsReal.cxx:530
 RooAbsReal.cxx:531
 RooAbsReal.cxx:532
 RooAbsReal.cxx:533
 RooAbsReal.cxx:534
 RooAbsReal.cxx:535
 RooAbsReal.cxx:536
 RooAbsReal.cxx:537
 RooAbsReal.cxx:538
 RooAbsReal.cxx:539
 RooAbsReal.cxx:540
 RooAbsReal.cxx:541
 RooAbsReal.cxx:542
 RooAbsReal.cxx:543
 RooAbsReal.cxx:544
 RooAbsReal.cxx:545
 RooAbsReal.cxx:546
 RooAbsReal.cxx:547
 RooAbsReal.cxx:548
 RooAbsReal.cxx:549
 RooAbsReal.cxx:550
 RooAbsReal.cxx:551
 RooAbsReal.cxx:552
 RooAbsReal.cxx:553
 RooAbsReal.cxx:554
 RooAbsReal.cxx:555
 RooAbsReal.cxx:556
 RooAbsReal.cxx:557
 RooAbsReal.cxx:558
 RooAbsReal.cxx:559
 RooAbsReal.cxx:560
 RooAbsReal.cxx:561
 RooAbsReal.cxx:562
 RooAbsReal.cxx:563
 RooAbsReal.cxx:564
 RooAbsReal.cxx:565
 RooAbsReal.cxx:566
 RooAbsReal.cxx:567
 RooAbsReal.cxx:568
 RooAbsReal.cxx:569
 RooAbsReal.cxx:570
 RooAbsReal.cxx:571
 RooAbsReal.cxx:572
 RooAbsReal.cxx:573
 RooAbsReal.cxx:574
 RooAbsReal.cxx:575
 RooAbsReal.cxx:576
 RooAbsReal.cxx:577
 RooAbsReal.cxx:578
 RooAbsReal.cxx:579
 RooAbsReal.cxx:580
 RooAbsReal.cxx:581
 RooAbsReal.cxx:582
 RooAbsReal.cxx:583
 RooAbsReal.cxx:584
 RooAbsReal.cxx:585
 RooAbsReal.cxx:586
 RooAbsReal.cxx:587
 RooAbsReal.cxx:588
 RooAbsReal.cxx:589
 RooAbsReal.cxx:590
 RooAbsReal.cxx:591
 RooAbsReal.cxx:592
 RooAbsReal.cxx:593
 RooAbsReal.cxx:594
 RooAbsReal.cxx:595
 RooAbsReal.cxx:596
 RooAbsReal.cxx:597
 RooAbsReal.cxx:598
 RooAbsReal.cxx:599
 RooAbsReal.cxx:600
 RooAbsReal.cxx:601
 RooAbsReal.cxx:602
 RooAbsReal.cxx:603
 RooAbsReal.cxx:604
 RooAbsReal.cxx:605
 RooAbsReal.cxx:606
 RooAbsReal.cxx:607
 RooAbsReal.cxx:608
 RooAbsReal.cxx:609
 RooAbsReal.cxx:610
 RooAbsReal.cxx:611
 RooAbsReal.cxx:612
 RooAbsReal.cxx:613
 RooAbsReal.cxx:614
 RooAbsReal.cxx:615
 RooAbsReal.cxx:616
 RooAbsReal.cxx:617
 RooAbsReal.cxx:618
 RooAbsReal.cxx:619
 RooAbsReal.cxx:620
 RooAbsReal.cxx:621
 RooAbsReal.cxx:622
 RooAbsReal.cxx:623
 RooAbsReal.cxx:624
 RooAbsReal.cxx:625
 RooAbsReal.cxx:626
 RooAbsReal.cxx:627
 RooAbsReal.cxx:628
 RooAbsReal.cxx:629
 RooAbsReal.cxx:630
 RooAbsReal.cxx:631
 RooAbsReal.cxx:632
 RooAbsReal.cxx:633
 RooAbsReal.cxx:634
 RooAbsReal.cxx:635
 RooAbsReal.cxx:636
 RooAbsReal.cxx:637
 RooAbsReal.cxx:638
 RooAbsReal.cxx:639
 RooAbsReal.cxx:640
 RooAbsReal.cxx:641
 RooAbsReal.cxx:642
 RooAbsReal.cxx:643
 RooAbsReal.cxx:644
 RooAbsReal.cxx:645
 RooAbsReal.cxx:646
 RooAbsReal.cxx:647
 RooAbsReal.cxx:648
 RooAbsReal.cxx:649
 RooAbsReal.cxx:650
 RooAbsReal.cxx:651
 RooAbsReal.cxx:652
 RooAbsReal.cxx:653
 RooAbsReal.cxx:654
 RooAbsReal.cxx:655
 RooAbsReal.cxx:656
 RooAbsReal.cxx:657
 RooAbsReal.cxx:658
 RooAbsReal.cxx:659
 RooAbsReal.cxx:660
 RooAbsReal.cxx:661
 RooAbsReal.cxx:662
 RooAbsReal.cxx:663
 RooAbsReal.cxx:664
 RooAbsReal.cxx:665
 RooAbsReal.cxx:666
 RooAbsReal.cxx:667
 RooAbsReal.cxx:668
 RooAbsReal.cxx:669
 RooAbsReal.cxx:670
 RooAbsReal.cxx:671
 RooAbsReal.cxx:672
 RooAbsReal.cxx:673
 RooAbsReal.cxx:674
 RooAbsReal.cxx:675
 RooAbsReal.cxx:676
 RooAbsReal.cxx:677
 RooAbsReal.cxx:678
 RooAbsReal.cxx:679
 RooAbsReal.cxx:680
 RooAbsReal.cxx:681
 RooAbsReal.cxx:682
 RooAbsReal.cxx:683
 RooAbsReal.cxx:684
 RooAbsReal.cxx:685
 RooAbsReal.cxx:686
 RooAbsReal.cxx:687
 RooAbsReal.cxx:688
 RooAbsReal.cxx:689
 RooAbsReal.cxx:690
 RooAbsReal.cxx:691
 RooAbsReal.cxx:692
 RooAbsReal.cxx:693
 RooAbsReal.cxx:694
 RooAbsReal.cxx:695
 RooAbsReal.cxx:696
 RooAbsReal.cxx:697
 RooAbsReal.cxx:698
 RooAbsReal.cxx:699
 RooAbsReal.cxx:700
 RooAbsReal.cxx:701
 RooAbsReal.cxx:702
 RooAbsReal.cxx:703
 RooAbsReal.cxx:704
 RooAbsReal.cxx:705
 RooAbsReal.cxx:706
 RooAbsReal.cxx:707
 RooAbsReal.cxx:708
 RooAbsReal.cxx:709
 RooAbsReal.cxx:710
 RooAbsReal.cxx:711
 RooAbsReal.cxx:712
 RooAbsReal.cxx:713
 RooAbsReal.cxx:714
 RooAbsReal.cxx:715
 RooAbsReal.cxx:716
 RooAbsReal.cxx:717
 RooAbsReal.cxx:718
 RooAbsReal.cxx:719
 RooAbsReal.cxx:720
 RooAbsReal.cxx:721
 RooAbsReal.cxx:722
 RooAbsReal.cxx:723
 RooAbsReal.cxx:724
 RooAbsReal.cxx:725
 RooAbsReal.cxx:726
 RooAbsReal.cxx:727
 RooAbsReal.cxx:728
 RooAbsReal.cxx:729
 RooAbsReal.cxx:730
 RooAbsReal.cxx:731
 RooAbsReal.cxx:732
 RooAbsReal.cxx:733
 RooAbsReal.cxx:734
 RooAbsReal.cxx:735
 RooAbsReal.cxx:736
 RooAbsReal.cxx:737
 RooAbsReal.cxx:738
 RooAbsReal.cxx:739
 RooAbsReal.cxx:740
 RooAbsReal.cxx:741
 RooAbsReal.cxx:742
 RooAbsReal.cxx:743
 RooAbsReal.cxx:744
 RooAbsReal.cxx:745
 RooAbsReal.cxx:746
 RooAbsReal.cxx:747
 RooAbsReal.cxx:748
 RooAbsReal.cxx:749
 RooAbsReal.cxx:750
 RooAbsReal.cxx:751
 RooAbsReal.cxx:752
 RooAbsReal.cxx:753
 RooAbsReal.cxx:754
 RooAbsReal.cxx:755
 RooAbsReal.cxx:756
 RooAbsReal.cxx:757
 RooAbsReal.cxx:758
 RooAbsReal.cxx:759
 RooAbsReal.cxx:760
 RooAbsReal.cxx:761
 RooAbsReal.cxx:762
 RooAbsReal.cxx:763
 RooAbsReal.cxx:764
 RooAbsReal.cxx:765
 RooAbsReal.cxx:766
 RooAbsReal.cxx:767
 RooAbsReal.cxx:768
 RooAbsReal.cxx:769
 RooAbsReal.cxx:770
 RooAbsReal.cxx:771
 RooAbsReal.cxx:772
 RooAbsReal.cxx:773
 RooAbsReal.cxx:774
 RooAbsReal.cxx:775
 RooAbsReal.cxx:776
 RooAbsReal.cxx:777
 RooAbsReal.cxx:778
 RooAbsReal.cxx:779
 RooAbsReal.cxx:780
 RooAbsReal.cxx:781
 RooAbsReal.cxx:782
 RooAbsReal.cxx:783
 RooAbsReal.cxx:784
 RooAbsReal.cxx:785
 RooAbsReal.cxx:786
 RooAbsReal.cxx:787
 RooAbsReal.cxx:788
 RooAbsReal.cxx:789
 RooAbsReal.cxx:790
 RooAbsReal.cxx:791
 RooAbsReal.cxx:792
 RooAbsReal.cxx:793
 RooAbsReal.cxx:794
 RooAbsReal.cxx:795
 RooAbsReal.cxx:796
 RooAbsReal.cxx:797
 RooAbsReal.cxx:798
 RooAbsReal.cxx:799
 RooAbsReal.cxx:800
 RooAbsReal.cxx:801
 RooAbsReal.cxx:802
 RooAbsReal.cxx:803
 RooAbsReal.cxx:804
 RooAbsReal.cxx:805
 RooAbsReal.cxx:806
 RooAbsReal.cxx:807
 RooAbsReal.cxx:808
 RooAbsReal.cxx:809
 RooAbsReal.cxx:810
 RooAbsReal.cxx:811
 RooAbsReal.cxx:812
 RooAbsReal.cxx:813
 RooAbsReal.cxx:814
 RooAbsReal.cxx:815
 RooAbsReal.cxx:816
 RooAbsReal.cxx:817
 RooAbsReal.cxx:818
 RooAbsReal.cxx:819
 RooAbsReal.cxx:820
 RooAbsReal.cxx:821
 RooAbsReal.cxx:822
 RooAbsReal.cxx:823
 RooAbsReal.cxx:824
 RooAbsReal.cxx:825
 RooAbsReal.cxx:826
 RooAbsReal.cxx:827
 RooAbsReal.cxx:828
 RooAbsReal.cxx:829
 RooAbsReal.cxx:830
 RooAbsReal.cxx:831
 RooAbsReal.cxx:832
 RooAbsReal.cxx:833
 RooAbsReal.cxx:834
 RooAbsReal.cxx:835
 RooAbsReal.cxx:836
 RooAbsReal.cxx:837
 RooAbsReal.cxx:838
 RooAbsReal.cxx:839
 RooAbsReal.cxx:840
 RooAbsReal.cxx:841
 RooAbsReal.cxx:842
 RooAbsReal.cxx:843
 RooAbsReal.cxx:844
 RooAbsReal.cxx:845
 RooAbsReal.cxx:846
 RooAbsReal.cxx:847
 RooAbsReal.cxx:848
 RooAbsReal.cxx:849
 RooAbsReal.cxx:850
 RooAbsReal.cxx:851
 RooAbsReal.cxx:852
 RooAbsReal.cxx:853
 RooAbsReal.cxx:854
 RooAbsReal.cxx:855
 RooAbsReal.cxx:856
 RooAbsReal.cxx:857
 RooAbsReal.cxx:858
 RooAbsReal.cxx:859
 RooAbsReal.cxx:860
 RooAbsReal.cxx:861
 RooAbsReal.cxx:862
 RooAbsReal.cxx:863
 RooAbsReal.cxx:864
 RooAbsReal.cxx:865
 RooAbsReal.cxx:866
 RooAbsReal.cxx:867
 RooAbsReal.cxx:868
 RooAbsReal.cxx:869
 RooAbsReal.cxx:870
 RooAbsReal.cxx:871
 RooAbsReal.cxx:872
 RooAbsReal.cxx:873
 RooAbsReal.cxx:874
 RooAbsReal.cxx:875
 RooAbsReal.cxx:876
 RooAbsReal.cxx:877
 RooAbsReal.cxx:878
 RooAbsReal.cxx:879
 RooAbsReal.cxx:880
 RooAbsReal.cxx:881
 RooAbsReal.cxx:882
 RooAbsReal.cxx:883
 RooAbsReal.cxx:884
 RooAbsReal.cxx:885
 RooAbsReal.cxx:886
 RooAbsReal.cxx:887
 RooAbsReal.cxx:888
 RooAbsReal.cxx:889
 RooAbsReal.cxx:890
 RooAbsReal.cxx:891
 RooAbsReal.cxx:892
 RooAbsReal.cxx:893
 RooAbsReal.cxx:894
 RooAbsReal.cxx:895
 RooAbsReal.cxx:896
 RooAbsReal.cxx:897
 RooAbsReal.cxx:898
 RooAbsReal.cxx:899
 RooAbsReal.cxx:900
 RooAbsReal.cxx:901
 RooAbsReal.cxx:902
 RooAbsReal.cxx:903
 RooAbsReal.cxx:904
 RooAbsReal.cxx:905
 RooAbsReal.cxx:906
 RooAbsReal.cxx:907
 RooAbsReal.cxx:908
 RooAbsReal.cxx:909
 RooAbsReal.cxx:910
 RooAbsReal.cxx:911
 RooAbsReal.cxx:912
 RooAbsReal.cxx:913
 RooAbsReal.cxx:914
 RooAbsReal.cxx:915
 RooAbsReal.cxx:916
 RooAbsReal.cxx:917
 RooAbsReal.cxx:918
 RooAbsReal.cxx:919
 RooAbsReal.cxx:920
 RooAbsReal.cxx:921
 RooAbsReal.cxx:922
 RooAbsReal.cxx:923
 RooAbsReal.cxx:924
 RooAbsReal.cxx:925
 RooAbsReal.cxx:926
 RooAbsReal.cxx:927
 RooAbsReal.cxx:928
 RooAbsReal.cxx:929
 RooAbsReal.cxx:930
 RooAbsReal.cxx:931
 RooAbsReal.cxx:932
 RooAbsReal.cxx:933
 RooAbsReal.cxx:934
 RooAbsReal.cxx:935
 RooAbsReal.cxx:936
 RooAbsReal.cxx:937
 RooAbsReal.cxx:938
 RooAbsReal.cxx:939
 RooAbsReal.cxx:940
 RooAbsReal.cxx:941
 RooAbsReal.cxx:942
 RooAbsReal.cxx:943
 RooAbsReal.cxx:944
 RooAbsReal.cxx:945
 RooAbsReal.cxx:946
 RooAbsReal.cxx:947
 RooAbsReal.cxx:948
 RooAbsReal.cxx:949
 RooAbsReal.cxx:950
 RooAbsReal.cxx:951
 RooAbsReal.cxx:952
 RooAbsReal.cxx:953
 RooAbsReal.cxx:954
 RooAbsReal.cxx:955
 RooAbsReal.cxx:956
 RooAbsReal.cxx:957
 RooAbsReal.cxx:958
 RooAbsReal.cxx:959
 RooAbsReal.cxx:960
 RooAbsReal.cxx:961
 RooAbsReal.cxx:962
 RooAbsReal.cxx:963
 RooAbsReal.cxx:964
 RooAbsReal.cxx:965
 RooAbsReal.cxx:966
 RooAbsReal.cxx:967
 RooAbsReal.cxx:968
 RooAbsReal.cxx:969
 RooAbsReal.cxx:970
 RooAbsReal.cxx:971
 RooAbsReal.cxx:972
 RooAbsReal.cxx:973
 RooAbsReal.cxx:974
 RooAbsReal.cxx:975
 RooAbsReal.cxx:976
 RooAbsReal.cxx:977
 RooAbsReal.cxx:978
 RooAbsReal.cxx:979
 RooAbsReal.cxx:980
 RooAbsReal.cxx:981
 RooAbsReal.cxx:982
 RooAbsReal.cxx:983
 RooAbsReal.cxx:984
 RooAbsReal.cxx:985
 RooAbsReal.cxx:986
 RooAbsReal.cxx:987
 RooAbsReal.cxx:988
 RooAbsReal.cxx:989
 RooAbsReal.cxx:990
 RooAbsReal.cxx:991
 RooAbsReal.cxx:992
 RooAbsReal.cxx:993
 RooAbsReal.cxx:994
 RooAbsReal.cxx:995
 RooAbsReal.cxx:996
 RooAbsReal.cxx:997
 RooAbsReal.cxx:998
 RooAbsReal.cxx:999
 RooAbsReal.cxx:1000
 RooAbsReal.cxx:1001
 RooAbsReal.cxx:1002
 RooAbsReal.cxx:1003
 RooAbsReal.cxx:1004
 RooAbsReal.cxx:1005
 RooAbsReal.cxx:1006
 RooAbsReal.cxx:1007
 RooAbsReal.cxx:1008
 RooAbsReal.cxx:1009
 RooAbsReal.cxx:1010
 RooAbsReal.cxx:1011
 RooAbsReal.cxx:1012
 RooAbsReal.cxx:1013
 RooAbsReal.cxx:1014
 RooAbsReal.cxx:1015
 RooAbsReal.cxx:1016
 RooAbsReal.cxx:1017
 RooAbsReal.cxx:1018
 RooAbsReal.cxx:1019
 RooAbsReal.cxx:1020
 RooAbsReal.cxx:1021
 RooAbsReal.cxx:1022
 RooAbsReal.cxx:1023
 RooAbsReal.cxx:1024
 RooAbsReal.cxx:1025
 RooAbsReal.cxx:1026
 RooAbsReal.cxx:1027
 RooAbsReal.cxx:1028
 RooAbsReal.cxx:1029
 RooAbsReal.cxx:1030
 RooAbsReal.cxx:1031
 RooAbsReal.cxx:1032
 RooAbsReal.cxx:1033
 RooAbsReal.cxx:1034
 RooAbsReal.cxx:1035
 RooAbsReal.cxx:1036
 RooAbsReal.cxx:1037
 RooAbsReal.cxx:1038
 RooAbsReal.cxx:1039
 RooAbsReal.cxx:1040
 RooAbsReal.cxx:1041
 RooAbsReal.cxx:1042
 RooAbsReal.cxx:1043
 RooAbsReal.cxx:1044
 RooAbsReal.cxx:1045
 RooAbsReal.cxx:1046
 RooAbsReal.cxx:1047
 RooAbsReal.cxx:1048
 RooAbsReal.cxx:1049
 RooAbsReal.cxx:1050
 RooAbsReal.cxx:1051
 RooAbsReal.cxx:1052
 RooAbsReal.cxx:1053
 RooAbsReal.cxx:1054
 RooAbsReal.cxx:1055
 RooAbsReal.cxx:1056
 RooAbsReal.cxx:1057
 RooAbsReal.cxx:1058
 RooAbsReal.cxx:1059
 RooAbsReal.cxx:1060
 RooAbsReal.cxx:1061
 RooAbsReal.cxx:1062
 RooAbsReal.cxx:1063
 RooAbsReal.cxx:1064
 RooAbsReal.cxx:1065
 RooAbsReal.cxx:1066
 RooAbsReal.cxx:1067
 RooAbsReal.cxx:1068
 RooAbsReal.cxx:1069
 RooAbsReal.cxx:1070
 RooAbsReal.cxx:1071
 RooAbsReal.cxx:1072
 RooAbsReal.cxx:1073
 RooAbsReal.cxx:1074
 RooAbsReal.cxx:1075
 RooAbsReal.cxx:1076
 RooAbsReal.cxx:1077
 RooAbsReal.cxx:1078
 RooAbsReal.cxx:1079
 RooAbsReal.cxx:1080
 RooAbsReal.cxx:1081
 RooAbsReal.cxx:1082
 RooAbsReal.cxx:1083
 RooAbsReal.cxx:1084
 RooAbsReal.cxx:1085
 RooAbsReal.cxx:1086
 RooAbsReal.cxx:1087
 RooAbsReal.cxx:1088
 RooAbsReal.cxx:1089
 RooAbsReal.cxx:1090
 RooAbsReal.cxx:1091
 RooAbsReal.cxx:1092
 RooAbsReal.cxx:1093
 RooAbsReal.cxx:1094
 RooAbsReal.cxx:1095
 RooAbsReal.cxx:1096
 RooAbsReal.cxx:1097
 RooAbsReal.cxx:1098
 RooAbsReal.cxx:1099
 RooAbsReal.cxx:1100
 RooAbsReal.cxx:1101
 RooAbsReal.cxx:1102
 RooAbsReal.cxx:1103
 RooAbsReal.cxx:1104
 RooAbsReal.cxx:1105
 RooAbsReal.cxx:1106
 RooAbsReal.cxx:1107
 RooAbsReal.cxx:1108
 RooAbsReal.cxx:1109
 RooAbsReal.cxx:1110
 RooAbsReal.cxx:1111
 RooAbsReal.cxx:1112
 RooAbsReal.cxx:1113
 RooAbsReal.cxx:1114
 RooAbsReal.cxx:1115
 RooAbsReal.cxx:1116
 RooAbsReal.cxx:1117
 RooAbsReal.cxx:1118
 RooAbsReal.cxx:1119
 RooAbsReal.cxx:1120
 RooAbsReal.cxx:1121
 RooAbsReal.cxx:1122
 RooAbsReal.cxx:1123
 RooAbsReal.cxx:1124
 RooAbsReal.cxx:1125
 RooAbsReal.cxx:1126
 RooAbsReal.cxx:1127
 RooAbsReal.cxx:1128
 RooAbsReal.cxx:1129
 RooAbsReal.cxx:1130
 RooAbsReal.cxx:1131
 RooAbsReal.cxx:1132
 RooAbsReal.cxx:1133
 RooAbsReal.cxx:1134
 RooAbsReal.cxx:1135
 RooAbsReal.cxx:1136
 RooAbsReal.cxx:1137
 RooAbsReal.cxx:1138
 RooAbsReal.cxx:1139
 RooAbsReal.cxx:1140
 RooAbsReal.cxx:1141
 RooAbsReal.cxx:1142
 RooAbsReal.cxx:1143
 RooAbsReal.cxx:1144
 RooAbsReal.cxx:1145
 RooAbsReal.cxx:1146
 RooAbsReal.cxx:1147
 RooAbsReal.cxx:1148
 RooAbsReal.cxx:1149
 RooAbsReal.cxx:1150
 RooAbsReal.cxx:1151
 RooAbsReal.cxx:1152
 RooAbsReal.cxx:1153
 RooAbsReal.cxx:1154
 RooAbsReal.cxx:1155
 RooAbsReal.cxx:1156
 RooAbsReal.cxx:1157
 RooAbsReal.cxx:1158
 RooAbsReal.cxx:1159
 RooAbsReal.cxx:1160
 RooAbsReal.cxx:1161
 RooAbsReal.cxx:1162
 RooAbsReal.cxx:1163
 RooAbsReal.cxx:1164
 RooAbsReal.cxx:1165
 RooAbsReal.cxx:1166
 RooAbsReal.cxx:1167
 RooAbsReal.cxx:1168
 RooAbsReal.cxx:1169
 RooAbsReal.cxx:1170
 RooAbsReal.cxx:1171
 RooAbsReal.cxx:1172
 RooAbsReal.cxx:1173
 RooAbsReal.cxx:1174
 RooAbsReal.cxx:1175
 RooAbsReal.cxx:1176
 RooAbsReal.cxx:1177
 RooAbsReal.cxx:1178
 RooAbsReal.cxx:1179
 RooAbsReal.cxx:1180
 RooAbsReal.cxx:1181
 RooAbsReal.cxx:1182
 RooAbsReal.cxx:1183
 RooAbsReal.cxx:1184
 RooAbsReal.cxx:1185
 RooAbsReal.cxx:1186
 RooAbsReal.cxx:1187
 RooAbsReal.cxx:1188
 RooAbsReal.cxx:1189
 RooAbsReal.cxx:1190
 RooAbsReal.cxx:1191
 RooAbsReal.cxx:1192
 RooAbsReal.cxx:1193
 RooAbsReal.cxx:1194
 RooAbsReal.cxx:1195
 RooAbsReal.cxx:1196
 RooAbsReal.cxx:1197
 RooAbsReal.cxx:1198
 RooAbsReal.cxx:1199
 RooAbsReal.cxx:1200
 RooAbsReal.cxx:1201
 RooAbsReal.cxx:1202
 RooAbsReal.cxx:1203
 RooAbsReal.cxx:1204
 RooAbsReal.cxx:1205
 RooAbsReal.cxx:1206
 RooAbsReal.cxx:1207
 RooAbsReal.cxx:1208
 RooAbsReal.cxx:1209
 RooAbsReal.cxx:1210
 RooAbsReal.cxx:1211
 RooAbsReal.cxx:1212
 RooAbsReal.cxx:1213
 RooAbsReal.cxx:1214
 RooAbsReal.cxx:1215
 RooAbsReal.cxx:1216
 RooAbsReal.cxx:1217
 RooAbsReal.cxx:1218
 RooAbsReal.cxx:1219
 RooAbsReal.cxx:1220
 RooAbsReal.cxx:1221
 RooAbsReal.cxx:1222
 RooAbsReal.cxx:1223
 RooAbsReal.cxx:1224
 RooAbsReal.cxx:1225
 RooAbsReal.cxx:1226
 RooAbsReal.cxx:1227
 RooAbsReal.cxx:1228
 RooAbsReal.cxx:1229
 RooAbsReal.cxx:1230
 RooAbsReal.cxx:1231
 RooAbsReal.cxx:1232
 RooAbsReal.cxx:1233
 RooAbsReal.cxx:1234
 RooAbsReal.cxx:1235
 RooAbsReal.cxx:1236
 RooAbsReal.cxx:1237
 RooAbsReal.cxx:1238
 RooAbsReal.cxx:1239
 RooAbsReal.cxx:1240
 RooAbsReal.cxx:1241
 RooAbsReal.cxx:1242
 RooAbsReal.cxx:1243
 RooAbsReal.cxx:1244
 RooAbsReal.cxx:1245
 RooAbsReal.cxx:1246
 RooAbsReal.cxx:1247
 RooAbsReal.cxx:1248
 RooAbsReal.cxx:1249
 RooAbsReal.cxx:1250
 RooAbsReal.cxx:1251
 RooAbsReal.cxx:1252
 RooAbsReal.cxx:1253
 RooAbsReal.cxx:1254
 RooAbsReal.cxx:1255
 RooAbsReal.cxx:1256
 RooAbsReal.cxx:1257
 RooAbsReal.cxx:1258
 RooAbsReal.cxx:1259
 RooAbsReal.cxx:1260
 RooAbsReal.cxx:1261
 RooAbsReal.cxx:1262
 RooAbsReal.cxx:1263
 RooAbsReal.cxx:1264
 RooAbsReal.cxx:1265
 RooAbsReal.cxx:1266
 RooAbsReal.cxx:1267
 RooAbsReal.cxx:1268
 RooAbsReal.cxx:1269
 RooAbsReal.cxx:1270
 RooAbsReal.cxx:1271
 RooAbsReal.cxx:1272
 RooAbsReal.cxx:1273
 RooAbsReal.cxx:1274
 RooAbsReal.cxx:1275
 RooAbsReal.cxx:1276
 RooAbsReal.cxx:1277
 RooAbsReal.cxx:1278
 RooAbsReal.cxx:1279
 RooAbsReal.cxx:1280
 RooAbsReal.cxx:1281
 RooAbsReal.cxx:1282
 RooAbsReal.cxx:1283
 RooAbsReal.cxx:1284
 RooAbsReal.cxx:1285
 RooAbsReal.cxx:1286
 RooAbsReal.cxx:1287
 RooAbsReal.cxx:1288
 RooAbsReal.cxx:1289
 RooAbsReal.cxx:1290
 RooAbsReal.cxx:1291
 RooAbsReal.cxx:1292
 RooAbsReal.cxx:1293
 RooAbsReal.cxx:1294
 RooAbsReal.cxx:1295
 RooAbsReal.cxx:1296
 RooAbsReal.cxx:1297
 RooAbsReal.cxx:1298
 RooAbsReal.cxx:1299
 RooAbsReal.cxx:1300
 RooAbsReal.cxx:1301
 RooAbsReal.cxx:1302
 RooAbsReal.cxx:1303
 RooAbsReal.cxx:1304
 RooAbsReal.cxx:1305
 RooAbsReal.cxx:1306
 RooAbsReal.cxx:1307
 RooAbsReal.cxx:1308
 RooAbsReal.cxx:1309
 RooAbsReal.cxx:1310
 RooAbsReal.cxx:1311
 RooAbsReal.cxx:1312
 RooAbsReal.cxx:1313
 RooAbsReal.cxx:1314
 RooAbsReal.cxx:1315
 RooAbsReal.cxx:1316
 RooAbsReal.cxx:1317
 RooAbsReal.cxx:1318
 RooAbsReal.cxx:1319
 RooAbsReal.cxx:1320
 RooAbsReal.cxx:1321
 RooAbsReal.cxx:1322
 RooAbsReal.cxx:1323
 RooAbsReal.cxx:1324
 RooAbsReal.cxx:1325
 RooAbsReal.cxx:1326
 RooAbsReal.cxx:1327
 RooAbsReal.cxx:1328
 RooAbsReal.cxx:1329
 RooAbsReal.cxx:1330
 RooAbsReal.cxx:1331
 RooAbsReal.cxx:1332
 RooAbsReal.cxx:1333
 RooAbsReal.cxx:1334
 RooAbsReal.cxx:1335
 RooAbsReal.cxx:1336
 RooAbsReal.cxx:1337
 RooAbsReal.cxx:1338
 RooAbsReal.cxx:1339
 RooAbsReal.cxx:1340
 RooAbsReal.cxx:1341
 RooAbsReal.cxx:1342
 RooAbsReal.cxx:1343
 RooAbsReal.cxx:1344
 RooAbsReal.cxx:1345
 RooAbsReal.cxx:1346
 RooAbsReal.cxx:1347
 RooAbsReal.cxx:1348
 RooAbsReal.cxx:1349
 RooAbsReal.cxx:1350
 RooAbsReal.cxx:1351
 RooAbsReal.cxx:1352
 RooAbsReal.cxx:1353
 RooAbsReal.cxx:1354
 RooAbsReal.cxx:1355
 RooAbsReal.cxx:1356
 RooAbsReal.cxx:1357
 RooAbsReal.cxx:1358
 RooAbsReal.cxx:1359
 RooAbsReal.cxx:1360
 RooAbsReal.cxx:1361
 RooAbsReal.cxx:1362
 RooAbsReal.cxx:1363
 RooAbsReal.cxx:1364
 RooAbsReal.cxx:1365
 RooAbsReal.cxx:1366
 RooAbsReal.cxx:1367
 RooAbsReal.cxx:1368
 RooAbsReal.cxx:1369
 RooAbsReal.cxx:1370
 RooAbsReal.cxx:1371
 RooAbsReal.cxx:1372
 RooAbsReal.cxx:1373
 RooAbsReal.cxx:1374
 RooAbsReal.cxx:1375
 RooAbsReal.cxx:1376
 RooAbsReal.cxx:1377
 RooAbsReal.cxx:1378
 RooAbsReal.cxx:1379
 RooAbsReal.cxx:1380
 RooAbsReal.cxx:1381
 RooAbsReal.cxx:1382
 RooAbsReal.cxx:1383
 RooAbsReal.cxx:1384
 RooAbsReal.cxx:1385
 RooAbsReal.cxx:1386
 RooAbsReal.cxx:1387
 RooAbsReal.cxx:1388
 RooAbsReal.cxx:1389
 RooAbsReal.cxx:1390
 RooAbsReal.cxx:1391
 RooAbsReal.cxx:1392
 RooAbsReal.cxx:1393
 RooAbsReal.cxx:1394
 RooAbsReal.cxx:1395
 RooAbsReal.cxx:1396
 RooAbsReal.cxx:1397
 RooAbsReal.cxx:1398
 RooAbsReal.cxx:1399
 RooAbsReal.cxx:1400
 RooAbsReal.cxx:1401
 RooAbsReal.cxx:1402
 RooAbsReal.cxx:1403
 RooAbsReal.cxx:1404
 RooAbsReal.cxx:1405
 RooAbsReal.cxx:1406
 RooAbsReal.cxx:1407
 RooAbsReal.cxx:1408
 RooAbsReal.cxx:1409
 RooAbsReal.cxx:1410
 RooAbsReal.cxx:1411
 RooAbsReal.cxx:1412
 RooAbsReal.cxx:1413
 RooAbsReal.cxx:1414
 RooAbsReal.cxx:1415
 RooAbsReal.cxx:1416
 RooAbsReal.cxx:1417
 RooAbsReal.cxx:1418
 RooAbsReal.cxx:1419
 RooAbsReal.cxx:1420
 RooAbsReal.cxx:1421
 RooAbsReal.cxx:1422
 RooAbsReal.cxx:1423
 RooAbsReal.cxx:1424
 RooAbsReal.cxx:1425
 RooAbsReal.cxx:1426
 RooAbsReal.cxx:1427
 RooAbsReal.cxx:1428
 RooAbsReal.cxx:1429
 RooAbsReal.cxx:1430
 RooAbsReal.cxx:1431
 RooAbsReal.cxx:1432
 RooAbsReal.cxx:1433
 RooAbsReal.cxx:1434
 RooAbsReal.cxx:1435
 RooAbsReal.cxx:1436
 RooAbsReal.cxx:1437
 RooAbsReal.cxx:1438
 RooAbsReal.cxx:1439
 RooAbsReal.cxx:1440
 RooAbsReal.cxx:1441
 RooAbsReal.cxx:1442
 RooAbsReal.cxx:1443
 RooAbsReal.cxx:1444
 RooAbsReal.cxx:1445
 RooAbsReal.cxx:1446
 RooAbsReal.cxx:1447
 RooAbsReal.cxx:1448
 RooAbsReal.cxx:1449
 RooAbsReal.cxx:1450
 RooAbsReal.cxx:1451
 RooAbsReal.cxx:1452
 RooAbsReal.cxx:1453
 RooAbsReal.cxx:1454
 RooAbsReal.cxx:1455
 RooAbsReal.cxx:1456
 RooAbsReal.cxx:1457
 RooAbsReal.cxx:1458
 RooAbsReal.cxx:1459
 RooAbsReal.cxx:1460
 RooAbsReal.cxx:1461
 RooAbsReal.cxx:1462
 RooAbsReal.cxx:1463
 RooAbsReal.cxx:1464
 RooAbsReal.cxx:1465
 RooAbsReal.cxx:1466
 RooAbsReal.cxx:1467
 RooAbsReal.cxx:1468
 RooAbsReal.cxx:1469
 RooAbsReal.cxx:1470
 RooAbsReal.cxx:1471
 RooAbsReal.cxx:1472
 RooAbsReal.cxx:1473
 RooAbsReal.cxx:1474
 RooAbsReal.cxx:1475
 RooAbsReal.cxx:1476
 RooAbsReal.cxx:1477
 RooAbsReal.cxx:1478
 RooAbsReal.cxx:1479
 RooAbsReal.cxx:1480
 RooAbsReal.cxx:1481
 RooAbsReal.cxx:1482
 RooAbsReal.cxx:1483
 RooAbsReal.cxx:1484
 RooAbsReal.cxx:1485
 RooAbsReal.cxx:1486
 RooAbsReal.cxx:1487
 RooAbsReal.cxx:1488
 RooAbsReal.cxx:1489
 RooAbsReal.cxx:1490
 RooAbsReal.cxx:1491
 RooAbsReal.cxx:1492
 RooAbsReal.cxx:1493
 RooAbsReal.cxx:1494
 RooAbsReal.cxx:1495
 RooAbsReal.cxx:1496
 RooAbsReal.cxx:1497
 RooAbsReal.cxx:1498
 RooAbsReal.cxx:1499
 RooAbsReal.cxx:1500
 RooAbsReal.cxx:1501
 RooAbsReal.cxx:1502
 RooAbsReal.cxx:1503
 RooAbsReal.cxx:1504
 RooAbsReal.cxx:1505
 RooAbsReal.cxx:1506
 RooAbsReal.cxx:1507
 RooAbsReal.cxx:1508
 RooAbsReal.cxx:1509
 RooAbsReal.cxx:1510
 RooAbsReal.cxx:1511
 RooAbsReal.cxx:1512
 RooAbsReal.cxx:1513
 RooAbsReal.cxx:1514
 RooAbsReal.cxx:1515
 RooAbsReal.cxx:1516
 RooAbsReal.cxx:1517
 RooAbsReal.cxx:1518
 RooAbsReal.cxx:1519
 RooAbsReal.cxx:1520
 RooAbsReal.cxx:1521
 RooAbsReal.cxx:1522
 RooAbsReal.cxx:1523
 RooAbsReal.cxx:1524
 RooAbsReal.cxx:1525
 RooAbsReal.cxx:1526
 RooAbsReal.cxx:1527
 RooAbsReal.cxx:1528
 RooAbsReal.cxx:1529
 RooAbsReal.cxx:1530
 RooAbsReal.cxx:1531
 RooAbsReal.cxx:1532
 RooAbsReal.cxx:1533
 RooAbsReal.cxx:1534
 RooAbsReal.cxx:1535
 RooAbsReal.cxx:1536
 RooAbsReal.cxx:1537
 RooAbsReal.cxx:1538
 RooAbsReal.cxx:1539
 RooAbsReal.cxx:1540
 RooAbsReal.cxx:1541
 RooAbsReal.cxx:1542
 RooAbsReal.cxx:1543
 RooAbsReal.cxx:1544
 RooAbsReal.cxx:1545
 RooAbsReal.cxx:1546
 RooAbsReal.cxx:1547
 RooAbsReal.cxx:1548
 RooAbsReal.cxx:1549
 RooAbsReal.cxx:1550
 RooAbsReal.cxx:1551
 RooAbsReal.cxx:1552
 RooAbsReal.cxx:1553
 RooAbsReal.cxx:1554
 RooAbsReal.cxx:1555
 RooAbsReal.cxx:1556
 RooAbsReal.cxx:1557
 RooAbsReal.cxx:1558
 RooAbsReal.cxx:1559
 RooAbsReal.cxx:1560
 RooAbsReal.cxx:1561
 RooAbsReal.cxx:1562
 RooAbsReal.cxx:1563
 RooAbsReal.cxx:1564
 RooAbsReal.cxx:1565
 RooAbsReal.cxx:1566
 RooAbsReal.cxx:1567
 RooAbsReal.cxx:1568
 RooAbsReal.cxx:1569
 RooAbsReal.cxx:1570
 RooAbsReal.cxx:1571
 RooAbsReal.cxx:1572
 RooAbsReal.cxx:1573
 RooAbsReal.cxx:1574
 RooAbsReal.cxx:1575
 RooAbsReal.cxx:1576
 RooAbsReal.cxx:1577
 RooAbsReal.cxx:1578
 RooAbsReal.cxx:1579
 RooAbsReal.cxx:1580
 RooAbsReal.cxx:1581
 RooAbsReal.cxx:1582
 RooAbsReal.cxx:1583
 RooAbsReal.cxx:1584
 RooAbsReal.cxx:1585
 RooAbsReal.cxx:1586
 RooAbsReal.cxx:1587
 RooAbsReal.cxx:1588
 RooAbsReal.cxx:1589
 RooAbsReal.cxx:1590
 RooAbsReal.cxx:1591
 RooAbsReal.cxx:1592
 RooAbsReal.cxx:1593
 RooAbsReal.cxx:1594
 RooAbsReal.cxx:1595
 RooAbsReal.cxx:1596
 RooAbsReal.cxx:1597
 RooAbsReal.cxx:1598
 RooAbsReal.cxx:1599
 RooAbsReal.cxx:1600
 RooAbsReal.cxx:1601
 RooAbsReal.cxx:1602
 RooAbsReal.cxx:1603
 RooAbsReal.cxx:1604
 RooAbsReal.cxx:1605
 RooAbsReal.cxx:1606
 RooAbsReal.cxx:1607
 RooAbsReal.cxx:1608
 RooAbsReal.cxx:1609
 RooAbsReal.cxx:1610
 RooAbsReal.cxx:1611
 RooAbsReal.cxx:1612
 RooAbsReal.cxx:1613
 RooAbsReal.cxx:1614
 RooAbsReal.cxx:1615
 RooAbsReal.cxx:1616
 RooAbsReal.cxx:1617
 RooAbsReal.cxx:1618
 RooAbsReal.cxx:1619
 RooAbsReal.cxx:1620
 RooAbsReal.cxx:1621
 RooAbsReal.cxx:1622
 RooAbsReal.cxx:1623
 RooAbsReal.cxx:1624
 RooAbsReal.cxx:1625
 RooAbsReal.cxx:1626
 RooAbsReal.cxx:1627
 RooAbsReal.cxx:1628
 RooAbsReal.cxx:1629
 RooAbsReal.cxx:1630
 RooAbsReal.cxx:1631
 RooAbsReal.cxx:1632
 RooAbsReal.cxx:1633
 RooAbsReal.cxx:1634
 RooAbsReal.cxx:1635
 RooAbsReal.cxx:1636
 RooAbsReal.cxx:1637
 RooAbsReal.cxx:1638
 RooAbsReal.cxx:1639
 RooAbsReal.cxx:1640
 RooAbsReal.cxx:1641
 RooAbsReal.cxx:1642
 RooAbsReal.cxx:1643
 RooAbsReal.cxx:1644
 RooAbsReal.cxx:1645
 RooAbsReal.cxx:1646
 RooAbsReal.cxx:1647
 RooAbsReal.cxx:1648
 RooAbsReal.cxx:1649
 RooAbsReal.cxx:1650
 RooAbsReal.cxx:1651
 RooAbsReal.cxx:1652
 RooAbsReal.cxx:1653
 RooAbsReal.cxx:1654
 RooAbsReal.cxx:1655
 RooAbsReal.cxx:1656
 RooAbsReal.cxx:1657
 RooAbsReal.cxx:1658
 RooAbsReal.cxx:1659
 RooAbsReal.cxx:1660
 RooAbsReal.cxx:1661
 RooAbsReal.cxx:1662
 RooAbsReal.cxx:1663
 RooAbsReal.cxx:1664
 RooAbsReal.cxx:1665
 RooAbsReal.cxx:1666
 RooAbsReal.cxx:1667
 RooAbsReal.cxx:1668
 RooAbsReal.cxx:1669
 RooAbsReal.cxx:1670
 RooAbsReal.cxx:1671
 RooAbsReal.cxx:1672
 RooAbsReal.cxx:1673
 RooAbsReal.cxx:1674
 RooAbsReal.cxx:1675
 RooAbsReal.cxx:1676
 RooAbsReal.cxx:1677
 RooAbsReal.cxx:1678
 RooAbsReal.cxx:1679
 RooAbsReal.cxx:1680
 RooAbsReal.cxx:1681
 RooAbsReal.cxx:1682
 RooAbsReal.cxx:1683
 RooAbsReal.cxx:1684
 RooAbsReal.cxx:1685
 RooAbsReal.cxx:1686
 RooAbsReal.cxx:1687
 RooAbsReal.cxx:1688
 RooAbsReal.cxx:1689
 RooAbsReal.cxx:1690
 RooAbsReal.cxx:1691
 RooAbsReal.cxx:1692
 RooAbsReal.cxx:1693
 RooAbsReal.cxx:1694
 RooAbsReal.cxx:1695
 RooAbsReal.cxx:1696
 RooAbsReal.cxx:1697
 RooAbsReal.cxx:1698
 RooAbsReal.cxx:1699
 RooAbsReal.cxx:1700
 RooAbsReal.cxx:1701
 RooAbsReal.cxx:1702
 RooAbsReal.cxx:1703
 RooAbsReal.cxx:1704
 RooAbsReal.cxx:1705
 RooAbsReal.cxx:1706
 RooAbsReal.cxx:1707
 RooAbsReal.cxx:1708
 RooAbsReal.cxx:1709
 RooAbsReal.cxx:1710
 RooAbsReal.cxx:1711
 RooAbsReal.cxx:1712
 RooAbsReal.cxx:1713
 RooAbsReal.cxx:1714
 RooAbsReal.cxx:1715
 RooAbsReal.cxx:1716
 RooAbsReal.cxx:1717
 RooAbsReal.cxx:1718
 RooAbsReal.cxx:1719
 RooAbsReal.cxx:1720
 RooAbsReal.cxx:1721
 RooAbsReal.cxx:1722
 RooAbsReal.cxx:1723
 RooAbsReal.cxx:1724
 RooAbsReal.cxx:1725
 RooAbsReal.cxx:1726
 RooAbsReal.cxx:1727
 RooAbsReal.cxx:1728
 RooAbsReal.cxx:1729
 RooAbsReal.cxx:1730
 RooAbsReal.cxx:1731
 RooAbsReal.cxx:1732
 RooAbsReal.cxx:1733
 RooAbsReal.cxx:1734
 RooAbsReal.cxx:1735
 RooAbsReal.cxx:1736
 RooAbsReal.cxx:1737
 RooAbsReal.cxx:1738
 RooAbsReal.cxx:1739
 RooAbsReal.cxx:1740
 RooAbsReal.cxx:1741
 RooAbsReal.cxx:1742
 RooAbsReal.cxx:1743
 RooAbsReal.cxx:1744
 RooAbsReal.cxx:1745
 RooAbsReal.cxx:1746
 RooAbsReal.cxx:1747
 RooAbsReal.cxx:1748
 RooAbsReal.cxx:1749
 RooAbsReal.cxx:1750
 RooAbsReal.cxx:1751
 RooAbsReal.cxx:1752
 RooAbsReal.cxx:1753
 RooAbsReal.cxx:1754
 RooAbsReal.cxx:1755
 RooAbsReal.cxx:1756
 RooAbsReal.cxx:1757
 RooAbsReal.cxx:1758
 RooAbsReal.cxx:1759
 RooAbsReal.cxx:1760
 RooAbsReal.cxx:1761
 RooAbsReal.cxx:1762
 RooAbsReal.cxx:1763
 RooAbsReal.cxx:1764
 RooAbsReal.cxx:1765
 RooAbsReal.cxx:1766
 RooAbsReal.cxx:1767
 RooAbsReal.cxx:1768
 RooAbsReal.cxx:1769
 RooAbsReal.cxx:1770
 RooAbsReal.cxx:1771
 RooAbsReal.cxx:1772
 RooAbsReal.cxx:1773
 RooAbsReal.cxx:1774
 RooAbsReal.cxx:1775
 RooAbsReal.cxx:1776
 RooAbsReal.cxx:1777
 RooAbsReal.cxx:1778
 RooAbsReal.cxx:1779
 RooAbsReal.cxx:1780
 RooAbsReal.cxx:1781
 RooAbsReal.cxx:1782
 RooAbsReal.cxx:1783
 RooAbsReal.cxx:1784
 RooAbsReal.cxx:1785
 RooAbsReal.cxx:1786
 RooAbsReal.cxx:1787
 RooAbsReal.cxx:1788
 RooAbsReal.cxx:1789
 RooAbsReal.cxx:1790
 RooAbsReal.cxx:1791
 RooAbsReal.cxx:1792
 RooAbsReal.cxx:1793
 RooAbsReal.cxx:1794
 RooAbsReal.cxx:1795
 RooAbsReal.cxx:1796
 RooAbsReal.cxx:1797
 RooAbsReal.cxx:1798
 RooAbsReal.cxx:1799
 RooAbsReal.cxx:1800
 RooAbsReal.cxx:1801
 RooAbsReal.cxx:1802
 RooAbsReal.cxx:1803
 RooAbsReal.cxx:1804
 RooAbsReal.cxx:1805
 RooAbsReal.cxx:1806
 RooAbsReal.cxx:1807
 RooAbsReal.cxx:1808
 RooAbsReal.cxx:1809
 RooAbsReal.cxx:1810
 RooAbsReal.cxx:1811
 RooAbsReal.cxx:1812
 RooAbsReal.cxx:1813
 RooAbsReal.cxx:1814
 RooAbsReal.cxx:1815
 RooAbsReal.cxx:1816
 RooAbsReal.cxx:1817
 RooAbsReal.cxx:1818
 RooAbsReal.cxx:1819
 RooAbsReal.cxx:1820
 RooAbsReal.cxx:1821
 RooAbsReal.cxx:1822
 RooAbsReal.cxx:1823
 RooAbsReal.cxx:1824
 RooAbsReal.cxx:1825
 RooAbsReal.cxx:1826
 RooAbsReal.cxx:1827
 RooAbsReal.cxx:1828
 RooAbsReal.cxx:1829
 RooAbsReal.cxx:1830
 RooAbsReal.cxx:1831
 RooAbsReal.cxx:1832
 RooAbsReal.cxx:1833
 RooAbsReal.cxx:1834
 RooAbsReal.cxx:1835
 RooAbsReal.cxx:1836
 RooAbsReal.cxx:1837
 RooAbsReal.cxx:1838
 RooAbsReal.cxx:1839
 RooAbsReal.cxx:1840
 RooAbsReal.cxx:1841
 RooAbsReal.cxx:1842
 RooAbsReal.cxx:1843
 RooAbsReal.cxx:1844
 RooAbsReal.cxx:1845
 RooAbsReal.cxx:1846
 RooAbsReal.cxx:1847
 RooAbsReal.cxx:1848
 RooAbsReal.cxx:1849
 RooAbsReal.cxx:1850
 RooAbsReal.cxx:1851
 RooAbsReal.cxx:1852
 RooAbsReal.cxx:1853
 RooAbsReal.cxx:1854
 RooAbsReal.cxx:1855
 RooAbsReal.cxx:1856
 RooAbsReal.cxx:1857
 RooAbsReal.cxx:1858
 RooAbsReal.cxx:1859
 RooAbsReal.cxx:1860
 RooAbsReal.cxx:1861
 RooAbsReal.cxx:1862
 RooAbsReal.cxx:1863
 RooAbsReal.cxx:1864
 RooAbsReal.cxx:1865
 RooAbsReal.cxx:1866
 RooAbsReal.cxx:1867
 RooAbsReal.cxx:1868
 RooAbsReal.cxx:1869
 RooAbsReal.cxx:1870
 RooAbsReal.cxx:1871
 RooAbsReal.cxx:1872
 RooAbsReal.cxx:1873
 RooAbsReal.cxx:1874
 RooAbsReal.cxx:1875
 RooAbsReal.cxx:1876
 RooAbsReal.cxx:1877
 RooAbsReal.cxx:1878
 RooAbsReal.cxx:1879
 RooAbsReal.cxx:1880
 RooAbsReal.cxx:1881
 RooAbsReal.cxx:1882
 RooAbsReal.cxx:1883
 RooAbsReal.cxx:1884
 RooAbsReal.cxx:1885
 RooAbsReal.cxx:1886
 RooAbsReal.cxx:1887
 RooAbsReal.cxx:1888
 RooAbsReal.cxx:1889
 RooAbsReal.cxx:1890
 RooAbsReal.cxx:1891
 RooAbsReal.cxx:1892
 RooAbsReal.cxx:1893
 RooAbsReal.cxx:1894
 RooAbsReal.cxx:1895
 RooAbsReal.cxx:1896
 RooAbsReal.cxx:1897
 RooAbsReal.cxx:1898
 RooAbsReal.cxx:1899
 RooAbsReal.cxx:1900
 RooAbsReal.cxx:1901
 RooAbsReal.cxx:1902
 RooAbsReal.cxx:1903
 RooAbsReal.cxx:1904
 RooAbsReal.cxx:1905
 RooAbsReal.cxx:1906
 RooAbsReal.cxx:1907
 RooAbsReal.cxx:1908
 RooAbsReal.cxx:1909
 RooAbsReal.cxx:1910
 RooAbsReal.cxx:1911
 RooAbsReal.cxx:1912
 RooAbsReal.cxx:1913
 RooAbsReal.cxx:1914
 RooAbsReal.cxx:1915
 RooAbsReal.cxx:1916
 RooAbsReal.cxx:1917
 RooAbsReal.cxx:1918
 RooAbsReal.cxx:1919
 RooAbsReal.cxx:1920
 RooAbsReal.cxx:1921
 RooAbsReal.cxx:1922
 RooAbsReal.cxx:1923
 RooAbsReal.cxx:1924
 RooAbsReal.cxx:1925
 RooAbsReal.cxx:1926
 RooAbsReal.cxx:1927
 RooAbsReal.cxx:1928
 RooAbsReal.cxx:1929
 RooAbsReal.cxx:1930
 RooAbsReal.cxx:1931
 RooAbsReal.cxx:1932
 RooAbsReal.cxx:1933
 RooAbsReal.cxx:1934
 RooAbsReal.cxx:1935
 RooAbsReal.cxx:1936
 RooAbsReal.cxx:1937
 RooAbsReal.cxx:1938
 RooAbsReal.cxx:1939
 RooAbsReal.cxx:1940
 RooAbsReal.cxx:1941
 RooAbsReal.cxx:1942
 RooAbsReal.cxx:1943
 RooAbsReal.cxx:1944
 RooAbsReal.cxx:1945
 RooAbsReal.cxx:1946
 RooAbsReal.cxx:1947
 RooAbsReal.cxx:1948
 RooAbsReal.cxx:1949
 RooAbsReal.cxx:1950
 RooAbsReal.cxx:1951
 RooAbsReal.cxx:1952
 RooAbsReal.cxx:1953
 RooAbsReal.cxx:1954
 RooAbsReal.cxx:1955
 RooAbsReal.cxx:1956
 RooAbsReal.cxx:1957
 RooAbsReal.cxx:1958
 RooAbsReal.cxx:1959
 RooAbsReal.cxx:1960
 RooAbsReal.cxx:1961
 RooAbsReal.cxx:1962
 RooAbsReal.cxx:1963
 RooAbsReal.cxx:1964
 RooAbsReal.cxx:1965
 RooAbsReal.cxx:1966
 RooAbsReal.cxx:1967
 RooAbsReal.cxx:1968
 RooAbsReal.cxx:1969
 RooAbsReal.cxx:1970
 RooAbsReal.cxx:1971
 RooAbsReal.cxx:1972
 RooAbsReal.cxx:1973
 RooAbsReal.cxx:1974
 RooAbsReal.cxx:1975
 RooAbsReal.cxx:1976
 RooAbsReal.cxx:1977
 RooAbsReal.cxx:1978
 RooAbsReal.cxx:1979
 RooAbsReal.cxx:1980
 RooAbsReal.cxx:1981
 RooAbsReal.cxx:1982
 RooAbsReal.cxx:1983
 RooAbsReal.cxx:1984
 RooAbsReal.cxx:1985
 RooAbsReal.cxx:1986
 RooAbsReal.cxx:1987
 RooAbsReal.cxx:1988
 RooAbsReal.cxx:1989
 RooAbsReal.cxx:1990
 RooAbsReal.cxx:1991
 RooAbsReal.cxx:1992
 RooAbsReal.cxx:1993
 RooAbsReal.cxx:1994
 RooAbsReal.cxx:1995
 RooAbsReal.cxx:1996
 RooAbsReal.cxx:1997
 RooAbsReal.cxx:1998
 RooAbsReal.cxx:1999
 RooAbsReal.cxx:2000
 RooAbsReal.cxx:2001
 RooAbsReal.cxx:2002
 RooAbsReal.cxx:2003
 RooAbsReal.cxx:2004
 RooAbsReal.cxx:2005
 RooAbsReal.cxx:2006
 RooAbsReal.cxx:2007
 RooAbsReal.cxx:2008
 RooAbsReal.cxx:2009
 RooAbsReal.cxx:2010
 RooAbsReal.cxx:2011
 RooAbsReal.cxx:2012
 RooAbsReal.cxx:2013
 RooAbsReal.cxx:2014
 RooAbsReal.cxx:2015
 RooAbsReal.cxx:2016
 RooAbsReal.cxx:2017
 RooAbsReal.cxx:2018
 RooAbsReal.cxx:2019
 RooAbsReal.cxx:2020
 RooAbsReal.cxx:2021
 RooAbsReal.cxx:2022
 RooAbsReal.cxx:2023
 RooAbsReal.cxx:2024
 RooAbsReal.cxx:2025
 RooAbsReal.cxx:2026
 RooAbsReal.cxx:2027
 RooAbsReal.cxx:2028
 RooAbsReal.cxx:2029
 RooAbsReal.cxx:2030
 RooAbsReal.cxx:2031
 RooAbsReal.cxx:2032
 RooAbsReal.cxx:2033
 RooAbsReal.cxx:2034
 RooAbsReal.cxx:2035
 RooAbsReal.cxx:2036
 RooAbsReal.cxx:2037
 RooAbsReal.cxx:2038
 RooAbsReal.cxx:2039
 RooAbsReal.cxx:2040
 RooAbsReal.cxx:2041
 RooAbsReal.cxx:2042
 RooAbsReal.cxx:2043
 RooAbsReal.cxx:2044
 RooAbsReal.cxx:2045
 RooAbsReal.cxx:2046
 RooAbsReal.cxx:2047
 RooAbsReal.cxx:2048
 RooAbsReal.cxx:2049
 RooAbsReal.cxx:2050
 RooAbsReal.cxx:2051
 RooAbsReal.cxx:2052
 RooAbsReal.cxx:2053
 RooAbsReal.cxx:2054
 RooAbsReal.cxx:2055
 RooAbsReal.cxx:2056
 RooAbsReal.cxx:2057
 RooAbsReal.cxx:2058
 RooAbsReal.cxx:2059
 RooAbsReal.cxx:2060
 RooAbsReal.cxx:2061
 RooAbsReal.cxx:2062
 RooAbsReal.cxx:2063
 RooAbsReal.cxx:2064
 RooAbsReal.cxx:2065
 RooAbsReal.cxx:2066
 RooAbsReal.cxx:2067
 RooAbsReal.cxx:2068
 RooAbsReal.cxx:2069
 RooAbsReal.cxx:2070
 RooAbsReal.cxx:2071
 RooAbsReal.cxx:2072
 RooAbsReal.cxx:2073
 RooAbsReal.cxx:2074
 RooAbsReal.cxx:2075
 RooAbsReal.cxx:2076
 RooAbsReal.cxx:2077
 RooAbsReal.cxx:2078
 RooAbsReal.cxx:2079
 RooAbsReal.cxx:2080
 RooAbsReal.cxx:2081
 RooAbsReal.cxx:2082
 RooAbsReal.cxx:2083
 RooAbsReal.cxx:2084
 RooAbsReal.cxx:2085
 RooAbsReal.cxx:2086
 RooAbsReal.cxx:2087
 RooAbsReal.cxx:2088
 RooAbsReal.cxx:2089
 RooAbsReal.cxx:2090
 RooAbsReal.cxx:2091
 RooAbsReal.cxx:2092
 RooAbsReal.cxx:2093
 RooAbsReal.cxx:2094
 RooAbsReal.cxx:2095
 RooAbsReal.cxx:2096
 RooAbsReal.cxx:2097
 RooAbsReal.cxx:2098
 RooAbsReal.cxx:2099
 RooAbsReal.cxx:2100
 RooAbsReal.cxx:2101
 RooAbsReal.cxx:2102
 RooAbsReal.cxx:2103
 RooAbsReal.cxx:2104
 RooAbsReal.cxx:2105
 RooAbsReal.cxx:2106
 RooAbsReal.cxx:2107
 RooAbsReal.cxx:2108
 RooAbsReal.cxx:2109
 RooAbsReal.cxx:2110
 RooAbsReal.cxx:2111
 RooAbsReal.cxx:2112
 RooAbsReal.cxx:2113
 RooAbsReal.cxx:2114
 RooAbsReal.cxx:2115
 RooAbsReal.cxx:2116
 RooAbsReal.cxx:2117
 RooAbsReal.cxx:2118
 RooAbsReal.cxx:2119
 RooAbsReal.cxx:2120
 RooAbsReal.cxx:2121
 RooAbsReal.cxx:2122
 RooAbsReal.cxx:2123
 RooAbsReal.cxx:2124
 RooAbsReal.cxx:2125
 RooAbsReal.cxx:2126
 RooAbsReal.cxx:2127
 RooAbsReal.cxx:2128
 RooAbsReal.cxx:2129
 RooAbsReal.cxx:2130
 RooAbsReal.cxx:2131
 RooAbsReal.cxx:2132
 RooAbsReal.cxx:2133
 RooAbsReal.cxx:2134
 RooAbsReal.cxx:2135
 RooAbsReal.cxx:2136
 RooAbsReal.cxx:2137
 RooAbsReal.cxx:2138
 RooAbsReal.cxx:2139
 RooAbsReal.cxx:2140
 RooAbsReal.cxx:2141
 RooAbsReal.cxx:2142
 RooAbsReal.cxx:2143
 RooAbsReal.cxx:2144
 RooAbsReal.cxx:2145
 RooAbsReal.cxx:2146
 RooAbsReal.cxx:2147
 RooAbsReal.cxx:2148
 RooAbsReal.cxx:2149
 RooAbsReal.cxx:2150
 RooAbsReal.cxx:2151
 RooAbsReal.cxx:2152
 RooAbsReal.cxx:2153
 RooAbsReal.cxx:2154
 RooAbsReal.cxx:2155
 RooAbsReal.cxx:2156
 RooAbsReal.cxx:2157
 RooAbsReal.cxx:2158
 RooAbsReal.cxx:2159
 RooAbsReal.cxx:2160
 RooAbsReal.cxx:2161
 RooAbsReal.cxx:2162
 RooAbsReal.cxx:2163
 RooAbsReal.cxx:2164
 RooAbsReal.cxx:2165
 RooAbsReal.cxx:2166
 RooAbsReal.cxx:2167
 RooAbsReal.cxx:2168
 RooAbsReal.cxx:2169
 RooAbsReal.cxx:2170
 RooAbsReal.cxx:2171
 RooAbsReal.cxx:2172
 RooAbsReal.cxx:2173
 RooAbsReal.cxx:2174
 RooAbsReal.cxx:2175
 RooAbsReal.cxx:2176
 RooAbsReal.cxx:2177
 RooAbsReal.cxx:2178
 RooAbsReal.cxx:2179
 RooAbsReal.cxx:2180
 RooAbsReal.cxx:2181
 RooAbsReal.cxx:2182
 RooAbsReal.cxx:2183
 RooAbsReal.cxx:2184
 RooAbsReal.cxx:2185
 RooAbsReal.cxx:2186
 RooAbsReal.cxx:2187
 RooAbsReal.cxx:2188
 RooAbsReal.cxx:2189
 RooAbsReal.cxx:2190
 RooAbsReal.cxx:2191
 RooAbsReal.cxx:2192
 RooAbsReal.cxx:2193
 RooAbsReal.cxx:2194
 RooAbsReal.cxx:2195
 RooAbsReal.cxx:2196
 RooAbsReal.cxx:2197
 RooAbsReal.cxx:2198
 RooAbsReal.cxx:2199
 RooAbsReal.cxx:2200
 RooAbsReal.cxx:2201
 RooAbsReal.cxx:2202
 RooAbsReal.cxx:2203
 RooAbsReal.cxx:2204
 RooAbsReal.cxx:2205
 RooAbsReal.cxx:2206
 RooAbsReal.cxx:2207
 RooAbsReal.cxx:2208
 RooAbsReal.cxx:2209
 RooAbsReal.cxx:2210
 RooAbsReal.cxx:2211
 RooAbsReal.cxx:2212
 RooAbsReal.cxx:2213
 RooAbsReal.cxx:2214
 RooAbsReal.cxx:2215
 RooAbsReal.cxx:2216
 RooAbsReal.cxx:2217
 RooAbsReal.cxx:2218
 RooAbsReal.cxx:2219
 RooAbsReal.cxx:2220
 RooAbsReal.cxx:2221
 RooAbsReal.cxx:2222
 RooAbsReal.cxx:2223
 RooAbsReal.cxx:2224
 RooAbsReal.cxx:2225
 RooAbsReal.cxx:2226
 RooAbsReal.cxx:2227
 RooAbsReal.cxx:2228
 RooAbsReal.cxx:2229
 RooAbsReal.cxx:2230
 RooAbsReal.cxx:2231
 RooAbsReal.cxx:2232
 RooAbsReal.cxx:2233
 RooAbsReal.cxx:2234
 RooAbsReal.cxx:2235
 RooAbsReal.cxx:2236
 RooAbsReal.cxx:2237
 RooAbsReal.cxx:2238
 RooAbsReal.cxx:2239
 RooAbsReal.cxx:2240
 RooAbsReal.cxx:2241
 RooAbsReal.cxx:2242
 RooAbsReal.cxx:2243
 RooAbsReal.cxx:2244
 RooAbsReal.cxx:2245
 RooAbsReal.cxx:2246
 RooAbsReal.cxx:2247
 RooAbsReal.cxx:2248
 RooAbsReal.cxx:2249
 RooAbsReal.cxx:2250
 RooAbsReal.cxx:2251
 RooAbsReal.cxx:2252
 RooAbsReal.cxx:2253
 RooAbsReal.cxx:2254
 RooAbsReal.cxx:2255
 RooAbsReal.cxx:2256
 RooAbsReal.cxx:2257
 RooAbsReal.cxx:2258
 RooAbsReal.cxx:2259
 RooAbsReal.cxx:2260
 RooAbsReal.cxx:2261
 RooAbsReal.cxx:2262
 RooAbsReal.cxx:2263
 RooAbsReal.cxx:2264
 RooAbsReal.cxx:2265
 RooAbsReal.cxx:2266
 RooAbsReal.cxx:2267
 RooAbsReal.cxx:2268
 RooAbsReal.cxx:2269
 RooAbsReal.cxx:2270
 RooAbsReal.cxx:2271
 RooAbsReal.cxx:2272
 RooAbsReal.cxx:2273
 RooAbsReal.cxx:2274
 RooAbsReal.cxx:2275
 RooAbsReal.cxx:2276
 RooAbsReal.cxx:2277
 RooAbsReal.cxx:2278
 RooAbsReal.cxx:2279
 RooAbsReal.cxx:2280
 RooAbsReal.cxx:2281
 RooAbsReal.cxx:2282
 RooAbsReal.cxx:2283
 RooAbsReal.cxx:2284
 RooAbsReal.cxx:2285
 RooAbsReal.cxx:2286
 RooAbsReal.cxx:2287
 RooAbsReal.cxx:2288
 RooAbsReal.cxx:2289
 RooAbsReal.cxx:2290
 RooAbsReal.cxx:2291
 RooAbsReal.cxx:2292
 RooAbsReal.cxx:2293
 RooAbsReal.cxx:2294
 RooAbsReal.cxx:2295
 RooAbsReal.cxx:2296
 RooAbsReal.cxx:2297
 RooAbsReal.cxx:2298
 RooAbsReal.cxx:2299
 RooAbsReal.cxx:2300
 RooAbsReal.cxx:2301
 RooAbsReal.cxx:2302
 RooAbsReal.cxx:2303
 RooAbsReal.cxx:2304
 RooAbsReal.cxx:2305
 RooAbsReal.cxx:2306
 RooAbsReal.cxx:2307
 RooAbsReal.cxx:2308
 RooAbsReal.cxx:2309
 RooAbsReal.cxx:2310
 RooAbsReal.cxx:2311
 RooAbsReal.cxx:2312
 RooAbsReal.cxx:2313
 RooAbsReal.cxx:2314
 RooAbsReal.cxx:2315
 RooAbsReal.cxx:2316
 RooAbsReal.cxx:2317
 RooAbsReal.cxx:2318
 RooAbsReal.cxx:2319
 RooAbsReal.cxx:2320
 RooAbsReal.cxx:2321
 RooAbsReal.cxx:2322
 RooAbsReal.cxx:2323
 RooAbsReal.cxx:2324
 RooAbsReal.cxx:2325
 RooAbsReal.cxx:2326
 RooAbsReal.cxx:2327
 RooAbsReal.cxx:2328
 RooAbsReal.cxx:2329
 RooAbsReal.cxx:2330
 RooAbsReal.cxx:2331
 RooAbsReal.cxx:2332
 RooAbsReal.cxx:2333
 RooAbsReal.cxx:2334
 RooAbsReal.cxx:2335
 RooAbsReal.cxx:2336
 RooAbsReal.cxx:2337
 RooAbsReal.cxx:2338
 RooAbsReal.cxx:2339
 RooAbsReal.cxx:2340
 RooAbsReal.cxx:2341
 RooAbsReal.cxx:2342
 RooAbsReal.cxx:2343
 RooAbsReal.cxx:2344
 RooAbsReal.cxx:2345
 RooAbsReal.cxx:2346
 RooAbsReal.cxx:2347
 RooAbsReal.cxx:2348
 RooAbsReal.cxx:2349
 RooAbsReal.cxx:2350
 RooAbsReal.cxx:2351
 RooAbsReal.cxx:2352
 RooAbsReal.cxx:2353
 RooAbsReal.cxx:2354
 RooAbsReal.cxx:2355
 RooAbsReal.cxx:2356
 RooAbsReal.cxx:2357
 RooAbsReal.cxx:2358
 RooAbsReal.cxx:2359
 RooAbsReal.cxx:2360
 RooAbsReal.cxx:2361
 RooAbsReal.cxx:2362
 RooAbsReal.cxx:2363
 RooAbsReal.cxx:2364
 RooAbsReal.cxx:2365
 RooAbsReal.cxx:2366
 RooAbsReal.cxx:2367
 RooAbsReal.cxx:2368
 RooAbsReal.cxx:2369
 RooAbsReal.cxx:2370
 RooAbsReal.cxx:2371
 RooAbsReal.cxx:2372
 RooAbsReal.cxx:2373
 RooAbsReal.cxx:2374
 RooAbsReal.cxx:2375
 RooAbsReal.cxx:2376
 RooAbsReal.cxx:2377
 RooAbsReal.cxx:2378
 RooAbsReal.cxx:2379
 RooAbsReal.cxx:2380
 RooAbsReal.cxx:2381
 RooAbsReal.cxx:2382
 RooAbsReal.cxx:2383
 RooAbsReal.cxx:2384
 RooAbsReal.cxx:2385
 RooAbsReal.cxx:2386
 RooAbsReal.cxx:2387
 RooAbsReal.cxx:2388
 RooAbsReal.cxx:2389
 RooAbsReal.cxx:2390
 RooAbsReal.cxx:2391
 RooAbsReal.cxx:2392
 RooAbsReal.cxx:2393
 RooAbsReal.cxx:2394
 RooAbsReal.cxx:2395
 RooAbsReal.cxx:2396
 RooAbsReal.cxx:2397
 RooAbsReal.cxx:2398
 RooAbsReal.cxx:2399
 RooAbsReal.cxx:2400
 RooAbsReal.cxx:2401
 RooAbsReal.cxx:2402
 RooAbsReal.cxx:2403
 RooAbsReal.cxx:2404
 RooAbsReal.cxx:2405
 RooAbsReal.cxx:2406
 RooAbsReal.cxx:2407
 RooAbsReal.cxx:2408
 RooAbsReal.cxx:2409
 RooAbsReal.cxx:2410
 RooAbsReal.cxx:2411
 RooAbsReal.cxx:2412
 RooAbsReal.cxx:2413
 RooAbsReal.cxx:2414
 RooAbsReal.cxx:2415
 RooAbsReal.cxx:2416
 RooAbsReal.cxx:2417
 RooAbsReal.cxx:2418
 RooAbsReal.cxx:2419
 RooAbsReal.cxx:2420
 RooAbsReal.cxx:2421
 RooAbsReal.cxx:2422
 RooAbsReal.cxx:2423
 RooAbsReal.cxx:2424
 RooAbsReal.cxx:2425
 RooAbsReal.cxx:2426
 RooAbsReal.cxx:2427
 RooAbsReal.cxx:2428
 RooAbsReal.cxx:2429
 RooAbsReal.cxx:2430
 RooAbsReal.cxx:2431
 RooAbsReal.cxx:2432
 RooAbsReal.cxx:2433
 RooAbsReal.cxx:2434
 RooAbsReal.cxx:2435
 RooAbsReal.cxx:2436
 RooAbsReal.cxx:2437
 RooAbsReal.cxx:2438
 RooAbsReal.cxx:2439
 RooAbsReal.cxx:2440
 RooAbsReal.cxx:2441
 RooAbsReal.cxx:2442
 RooAbsReal.cxx:2443
 RooAbsReal.cxx:2444
 RooAbsReal.cxx:2445
 RooAbsReal.cxx:2446
 RooAbsReal.cxx:2447
 RooAbsReal.cxx:2448
 RooAbsReal.cxx:2449
 RooAbsReal.cxx:2450
 RooAbsReal.cxx:2451
 RooAbsReal.cxx:2452
 RooAbsReal.cxx:2453
 RooAbsReal.cxx:2454
 RooAbsReal.cxx:2455
 RooAbsReal.cxx:2456
 RooAbsReal.cxx:2457
 RooAbsReal.cxx:2458
 RooAbsReal.cxx:2459
 RooAbsReal.cxx:2460
 RooAbsReal.cxx:2461
 RooAbsReal.cxx:2462
 RooAbsReal.cxx:2463
 RooAbsReal.cxx:2464
 RooAbsReal.cxx:2465
 RooAbsReal.cxx:2466
 RooAbsReal.cxx:2467
 RooAbsReal.cxx:2468
 RooAbsReal.cxx:2469
 RooAbsReal.cxx:2470
 RooAbsReal.cxx:2471
 RooAbsReal.cxx:2472
 RooAbsReal.cxx:2473
 RooAbsReal.cxx:2474
 RooAbsReal.cxx:2475
 RooAbsReal.cxx:2476
 RooAbsReal.cxx:2477
 RooAbsReal.cxx:2478
 RooAbsReal.cxx:2479
 RooAbsReal.cxx:2480
 RooAbsReal.cxx:2481
 RooAbsReal.cxx:2482
 RooAbsReal.cxx:2483
 RooAbsReal.cxx:2484
 RooAbsReal.cxx:2485
 RooAbsReal.cxx:2486
 RooAbsReal.cxx:2487
 RooAbsReal.cxx:2488
 RooAbsReal.cxx:2489
 RooAbsReal.cxx:2490
 RooAbsReal.cxx:2491
 RooAbsReal.cxx:2492
 RooAbsReal.cxx:2493
 RooAbsReal.cxx:2494
 RooAbsReal.cxx:2495
 RooAbsReal.cxx:2496
 RooAbsReal.cxx:2497
 RooAbsReal.cxx:2498
 RooAbsReal.cxx:2499
 RooAbsReal.cxx:2500
 RooAbsReal.cxx:2501
 RooAbsReal.cxx:2502
 RooAbsReal.cxx:2503
 RooAbsReal.cxx:2504
 RooAbsReal.cxx:2505
 RooAbsReal.cxx:2506
 RooAbsReal.cxx:2507
 RooAbsReal.cxx:2508
 RooAbsReal.cxx:2509
 RooAbsReal.cxx:2510
 RooAbsReal.cxx:2511
 RooAbsReal.cxx:2512
 RooAbsReal.cxx:2513
 RooAbsReal.cxx:2514
 RooAbsReal.cxx:2515
 RooAbsReal.cxx:2516
 RooAbsReal.cxx:2517
 RooAbsReal.cxx:2518
 RooAbsReal.cxx:2519
 RooAbsReal.cxx:2520
 RooAbsReal.cxx:2521
 RooAbsReal.cxx:2522
 RooAbsReal.cxx:2523
 RooAbsReal.cxx:2524
 RooAbsReal.cxx:2525
 RooAbsReal.cxx:2526
 RooAbsReal.cxx:2527
 RooAbsReal.cxx:2528
 RooAbsReal.cxx:2529
 RooAbsReal.cxx:2530
 RooAbsReal.cxx:2531
 RooAbsReal.cxx:2532
 RooAbsReal.cxx:2533
 RooAbsReal.cxx:2534
 RooAbsReal.cxx:2535
 RooAbsReal.cxx:2536
 RooAbsReal.cxx:2537
 RooAbsReal.cxx:2538
 RooAbsReal.cxx:2539
 RooAbsReal.cxx:2540
 RooAbsReal.cxx:2541
 RooAbsReal.cxx:2542
 RooAbsReal.cxx:2543
 RooAbsReal.cxx:2544
 RooAbsReal.cxx:2545
 RooAbsReal.cxx:2546
 RooAbsReal.cxx:2547
 RooAbsReal.cxx:2548
 RooAbsReal.cxx:2549
 RooAbsReal.cxx:2550
 RooAbsReal.cxx:2551
 RooAbsReal.cxx:2552
 RooAbsReal.cxx:2553
 RooAbsReal.cxx:2554
 RooAbsReal.cxx:2555
 RooAbsReal.cxx:2556
 RooAbsReal.cxx:2557
 RooAbsReal.cxx:2558
 RooAbsReal.cxx:2559
 RooAbsReal.cxx:2560
 RooAbsReal.cxx:2561
 RooAbsReal.cxx:2562
 RooAbsReal.cxx:2563
 RooAbsReal.cxx:2564
 RooAbsReal.cxx:2565
 RooAbsReal.cxx:2566
 RooAbsReal.cxx:2567
 RooAbsReal.cxx:2568
 RooAbsReal.cxx:2569
 RooAbsReal.cxx:2570
 RooAbsReal.cxx:2571
 RooAbsReal.cxx:2572
 RooAbsReal.cxx:2573
 RooAbsReal.cxx:2574
 RooAbsReal.cxx:2575
 RooAbsReal.cxx:2576
 RooAbsReal.cxx:2577
 RooAbsReal.cxx:2578
 RooAbsReal.cxx:2579
 RooAbsReal.cxx:2580
 RooAbsReal.cxx:2581
 RooAbsReal.cxx:2582
 RooAbsReal.cxx:2583
 RooAbsReal.cxx:2584
 RooAbsReal.cxx:2585
 RooAbsReal.cxx:2586
 RooAbsReal.cxx:2587
 RooAbsReal.cxx:2588
 RooAbsReal.cxx:2589
 RooAbsReal.cxx:2590
 RooAbsReal.cxx:2591
 RooAbsReal.cxx:2592
 RooAbsReal.cxx:2593
 RooAbsReal.cxx:2594
 RooAbsReal.cxx:2595
 RooAbsReal.cxx:2596
 RooAbsReal.cxx:2597
 RooAbsReal.cxx:2598
 RooAbsReal.cxx:2599
 RooAbsReal.cxx:2600
 RooAbsReal.cxx:2601
 RooAbsReal.cxx:2602
 RooAbsReal.cxx:2603
 RooAbsReal.cxx:2604
 RooAbsReal.cxx:2605
 RooAbsReal.cxx:2606
 RooAbsReal.cxx:2607
 RooAbsReal.cxx:2608
 RooAbsReal.cxx:2609
 RooAbsReal.cxx:2610
 RooAbsReal.cxx:2611
 RooAbsReal.cxx:2612
 RooAbsReal.cxx:2613
 RooAbsReal.cxx:2614
 RooAbsReal.cxx:2615
 RooAbsReal.cxx:2616
 RooAbsReal.cxx:2617
 RooAbsReal.cxx:2618
 RooAbsReal.cxx:2619
 RooAbsReal.cxx:2620
 RooAbsReal.cxx:2621
 RooAbsReal.cxx:2622
 RooAbsReal.cxx:2623
 RooAbsReal.cxx:2624
 RooAbsReal.cxx:2625
 RooAbsReal.cxx:2626
 RooAbsReal.cxx:2627
 RooAbsReal.cxx:2628
 RooAbsReal.cxx:2629
 RooAbsReal.cxx:2630
 RooAbsReal.cxx:2631
 RooAbsReal.cxx:2632
 RooAbsReal.cxx:2633
 RooAbsReal.cxx:2634
 RooAbsReal.cxx:2635
 RooAbsReal.cxx:2636
 RooAbsReal.cxx:2637
 RooAbsReal.cxx:2638
 RooAbsReal.cxx:2639
 RooAbsReal.cxx:2640
 RooAbsReal.cxx:2641
 RooAbsReal.cxx:2642
 RooAbsReal.cxx:2643
 RooAbsReal.cxx:2644
 RooAbsReal.cxx:2645
 RooAbsReal.cxx:2646
 RooAbsReal.cxx:2647
 RooAbsReal.cxx:2648
 RooAbsReal.cxx:2649
 RooAbsReal.cxx:2650
 RooAbsReal.cxx:2651
 RooAbsReal.cxx:2652
 RooAbsReal.cxx:2653
 RooAbsReal.cxx:2654
 RooAbsReal.cxx:2655
 RooAbsReal.cxx:2656
 RooAbsReal.cxx:2657
 RooAbsReal.cxx:2658
 RooAbsReal.cxx:2659
 RooAbsReal.cxx:2660
 RooAbsReal.cxx:2661
 RooAbsReal.cxx:2662
 RooAbsReal.cxx:2663
 RooAbsReal.cxx:2664
 RooAbsReal.cxx:2665
 RooAbsReal.cxx:2666
 RooAbsReal.cxx:2667
 RooAbsReal.cxx:2668
 RooAbsReal.cxx:2669
 RooAbsReal.cxx:2670
 RooAbsReal.cxx:2671
 RooAbsReal.cxx:2672
 RooAbsReal.cxx:2673
 RooAbsReal.cxx:2674
 RooAbsReal.cxx:2675
 RooAbsReal.cxx:2676
 RooAbsReal.cxx:2677
 RooAbsReal.cxx:2678
 RooAbsReal.cxx:2679
 RooAbsReal.cxx:2680
 RooAbsReal.cxx:2681
 RooAbsReal.cxx:2682
 RooAbsReal.cxx:2683
 RooAbsReal.cxx:2684
 RooAbsReal.cxx:2685
 RooAbsReal.cxx:2686
 RooAbsReal.cxx:2687
 RooAbsReal.cxx:2688
 RooAbsReal.cxx:2689
 RooAbsReal.cxx:2690
 RooAbsReal.cxx:2691
 RooAbsReal.cxx:2692
 RooAbsReal.cxx:2693
 RooAbsReal.cxx:2694
 RooAbsReal.cxx:2695
 RooAbsReal.cxx:2696
 RooAbsReal.cxx:2697
 RooAbsReal.cxx:2698
 RooAbsReal.cxx:2699
 RooAbsReal.cxx:2700
 RooAbsReal.cxx:2701
 RooAbsReal.cxx:2702
 RooAbsReal.cxx:2703
 RooAbsReal.cxx:2704
 RooAbsReal.cxx:2705
 RooAbsReal.cxx:2706
 RooAbsReal.cxx:2707
 RooAbsReal.cxx:2708
 RooAbsReal.cxx:2709
 RooAbsReal.cxx:2710
 RooAbsReal.cxx:2711
 RooAbsReal.cxx:2712
 RooAbsReal.cxx:2713
 RooAbsReal.cxx:2714
 RooAbsReal.cxx:2715
 RooAbsReal.cxx:2716
 RooAbsReal.cxx:2717
 RooAbsReal.cxx:2718
 RooAbsReal.cxx:2719
 RooAbsReal.cxx:2720
 RooAbsReal.cxx:2721
 RooAbsReal.cxx:2722
 RooAbsReal.cxx:2723
 RooAbsReal.cxx:2724
 RooAbsReal.cxx:2725
 RooAbsReal.cxx:2726
 RooAbsReal.cxx:2727
 RooAbsReal.cxx:2728
 RooAbsReal.cxx:2729
 RooAbsReal.cxx:2730
 RooAbsReal.cxx:2731
 RooAbsReal.cxx:2732
 RooAbsReal.cxx:2733
 RooAbsReal.cxx:2734
 RooAbsReal.cxx:2735
 RooAbsReal.cxx:2736
 RooAbsReal.cxx:2737
 RooAbsReal.cxx:2738
 RooAbsReal.cxx:2739
 RooAbsReal.cxx:2740
 RooAbsReal.cxx:2741
 RooAbsReal.cxx:2742
 RooAbsReal.cxx:2743
 RooAbsReal.cxx:2744
 RooAbsReal.cxx:2745
 RooAbsReal.cxx:2746
 RooAbsReal.cxx:2747
 RooAbsReal.cxx:2748
 RooAbsReal.cxx:2749
 RooAbsReal.cxx:2750
 RooAbsReal.cxx:2751
 RooAbsReal.cxx:2752
 RooAbsReal.cxx:2753
 RooAbsReal.cxx:2754
 RooAbsReal.cxx:2755
 RooAbsReal.cxx:2756
 RooAbsReal.cxx:2757
 RooAbsReal.cxx:2758
 RooAbsReal.cxx:2759
 RooAbsReal.cxx:2760
 RooAbsReal.cxx:2761
 RooAbsReal.cxx:2762
 RooAbsReal.cxx:2763
 RooAbsReal.cxx:2764
 RooAbsReal.cxx:2765
 RooAbsReal.cxx:2766
 RooAbsReal.cxx:2767
 RooAbsReal.cxx:2768
 RooAbsReal.cxx:2769
 RooAbsReal.cxx:2770
 RooAbsReal.cxx:2771
 RooAbsReal.cxx:2772
 RooAbsReal.cxx:2773
 RooAbsReal.cxx:2774
 RooAbsReal.cxx:2775
 RooAbsReal.cxx:2776
 RooAbsReal.cxx:2777
 RooAbsReal.cxx:2778
 RooAbsReal.cxx:2779
 RooAbsReal.cxx:2780
 RooAbsReal.cxx:2781
 RooAbsReal.cxx:2782
 RooAbsReal.cxx:2783
 RooAbsReal.cxx:2784
 RooAbsReal.cxx:2785
 RooAbsReal.cxx:2786
 RooAbsReal.cxx:2787
 RooAbsReal.cxx:2788
 RooAbsReal.cxx:2789
 RooAbsReal.cxx:2790
 RooAbsReal.cxx:2791
 RooAbsReal.cxx:2792
 RooAbsReal.cxx:2793
 RooAbsReal.cxx:2794
 RooAbsReal.cxx:2795
 RooAbsReal.cxx:2796
 RooAbsReal.cxx:2797
 RooAbsReal.cxx:2798
 RooAbsReal.cxx:2799
 RooAbsReal.cxx:2800
 RooAbsReal.cxx:2801
 RooAbsReal.cxx:2802
 RooAbsReal.cxx:2803
 RooAbsReal.cxx:2804
 RooAbsReal.cxx:2805
 RooAbsReal.cxx:2806
 RooAbsReal.cxx:2807
 RooAbsReal.cxx:2808
 RooAbsReal.cxx:2809
 RooAbsReal.cxx:2810
 RooAbsReal.cxx:2811
 RooAbsReal.cxx:2812
 RooAbsReal.cxx:2813
 RooAbsReal.cxx:2814
 RooAbsReal.cxx:2815
 RooAbsReal.cxx:2816
 RooAbsReal.cxx:2817
 RooAbsReal.cxx:2818
 RooAbsReal.cxx:2819
 RooAbsReal.cxx:2820
 RooAbsReal.cxx:2821
 RooAbsReal.cxx:2822
 RooAbsReal.cxx:2823
 RooAbsReal.cxx:2824
 RooAbsReal.cxx:2825
 RooAbsReal.cxx:2826
 RooAbsReal.cxx:2827
 RooAbsReal.cxx:2828
 RooAbsReal.cxx:2829
 RooAbsReal.cxx:2830
 RooAbsReal.cxx:2831
 RooAbsReal.cxx:2832
 RooAbsReal.cxx:2833
 RooAbsReal.cxx:2834
 RooAbsReal.cxx:2835
 RooAbsReal.cxx:2836
 RooAbsReal.cxx:2837
 RooAbsReal.cxx:2838
 RooAbsReal.cxx:2839
 RooAbsReal.cxx:2840
 RooAbsReal.cxx:2841
 RooAbsReal.cxx:2842
 RooAbsReal.cxx:2843
 RooAbsReal.cxx:2844
 RooAbsReal.cxx:2845
 RooAbsReal.cxx:2846
 RooAbsReal.cxx:2847
 RooAbsReal.cxx:2848
 RooAbsReal.cxx:2849
 RooAbsReal.cxx:2850
 RooAbsReal.cxx:2851
 RooAbsReal.cxx:2852
 RooAbsReal.cxx:2853
 RooAbsReal.cxx:2854
 RooAbsReal.cxx:2855
 RooAbsReal.cxx:2856
 RooAbsReal.cxx:2857
 RooAbsReal.cxx:2858
 RooAbsReal.cxx:2859
 RooAbsReal.cxx:2860
 RooAbsReal.cxx:2861
 RooAbsReal.cxx:2862
 RooAbsReal.cxx:2863
 RooAbsReal.cxx:2864
 RooAbsReal.cxx:2865
 RooAbsReal.cxx:2866
 RooAbsReal.cxx:2867
 RooAbsReal.cxx:2868
 RooAbsReal.cxx:2869
 RooAbsReal.cxx:2870
 RooAbsReal.cxx:2871
 RooAbsReal.cxx:2872
 RooAbsReal.cxx:2873
 RooAbsReal.cxx:2874
 RooAbsReal.cxx:2875
 RooAbsReal.cxx:2876
 RooAbsReal.cxx:2877
 RooAbsReal.cxx:2878
 RooAbsReal.cxx:2879
 RooAbsReal.cxx:2880
 RooAbsReal.cxx:2881
 RooAbsReal.cxx:2882
 RooAbsReal.cxx:2883
 RooAbsReal.cxx:2884
 RooAbsReal.cxx:2885
 RooAbsReal.cxx:2886
 RooAbsReal.cxx:2887
 RooAbsReal.cxx:2888
 RooAbsReal.cxx:2889
 RooAbsReal.cxx:2890
 RooAbsReal.cxx:2891
 RooAbsReal.cxx:2892
 RooAbsReal.cxx:2893
 RooAbsReal.cxx:2894
 RooAbsReal.cxx:2895
 RooAbsReal.cxx:2896
 RooAbsReal.cxx:2897
 RooAbsReal.cxx:2898
 RooAbsReal.cxx:2899
 RooAbsReal.cxx:2900
 RooAbsReal.cxx:2901
 RooAbsReal.cxx:2902
 RooAbsReal.cxx:2903
 RooAbsReal.cxx:2904
 RooAbsReal.cxx:2905
 RooAbsReal.cxx:2906
 RooAbsReal.cxx:2907
 RooAbsReal.cxx:2908
 RooAbsReal.cxx:2909
 RooAbsReal.cxx:2910
 RooAbsReal.cxx:2911
 RooAbsReal.cxx:2912
 RooAbsReal.cxx:2913
 RooAbsReal.cxx:2914
 RooAbsReal.cxx:2915
 RooAbsReal.cxx:2916
 RooAbsReal.cxx:2917
 RooAbsReal.cxx:2918
 RooAbsReal.cxx:2919
 RooAbsReal.cxx:2920
 RooAbsReal.cxx:2921
 RooAbsReal.cxx:2922
 RooAbsReal.cxx:2923
 RooAbsReal.cxx:2924
 RooAbsReal.cxx:2925
 RooAbsReal.cxx:2926
 RooAbsReal.cxx:2927
 RooAbsReal.cxx:2928
 RooAbsReal.cxx:2929
 RooAbsReal.cxx:2930
 RooAbsReal.cxx:2931
 RooAbsReal.cxx:2932
 RooAbsReal.cxx:2933
 RooAbsReal.cxx:2934
 RooAbsReal.cxx:2935
 RooAbsReal.cxx:2936
 RooAbsReal.cxx:2937
 RooAbsReal.cxx:2938
 RooAbsReal.cxx:2939
 RooAbsReal.cxx:2940
 RooAbsReal.cxx:2941
 RooAbsReal.cxx:2942
 RooAbsReal.cxx:2943
 RooAbsReal.cxx:2944
 RooAbsReal.cxx:2945
 RooAbsReal.cxx:2946
 RooAbsReal.cxx:2947
 RooAbsReal.cxx:2948
 RooAbsReal.cxx:2949
 RooAbsReal.cxx:2950
 RooAbsReal.cxx:2951
 RooAbsReal.cxx:2952
 RooAbsReal.cxx:2953
 RooAbsReal.cxx:2954
 RooAbsReal.cxx:2955
 RooAbsReal.cxx:2956
 RooAbsReal.cxx:2957
 RooAbsReal.cxx:2958
 RooAbsReal.cxx:2959
 RooAbsReal.cxx:2960
 RooAbsReal.cxx:2961
 RooAbsReal.cxx:2962
 RooAbsReal.cxx:2963
 RooAbsReal.cxx:2964
 RooAbsReal.cxx:2965
 RooAbsReal.cxx:2966
 RooAbsReal.cxx:2967
 RooAbsReal.cxx:2968
 RooAbsReal.cxx:2969
 RooAbsReal.cxx:2970
 RooAbsReal.cxx:2971
 RooAbsReal.cxx:2972
 RooAbsReal.cxx:2973
 RooAbsReal.cxx:2974
 RooAbsReal.cxx:2975
 RooAbsReal.cxx:2976
 RooAbsReal.cxx:2977
 RooAbsReal.cxx:2978
 RooAbsReal.cxx:2979
 RooAbsReal.cxx:2980
 RooAbsReal.cxx:2981
 RooAbsReal.cxx:2982
 RooAbsReal.cxx:2983
 RooAbsReal.cxx:2984
 RooAbsReal.cxx:2985
 RooAbsReal.cxx:2986
 RooAbsReal.cxx:2987
 RooAbsReal.cxx:2988
 RooAbsReal.cxx:2989
 RooAbsReal.cxx:2990
 RooAbsReal.cxx:2991
 RooAbsReal.cxx:2992
 RooAbsReal.cxx:2993
 RooAbsReal.cxx:2994
 RooAbsReal.cxx:2995
 RooAbsReal.cxx:2996
 RooAbsReal.cxx:2997
 RooAbsReal.cxx:2998
 RooAbsReal.cxx:2999
 RooAbsReal.cxx:3000
 RooAbsReal.cxx:3001
 RooAbsReal.cxx:3002
 RooAbsReal.cxx:3003
 RooAbsReal.cxx:3004
 RooAbsReal.cxx:3005
 RooAbsReal.cxx:3006
 RooAbsReal.cxx:3007
 RooAbsReal.cxx:3008
 RooAbsReal.cxx:3009
 RooAbsReal.cxx:3010
 RooAbsReal.cxx:3011
 RooAbsReal.cxx:3012
 RooAbsReal.cxx:3013
 RooAbsReal.cxx:3014
 RooAbsReal.cxx:3015
 RooAbsReal.cxx:3016
 RooAbsReal.cxx:3017
 RooAbsReal.cxx:3018
 RooAbsReal.cxx:3019
 RooAbsReal.cxx:3020
 RooAbsReal.cxx:3021
 RooAbsReal.cxx:3022
 RooAbsReal.cxx:3023
 RooAbsReal.cxx:3024
 RooAbsReal.cxx:3025
 RooAbsReal.cxx:3026
 RooAbsReal.cxx:3027
 RooAbsReal.cxx:3028
 RooAbsReal.cxx:3029
 RooAbsReal.cxx:3030
 RooAbsReal.cxx:3031
 RooAbsReal.cxx:3032
 RooAbsReal.cxx:3033
 RooAbsReal.cxx:3034
 RooAbsReal.cxx:3035
 RooAbsReal.cxx:3036
 RooAbsReal.cxx:3037
 RooAbsReal.cxx:3038
 RooAbsReal.cxx:3039
 RooAbsReal.cxx:3040
 RooAbsReal.cxx:3041
 RooAbsReal.cxx:3042
 RooAbsReal.cxx:3043
 RooAbsReal.cxx:3044
 RooAbsReal.cxx:3045
 RooAbsReal.cxx:3046
 RooAbsReal.cxx:3047
 RooAbsReal.cxx:3048
 RooAbsReal.cxx:3049
 RooAbsReal.cxx:3050
 RooAbsReal.cxx:3051
 RooAbsReal.cxx:3052
 RooAbsReal.cxx:3053
 RooAbsReal.cxx:3054
 RooAbsReal.cxx:3055
 RooAbsReal.cxx:3056
 RooAbsReal.cxx:3057
 RooAbsReal.cxx:3058
 RooAbsReal.cxx:3059
 RooAbsReal.cxx:3060
 RooAbsReal.cxx:3061
 RooAbsReal.cxx:3062
 RooAbsReal.cxx:3063
 RooAbsReal.cxx:3064
 RooAbsReal.cxx:3065
 RooAbsReal.cxx:3066
 RooAbsReal.cxx:3067
 RooAbsReal.cxx:3068
 RooAbsReal.cxx:3069
 RooAbsReal.cxx:3070
 RooAbsReal.cxx:3071
 RooAbsReal.cxx:3072
 RooAbsReal.cxx:3073
 RooAbsReal.cxx:3074
 RooAbsReal.cxx:3075
 RooAbsReal.cxx:3076
 RooAbsReal.cxx:3077
 RooAbsReal.cxx:3078
 RooAbsReal.cxx:3079
 RooAbsReal.cxx:3080
 RooAbsReal.cxx:3081
 RooAbsReal.cxx:3082
 RooAbsReal.cxx:3083
 RooAbsReal.cxx:3084
 RooAbsReal.cxx:3085
 RooAbsReal.cxx:3086
 RooAbsReal.cxx:3087
 RooAbsReal.cxx:3088
 RooAbsReal.cxx:3089
 RooAbsReal.cxx:3090
 RooAbsReal.cxx:3091
 RooAbsReal.cxx:3092
 RooAbsReal.cxx:3093
 RooAbsReal.cxx:3094
 RooAbsReal.cxx:3095
 RooAbsReal.cxx:3096
 RooAbsReal.cxx:3097
 RooAbsReal.cxx:3098
 RooAbsReal.cxx:3099
 RooAbsReal.cxx:3100
 RooAbsReal.cxx:3101
 RooAbsReal.cxx:3102
 RooAbsReal.cxx:3103
 RooAbsReal.cxx:3104
 RooAbsReal.cxx:3105
 RooAbsReal.cxx:3106
 RooAbsReal.cxx:3107
 RooAbsReal.cxx:3108
 RooAbsReal.cxx:3109
 RooAbsReal.cxx:3110
 RooAbsReal.cxx:3111
 RooAbsReal.cxx:3112
 RooAbsReal.cxx:3113
 RooAbsReal.cxx:3114
 RooAbsReal.cxx:3115
 RooAbsReal.cxx:3116
 RooAbsReal.cxx:3117
 RooAbsReal.cxx:3118
 RooAbsReal.cxx:3119
 RooAbsReal.cxx:3120
 RooAbsReal.cxx:3121
 RooAbsReal.cxx:3122
 RooAbsReal.cxx:3123
 RooAbsReal.cxx:3124
 RooAbsReal.cxx:3125
 RooAbsReal.cxx:3126
 RooAbsReal.cxx:3127
 RooAbsReal.cxx:3128
 RooAbsReal.cxx:3129
 RooAbsReal.cxx:3130
 RooAbsReal.cxx:3131
 RooAbsReal.cxx:3132
 RooAbsReal.cxx:3133
 RooAbsReal.cxx:3134
 RooAbsReal.cxx:3135
 RooAbsReal.cxx:3136
 RooAbsReal.cxx:3137
 RooAbsReal.cxx:3138
 RooAbsReal.cxx:3139
 RooAbsReal.cxx:3140
 RooAbsReal.cxx:3141
 RooAbsReal.cxx:3142
 RooAbsReal.cxx:3143
 RooAbsReal.cxx:3144
 RooAbsReal.cxx:3145
 RooAbsReal.cxx:3146
 RooAbsReal.cxx:3147
 RooAbsReal.cxx:3148
 RooAbsReal.cxx:3149
 RooAbsReal.cxx:3150
 RooAbsReal.cxx:3151
 RooAbsReal.cxx:3152
 RooAbsReal.cxx:3153
 RooAbsReal.cxx:3154
 RooAbsReal.cxx:3155
 RooAbsReal.cxx:3156
 RooAbsReal.cxx:3157
 RooAbsReal.cxx:3158
 RooAbsReal.cxx:3159
 RooAbsReal.cxx:3160
 RooAbsReal.cxx:3161
 RooAbsReal.cxx:3162
 RooAbsReal.cxx:3163
 RooAbsReal.cxx:3164
 RooAbsReal.cxx:3165
 RooAbsReal.cxx:3166
 RooAbsReal.cxx:3167
 RooAbsReal.cxx:3168
 RooAbsReal.cxx:3169
 RooAbsReal.cxx:3170
 RooAbsReal.cxx:3171
 RooAbsReal.cxx:3172
 RooAbsReal.cxx:3173
 RooAbsReal.cxx:3174
 RooAbsReal.cxx:3175
 RooAbsReal.cxx:3176
 RooAbsReal.cxx:3177
 RooAbsReal.cxx:3178
 RooAbsReal.cxx:3179
 RooAbsReal.cxx:3180
 RooAbsReal.cxx:3181
 RooAbsReal.cxx:3182
 RooAbsReal.cxx:3183
 RooAbsReal.cxx:3184
 RooAbsReal.cxx:3185
 RooAbsReal.cxx:3186
 RooAbsReal.cxx:3187
 RooAbsReal.cxx:3188
 RooAbsReal.cxx:3189
 RooAbsReal.cxx:3190
 RooAbsReal.cxx:3191
 RooAbsReal.cxx:3192
 RooAbsReal.cxx:3193
 RooAbsReal.cxx:3194
 RooAbsReal.cxx:3195
 RooAbsReal.cxx:3196
 RooAbsReal.cxx:3197
 RooAbsReal.cxx:3198
 RooAbsReal.cxx:3199
 RooAbsReal.cxx:3200
 RooAbsReal.cxx:3201
 RooAbsReal.cxx:3202
 RooAbsReal.cxx:3203
 RooAbsReal.cxx:3204
 RooAbsReal.cxx:3205
 RooAbsReal.cxx:3206
 RooAbsReal.cxx:3207
 RooAbsReal.cxx:3208
 RooAbsReal.cxx:3209
 RooAbsReal.cxx:3210
 RooAbsReal.cxx:3211
 RooAbsReal.cxx:3212
 RooAbsReal.cxx:3213
 RooAbsReal.cxx:3214
 RooAbsReal.cxx:3215
 RooAbsReal.cxx:3216
 RooAbsReal.cxx:3217
 RooAbsReal.cxx:3218
 RooAbsReal.cxx:3219
 RooAbsReal.cxx:3220
 RooAbsReal.cxx:3221
 RooAbsReal.cxx:3222
 RooAbsReal.cxx:3223
 RooAbsReal.cxx:3224
 RooAbsReal.cxx:3225
 RooAbsReal.cxx:3226
 RooAbsReal.cxx:3227
 RooAbsReal.cxx:3228
 RooAbsReal.cxx:3229
 RooAbsReal.cxx:3230
 RooAbsReal.cxx:3231
 RooAbsReal.cxx:3232
 RooAbsReal.cxx:3233
 RooAbsReal.cxx:3234
 RooAbsReal.cxx:3235
 RooAbsReal.cxx:3236
 RooAbsReal.cxx:3237
 RooAbsReal.cxx:3238
 RooAbsReal.cxx:3239
 RooAbsReal.cxx:3240
 RooAbsReal.cxx:3241
 RooAbsReal.cxx:3242
 RooAbsReal.cxx:3243
 RooAbsReal.cxx:3244
 RooAbsReal.cxx:3245
 RooAbsReal.cxx:3246
 RooAbsReal.cxx:3247
 RooAbsReal.cxx:3248
 RooAbsReal.cxx:3249
 RooAbsReal.cxx:3250
 RooAbsReal.cxx:3251
 RooAbsReal.cxx:3252
 RooAbsReal.cxx:3253
 RooAbsReal.cxx:3254
 RooAbsReal.cxx:3255
 RooAbsReal.cxx:3256
 RooAbsReal.cxx:3257
 RooAbsReal.cxx:3258
 RooAbsReal.cxx:3259
 RooAbsReal.cxx:3260
 RooAbsReal.cxx:3261
 RooAbsReal.cxx:3262
 RooAbsReal.cxx:3263
 RooAbsReal.cxx:3264
 RooAbsReal.cxx:3265
 RooAbsReal.cxx:3266
 RooAbsReal.cxx:3267
 RooAbsReal.cxx:3268
 RooAbsReal.cxx:3269
 RooAbsReal.cxx:3270
 RooAbsReal.cxx:3271
 RooAbsReal.cxx:3272
 RooAbsReal.cxx:3273
 RooAbsReal.cxx:3274
 RooAbsReal.cxx:3275
 RooAbsReal.cxx:3276
 RooAbsReal.cxx:3277
 RooAbsReal.cxx:3278
 RooAbsReal.cxx:3279
 RooAbsReal.cxx:3280
 RooAbsReal.cxx:3281
 RooAbsReal.cxx:3282
 RooAbsReal.cxx:3283
 RooAbsReal.cxx:3284
 RooAbsReal.cxx:3285
 RooAbsReal.cxx:3286
 RooAbsReal.cxx:3287
 RooAbsReal.cxx:3288
 RooAbsReal.cxx:3289
 RooAbsReal.cxx:3290
 RooAbsReal.cxx:3291
 RooAbsReal.cxx:3292
 RooAbsReal.cxx:3293
 RooAbsReal.cxx:3294
 RooAbsReal.cxx:3295
 RooAbsReal.cxx:3296
 RooAbsReal.cxx:3297
 RooAbsReal.cxx:3298
 RooAbsReal.cxx:3299
 RooAbsReal.cxx:3300
 RooAbsReal.cxx:3301
 RooAbsReal.cxx:3302
 RooAbsReal.cxx:3303
 RooAbsReal.cxx:3304
 RooAbsReal.cxx:3305
 RooAbsReal.cxx:3306
 RooAbsReal.cxx:3307
 RooAbsReal.cxx:3308
 RooAbsReal.cxx:3309
 RooAbsReal.cxx:3310
 RooAbsReal.cxx:3311
 RooAbsReal.cxx:3312
 RooAbsReal.cxx:3313
 RooAbsReal.cxx:3314
 RooAbsReal.cxx:3315
 RooAbsReal.cxx:3316
 RooAbsReal.cxx:3317
 RooAbsReal.cxx:3318
 RooAbsReal.cxx:3319
 RooAbsReal.cxx:3320
 RooAbsReal.cxx:3321
 RooAbsReal.cxx:3322
 RooAbsReal.cxx:3323
 RooAbsReal.cxx:3324
 RooAbsReal.cxx:3325
 RooAbsReal.cxx:3326
 RooAbsReal.cxx:3327
 RooAbsReal.cxx:3328
 RooAbsReal.cxx:3329
 RooAbsReal.cxx:3330
 RooAbsReal.cxx:3331
 RooAbsReal.cxx:3332
 RooAbsReal.cxx:3333
 RooAbsReal.cxx:3334
 RooAbsReal.cxx:3335
 RooAbsReal.cxx:3336
 RooAbsReal.cxx:3337
 RooAbsReal.cxx:3338
 RooAbsReal.cxx:3339
 RooAbsReal.cxx:3340
 RooAbsReal.cxx:3341
 RooAbsReal.cxx:3342
 RooAbsReal.cxx:3343
 RooAbsReal.cxx:3344
 RooAbsReal.cxx:3345
 RooAbsReal.cxx:3346
 RooAbsReal.cxx:3347
 RooAbsReal.cxx:3348
 RooAbsReal.cxx:3349
 RooAbsReal.cxx:3350
 RooAbsReal.cxx:3351
 RooAbsReal.cxx:3352
 RooAbsReal.cxx:3353
 RooAbsReal.cxx:3354
 RooAbsReal.cxx:3355
 RooAbsReal.cxx:3356
 RooAbsReal.cxx:3357
 RooAbsReal.cxx:3358
 RooAbsReal.cxx:3359
 RooAbsReal.cxx:3360
 RooAbsReal.cxx:3361
 RooAbsReal.cxx:3362
 RooAbsReal.cxx:3363
 RooAbsReal.cxx:3364
 RooAbsReal.cxx:3365
 RooAbsReal.cxx:3366
 RooAbsReal.cxx:3367
 RooAbsReal.cxx:3368
 RooAbsReal.cxx:3369
 RooAbsReal.cxx:3370
 RooAbsReal.cxx:3371
 RooAbsReal.cxx:3372
 RooAbsReal.cxx:3373
 RooAbsReal.cxx:3374
 RooAbsReal.cxx:3375
 RooAbsReal.cxx:3376
 RooAbsReal.cxx:3377
 RooAbsReal.cxx:3378
 RooAbsReal.cxx:3379
 RooAbsReal.cxx:3380
 RooAbsReal.cxx:3381
 RooAbsReal.cxx:3382
 RooAbsReal.cxx:3383
 RooAbsReal.cxx:3384
 RooAbsReal.cxx:3385
 RooAbsReal.cxx:3386
 RooAbsReal.cxx:3387
 RooAbsReal.cxx:3388
 RooAbsReal.cxx:3389
 RooAbsReal.cxx:3390
 RooAbsReal.cxx:3391
 RooAbsReal.cxx:3392
 RooAbsReal.cxx:3393
 RooAbsReal.cxx:3394
 RooAbsReal.cxx:3395
 RooAbsReal.cxx:3396
 RooAbsReal.cxx:3397
 RooAbsReal.cxx:3398
 RooAbsReal.cxx:3399
 RooAbsReal.cxx:3400
 RooAbsReal.cxx:3401
 RooAbsReal.cxx:3402
 RooAbsReal.cxx:3403
 RooAbsReal.cxx:3404
 RooAbsReal.cxx:3405
 RooAbsReal.cxx:3406
 RooAbsReal.cxx:3407
 RooAbsReal.cxx:3408
 RooAbsReal.cxx:3409
 RooAbsReal.cxx:3410
 RooAbsReal.cxx:3411
 RooAbsReal.cxx:3412
 RooAbsReal.cxx:3413
 RooAbsReal.cxx:3414
 RooAbsReal.cxx:3415
 RooAbsReal.cxx:3416
 RooAbsReal.cxx:3417
 RooAbsReal.cxx:3418
 RooAbsReal.cxx:3419
 RooAbsReal.cxx:3420
 RooAbsReal.cxx:3421
 RooAbsReal.cxx:3422
 RooAbsReal.cxx:3423
 RooAbsReal.cxx:3424
 RooAbsReal.cxx:3425
 RooAbsReal.cxx:3426
 RooAbsReal.cxx:3427
 RooAbsReal.cxx:3428
 RooAbsReal.cxx:3429
 RooAbsReal.cxx:3430
 RooAbsReal.cxx:3431
 RooAbsReal.cxx:3432
 RooAbsReal.cxx:3433
 RooAbsReal.cxx:3434
 RooAbsReal.cxx:3435
 RooAbsReal.cxx:3436
 RooAbsReal.cxx:3437
 RooAbsReal.cxx:3438
 RooAbsReal.cxx:3439
 RooAbsReal.cxx:3440
 RooAbsReal.cxx:3441
 RooAbsReal.cxx:3442
 RooAbsReal.cxx:3443
 RooAbsReal.cxx:3444
 RooAbsReal.cxx:3445
 RooAbsReal.cxx:3446
 RooAbsReal.cxx:3447
 RooAbsReal.cxx:3448
 RooAbsReal.cxx:3449
 RooAbsReal.cxx:3450
 RooAbsReal.cxx:3451
 RooAbsReal.cxx:3452
 RooAbsReal.cxx:3453
 RooAbsReal.cxx:3454
 RooAbsReal.cxx:3455
 RooAbsReal.cxx:3456
 RooAbsReal.cxx:3457
 RooAbsReal.cxx:3458
 RooAbsReal.cxx:3459
 RooAbsReal.cxx:3460
 RooAbsReal.cxx:3461
 RooAbsReal.cxx:3462
 RooAbsReal.cxx:3463
 RooAbsReal.cxx:3464
 RooAbsReal.cxx:3465
 RooAbsReal.cxx:3466
 RooAbsReal.cxx:3467
 RooAbsReal.cxx:3468
 RooAbsReal.cxx:3469
 RooAbsReal.cxx:3470
 RooAbsReal.cxx:3471
 RooAbsReal.cxx:3472
 RooAbsReal.cxx:3473
 RooAbsReal.cxx:3474
 RooAbsReal.cxx:3475
 RooAbsReal.cxx:3476
 RooAbsReal.cxx:3477
 RooAbsReal.cxx:3478
 RooAbsReal.cxx:3479
 RooAbsReal.cxx:3480
 RooAbsReal.cxx:3481
 RooAbsReal.cxx:3482
 RooAbsReal.cxx:3483
 RooAbsReal.cxx:3484
 RooAbsReal.cxx:3485
 RooAbsReal.cxx:3486
 RooAbsReal.cxx:3487
 RooAbsReal.cxx:3488
 RooAbsReal.cxx:3489
 RooAbsReal.cxx:3490
 RooAbsReal.cxx:3491
 RooAbsReal.cxx:3492
 RooAbsReal.cxx:3493
 RooAbsReal.cxx:3494
 RooAbsReal.cxx:3495
 RooAbsReal.cxx:3496
 RooAbsReal.cxx:3497
 RooAbsReal.cxx:3498
 RooAbsReal.cxx:3499
 RooAbsReal.cxx:3500
 RooAbsReal.cxx:3501
 RooAbsReal.cxx:3502
 RooAbsReal.cxx:3503
 RooAbsReal.cxx:3504
 RooAbsReal.cxx:3505
 RooAbsReal.cxx:3506
 RooAbsReal.cxx:3507
 RooAbsReal.cxx:3508
 RooAbsReal.cxx:3509
 RooAbsReal.cxx:3510
 RooAbsReal.cxx:3511
 RooAbsReal.cxx:3512
 RooAbsReal.cxx:3513
 RooAbsReal.cxx:3514
 RooAbsReal.cxx:3515
 RooAbsReal.cxx:3516
 RooAbsReal.cxx:3517
 RooAbsReal.cxx:3518
 RooAbsReal.cxx:3519
 RooAbsReal.cxx:3520
 RooAbsReal.cxx:3521
 RooAbsReal.cxx:3522
 RooAbsReal.cxx:3523
 RooAbsReal.cxx:3524
 RooAbsReal.cxx:3525
 RooAbsReal.cxx:3526
 RooAbsReal.cxx:3527
 RooAbsReal.cxx:3528
 RooAbsReal.cxx:3529
 RooAbsReal.cxx:3530
 RooAbsReal.cxx:3531
 RooAbsReal.cxx:3532
 RooAbsReal.cxx:3533
 RooAbsReal.cxx:3534
 RooAbsReal.cxx:3535
 RooAbsReal.cxx:3536
 RooAbsReal.cxx:3537
 RooAbsReal.cxx:3538
 RooAbsReal.cxx:3539
 RooAbsReal.cxx:3540
 RooAbsReal.cxx:3541
 RooAbsReal.cxx:3542
 RooAbsReal.cxx:3543
 RooAbsReal.cxx:3544
 RooAbsReal.cxx:3545
 RooAbsReal.cxx:3546
 RooAbsReal.cxx:3547
 RooAbsReal.cxx:3548
 RooAbsReal.cxx:3549
 RooAbsReal.cxx:3550
 RooAbsReal.cxx:3551
 RooAbsReal.cxx:3552
 RooAbsReal.cxx:3553
 RooAbsReal.cxx:3554
 RooAbsReal.cxx:3555
 RooAbsReal.cxx:3556
 RooAbsReal.cxx:3557
 RooAbsReal.cxx:3558
 RooAbsReal.cxx:3559
 RooAbsReal.cxx:3560
 RooAbsReal.cxx:3561
 RooAbsReal.cxx:3562
 RooAbsReal.cxx:3563
 RooAbsReal.cxx:3564
 RooAbsReal.cxx:3565
 RooAbsReal.cxx:3566
 RooAbsReal.cxx:3567
 RooAbsReal.cxx:3568
 RooAbsReal.cxx:3569
 RooAbsReal.cxx:3570
 RooAbsReal.cxx:3571
 RooAbsReal.cxx:3572
 RooAbsReal.cxx:3573
 RooAbsReal.cxx:3574
 RooAbsReal.cxx:3575
 RooAbsReal.cxx:3576
 RooAbsReal.cxx:3577
 RooAbsReal.cxx:3578
 RooAbsReal.cxx:3579
 RooAbsReal.cxx:3580
 RooAbsReal.cxx:3581
 RooAbsReal.cxx:3582
 RooAbsReal.cxx:3583
 RooAbsReal.cxx:3584
 RooAbsReal.cxx:3585
 RooAbsReal.cxx:3586
 RooAbsReal.cxx:3587
 RooAbsReal.cxx:3588
 RooAbsReal.cxx:3589
 RooAbsReal.cxx:3590
 RooAbsReal.cxx:3591
 RooAbsReal.cxx:3592
 RooAbsReal.cxx:3593
 RooAbsReal.cxx:3594
 RooAbsReal.cxx:3595
 RooAbsReal.cxx:3596
 RooAbsReal.cxx:3597
 RooAbsReal.cxx:3598
 RooAbsReal.cxx:3599
 RooAbsReal.cxx:3600
 RooAbsReal.cxx:3601
 RooAbsReal.cxx:3602
 RooAbsReal.cxx:3603
 RooAbsReal.cxx:3604
 RooAbsReal.cxx:3605
 RooAbsReal.cxx:3606
 RooAbsReal.cxx:3607
 RooAbsReal.cxx:3608
 RooAbsReal.cxx:3609
 RooAbsReal.cxx:3610
 RooAbsReal.cxx:3611
 RooAbsReal.cxx:3612
 RooAbsReal.cxx:3613
 RooAbsReal.cxx:3614
 RooAbsReal.cxx:3615
 RooAbsReal.cxx:3616
 RooAbsReal.cxx:3617
 RooAbsReal.cxx:3618
 RooAbsReal.cxx:3619
 RooAbsReal.cxx:3620
 RooAbsReal.cxx:3621
 RooAbsReal.cxx:3622
 RooAbsReal.cxx:3623
 RooAbsReal.cxx:3624
 RooAbsReal.cxx:3625
 RooAbsReal.cxx:3626
 RooAbsReal.cxx:3627
 RooAbsReal.cxx:3628
 RooAbsReal.cxx:3629
 RooAbsReal.cxx:3630
 RooAbsReal.cxx:3631
 RooAbsReal.cxx:3632
 RooAbsReal.cxx:3633
 RooAbsReal.cxx:3634
 RooAbsReal.cxx:3635
 RooAbsReal.cxx:3636
 RooAbsReal.cxx:3637
 RooAbsReal.cxx:3638
 RooAbsReal.cxx:3639
 RooAbsReal.cxx:3640
 RooAbsReal.cxx:3641
 RooAbsReal.cxx:3642
 RooAbsReal.cxx:3643
 RooAbsReal.cxx:3644
 RooAbsReal.cxx:3645
 RooAbsReal.cxx:3646
 RooAbsReal.cxx:3647
 RooAbsReal.cxx:3648
 RooAbsReal.cxx:3649
 RooAbsReal.cxx:3650
 RooAbsReal.cxx:3651
 RooAbsReal.cxx:3652
 RooAbsReal.cxx:3653
 RooAbsReal.cxx:3654
 RooAbsReal.cxx:3655
 RooAbsReal.cxx:3656
 RooAbsReal.cxx:3657
 RooAbsReal.cxx:3658
 RooAbsReal.cxx:3659
 RooAbsReal.cxx:3660
 RooAbsReal.cxx:3661
 RooAbsReal.cxx:3662
 RooAbsReal.cxx:3663
 RooAbsReal.cxx:3664
 RooAbsReal.cxx:3665
 RooAbsReal.cxx:3666
 RooAbsReal.cxx:3667
 RooAbsReal.cxx:3668
 RooAbsReal.cxx:3669
 RooAbsReal.cxx:3670
 RooAbsReal.cxx:3671
 RooAbsReal.cxx:3672
 RooAbsReal.cxx:3673
 RooAbsReal.cxx:3674
 RooAbsReal.cxx:3675
 RooAbsReal.cxx:3676
 RooAbsReal.cxx:3677
 RooAbsReal.cxx:3678
 RooAbsReal.cxx:3679
 RooAbsReal.cxx:3680
 RooAbsReal.cxx:3681
 RooAbsReal.cxx:3682
 RooAbsReal.cxx:3683
 RooAbsReal.cxx:3684
 RooAbsReal.cxx:3685
 RooAbsReal.cxx:3686
 RooAbsReal.cxx:3687
 RooAbsReal.cxx:3688
 RooAbsReal.cxx:3689
 RooAbsReal.cxx:3690
 RooAbsReal.cxx:3691
 RooAbsReal.cxx:3692
 RooAbsReal.cxx:3693
 RooAbsReal.cxx:3694
 RooAbsReal.cxx:3695
 RooAbsReal.cxx:3696
 RooAbsReal.cxx:3697
 RooAbsReal.cxx:3698
 RooAbsReal.cxx:3699
 RooAbsReal.cxx:3700
 RooAbsReal.cxx:3701
 RooAbsReal.cxx:3702
 RooAbsReal.cxx:3703
 RooAbsReal.cxx:3704
 RooAbsReal.cxx:3705
 RooAbsReal.cxx:3706
 RooAbsReal.cxx:3707
 RooAbsReal.cxx:3708
 RooAbsReal.cxx:3709
 RooAbsReal.cxx:3710
 RooAbsReal.cxx:3711
 RooAbsReal.cxx:3712
 RooAbsReal.cxx:3713
 RooAbsReal.cxx:3714
 RooAbsReal.cxx:3715
 RooAbsReal.cxx:3716
 RooAbsReal.cxx:3717
 RooAbsReal.cxx:3718
 RooAbsReal.cxx:3719
 RooAbsReal.cxx:3720
 RooAbsReal.cxx:3721
 RooAbsReal.cxx:3722
 RooAbsReal.cxx:3723
 RooAbsReal.cxx:3724
 RooAbsReal.cxx:3725
 RooAbsReal.cxx:3726
 RooAbsReal.cxx:3727
 RooAbsReal.cxx:3728
 RooAbsReal.cxx:3729
 RooAbsReal.cxx:3730
 RooAbsReal.cxx:3731
 RooAbsReal.cxx:3732
 RooAbsReal.cxx:3733
 RooAbsReal.cxx:3734
 RooAbsReal.cxx:3735
 RooAbsReal.cxx:3736
 RooAbsReal.cxx:3737
 RooAbsReal.cxx:3738
 RooAbsReal.cxx:3739
 RooAbsReal.cxx:3740
 RooAbsReal.cxx:3741
 RooAbsReal.cxx:3742
 RooAbsReal.cxx:3743
 RooAbsReal.cxx:3744
 RooAbsReal.cxx:3745
 RooAbsReal.cxx:3746
 RooAbsReal.cxx:3747
 RooAbsReal.cxx:3748
 RooAbsReal.cxx:3749
 RooAbsReal.cxx:3750
 RooAbsReal.cxx:3751
 RooAbsReal.cxx:3752
 RooAbsReal.cxx:3753
 RooAbsReal.cxx:3754
 RooAbsReal.cxx:3755
 RooAbsReal.cxx:3756
 RooAbsReal.cxx:3757
 RooAbsReal.cxx:3758
 RooAbsReal.cxx:3759
 RooAbsReal.cxx:3760
 RooAbsReal.cxx:3761
 RooAbsReal.cxx:3762
 RooAbsReal.cxx:3763
 RooAbsReal.cxx:3764
 RooAbsReal.cxx:3765
 RooAbsReal.cxx:3766
 RooAbsReal.cxx:3767
 RooAbsReal.cxx:3768
 RooAbsReal.cxx:3769
 RooAbsReal.cxx:3770
 RooAbsReal.cxx:3771
 RooAbsReal.cxx:3772
 RooAbsReal.cxx:3773
 RooAbsReal.cxx:3774
 RooAbsReal.cxx:3775
 RooAbsReal.cxx:3776
 RooAbsReal.cxx:3777
 RooAbsReal.cxx:3778
 RooAbsReal.cxx:3779
 RooAbsReal.cxx:3780
 RooAbsReal.cxx:3781
 RooAbsReal.cxx:3782
 RooAbsReal.cxx:3783
 RooAbsReal.cxx:3784
 RooAbsReal.cxx:3785
 RooAbsReal.cxx:3786
 RooAbsReal.cxx:3787
 RooAbsReal.cxx:3788
 RooAbsReal.cxx:3789
 RooAbsReal.cxx:3790
 RooAbsReal.cxx:3791
 RooAbsReal.cxx:3792
 RooAbsReal.cxx:3793
 RooAbsReal.cxx:3794
 RooAbsReal.cxx:3795
 RooAbsReal.cxx:3796
 RooAbsReal.cxx:3797
 RooAbsReal.cxx:3798
 RooAbsReal.cxx:3799
 RooAbsReal.cxx:3800
 RooAbsReal.cxx:3801
 RooAbsReal.cxx:3802
 RooAbsReal.cxx:3803
 RooAbsReal.cxx:3804
 RooAbsReal.cxx:3805
 RooAbsReal.cxx:3806
 RooAbsReal.cxx:3807
 RooAbsReal.cxx:3808
 RooAbsReal.cxx:3809
 RooAbsReal.cxx:3810
 RooAbsReal.cxx:3811
 RooAbsReal.cxx:3812
 RooAbsReal.cxx:3813
 RooAbsReal.cxx:3814
 RooAbsReal.cxx:3815
 RooAbsReal.cxx:3816
 RooAbsReal.cxx:3817
 RooAbsReal.cxx:3818
 RooAbsReal.cxx:3819
 RooAbsReal.cxx:3820
 RooAbsReal.cxx:3821
 RooAbsReal.cxx:3822
 RooAbsReal.cxx:3823
 RooAbsReal.cxx:3824
 RooAbsReal.cxx:3825
 RooAbsReal.cxx:3826
 RooAbsReal.cxx:3827
 RooAbsReal.cxx:3828
 RooAbsReal.cxx:3829
 RooAbsReal.cxx:3830
 RooAbsReal.cxx:3831
 RooAbsReal.cxx:3832
 RooAbsReal.cxx:3833
 RooAbsReal.cxx:3834
 RooAbsReal.cxx:3835
 RooAbsReal.cxx:3836
 RooAbsReal.cxx:3837
 RooAbsReal.cxx:3838
 RooAbsReal.cxx:3839
 RooAbsReal.cxx:3840
 RooAbsReal.cxx:3841
 RooAbsReal.cxx:3842
 RooAbsReal.cxx:3843
 RooAbsReal.cxx:3844
 RooAbsReal.cxx:3845
 RooAbsReal.cxx:3846
 RooAbsReal.cxx:3847
 RooAbsReal.cxx:3848
 RooAbsReal.cxx:3849
 RooAbsReal.cxx:3850
 RooAbsReal.cxx:3851
 RooAbsReal.cxx:3852
 RooAbsReal.cxx:3853
 RooAbsReal.cxx:3854
 RooAbsReal.cxx:3855
 RooAbsReal.cxx:3856
 RooAbsReal.cxx:3857
 RooAbsReal.cxx:3858
 RooAbsReal.cxx:3859
 RooAbsReal.cxx:3860
 RooAbsReal.cxx:3861
 RooAbsReal.cxx:3862
 RooAbsReal.cxx:3863
 RooAbsReal.cxx:3864
 RooAbsReal.cxx:3865
 RooAbsReal.cxx:3866
 RooAbsReal.cxx:3867
 RooAbsReal.cxx:3868
 RooAbsReal.cxx:3869
 RooAbsReal.cxx:3870
 RooAbsReal.cxx:3871
 RooAbsReal.cxx:3872
 RooAbsReal.cxx:3873
 RooAbsReal.cxx:3874
 RooAbsReal.cxx:3875
 RooAbsReal.cxx:3876
 RooAbsReal.cxx:3877
 RooAbsReal.cxx:3878
 RooAbsReal.cxx:3879
 RooAbsReal.cxx:3880
 RooAbsReal.cxx:3881
 RooAbsReal.cxx:3882
 RooAbsReal.cxx:3883
 RooAbsReal.cxx:3884
 RooAbsReal.cxx:3885
 RooAbsReal.cxx:3886
 RooAbsReal.cxx:3887
 RooAbsReal.cxx:3888
 RooAbsReal.cxx:3889
 RooAbsReal.cxx:3890
 RooAbsReal.cxx:3891
 RooAbsReal.cxx:3892
 RooAbsReal.cxx:3893
 RooAbsReal.cxx:3894
 RooAbsReal.cxx:3895
 RooAbsReal.cxx:3896
 RooAbsReal.cxx:3897
 RooAbsReal.cxx:3898
 RooAbsReal.cxx:3899
 RooAbsReal.cxx:3900
 RooAbsReal.cxx:3901
 RooAbsReal.cxx:3902
 RooAbsReal.cxx:3903
 RooAbsReal.cxx:3904
 RooAbsReal.cxx:3905
 RooAbsReal.cxx:3906
 RooAbsReal.cxx:3907
 RooAbsReal.cxx:3908
 RooAbsReal.cxx:3909
 RooAbsReal.cxx:3910
 RooAbsReal.cxx:3911
 RooAbsReal.cxx:3912
 RooAbsReal.cxx:3913
 RooAbsReal.cxx:3914
 RooAbsReal.cxx:3915
 RooAbsReal.cxx:3916
 RooAbsReal.cxx:3917
 RooAbsReal.cxx:3918
 RooAbsReal.cxx:3919
 RooAbsReal.cxx:3920
 RooAbsReal.cxx:3921
 RooAbsReal.cxx:3922
 RooAbsReal.cxx:3923
 RooAbsReal.cxx:3924
 RooAbsReal.cxx:3925
 RooAbsReal.cxx:3926
 RooAbsReal.cxx:3927
 RooAbsReal.cxx:3928
 RooAbsReal.cxx:3929
 RooAbsReal.cxx:3930
 RooAbsReal.cxx:3931
 RooAbsReal.cxx:3932
 RooAbsReal.cxx:3933
 RooAbsReal.cxx:3934
 RooAbsReal.cxx:3935
 RooAbsReal.cxx:3936
 RooAbsReal.cxx:3937
 RooAbsReal.cxx:3938
 RooAbsReal.cxx:3939
 RooAbsReal.cxx:3940
 RooAbsReal.cxx:3941
 RooAbsReal.cxx:3942
 RooAbsReal.cxx:3943
 RooAbsReal.cxx:3944
 RooAbsReal.cxx:3945
 RooAbsReal.cxx:3946
 RooAbsReal.cxx:3947
 RooAbsReal.cxx:3948
 RooAbsReal.cxx:3949
 RooAbsReal.cxx:3950
 RooAbsReal.cxx:3951
 RooAbsReal.cxx:3952
 RooAbsReal.cxx:3953
 RooAbsReal.cxx:3954
 RooAbsReal.cxx:3955
 RooAbsReal.cxx:3956
 RooAbsReal.cxx:3957
 RooAbsReal.cxx:3958
 RooAbsReal.cxx:3959
 RooAbsReal.cxx:3960
 RooAbsReal.cxx:3961
 RooAbsReal.cxx:3962
 RooAbsReal.cxx:3963
 RooAbsReal.cxx:3964
 RooAbsReal.cxx:3965
 RooAbsReal.cxx:3966
 RooAbsReal.cxx:3967
 RooAbsReal.cxx:3968
 RooAbsReal.cxx:3969
 RooAbsReal.cxx:3970
 RooAbsReal.cxx:3971
 RooAbsReal.cxx:3972
 RooAbsReal.cxx:3973
 RooAbsReal.cxx:3974
 RooAbsReal.cxx:3975
 RooAbsReal.cxx:3976
 RooAbsReal.cxx:3977
 RooAbsReal.cxx:3978
 RooAbsReal.cxx:3979
 RooAbsReal.cxx:3980
 RooAbsReal.cxx:3981
 RooAbsReal.cxx:3982
 RooAbsReal.cxx:3983
 RooAbsReal.cxx:3984
 RooAbsReal.cxx:3985
 RooAbsReal.cxx:3986
 RooAbsReal.cxx:3987
 RooAbsReal.cxx:3988
 RooAbsReal.cxx:3989
 RooAbsReal.cxx:3990
 RooAbsReal.cxx:3991
 RooAbsReal.cxx:3992
 RooAbsReal.cxx:3993
 RooAbsReal.cxx:3994
 RooAbsReal.cxx:3995
 RooAbsReal.cxx:3996
 RooAbsReal.cxx:3997
 RooAbsReal.cxx:3998
 RooAbsReal.cxx:3999
 RooAbsReal.cxx:4000
 RooAbsReal.cxx:4001
 RooAbsReal.cxx:4002
 RooAbsReal.cxx:4003
 RooAbsReal.cxx:4004
 RooAbsReal.cxx:4005
 RooAbsReal.cxx:4006
 RooAbsReal.cxx:4007
 RooAbsReal.cxx:4008
 RooAbsReal.cxx:4009
 RooAbsReal.cxx:4010
 RooAbsReal.cxx:4011
 RooAbsReal.cxx:4012
 RooAbsReal.cxx:4013
 RooAbsReal.cxx:4014
 RooAbsReal.cxx:4015
 RooAbsReal.cxx:4016
 RooAbsReal.cxx:4017
 RooAbsReal.cxx:4018
 RooAbsReal.cxx:4019
 RooAbsReal.cxx:4020
 RooAbsReal.cxx:4021
 RooAbsReal.cxx:4022
 RooAbsReal.cxx:4023
 RooAbsReal.cxx:4024
 RooAbsReal.cxx:4025
 RooAbsReal.cxx:4026
 RooAbsReal.cxx:4027
 RooAbsReal.cxx:4028
 RooAbsReal.cxx:4029
 RooAbsReal.cxx:4030
 RooAbsReal.cxx:4031
 RooAbsReal.cxx:4032
 RooAbsReal.cxx:4033
 RooAbsReal.cxx:4034
 RooAbsReal.cxx:4035
 RooAbsReal.cxx:4036
 RooAbsReal.cxx:4037
 RooAbsReal.cxx:4038
 RooAbsReal.cxx:4039
 RooAbsReal.cxx:4040
 RooAbsReal.cxx:4041
 RooAbsReal.cxx:4042
 RooAbsReal.cxx:4043
 RooAbsReal.cxx:4044
 RooAbsReal.cxx:4045
 RooAbsReal.cxx:4046
 RooAbsReal.cxx:4047
 RooAbsReal.cxx:4048
 RooAbsReal.cxx:4049
 RooAbsReal.cxx:4050
 RooAbsReal.cxx:4051
 RooAbsReal.cxx:4052
 RooAbsReal.cxx:4053
 RooAbsReal.cxx:4054
 RooAbsReal.cxx:4055
 RooAbsReal.cxx:4056
 RooAbsReal.cxx:4057
 RooAbsReal.cxx:4058
 RooAbsReal.cxx:4059
 RooAbsReal.cxx:4060
 RooAbsReal.cxx:4061
 RooAbsReal.cxx:4062
 RooAbsReal.cxx:4063
 RooAbsReal.cxx:4064
 RooAbsReal.cxx:4065
 RooAbsReal.cxx:4066
 RooAbsReal.cxx:4067
 RooAbsReal.cxx:4068
 RooAbsReal.cxx:4069
 RooAbsReal.cxx:4070
 RooAbsReal.cxx:4071
 RooAbsReal.cxx:4072
 RooAbsReal.cxx:4073
 RooAbsReal.cxx:4074
 RooAbsReal.cxx:4075
 RooAbsReal.cxx:4076
 RooAbsReal.cxx:4077
 RooAbsReal.cxx:4078
 RooAbsReal.cxx:4079
 RooAbsReal.cxx:4080
 RooAbsReal.cxx:4081
 RooAbsReal.cxx:4082
 RooAbsReal.cxx:4083
 RooAbsReal.cxx:4084
 RooAbsReal.cxx:4085
 RooAbsReal.cxx:4086
 RooAbsReal.cxx:4087
 RooAbsReal.cxx:4088
 RooAbsReal.cxx:4089
 RooAbsReal.cxx:4090
 RooAbsReal.cxx:4091
 RooAbsReal.cxx:4092
 RooAbsReal.cxx:4093
 RooAbsReal.cxx:4094
 RooAbsReal.cxx:4095
 RooAbsReal.cxx:4096
 RooAbsReal.cxx:4097
 RooAbsReal.cxx:4098
 RooAbsReal.cxx:4099
 RooAbsReal.cxx:4100
 RooAbsReal.cxx:4101
 RooAbsReal.cxx:4102
 RooAbsReal.cxx:4103
 RooAbsReal.cxx:4104
 RooAbsReal.cxx:4105
 RooAbsReal.cxx:4106
 RooAbsReal.cxx:4107
 RooAbsReal.cxx:4108
 RooAbsReal.cxx:4109
 RooAbsReal.cxx:4110
 RooAbsReal.cxx:4111
 RooAbsReal.cxx:4112
 RooAbsReal.cxx:4113
 RooAbsReal.cxx:4114
 RooAbsReal.cxx:4115
 RooAbsReal.cxx:4116
 RooAbsReal.cxx:4117
 RooAbsReal.cxx:4118
 RooAbsReal.cxx:4119
 RooAbsReal.cxx:4120
 RooAbsReal.cxx:4121
 RooAbsReal.cxx:4122
 RooAbsReal.cxx:4123
 RooAbsReal.cxx:4124
 RooAbsReal.cxx:4125
 RooAbsReal.cxx:4126
 RooAbsReal.cxx:4127
 RooAbsReal.cxx:4128
 RooAbsReal.cxx:4129
 RooAbsReal.cxx:4130
 RooAbsReal.cxx:4131
 RooAbsReal.cxx:4132
 RooAbsReal.cxx:4133
 RooAbsReal.cxx:4134
 RooAbsReal.cxx:4135
 RooAbsReal.cxx:4136
 RooAbsReal.cxx:4137
 RooAbsReal.cxx:4138
 RooAbsReal.cxx:4139
 RooAbsReal.cxx:4140
 RooAbsReal.cxx:4141
 RooAbsReal.cxx:4142
 RooAbsReal.cxx:4143
 RooAbsReal.cxx:4144
 RooAbsReal.cxx:4145
 RooAbsReal.cxx:4146
 RooAbsReal.cxx:4147
 RooAbsReal.cxx:4148
 RooAbsReal.cxx:4149
 RooAbsReal.cxx:4150
 RooAbsReal.cxx:4151
 RooAbsReal.cxx:4152
 RooAbsReal.cxx:4153
 RooAbsReal.cxx:4154
 RooAbsReal.cxx:4155
 RooAbsReal.cxx:4156
 RooAbsReal.cxx:4157
 RooAbsReal.cxx:4158
 RooAbsReal.cxx:4159
 RooAbsReal.cxx:4160
 RooAbsReal.cxx:4161
 RooAbsReal.cxx:4162
 RooAbsReal.cxx:4163
 RooAbsReal.cxx:4164
 RooAbsReal.cxx:4165
 RooAbsReal.cxx:4166
 RooAbsReal.cxx:4167
 RooAbsReal.cxx:4168
 RooAbsReal.cxx:4169
 RooAbsReal.cxx:4170
 RooAbsReal.cxx:4171
 RooAbsReal.cxx:4172
 RooAbsReal.cxx:4173
 RooAbsReal.cxx:4174
 RooAbsReal.cxx:4175
 RooAbsReal.cxx:4176
 RooAbsReal.cxx:4177
 RooAbsReal.cxx:4178
 RooAbsReal.cxx:4179
 RooAbsReal.cxx:4180
 RooAbsReal.cxx:4181
 RooAbsReal.cxx:4182
 RooAbsReal.cxx:4183
 RooAbsReal.cxx:4184
 RooAbsReal.cxx:4185
 RooAbsReal.cxx:4186
 RooAbsReal.cxx:4187
 RooAbsReal.cxx:4188
 RooAbsReal.cxx:4189
 RooAbsReal.cxx:4190
 RooAbsReal.cxx:4191
 RooAbsReal.cxx:4192
 RooAbsReal.cxx:4193
 RooAbsReal.cxx:4194
 RooAbsReal.cxx:4195
 RooAbsReal.cxx:4196
 RooAbsReal.cxx:4197
 RooAbsReal.cxx:4198
 RooAbsReal.cxx:4199
 RooAbsReal.cxx:4200
 RooAbsReal.cxx:4201
 RooAbsReal.cxx:4202
 RooAbsReal.cxx:4203
 RooAbsReal.cxx:4204
 RooAbsReal.cxx:4205
 RooAbsReal.cxx:4206
 RooAbsReal.cxx:4207
 RooAbsReal.cxx:4208
 RooAbsReal.cxx:4209
 RooAbsReal.cxx:4210
 RooAbsReal.cxx:4211
 RooAbsReal.cxx:4212
 RooAbsReal.cxx:4213
 RooAbsReal.cxx:4214
 RooAbsReal.cxx:4215
 RooAbsReal.cxx:4216
 RooAbsReal.cxx:4217
 RooAbsReal.cxx:4218
 RooAbsReal.cxx:4219
 RooAbsReal.cxx:4220
 RooAbsReal.cxx:4221
 RooAbsReal.cxx:4222
 RooAbsReal.cxx:4223
 RooAbsReal.cxx:4224
 RooAbsReal.cxx:4225
 RooAbsReal.cxx:4226
 RooAbsReal.cxx:4227
 RooAbsReal.cxx:4228
 RooAbsReal.cxx:4229
 RooAbsReal.cxx:4230
 RooAbsReal.cxx:4231
 RooAbsReal.cxx:4232
 RooAbsReal.cxx:4233
 RooAbsReal.cxx:4234
 RooAbsReal.cxx:4235
 RooAbsReal.cxx:4236
 RooAbsReal.cxx:4237
 RooAbsReal.cxx:4238
 RooAbsReal.cxx:4239
 RooAbsReal.cxx:4240
 RooAbsReal.cxx:4241
 RooAbsReal.cxx:4242
 RooAbsReal.cxx:4243
 RooAbsReal.cxx:4244
 RooAbsReal.cxx:4245
 RooAbsReal.cxx:4246
 RooAbsReal.cxx:4247
 RooAbsReal.cxx:4248
 RooAbsReal.cxx:4249
 RooAbsReal.cxx:4250
 RooAbsReal.cxx:4251
 RooAbsReal.cxx:4252
 RooAbsReal.cxx:4253
 RooAbsReal.cxx:4254
 RooAbsReal.cxx:4255
 RooAbsReal.cxx:4256
 RooAbsReal.cxx:4257
 RooAbsReal.cxx:4258
 RooAbsReal.cxx:4259
 RooAbsReal.cxx:4260
 RooAbsReal.cxx:4261
 RooAbsReal.cxx:4262
 RooAbsReal.cxx:4263
 RooAbsReal.cxx:4264
 RooAbsReal.cxx:4265
 RooAbsReal.cxx:4266
 RooAbsReal.cxx:4267
 RooAbsReal.cxx:4268
 RooAbsReal.cxx:4269
 RooAbsReal.cxx:4270
 RooAbsReal.cxx:4271
 RooAbsReal.cxx:4272
 RooAbsReal.cxx:4273
 RooAbsReal.cxx:4274
 RooAbsReal.cxx:4275
 RooAbsReal.cxx:4276
 RooAbsReal.cxx:4277
 RooAbsReal.cxx:4278
 RooAbsReal.cxx:4279
 RooAbsReal.cxx:4280
 RooAbsReal.cxx:4281
 RooAbsReal.cxx:4282
 RooAbsReal.cxx:4283
 RooAbsReal.cxx:4284
 RooAbsReal.cxx:4285
 RooAbsReal.cxx:4286
 RooAbsReal.cxx:4287
 RooAbsReal.cxx:4288
 RooAbsReal.cxx:4289
 RooAbsReal.cxx:4290
 RooAbsReal.cxx:4291
 RooAbsReal.cxx:4292
 RooAbsReal.cxx:4293
 RooAbsReal.cxx:4294
 RooAbsReal.cxx:4295
 RooAbsReal.cxx:4296
 RooAbsReal.cxx:4297
 RooAbsReal.cxx:4298
 RooAbsReal.cxx:4299
 RooAbsReal.cxx:4300
 RooAbsReal.cxx:4301
 RooAbsReal.cxx:4302
 RooAbsReal.cxx:4303
 RooAbsReal.cxx:4304
 RooAbsReal.cxx:4305
 RooAbsReal.cxx:4306
 RooAbsReal.cxx:4307
 RooAbsReal.cxx:4308
 RooAbsReal.cxx:4309
 RooAbsReal.cxx:4310
 RooAbsReal.cxx:4311
 RooAbsReal.cxx:4312
 RooAbsReal.cxx:4313
 RooAbsReal.cxx:4314
 RooAbsReal.cxx:4315
 RooAbsReal.cxx:4316
 RooAbsReal.cxx:4317
 RooAbsReal.cxx:4318
 RooAbsReal.cxx:4319
 RooAbsReal.cxx:4320
 RooAbsReal.cxx:4321
 RooAbsReal.cxx:4322
 RooAbsReal.cxx:4323
 RooAbsReal.cxx:4324
 RooAbsReal.cxx:4325
 RooAbsReal.cxx:4326
 RooAbsReal.cxx:4327
 RooAbsReal.cxx:4328
 RooAbsReal.cxx:4329
 RooAbsReal.cxx:4330
 RooAbsReal.cxx:4331
 RooAbsReal.cxx:4332
 RooAbsReal.cxx:4333
 RooAbsReal.cxx:4334
 RooAbsReal.cxx:4335
 RooAbsReal.cxx:4336
 RooAbsReal.cxx:4337
 RooAbsReal.cxx:4338
 RooAbsReal.cxx:4339
 RooAbsReal.cxx:4340
 RooAbsReal.cxx:4341
 RooAbsReal.cxx:4342
 RooAbsReal.cxx:4343
 RooAbsReal.cxx:4344
 RooAbsReal.cxx:4345
 RooAbsReal.cxx:4346
 RooAbsReal.cxx:4347
 RooAbsReal.cxx:4348
 RooAbsReal.cxx:4349
 RooAbsReal.cxx:4350
 RooAbsReal.cxx:4351
 RooAbsReal.cxx:4352
 RooAbsReal.cxx:4353
 RooAbsReal.cxx:4354
 RooAbsReal.cxx:4355
 RooAbsReal.cxx:4356
 RooAbsReal.cxx:4357
 RooAbsReal.cxx:4358
 RooAbsReal.cxx:4359
 RooAbsReal.cxx:4360
 RooAbsReal.cxx:4361
 RooAbsReal.cxx:4362
 RooAbsReal.cxx:4363
 RooAbsReal.cxx:4364
 RooAbsReal.cxx:4365
 RooAbsReal.cxx:4366
 RooAbsReal.cxx:4367
 RooAbsReal.cxx:4368
 RooAbsReal.cxx:4369
 RooAbsReal.cxx:4370
 RooAbsReal.cxx:4371
 RooAbsReal.cxx:4372
 RooAbsReal.cxx:4373
 RooAbsReal.cxx:4374
 RooAbsReal.cxx:4375
 RooAbsReal.cxx:4376
 RooAbsReal.cxx:4377
 RooAbsReal.cxx:4378
 RooAbsReal.cxx:4379
 RooAbsReal.cxx:4380
 RooAbsReal.cxx:4381
 RooAbsReal.cxx:4382
 RooAbsReal.cxx:4383
 RooAbsReal.cxx:4384
 RooAbsReal.cxx:4385
 RooAbsReal.cxx:4386
 RooAbsReal.cxx:4387
 RooAbsReal.cxx:4388
 RooAbsReal.cxx:4389
 RooAbsReal.cxx:4390
 RooAbsReal.cxx:4391
 RooAbsReal.cxx:4392
 RooAbsReal.cxx:4393
 RooAbsReal.cxx:4394
 RooAbsReal.cxx:4395
 RooAbsReal.cxx:4396
 RooAbsReal.cxx:4397
 RooAbsReal.cxx:4398
 RooAbsReal.cxx:4399
 RooAbsReal.cxx:4400
 RooAbsReal.cxx:4401
 RooAbsReal.cxx:4402
 RooAbsReal.cxx:4403
 RooAbsReal.cxx:4404
 RooAbsReal.cxx:4405
 RooAbsReal.cxx:4406
 RooAbsReal.cxx:4407
 RooAbsReal.cxx:4408
 RooAbsReal.cxx:4409
 RooAbsReal.cxx:4410
 RooAbsReal.cxx:4411
 RooAbsReal.cxx:4412
 RooAbsReal.cxx:4413
 RooAbsReal.cxx:4414
 RooAbsReal.cxx:4415
 RooAbsReal.cxx:4416
 RooAbsReal.cxx:4417
 RooAbsReal.cxx:4418
 RooAbsReal.cxx:4419
 RooAbsReal.cxx:4420
 RooAbsReal.cxx:4421
 RooAbsReal.cxx:4422
 RooAbsReal.cxx:4423
 RooAbsReal.cxx:4424
 RooAbsReal.cxx:4425
 RooAbsReal.cxx:4426
 RooAbsReal.cxx:4427
 RooAbsReal.cxx:4428
 RooAbsReal.cxx:4429
 RooAbsReal.cxx:4430
 RooAbsReal.cxx:4431
 RooAbsReal.cxx:4432
 RooAbsReal.cxx:4433
 RooAbsReal.cxx:4434
 RooAbsReal.cxx:4435
 RooAbsReal.cxx:4436
 RooAbsReal.cxx:4437
 RooAbsReal.cxx:4438
 RooAbsReal.cxx:4439
 RooAbsReal.cxx:4440
 RooAbsReal.cxx:4441
 RooAbsReal.cxx:4442
 RooAbsReal.cxx:4443
 RooAbsReal.cxx:4444
 RooAbsReal.cxx:4445
 RooAbsReal.cxx:4446
 RooAbsReal.cxx:4447
 RooAbsReal.cxx:4448
 RooAbsReal.cxx:4449
 RooAbsReal.cxx:4450
 RooAbsReal.cxx:4451
 RooAbsReal.cxx:4452
 RooAbsReal.cxx:4453
 RooAbsReal.cxx:4454
 RooAbsReal.cxx:4455
 RooAbsReal.cxx:4456
 RooAbsReal.cxx:4457
 RooAbsReal.cxx:4458
 RooAbsReal.cxx:4459
 RooAbsReal.cxx:4460
 RooAbsReal.cxx:4461
 RooAbsReal.cxx:4462
 RooAbsReal.cxx:4463
 RooAbsReal.cxx:4464
 RooAbsReal.cxx:4465
 RooAbsReal.cxx:4466
 RooAbsReal.cxx:4467
 RooAbsReal.cxx:4468
 RooAbsReal.cxx:4469
 RooAbsReal.cxx:4470
 RooAbsReal.cxx:4471
 RooAbsReal.cxx:4472
 RooAbsReal.cxx:4473
 RooAbsReal.cxx:4474
 RooAbsReal.cxx:4475
 RooAbsReal.cxx:4476
 RooAbsReal.cxx:4477
 RooAbsReal.cxx:4478
 RooAbsReal.cxx:4479
 RooAbsReal.cxx:4480
 RooAbsReal.cxx:4481
 RooAbsReal.cxx:4482
 RooAbsReal.cxx:4483
 RooAbsReal.cxx:4484
 RooAbsReal.cxx:4485
 RooAbsReal.cxx:4486
 RooAbsReal.cxx:4487
 RooAbsReal.cxx:4488
 RooAbsReal.cxx:4489
 RooAbsReal.cxx:4490
 RooAbsReal.cxx:4491
 RooAbsReal.cxx:4492
 RooAbsReal.cxx:4493
 RooAbsReal.cxx:4494
 RooAbsReal.cxx:4495
 RooAbsReal.cxx:4496
 RooAbsReal.cxx:4497
 RooAbsReal.cxx:4498
 RooAbsReal.cxx:4499
 RooAbsReal.cxx:4500
 RooAbsReal.cxx:4501
 RooAbsReal.cxx:4502
 RooAbsReal.cxx:4503
 RooAbsReal.cxx:4504
 RooAbsReal.cxx:4505
 RooAbsReal.cxx:4506
 RooAbsReal.cxx:4507
 RooAbsReal.cxx:4508
 RooAbsReal.cxx:4509
 RooAbsReal.cxx:4510
 RooAbsReal.cxx:4511
 RooAbsReal.cxx:4512
 RooAbsReal.cxx:4513
 RooAbsReal.cxx:4514
 RooAbsReal.cxx:4515
 RooAbsReal.cxx:4516
 RooAbsReal.cxx:4517
 RooAbsReal.cxx:4518
 RooAbsReal.cxx:4519
 RooAbsReal.cxx:4520
 RooAbsReal.cxx:4521
 RooAbsReal.cxx:4522
 RooAbsReal.cxx:4523
 RooAbsReal.cxx:4524
 RooAbsReal.cxx:4525
 RooAbsReal.cxx:4526
 RooAbsReal.cxx:4527
 RooAbsReal.cxx:4528
 RooAbsReal.cxx:4529
 RooAbsReal.cxx:4530
 RooAbsReal.cxx:4531
 RooAbsReal.cxx:4532
 RooAbsReal.cxx:4533
 RooAbsReal.cxx:4534
 RooAbsReal.cxx:4535
 RooAbsReal.cxx:4536
 RooAbsReal.cxx:4537
 RooAbsReal.cxx:4538
 RooAbsReal.cxx:4539
 RooAbsReal.cxx:4540
 RooAbsReal.cxx:4541
 RooAbsReal.cxx:4542
 RooAbsReal.cxx:4543
 RooAbsReal.cxx:4544
 RooAbsReal.cxx:4545
 RooAbsReal.cxx:4546
 RooAbsReal.cxx:4547
 RooAbsReal.cxx:4548
 RooAbsReal.cxx:4549
 RooAbsReal.cxx:4550
 RooAbsReal.cxx:4551
 RooAbsReal.cxx:4552
 RooAbsReal.cxx:4553
 RooAbsReal.cxx:4554
 RooAbsReal.cxx:4555
 RooAbsReal.cxx:4556
 RooAbsReal.cxx:4557
 RooAbsReal.cxx:4558
 RooAbsReal.cxx:4559
 RooAbsReal.cxx:4560
 RooAbsReal.cxx:4561
 RooAbsReal.cxx:4562
 RooAbsReal.cxx:4563
 RooAbsReal.cxx:4564
 RooAbsReal.cxx:4565
 RooAbsReal.cxx:4566
 RooAbsReal.cxx:4567
 RooAbsReal.cxx:4568
 RooAbsReal.cxx:4569
 RooAbsReal.cxx:4570
 RooAbsReal.cxx:4571
 RooAbsReal.cxx:4572
 RooAbsReal.cxx:4573
 RooAbsReal.cxx:4574
 RooAbsReal.cxx:4575
 RooAbsReal.cxx:4576
 RooAbsReal.cxx:4577
 RooAbsReal.cxx:4578
 RooAbsReal.cxx:4579
 RooAbsReal.cxx:4580
 RooAbsReal.cxx:4581
 RooAbsReal.cxx:4582
 RooAbsReal.cxx:4583
 RooAbsReal.cxx:4584
 RooAbsReal.cxx:4585
 RooAbsReal.cxx:4586
 RooAbsReal.cxx:4587
 RooAbsReal.cxx:4588
 RooAbsReal.cxx:4589
 RooAbsReal.cxx:4590
 RooAbsReal.cxx:4591
 RooAbsReal.cxx:4592
 RooAbsReal.cxx:4593
 RooAbsReal.cxx:4594
 RooAbsReal.cxx:4595
 RooAbsReal.cxx:4596
 RooAbsReal.cxx:4597
 RooAbsReal.cxx:4598
 RooAbsReal.cxx:4599
 RooAbsReal.cxx:4600
 RooAbsReal.cxx:4601
 RooAbsReal.cxx:4602
 RooAbsReal.cxx:4603
 RooAbsReal.cxx:4604
 RooAbsReal.cxx:4605
 RooAbsReal.cxx:4606
 RooAbsReal.cxx:4607
 RooAbsReal.cxx:4608
 RooAbsReal.cxx:4609
 RooAbsReal.cxx:4610
 RooAbsReal.cxx:4611
 RooAbsReal.cxx:4612
 RooAbsReal.cxx:4613
 RooAbsReal.cxx:4614
 RooAbsReal.cxx:4615
 RooAbsReal.cxx:4616
 RooAbsReal.cxx:4617
 RooAbsReal.cxx:4618
 RooAbsReal.cxx:4619
 RooAbsReal.cxx:4620
 RooAbsReal.cxx:4621
 RooAbsReal.cxx:4622
 RooAbsReal.cxx:4623
 RooAbsReal.cxx:4624
 RooAbsReal.cxx:4625
 RooAbsReal.cxx:4626
 RooAbsReal.cxx:4627
 RooAbsReal.cxx:4628
 RooAbsReal.cxx:4629
 RooAbsReal.cxx:4630
 RooAbsReal.cxx:4631
 RooAbsReal.cxx:4632
 RooAbsReal.cxx:4633
 RooAbsReal.cxx:4634
 RooAbsReal.cxx:4635
 RooAbsReal.cxx:4636
 RooAbsReal.cxx:4637
 RooAbsReal.cxx:4638
 RooAbsReal.cxx:4639
 RooAbsReal.cxx:4640
 RooAbsReal.cxx:4641
 RooAbsReal.cxx:4642
 RooAbsReal.cxx:4643
 RooAbsReal.cxx:4644
 RooAbsReal.cxx:4645
 RooAbsReal.cxx:4646
 RooAbsReal.cxx:4647
 RooAbsReal.cxx:4648
 RooAbsReal.cxx:4649
 RooAbsReal.cxx:4650
 RooAbsReal.cxx:4651
 RooAbsReal.cxx:4652
 RooAbsReal.cxx:4653
 RooAbsReal.cxx:4654
 RooAbsReal.cxx:4655
 RooAbsReal.cxx:4656
 RooAbsReal.cxx:4657
 RooAbsReal.cxx:4658
 RooAbsReal.cxx:4659
 RooAbsReal.cxx:4660
 RooAbsReal.cxx:4661
 RooAbsReal.cxx:4662
 RooAbsReal.cxx:4663
 RooAbsReal.cxx:4664
 RooAbsReal.cxx:4665
 RooAbsReal.cxx:4666
 RooAbsReal.cxx:4667
 RooAbsReal.cxx:4668
 RooAbsReal.cxx:4669
 RooAbsReal.cxx:4670
 RooAbsReal.cxx:4671
 RooAbsReal.cxx:4672
 RooAbsReal.cxx:4673
 RooAbsReal.cxx:4674
 RooAbsReal.cxx:4675
 RooAbsReal.cxx:4676
 RooAbsReal.cxx:4677
 RooAbsReal.cxx:4678
 RooAbsReal.cxx:4679
 RooAbsReal.cxx:4680
 RooAbsReal.cxx:4681
 RooAbsReal.cxx:4682
 RooAbsReal.cxx:4683
 RooAbsReal.cxx:4684
 RooAbsReal.cxx:4685
 RooAbsReal.cxx:4686
 RooAbsReal.cxx:4687
 RooAbsReal.cxx:4688
 RooAbsReal.cxx:4689
 RooAbsReal.cxx:4690
 RooAbsReal.cxx:4691
 RooAbsReal.cxx:4692
 RooAbsReal.cxx:4693
 RooAbsReal.cxx:4694
 RooAbsReal.cxx:4695
 RooAbsReal.cxx:4696
 RooAbsReal.cxx:4697
 RooAbsReal.cxx:4698
 RooAbsReal.cxx:4699
 RooAbsReal.cxx:4700
 RooAbsReal.cxx:4701
 RooAbsReal.cxx:4702
 RooAbsReal.cxx:4703
 RooAbsReal.cxx:4704
 RooAbsReal.cxx:4705
 RooAbsReal.cxx:4706
 RooAbsReal.cxx:4707
 RooAbsReal.cxx:4708
 RooAbsReal.cxx:4709
 RooAbsReal.cxx:4710
 RooAbsReal.cxx:4711
 RooAbsReal.cxx:4712
 RooAbsReal.cxx:4713
 RooAbsReal.cxx:4714
 RooAbsReal.cxx:4715
 RooAbsReal.cxx:4716
 RooAbsReal.cxx:4717