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

//////////////////////////////////////////////////////////////////////////////
//
// BEGIN_HTML
// RooProdPdf is an efficient implementation of a product of PDFs of the form 
//
//  PDF_1 * PDF_2 * ... * PDF_N
//
// PDFs may share observables. If that is the case any irreducable subset
// of PDFS that share observables will be normalized with explicit numeric
// integration as any built-in normalization will no longer be valid.
//
// Alternatively, products using conditional PDFs can be defined, e.g.
//
//    F(x|y) * G(y)
//
// meaning a pdf F(x) _given_ y and a PDF G(y). In this contruction F is only
// normalized w.r.t x and G is normalized w.r.t y. The product in this construction
// is properly normalized.
//
// If exactly one of the component PDFs supports extended likelihood fits, the
// product will also be usable in extended mode, returning the number of expected
// events from the extendable component PDF. The extendable component does not
// have to appear in any specific place in the list.
// 
// END_HTML
//

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

#include "TIterator.h"
#include "RooProdPdf.h"
#include "RooRealProxy.h"
#include "RooProdGenContext.h"
#include "RooGenProdProj.h"
#include "RooProduct.h"
#include "RooNameReg.h"
#include "RooMsgService.h"



ClassImp(RooProdPdf)
;



//_____________________________________________________________________________
RooProdPdf::RooProdPdf() :
  _curNormSet(0),
  _cutOff(0),
  _extendedIndex(-1),
  _useDefaultGen(kFALSE)
{
  // Default constructor
  _pdfIter = _pdfList.createIterator() ;  
}



//_____________________________________________________________________________
RooProdPdf::RooProdPdf(const char *name, const char *title, Double_t cutOff) :
  RooAbsPdf(name,title), 
  _cacheMgr(this,10),
  _genCode(10),
  _cutOff(cutOff),
  _pdfList("!pdfs","List of PDFs",this),
  _extendedIndex(-1),
  _useDefaultGen(kFALSE)
{
  // Dummy constructor
  _pdfIter = _pdfList.createIterator() ;
}



//_____________________________________________________________________________
RooProdPdf::RooProdPdf(const char *name, const char *title,
		       RooAbsPdf& pdf1, RooAbsPdf& pdf2, Double_t cutOff) : 
  RooAbsPdf(name,title), 
  _cacheMgr(this,10),
  _genCode(10),
  _cutOff(cutOff),
  _pdfList("!pdfs","List of PDFs",this),
  _pdfIter(_pdfList.createIterator()), 
  _extendedIndex(-1),
  _useDefaultGen(kFALSE)
{
  // Constructor with 2 PDFs (most frequent use case).
  // 
  // The optional cutOff parameter can be used as a speed optimization if
  // one or more of the PDF have sizable regions with very small values,
  // which would pull the entire product of PDFs to zero in those regions.
  //
  // After each PDF multiplication, the running product is compared with
  // the cutOff parameter. If the running product is smaller than the
  // cutOff value, the product series is terminated and remaining PDFs
  // are not evaluated.
  //
  // There is no magic value of the cutOff, the user should experiment
  // to find the appropriate balance between speed and precision.
  // If a cutoff is specified, the PDFs most likely to be small should
  // be put first in the product. The default cutOff value is zero.
  //

  _pdfList.add(pdf1) ;
  RooArgSet* nset1 = new RooArgSet("nset") ;
  _pdfNSetList.Add(nset1) ;
  if (pdf1.canBeExtended()) {
    _extendedIndex = _pdfList.index(&pdf1) ;
  }

  _pdfList.add(pdf2) ;
  RooArgSet* nset2 = new RooArgSet("nset") ;
  _pdfNSetList.Add(nset2) ;

  if (pdf2.canBeExtended()) {
    if (_extendedIndex>=0) {
      // Protect against multiple extended terms
      coutW(InputArguments) << "RooProdPdf::RooProdPdf(" << GetName() 
			    << ") multiple components with extended terms detected,"
			    << " product will not be extendible." << endl ;
      _extendedIndex=-1 ;
    } else {
      _extendedIndex=_pdfList.index(&pdf2) ;
    }
  }
}



//_____________________________________________________________________________
RooProdPdf::RooProdPdf(const char* name, const char* title, const RooArgList& inPdfList, Double_t cutOff) :
  RooAbsPdf(name,title), 
  _cacheMgr(this,10),
  _genCode(10),
  _cutOff(cutOff),
  _pdfList("!pdfs","List of PDFs",this),
  _pdfIter(_pdfList.createIterator()), 
  _extendedIndex(-1),
  _useDefaultGen(kFALSE)
{
  // Constructor from a list of PDFs
  // 
  // The optional cutOff parameter can be used as a speed optimization if
  // one or more of the PDF have sizable regions with very small values,
  // which would pull the entire product of PDFs to zero in those regions.
  //
  // After each PDF multiplication, the running product is compared with
  // the cutOff parameter. If the running product is smaller than the
  // cutOff value, the product series is terminated and remaining PDFs
  // are not evaluated.
  //
  // There is no magic value of the cutOff, the user should experiment
  // to find the appropriate balance between speed and precision.
  // If a cutoff is specified, the PDFs most likely to be small should
  // be put first in the product. The default cutOff value is zero.

  TIterator* iter = inPdfList.createIterator() ;
  RooAbsArg* arg ;
  Int_t numExtended(0) ;
  while((arg=(RooAbsArg*)iter->Next())) {
    RooAbsPdf* pdf = dynamic_cast<RooAbsPdf*>(arg) ;
    if (!pdf) {
      coutW(InputArguments) << "RooProdPdf::RooProdPdf(" << GetName() << ") list arg " 
			    << pdf->GetName() << " is not a PDF, ignored" << endl ;
      continue ;
    }
    _pdfList.add(*pdf) ;

    RooArgSet* nset = new RooArgSet("nset") ;
    _pdfNSetList.Add(nset) ;

    if (pdf->canBeExtended()) {
      _extendedIndex = _pdfList.index(pdf) ;
      numExtended++ ;
    }
  }

  // Protect against multiple extended terms
  if (numExtended>1) {
    coutW(InputArguments) << "RooProdPdf::RooProdPdf(" << GetName() 
			  << ") WARNING: multiple components with extended terms detected,"
			  << " product will not be extendible." << endl ;
    _extendedIndex = -1 ;
  }

  delete iter ;
}



//_____________________________________________________________________________
RooProdPdf::RooProdPdf(const char* name, const char* title, const RooArgSet& fullPdfSet,
		       const RooCmdArg& arg1, const RooCmdArg& arg2,
		       const RooCmdArg& arg3, const RooCmdArg& arg4,
		       const RooCmdArg& arg5, const RooCmdArg& arg6,
		       const RooCmdArg& arg7, const RooCmdArg& arg8) :
  RooAbsPdf(name,title), 
  _cacheMgr(this,10),
  _genCode(10),
  _cutOff(0),
  _pdfList("!pdfs","List of PDFs",this),
  _pdfIter(_pdfList.createIterator()), 
  _extendedIndex(-1),
  _useDefaultGen(kFALSE)
{
  // Constructor from named argument list
  //
  // fullPdf -- Set of 'regular' PDFS that are normalized over all their observables
  // Conditional(pdfSet,depSet) -- Add PDF to product with condition that it
  //                               only be normalized over specified observables
  //                               any remaining observables will be conditional
  //                               observables
  //                               
  //
  // For example, given a PDF F(x,y) and G(y)
  //
  // RooProdPdf("P","P",G,Conditional(F,x)) will construct a 2-dimensional PDF as follows:
  // 
  //   P(x,y) = G(y)/Int[y]G(y) * F(x,y)/Int[x]G(x,y)
  //
  // which is a well normalized and properly defined PDF, but different from the
  //  
  //  P'(x,y) = F(x,y)*G(y) / Int[x,y] F(x,y)*G(y)
  //
  // In the former case the y distribution of P is identical to that of G, while
  // F only is used to determine the correlation between X and Y. In the latter
  // case the Y distribution is defined by the product of F and G.
  //
  // This P(x,y) construction is analoguous to generating events from F(x,y) with
  // a prototype dataset sampled from G(y)
  
  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) ;

  initializeFromCmdArgList(fullPdfSet,l) ;
}



//_____________________________________________________________________________
RooProdPdf::RooProdPdf(const char* name, const char* title,
		       const RooCmdArg& arg1, const RooCmdArg& arg2,
		       const RooCmdArg& arg3, const RooCmdArg& arg4,
		       const RooCmdArg& arg5, const RooCmdArg& arg6,
		       const RooCmdArg& arg7, const RooCmdArg& arg8) :
  RooAbsPdf(name,title), 
  _cacheMgr(this,10),
  _genCode(10),
  _cutOff(0),
  _pdfList("!pdfList","List of PDFs",this),
  _pdfIter(_pdfList.createIterator()), 
  _extendedIndex(-1),
  _useDefaultGen(kFALSE)
{
  // Constructor from named argument list
  //
  // fullPdf -- Set of 'regular' PDFS that are normalized over all their observables
  // Conditional(pdfSet,depSet) -- Add PDF to product with condition that it
  //                               only be normalized over specified observables
  //                               any remaining observables will be conditional
  //                               observables
  //                               
  //
  // For example, given a PDF F(x,y) and G(y)
  //
  // RooProdPdf("P","P",G,Conditional(F,x)) will construct a 2-dimensional PDF as follows:
  // 
  //   P(x,y) = G(y)/Int[y]G(y) * F(x,y)/Int[x]G(x,y)
  //
  // which is a well normalized and properly defined PDF, but different from the
  //  
  //  P'(x,y) = F(x,y)*G(y) / Int[x,y] F(x,y)*G(y)
  //
  // In the former case the y distribution of P is identical to that of G, while
  // F only is used to determine the correlation between X and Y. In the latter
  // case the Y distribution is defined by the product of F and G.
  //
  // This P(x,y) construction is analoguous to generating events from F(x,y) with
  // a prototype dataset sampled from G(y)
  
  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) ;

  initializeFromCmdArgList(RooArgSet(),l) ;
}



//_____________________________________________________________________________
RooProdPdf::RooProdPdf(const char* name, const char* title, const RooArgSet& fullPdfSet, const RooLinkedList& cmdArgList) :
  RooAbsPdf(name,title), 
  _cacheMgr(this,10),
  _genCode(10),
  _cutOff(0),
  _pdfList("!pdfs","List of PDFs",this),
  _pdfIter(_pdfList.createIterator()), 
  _extendedIndex(-1),
  _useDefaultGen(kFALSE)
{
  // Internal constructor from list of named arguments  
  initializeFromCmdArgList(fullPdfSet, cmdArgList) ;
}



//_____________________________________________________________________________
RooProdPdf::RooProdPdf(const RooProdPdf& other, const char* name) :
  RooAbsPdf(other,name), 
  _cacheMgr(other._cacheMgr,this),
  _genCode(other._genCode),
  _cutOff(other._cutOff),
  _pdfList("!pdfs",this,other._pdfList),
  _pdfIter(_pdfList.createIterator()), 
  _extendedIndex(other._extendedIndex),
  _useDefaultGen(other._useDefaultGen)
{
  // Copy constructor

  // Clone contents of normalizarion set list
  TIterator* iter = other._pdfNSetList.MakeIterator() ;
  RooArgSet* nset ;
  while((nset=(RooArgSet*)iter->Next())) {
    RooArgSet* tmp = (RooArgSet*) nset->snapshot() ;
    tmp->setName(nset->GetName()) ;
    _pdfNSetList.Add(tmp) ;
  }
  delete iter ;

}



//_____________________________________________________________________________
void RooProdPdf::initializeFromCmdArgList(const RooArgSet& fullPdfSet, const RooLinkedList& l)
{
  // Initialize RooProdPdf configuration from given list of RooCmdArg configuration arguments
  // and set of 'regular' p.d.f.s in product

  Int_t numExtended(0) ;

  // Process set of full PDFS
  TIterator* siter = fullPdfSet.createIterator() ;
  RooAbsPdf* pdf ;
  while((pdf=(RooAbsPdf*)siter->Next())) {
    _pdfList.add(*pdf) ;
    RooArgSet* nset1 = new RooArgSet("nset") ;
    _pdfNSetList.Add(nset1) ;       

    if (pdf->canBeExtended()) {
      _extendedIndex = _pdfList.index(pdf) ;
      numExtended++ ;
    }

  }
  delete siter ;

  // Process list of conditional PDFs
  TIterator* iter = l.MakeIterator() ;
  RooCmdArg* carg ;
  while((carg=(RooCmdArg*)iter->Next())) {

    if (!TString(carg->GetName()).CompareTo("Conditional")) {

      Int_t argType = carg->getInt(0) ;
      RooArgSet* pdfSet = (RooArgSet*) carg->getSet(0) ;
      RooArgSet* normSet = (RooArgSet*) carg->getSet(1) ;

      TIterator* siter2 = pdfSet->createIterator() ;
      RooAbsPdf* thePdf ;
      while((thePdf=(RooAbsPdf*)siter2->Next())) {
	_pdfList.add(*thePdf) ;

	if (argType==0) {
	  RooArgSet* tmp = (RooArgSet*) normSet->snapshot() ;
	  tmp->setName("nset") ;
	  _pdfNSetList.Add(tmp) ;       	  
	} else {
	  RooArgSet* tmp = (RooArgSet*) normSet->snapshot() ;
	  tmp->setName("cset") ;
	  _pdfNSetList.Add(tmp) ;       	  
	}

	if (thePdf->canBeExtended()) {
	  _extendedIndex = _pdfList.index(thePdf) ;
	  numExtended++ ;
	}

      }
      delete siter2 ;


    } else if (TString(carg->GetName()).CompareTo("")) {
      coutW(InputArguments) << "Unknown arg: " << carg->GetName() << endl ;
    }
  }

  // Protect against multiple extended terms
  if (numExtended>1) {
    coutW(InputArguments) << "RooProdPdf::RooProdPdf(" << GetName() 
			  << ") WARNING: multiple components with extended terms detected,"
			  << " product will not be extendible." << endl ;
    _extendedIndex = -1 ;
  }


  delete iter ;
}



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

  _pdfNSetList.Delete() ;
  delete _pdfIter ;
}



//_____________________________________________________________________________
Double_t RooProdPdf::getVal(const RooArgSet* set) const 
{
  // Overload getVal() to intercept normalization set for use in evaluate()
  _curNormSet = (RooArgSet*)set ;
  return RooAbsPdf::getVal(set) ;
}



//_____________________________________________________________________________
Double_t RooProdPdf::evaluate() const 
{
  // Calculate current value of object

  Int_t code ;
  RooArgList *plist ;
  RooLinkedList *nlist ;
  getPartIntList(_curNormSet,0,plist,nlist,code) ;

  Double_t ret =  calculate(plist,nlist) ;
  return ret ;
}



//_____________________________________________________________________________
Double_t RooProdPdf::calculate(const RooArgList* partIntList, const RooLinkedList* normSetList) const
{
  // Calculate running product of pdfs terms, using the supplied
  // normalization set in 'normSetList' for each component

  RooAbsReal* partInt ;
  RooArgSet* normSet ;
  Double_t value(1.0) ;
  Int_t n = partIntList->getSize() ;

  Int_t i ;
  for (i=0 ; i<n ; i++) {
    partInt = ((RooAbsReal*)partIntList->at(i)) ;
    normSet = ((RooArgSet*)normSetList->At(i)) ;    
    Double_t piVal = partInt->getVal(normSet->getSize()>0 ? normSet : 0) ;
    value *= piVal ;
    if (value<_cutOff) {
      break ;
    }
  }

  return value ;
}



//_____________________________________________________________________________
void RooProdPdf::factorizeProduct(const RooArgSet& normSet, const RooArgSet& intSet,
				  RooLinkedList& termList, RooLinkedList& normList, 
				  RooLinkedList& impDepList, RooLinkedList& crossDepList,
				  RooLinkedList& intList) const 
{
  // Factorize product in irreducible terms for given choice of integration/normalization
 
  _pdfIter->Reset() ;
  RooAbsPdf* pdf ;

  // List of all term dependents: normalization and imported
  RooLinkedList depAllList ;
  RooLinkedList depIntNoNormList ;

  // Setup lists for factorization terms and their dependents
  RooArgSet* term(0) ;
  RooArgSet* termNormDeps(0) ;
  RooArgSet* termAllDeps(0) ;
  RooArgSet* termIntDeps(0) ;
  RooArgSet* termIntNoNormDeps(0) ;
  TIterator* lIter = termList.MakeIterator() ;
  TIterator* ldIter = normList.MakeIterator() ;
  TIterator* laIter = depAllList.MakeIterator() ;
  TIterator* nIter = _pdfNSetList.MakeIterator() ;
  RooArgSet* pdfNSet ;

  // Loop over the PDFs
  while((pdf=(RooAbsPdf*)_pdfIter->Next())) {    
    pdfNSet = (RooArgSet*) nIter->Next() ;
    lIter->Reset() ;
    ldIter->Reset() ;
    laIter->Reset() ;

    // Reduce pdfNSet to actual dependents
    if (string("nset")==pdfNSet->GetName()) {
      pdfNSet = pdf->getObservables(*pdfNSet) ;
    } else if (string("cset") == pdfNSet->GetName()) {
      RooArgSet* tmp = pdf->getObservables(normSet) ;
      tmp->remove(*pdfNSet,kTRUE,kTRUE) ;
      pdfNSet = tmp ;
    } else {
      // Legacy mode. Interpret at NSet for backward compatibility
      pdfNSet = pdf->getObservables(*pdfNSet) ;
//       coutE(InputArguments) << "RooProdPdf::factorizeProduct(" << GetName() << ") ERROR: internal error encountered in input arguments set of observables associated with pdf " 
// 			    << pdf->GetName() << " is labeled neither 'nset' nor 'cset'" << endl ;
      return ;
    }

    RooArgSet pdfNormDeps ; // Dependents to be normalized for the PDF
    RooArgSet pdfAllDeps ; // All dependents of this PDF ;

    // Make list of all dependents of this PDF
    RooArgSet* tmp = pdf->getObservables(normSet) ;
    pdfAllDeps.add(*tmp) ;
    delete tmp ;

    // Make list of normalization dependents for this PDF ;
    if (pdfNSet->getSize()>0) {
      RooArgSet* tmp2 = (RooArgSet*) pdfAllDeps.selectCommon(*pdfNSet) ;
      pdfNormDeps.add(*tmp2) ;
      delete tmp2 ;
    } else {
      pdfNormDeps.add(pdfAllDeps) ;
    }

//     cout << "pdfNormDeps for " << pdf->GetName() << " = " << pdfNormDeps << endl ;

    RooArgSet* pdfIntSet = pdf->getObservables(intSet) ;

    RooArgSet pdfIntNoNormDeps(*pdfIntSet) ;
    pdfIntNoNormDeps.remove(pdfNormDeps,kTRUE,kTRUE) ;

    // Check if this PDF has dependents overlapping with one of the existing terms
    Bool_t done(kFALSE) ;
    while((term=(RooArgSet*)lIter->Next())) {      
      termNormDeps=(RooArgSet*)ldIter->Next() ;
      termAllDeps=(RooArgSet*)laIter->Next() ;

      // PDF should be added to existing term if 
      // 1) It has overlapping normalization dependents with any other PDF in existing term
      // 2) It has overlapping dependents of any class for which integration is requested

      Bool_t normOverlap = pdfNormDeps.overlaps(*termNormDeps)  ;
      // Bool_t intOverlap =  pdfIntSet->overlaps(*termAllDeps) ;

      //if (normOverlap || intOverlap) {
      if (normOverlap) {
	term->add(*pdf) ;
	termNormDeps->add(pdfNormDeps,kFALSE) ;
	termAllDeps->add(pdfAllDeps,kFALSE) ;
	termIntDeps->add(*pdfIntSet,kFALSE) ;
	termIntNoNormDeps->add(pdfIntNoNormDeps,kFALSE) ;
	done = kTRUE ;
      }
    }

    // If not, create a new term
    if (!done) {
      term = new RooArgSet("term") ;
      termNormDeps = new RooArgSet("termNormDeps") ;
      termAllDeps = new RooArgSet("termAllDeps") ;
      termIntDeps = new RooArgSet("termIntDeps") ;
      termIntNoNormDeps = new RooArgSet("termIntNoNormDeps") ;

      term->add(*pdf) ;
      termNormDeps->add(pdfNormDeps,kFALSE) ;
      termAllDeps->add(pdfAllDeps,kFALSE) ;
      termIntDeps->add(*pdfIntSet,kFALSE) ;
      termIntNoNormDeps->add(pdfIntNoNormDeps,kFALSE) ;

      termList.Add(term) ;
      normList.Add(termNormDeps) ;
      depAllList.Add(termAllDeps) ;
      intList.Add(termIntDeps) ;
      depIntNoNormList.Add(termIntNoNormDeps) ;
    }

    // We own the reduced version of pdfNSet
    delete pdfNSet ;
    delete pdfIntSet ;
  }

  // Loop over list of terms again to determine 'imported' observables
  lIter->Reset() ;
  ldIter->Reset() ;
  laIter->Reset() ;
  TIterator* innIter = depIntNoNormList.MakeIterator() ;

  while((term=(RooArgSet*)lIter->Next())) {
    RooArgSet* normDeps = (RooArgSet*) ldIter->Next() ;
    RooArgSet* allDeps = (RooArgSet*) laIter->Next() ;
    RooArgSet* intNoNormDeps = (RooArgSet*) innIter->Next() ;

    // Make list of wholly imported dependents
    RooArgSet impDeps(*allDeps) ;
    impDeps.remove(*normDeps,kTRUE,kTRUE) ;
    impDepList.Add(impDeps.snapshot()) ;

    // Make list of cross dependents (term is self contained for these dependents, 
    // but components import dependents from other components)
    RooArgSet* crossDeps = (RooArgSet*) intNoNormDeps->selectCommon(*normDeps) ;
    crossDepList.Add(crossDeps->snapshot()) ;
    delete crossDeps ;
  }


  depAllList.Delete() ;
  depIntNoNormList.Delete() ;

  delete nIter ;
  delete lIter ;
  delete ldIter ;
  delete laIter ;
  delete innIter ;

  return ;
}




//_____________________________________________________________________________
void RooProdPdf::getPartIntList(const RooArgSet* nset, const RooArgSet* iset, 
				pRooArgList& partList, pRooLinkedList& nsetList, 
				Int_t& code, const char* isetRangeName) const 
{
  // Return list of (partial) integrals of product terms for integration
  // of p.d.f over observables iset while normalization over observables nset.
  // Also return list of normalization sets to be used to evaluate 
  // each component in the list correctly.

  // Check if this configuration was created before
  Int_t sterileIdx(-1) ;

  CacheElem* cache = (CacheElem*) _cacheMgr.getObj(nset,iset,&sterileIdx,RooNameReg::ptr(isetRangeName)) ;
  if (cache) {
    code = _cacheMgr.lastIndex() ;
    partList = &cache->_partList ;
    nsetList = &cache->_normList ;

    return ;
  }

  // Create containers for partial integral components to be generated
  cache = new CacheElem ;

  // Factorize the product in irreducible terms for this nset
  RooLinkedList terms, norms, imp, ints, cross ;
  factorizeProduct(nset?(*nset):RooArgSet(),iset?(*iset):RooArgSet(),terms,norms,imp,cross,ints) ;

  RooArgSet *norm, *integ, *xdeps ;
  
  // Group irriducible terms that need to be (partially) integrated together
  RooLinkedList groupedList ; 
  RooArgSet outerIntDeps ;
  groupProductTerms(groupedList,outerIntDeps,terms,norms,imp,ints,cross) ;
  TIterator* gIter = groupedList.MakeIterator() ;
  RooLinkedList* group ;
  
  while((group=(RooLinkedList*)gIter->Next())) {

//     group->Print("1") ;
    
    if (group->GetSize()==1) {
      RooArgSet* term = (RooArgSet*) group->At(0) ;

      Int_t termIdx = terms.IndexOf(term) ;
      norm=(RooArgSet*) norms.At(termIdx) ;
      integ=(RooArgSet*) ints.At(termIdx) ;
      xdeps=(RooArgSet*)cross.At(termIdx) ;

      RooArgSet termNSet, termISet, termXSet ;
      
      // Take list of normalization, integrated dependents from factorization algorithm
      termISet.add(*integ) ;
      termNSet.add(*norm) ;
      
      // Cross-imported integrated dependents
      termXSet.add(*xdeps) ;
      
      // Add prefab term to partIntList. 
      Bool_t isOwned ;
      RooAbsReal* func = processProductTerm(nset,iset,isetRangeName,term,termNSet,termISet,isOwned) ;
      if (func) {
	cache->_partList.add(*func) ;
	if (isOwned) cache->_ownedList.addOwned(*func) ;
	cache->_normList.Add(norm->snapshot()) ;
      }
    } else {

//       cout << "prod: composite group encountered!" << endl ;

      RooArgSet compTermSet, compTermNorm ;
      TIterator* tIter = group->MakeIterator() ;
      RooArgSet* term ;
      while((term=(RooArgSet*)tIter->Next())) {
	
	Int_t termIdx = terms.IndexOf(term) ;
	norm=(RooArgSet*) norms.At(termIdx) ;
	integ=(RooArgSet*) ints.At(termIdx) ;
	xdeps=(RooArgSet*)cross.At(termIdx) ;
	
	RooArgSet termNSet, termISet, termXSet ;
	termISet.add(*integ) ;
	termNSet.add(*norm) ;
	termXSet.add(*xdeps) ;

	// Remove outer integration dependents from termISet
	termISet.remove(outerIntDeps,kTRUE,kTRUE) ;
// 	cout << "termISet = " ; termISet.Print("1") ;

	Bool_t isOwned ;
	RooAbsReal* func = processProductTerm(nset,iset,isetRangeName,term,termNSet,termISet,isOwned,kTRUE) ;
// 	cout << "created composite term component " << func->GetName() << endl ;
	if (func) {
	  compTermSet.add(*func) ;
	  if (isOwned) cache->_ownedList.addOwned(*func) ;
	  compTermNorm.add(*norm,kFALSE) ;
	}      
      }

//       cout << "constructing special composite product" << endl ;
//       cout << "compTermSet = " ; compTermSet.Print("1") ;

      // WVE this doesn't work (yet) for some reason
      //const char* name = makeRGPPName("SPECPROJ_",compTermSet,outerIntDeps,RooArgSet()) ;
      //RooAbsReal* func = new RooGenProdProj(name,name,compTermSet,outerIntDeps,RooArgSet()) ;
      //partIntList->add(*func) ;
      //cache->_ownedList->addOwned(*func) ;

      // WVE but this does, so we'll keep it for the moment
      const char* prodname = makeRGPPName("SPECPROD_",compTermSet,outerIntDeps,RooArgSet(),isetRangeName) ;
      RooProduct* prodtmp = new RooProduct(prodname,prodname,compTermSet) ;
      cache->_ownedList.addOwned(*prodtmp) ;

      const char* intname = makeRGPPName("SPECINT_",compTermSet,outerIntDeps,RooArgSet(),isetRangeName) ;
      RooRealIntegral* inttmp = new RooRealIntegral(intname,intname,*prodtmp,outerIntDeps,0,0,isetRangeName) ;

      cache->_ownedList.addOwned(*inttmp) ;
      cache->_partList.add(*inttmp);

      cache->_normList.Add(compTermNorm.snapshot()) ;

      delete tIter ;      
    }
  }
  delete gIter ;

  // Store the partial integral list and return the assigned code ;
  code = _cacheMgr.setObj(nset,iset,(RooAbsCacheElement*)cache,RooNameReg::ptr(isetRangeName)) ;

  // Fill references to be returned
  partList = &cache->_partList ;
  nsetList = &cache->_normList; 

  // We own contents of all lists filled by factorizeProduct() 
  groupedList.Delete() ;
  terms.Delete() ;
  ints.Delete() ;
  imp.Delete() ;
  norms.Delete() ;
  cross.Delete() ;
}



//_____________________________________________________________________________
void RooProdPdf::groupProductTerms(RooLinkedList& groupedTerms, RooArgSet& outerIntDeps, 
				   const RooLinkedList& terms, const RooLinkedList& norms, 
				   const RooLinkedList& imps, const RooLinkedList& ints, const RooLinkedList& /*cross*/) const
{
  // Group product into terms that can be calculated independently

  // Start out with each term in its own group
  TIterator* tIter = terms.MakeIterator() ;
  RooArgSet* term ;
  while((term=(RooArgSet*)tIter->Next())) {
    RooLinkedList* group = new RooLinkedList ;
    group->Add(term) ;
    groupedTerms.Add(group) ;
  }
  delete tIter ;

  // Make list of imported dependents that occur in any term
  RooArgSet allImpDeps ;
  TIterator* iIter = imps.MakeIterator() ;
  RooArgSet *impDeps ;
  while((impDeps=(RooArgSet*)iIter->Next())) {
    allImpDeps.add(*impDeps,kFALSE) ;
  }
  delete iIter ;

  // Make list of integrated dependents that occur in any term
  RooArgSet allIntDeps ;
  iIter = ints.MakeIterator() ;
  RooArgSet *intDeps ;
  while((intDeps=(RooArgSet*)iIter->Next())) {
    allIntDeps.add(*intDeps,kFALSE) ;
  }
  delete iIter ;
  
  RooArgSet* tmp = (RooArgSet*) allIntDeps.selectCommon(allImpDeps) ;
  outerIntDeps.removeAll() ;
  outerIntDeps.add(*tmp) ;
  delete tmp ;

  // Now iteratively merge groups that should be (partially) integrated together
  TIterator* oidIter = outerIntDeps.createIterator() ;
  TIterator* glIter = groupedTerms.MakeIterator() ;
  RooAbsArg* outerIntDep ;
  while ((outerIntDep =(RooAbsArg*)oidIter->Next())) {
    
    // Collect groups that feature this dependent
    RooLinkedList* newGroup = 0 ;

    // Loop over groups
    RooLinkedList* group ;
    glIter->Reset() ;    
    Bool_t needMerge = kFALSE ;
    while((group=(RooLinkedList*)glIter->Next())) {

      // See if any term in this group depends in any ay on outerDepInt
      RooArgSet* term2 ;
      TIterator* tIter2 = group->MakeIterator() ;
      while((term2=(RooArgSet*)tIter2->Next())) {

	Int_t termIdx = terms.IndexOf(term2) ;
	RooArgSet* termNormDeps = (RooArgSet*) norms.At(termIdx) ;
	RooArgSet* termIntDeps = (RooArgSet*) ints.At(termIdx) ;
	RooArgSet* termImpDeps = (RooArgSet*) imps.At(termIdx) ;

	if (termNormDeps->contains(*outerIntDep) || 
	    termIntDeps->contains(*outerIntDep) || 
	    termImpDeps->contains(*outerIntDep)) {
	  needMerge = kTRUE ;
	}
	
      }

      if (needMerge) {
	// Create composite group if not yet existing
	if (newGroup==0) {
	  newGroup = new RooLinkedList ;
	}
	
	// Add terms of this group to new term      
	tIter2->Reset() ;
	while((term2=(RooArgSet*)tIter2->Next())) {
	  newGroup->Add(term2) ;	  
	}

	// Remove this group from list and delete it (but not its contents)
	groupedTerms.Remove(group) ;
	delete group ;
      }
      delete tIter2 ;
    }
    // If a new group has been created to merge terms dependent on current outerIntDep, add it to group list
    if (newGroup) {
      groupedTerms.Add(newGroup) ;
    }

  }

  delete glIter ;
  delete oidIter ;
}



//_____________________________________________________________________________
RooAbsReal* RooProdPdf::processProductTerm(const RooArgSet* nset, const RooArgSet* iset, const char* isetRangeName,
				           const RooArgSet* term,const RooArgSet& termNSet, const RooArgSet& termISet,
				           Bool_t& isOwned, Bool_t forceWrap) const
{
  // Calculate integrals of factorized product terms over observables iset while normalized
  // to observables in nset.


  // CASE I: factorizing term: term is integrated over all normalizing observables
  // -----------------------------------------------------------------------------
  // Check if all observbales of this term are integrated. If so the term cancels
  if (termNSet.getSize()>0 && termNSet.getSize()==termISet.getSize() && isetRangeName==0) {

    // Term factorizes    
    return 0 ;
  }
  
  // CASE II: Dropped terms: if term is entirely unnormalized, it should be dropped
  // ------------------------------------------------------------------------------
  if (nset && termNSet.getSize()==0) {
    
    // Drop terms that are not asked to be normalized  
    return 0 ;
  }
  
  if (iset && termISet.getSize()>0) {
    if (term->getSize()==1) {
      
      // CASE IIIa: Normalized and partially integrated single PDF term
      //---------------------------------------------------------------
      
      TIterator* pIter = term->createIterator() ;
      RooAbsPdf* pdf = (RooAbsPdf*) pIter->Next() ;
      delete pIter ;
      
      RooAbsReal* partInt = pdf->createIntegral(termISet,termNSet,isetRangeName) ;
      //partInt->setOperMode(operMode()) ;

      isOwned=kTRUE ;
      return partInt ;
      
    } else {
      
      // CASE IIIb: Normalized and partially integrated composite PDF term
      //---------------------------------------------------------------
      
      // Use auxiliary class RooGenProdProj to calculate this term
      const char* name = makeRGPPName("GENPROJ_",*term,termISet,termNSet,isetRangeName) ;
      RooAbsReal* partInt = new RooGenProdProj(name,name,*term,termISet,termNSet,isetRangeName) ;
      //partInt->setOperMode(operMode()) ;
      
      isOwned=kTRUE ;
      return partInt ;
    }      
  }
  
  // CASE IVa: Normalized non-integrated composite PDF term
  // -------------------------------------------------------
  if (nset && nset->getSize()>0 && term->getSize()>1) {
    // Composite term needs normalized integration
    const char* name = makeRGPPName("GENPROJ_",*term,termISet,termNSet,isetRangeName) ;
    RooAbsReal* partInt = new RooGenProdProj(name,name,*term,termISet,termNSet,isetRangeName) ;
    //partInt->setOperMode(operMode()) ;

    isOwned=kTRUE ;
    return partInt ;
  }
  
  // CASE IVb: Normalized, non-integrated single PDF term 
  // -----------------------------------------------------
  TIterator* pIter = term->createIterator() ;
  RooAbsPdf* pdf ;
  while((pdf=(RooAbsPdf*)pIter->Next())) {

    if (forceWrap) {

      // Construct representative name of normalization wrapper
      TString name(pdf->GetName()) ;
      name.Append("_NORM[") ;
      TIterator* nIter = termNSet.createIterator() ;
      RooAbsArg* arg ;
      Bool_t first(kTRUE) ;
      while((arg=(RooAbsArg*)nIter->Next())) {
	if (!first) {
	  name.Append(",") ;
	} else {
	  first=kFALSE ;
	}		   
	name.Append(arg->GetName()) ;
      }      
      name.Append("]") ;
      delete nIter ;

      
      RooAbsReal* partInt = new RooRealIntegral(name.Data(),name.Data(),*pdf,RooArgSet(),&termNSet) ;
      isOwned=kTRUE ;      

      delete pIter ;
      return partInt ;

    } else {
      isOwned=kFALSE ;

      delete pIter ;
      return pdf  ;
    }
  }
  delete pIter ;

  coutE(Eval) << "RooProdPdf::processProductTerm(" << GetName() << ") unidentified term!!!" << endl ;
  return 0;
}




//_____________________________________________________________________________
const char* RooProdPdf::makeRGPPName(const char* pfx, const RooArgSet& term, const RooArgSet& iset, 
				     const RooArgSet& nset, const char* isetRangeName) const
{
  // Make an appropriate automatic name for a RooGenProdProj object in getPartIntList() 

  static TString pname ;
  pname = pfx ;

  TIterator* pIter = term.createIterator() ;
  
  // Encode component names
  Bool_t first(kTRUE) ;
  RooAbsPdf* pdf ;
  while((pdf=(RooAbsPdf*)pIter->Next())) {
    if (first) {
      first = kFALSE ;
    } else {
      pname.Append("_X_") ;
    }
    pname.Append(pdf->GetName()) ;
  }
  delete pIter ;

  pname.Append(integralNameSuffix(iset,&nset,isetRangeName,kTRUE)) ;  

  return pname.Data() ;
}



//_____________________________________________________________________________
Bool_t RooProdPdf::forceAnalyticalInt(const RooAbsArg& /*dep*/) const 
{
  // Force RooRealIntegral to offer all observables for internal integration
  return kTRUE ;
}



//_____________________________________________________________________________
Int_t RooProdPdf::getAnalyticalIntegralWN(RooArgSet& allVars, RooArgSet& analVars, 
					  const RooArgSet* normSet, const char* rangeName) const 
{
  // Determine which part (if any) of given integral can be performed analytically.
  // If any analytical integration is possible, return integration scenario code.
  //
  // RooProdPdf implements two strategies in implementing analytical integrals
  //
  // First, PDF components whose entire set of dependents are requested to be integrated
  // can be dropped from the product, as they will integrate out to 1 by construction
  //
  // Second, RooProdPdf queries each remaining component PDF for its analytical integration 
  // capability of the requested set ('allVars'). It finds the largest common set of variables 
  // that can be integrated by all remaining components. If such a set exists, it reconfirms that 
  // each component is capable of analytically integrating the common set, and combines the components 
  // individual integration codes into a single integration code valid for RooProdPdf.

  if (_forceNumInt) return 0 ;

  // Declare that we can analytically integrate all requested observables
  analVars.add(allVars) ;

  // Retrieve (or create) the required partial integral list
  Int_t code ;
  RooArgList *plist ;
  RooLinkedList *nlist ;
  getPartIntList(normSet,&allVars,plist,nlist,code,rangeName) ;
  
  return code+1 ;
}




//_____________________________________________________________________________
Double_t RooProdPdf::analyticalIntegralWN(Int_t code, const RooArgSet* normSet, const char* rangeName) const 
{
  // Return analytical integral defined by given scenario code

  // No integration scenario
  if (code==0) {
    return getVal(normSet) ;
  }

  // WVE needs adaptation for rangename feature

  // Partial integration scenarios
  CacheElem* cache = (CacheElem*) _cacheMgr.getObjByIndex(code-1) ;
  
  RooArgList* partIntList ;
  RooLinkedList* normList ;

  // If cache has been sterilized, revive this slot
  if (cache==0) {
    RooArgSet* vars = getParameters(RooArgSet()) ;
    RooArgSet* nset = _cacheMgr.nameSet1ByIndex(code-1)->select(*vars) ;
    RooArgSet* iset = _cacheMgr.nameSet2ByIndex(code-1)->select(*vars) ;

    Int_t code2(-1) ;
    getPartIntList(nset,iset,partIntList,normList,code2,rangeName) ;

    delete vars ;
    delete nset ;
    delete iset ;
  } else {

    partIntList = &cache->_partList ;
    normList = &cache->_normList ;

  }

  Double_t val = calculate(partIntList,normList) ;
  
//   cout << "RPP::aIWN(" << GetName() << ") ,code = " << code << ", value = " << val << endl ;
//   partIntList->Print("v") ;
  return val ;
}



//_____________________________________________________________________________
Bool_t RooProdPdf::checkObservables(const RooArgSet* /*nset*/) const 
{
  // Obsolete
  return kFALSE ;
  
}




//_____________________________________________________________________________
RooAbsPdf::ExtendMode RooProdPdf::extendMode() const
{
  // If this product contains exactly one extendable p.d.f return the extension abilities of
  // that p.d.f, otherwise return CanNotBeExtended
  return (_extendedIndex>=0) ? ((RooAbsPdf*)_pdfList.at(_extendedIndex))->extendMode() : CanNotBeExtended ;
}



//_____________________________________________________________________________
Double_t RooProdPdf::expectedEvents(const RooArgSet* nset) const 
{
  // Return the expected number of events associated with the extentable input p.d.f
  // in the product. If there is no extendable term, return zero and issue and error

  if (_extendedIndex<0) {
    coutE(Generation) << "ERROR: Requesting expected number of events from a RooProdPdf that does not contain an extended p.d.f" << endl ;
  }
  assert(_extendedIndex>=0) ;
  return ((RooAbsPdf*)_pdfList.at(_extendedIndex))->expectedEvents(nset) ;
}




//_____________________________________________________________________________
RooAbsGenContext* RooProdPdf::genContext(const RooArgSet &vars, const RooDataSet *prototype, 
					 const RooArgSet* auxProto, Bool_t verbose) const 
{
  // Return generator context optimized for generating events from product p.d.f.s

  if (_useDefaultGen) return RooAbsPdf::genContext(vars,prototype,auxProto,verbose) ;
  return new RooProdGenContext(*this,vars,prototype,auxProto,verbose) ;
}



//_____________________________________________________________________________
Int_t RooProdPdf::getGenerator(const RooArgSet& directVars, RooArgSet &generateVars, Bool_t staticInitOK) const
{
  // Query internal generation capabilities of component p.d.f.s and aggregate capabilities
  // into master configuration passed to the generator context

  if (!_useDefaultGen) return 0 ;

  // Find the subset directVars that only depend on a single PDF in the product
  RooArgSet directSafe ;
  TIterator* dIter = directVars.createIterator() ;
  RooAbsArg* arg ;
  while((arg=(RooAbsArg*)dIter->Next())) {
    if (isDirectGenSafe(*arg)) directSafe.add(*arg) ;
  }
  delete dIter ;


  // Now find direct integrator for relevant components ;
  _pdfIter->Reset() ;
  RooAbsPdf* pdf ;
  Int_t code[64], n(0) ;
  while((pdf=(RooAbsPdf*)_pdfIter->Next())) {
    RooArgSet pdfDirect ;
    code[n] = pdf->getGenerator(directSafe,pdfDirect,staticInitOK) ;
    if (code[n]!=0) {
      generateVars.add(pdfDirect) ;
    }
    n++ ;
  }


  if (generateVars.getSize()>0) {
    Int_t masterCode = _genCode.store(code,n) ;
    return masterCode+1 ;    
  } else {
    return 0 ;
  }
}



//_____________________________________________________________________________
void RooProdPdf::initGenerator(Int_t code)
{
  // Forward one-time initialization call to component generation initialization
  // methods.

  if (!_useDefaultGen) return ;

  const Int_t* codeList = _genCode.retrieve(code-1) ;
  _pdfIter->Reset() ;
  RooAbsPdf* pdf ;
  Int_t i(0) ;
  while((pdf=(RooAbsPdf*)_pdfIter->Next())) {
    if (codeList[i]!=0) {
      pdf->initGenerator(codeList[i]) ;
    }
    i++ ;
  }
}



//_____________________________________________________________________________
void RooProdPdf::generateEvent(Int_t code)
{  
  // Generate a single event with configuration specified by 'code'
  // Defer internal generation to components as encoded in the _genCode
  // registry for given generator code.

  if (!_useDefaultGen) return ;

  const Int_t* codeList = _genCode.retrieve(code-1) ;
  _pdfIter->Reset() ;
  RooAbsPdf* pdf ;
  Int_t i(0) ;
  while((pdf=(RooAbsPdf*)_pdfIter->Next())) {
    if (codeList[i]!=0) {
      pdf->generateEvent(codeList[i]) ;
    }
    i++ ;
  }

}



//_____________________________________________________________________________
RooProdPdf::CacheElem::~CacheElem() 
{
  // Destructor
  _normList.Delete() ;
}



//_____________________________________________________________________________
RooArgList RooProdPdf::CacheElem::containedArgs(Action) 
{
  // Return RooAbsArg components contained in the cache
  RooArgList ret ;
  ret.add(_partList) ;
  return ret ;

}



//_____________________________________________________________________________
void RooProdPdf::CacheElem::printCompactTreeHook(ostream& os, const char* indent, Int_t curElem, Int_t maxElem) 
{
  // Hook function to print cache contents in tree printing of RooProdPdf

   if (curElem==0) {
     os << indent << "RooProdPdf begin partial integral cache" << endl ;
   }

   TIterator* iter = _partList.createIterator() ;
   RooAbsArg* arg ;
   TString indent2(indent) ;
   indent2 += Form("[%d] ",curElem) ;
   while((arg=(RooAbsArg*)iter->Next())) {      
     arg->printCompactTree(os,indent2) ;
   }
   delete iter ;

   if (curElem==maxElem) {
     os << indent << "RooProdPdf end partial integral cache" << endl ;
   }
}



//_____________________________________________________________________________
Bool_t RooProdPdf::isDirectGenSafe(const RooAbsArg& arg) const 
{
  // Forward determination of safety of internal generator code to
  // component p.d.f that would generate the given observable

  // Only override base class behaviour if default generator method is enabled
  if (!_useDefaultGen) return RooAbsPdf::isDirectGenSafe(arg) ;

  // Argument may appear in only one PDF component
  _pdfIter->Reset() ;
  RooAbsPdf* pdf, *thePdf(0) ;  
  while((pdf=(RooAbsPdf*)_pdfIter->Next())) {

    if (pdf->dependsOn(arg)) {
      // Found PDF depending on arg

      // If multiple PDFs depend on arg directGen is not safe
      if (thePdf) return kFALSE ;

      thePdf = pdf ;
    }
  }
  // Forward call to relevant component PDF
  return thePdf?(thePdf->isDirectGenSafe(arg)):kFALSE ;
}



//_____________________________________________________________________________
RooArgSet* RooProdPdf::findPdfNSet(RooAbsPdf& pdf) const 
{
  // Look up user specified normalization set for given input PDF component

  Int_t idx = _pdfList.index(&pdf) ;
  if (idx<0) return 0 ;
  return (RooArgSet*) _pdfNSetList.At(idx) ;
}



//_____________________________________________________________________________
RooArgSet* RooProdPdf::getConstraints(const RooArgSet& observables, const RooArgSet& constrainedParams) const
{
  // Return all parameter constraint p.d.f.s on parameters listed in constrainedParams
  // The observables set is required to distinguish unambiguously p.d.f in terms 
  // of observables and parameters, which are not constraints, and p.d.fs in terms
  // of parameters only, which can serve as constraints p.d.f.s

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

  // Loop over p.d.f. components
  TIterator* piter = _pdfList.createIterator() ;
  RooAbsPdf* pdf ;
  while((pdf=(RooAbsPdf*)piter->Next())) {
    // A constraint term is a p.d.f that does not depend on any of the listed observables
    // but does depends on any of the parameters that should be constrained
    if (!pdf->dependsOnValue(observables) && pdf->dependsOnValue(constrainedParams)) {
      ret->add(*pdf) ;
    }
  }

  delete piter ;

  return ret ;
}



//_____________________________________________________________________________
std::list<Double_t>* RooProdPdf::plotSamplingHint(RooAbsRealLValue& obs, Double_t xlo, Double_t xhi) const 
{
  // Forward the plot sampling hint from the p.d.f. that defines the observable obs  
  _pdfIter->Reset() ;
  RooAbsPdf* pdf ;
  while((pdf=(RooAbsPdf*)_pdfIter->Next())) {
    list<Double_t>* hint = pdf->plotSamplingHint(obs,xlo,xhi) ;      
    if (hint) {
      return hint ;
    }
  }
  
  return 0 ;
}



//_____________________________________________________________________________
void RooProdPdf::printMetaArgs(ostream& os) const 
{
  // Customized printing of arguments of a RooProdPdf to more intuitively reflect the contents of the
  // product operator construction

  TIterator* niter = _pdfNSetList.MakeIterator() ;
  for (int i=0 ; i<_pdfList.getSize() ; i++) {
    if (i>0) os << " * " ;
    RooArgSet* ncset = (RooArgSet*) niter->Next() ;
    os << _pdfList.at(i)->GetName() ;
    if (ncset->getSize()>0) {
      if (string("nset")==ncset->GetName()) {
	os << *ncset  ;
      } else {
	os << "|" ;
	TIterator* nciter = ncset->createIterator() ;
	RooAbsArg* arg ;
	Bool_t first(kTRUE) ;
	while((arg=(RooAbsArg*)nciter->Next())) {
	  if (!first) {
	    os << "," ;
	  } else {
	    first = kFALSE ;
	  }	  
	  os << arg->GetName() ;	  
	}
      }
    }
  }
  os << " " ;    
}
 RooProdPdf.cxx:1
 RooProdPdf.cxx:2
 RooProdPdf.cxx:3
 RooProdPdf.cxx:4
 RooProdPdf.cxx:5
 RooProdPdf.cxx:6
 RooProdPdf.cxx:7
 RooProdPdf.cxx:8
 RooProdPdf.cxx:9
 RooProdPdf.cxx:10
 RooProdPdf.cxx:11
 RooProdPdf.cxx:12
 RooProdPdf.cxx:13
 RooProdPdf.cxx:14
 RooProdPdf.cxx:15
 RooProdPdf.cxx:16
 RooProdPdf.cxx:17
 RooProdPdf.cxx:18
 RooProdPdf.cxx:19
 RooProdPdf.cxx:20
 RooProdPdf.cxx:21
 RooProdPdf.cxx:22
 RooProdPdf.cxx:23
 RooProdPdf.cxx:24
 RooProdPdf.cxx:25
 RooProdPdf.cxx:26
 RooProdPdf.cxx:27
 RooProdPdf.cxx:28
 RooProdPdf.cxx:29
 RooProdPdf.cxx:30
 RooProdPdf.cxx:31
 RooProdPdf.cxx:32
 RooProdPdf.cxx:33
 RooProdPdf.cxx:34
 RooProdPdf.cxx:35
 RooProdPdf.cxx:36
 RooProdPdf.cxx:37
 RooProdPdf.cxx:38
 RooProdPdf.cxx:39
 RooProdPdf.cxx:40
 RooProdPdf.cxx:41
 RooProdPdf.cxx:42
 RooProdPdf.cxx:43
 RooProdPdf.cxx:44
 RooProdPdf.cxx:45
 RooProdPdf.cxx:46
 RooProdPdf.cxx:47
 RooProdPdf.cxx:48
 RooProdPdf.cxx:49
 RooProdPdf.cxx:50
 RooProdPdf.cxx:51
 RooProdPdf.cxx:52
 RooProdPdf.cxx:53
 RooProdPdf.cxx:54
 RooProdPdf.cxx:55
 RooProdPdf.cxx:56
 RooProdPdf.cxx:57
 RooProdPdf.cxx:58
 RooProdPdf.cxx:59
 RooProdPdf.cxx:60
 RooProdPdf.cxx:61
 RooProdPdf.cxx:62
 RooProdPdf.cxx:63
 RooProdPdf.cxx:64
 RooProdPdf.cxx:65
 RooProdPdf.cxx:66
 RooProdPdf.cxx:67
 RooProdPdf.cxx:68
 RooProdPdf.cxx:69
 RooProdPdf.cxx:70
 RooProdPdf.cxx:71
 RooProdPdf.cxx:72
 RooProdPdf.cxx:73
 RooProdPdf.cxx:74
 RooProdPdf.cxx:75
 RooProdPdf.cxx:76
 RooProdPdf.cxx:77
 RooProdPdf.cxx:78
 RooProdPdf.cxx:79
 RooProdPdf.cxx:80
 RooProdPdf.cxx:81
 RooProdPdf.cxx:82
 RooProdPdf.cxx:83
 RooProdPdf.cxx:84
 RooProdPdf.cxx:85
 RooProdPdf.cxx:86
 RooProdPdf.cxx:87
 RooProdPdf.cxx:88
 RooProdPdf.cxx:89
 RooProdPdf.cxx:90
 RooProdPdf.cxx:91
 RooProdPdf.cxx:92
 RooProdPdf.cxx:93
 RooProdPdf.cxx:94
 RooProdPdf.cxx:95
 RooProdPdf.cxx:96
 RooProdPdf.cxx:97
 RooProdPdf.cxx:98
 RooProdPdf.cxx:99
 RooProdPdf.cxx:100
 RooProdPdf.cxx:101
 RooProdPdf.cxx:102
 RooProdPdf.cxx:103
 RooProdPdf.cxx:104
 RooProdPdf.cxx:105
 RooProdPdf.cxx:106
 RooProdPdf.cxx:107
 RooProdPdf.cxx:108
 RooProdPdf.cxx:109
 RooProdPdf.cxx:110
 RooProdPdf.cxx:111
 RooProdPdf.cxx:112
 RooProdPdf.cxx:113
 RooProdPdf.cxx:114
 RooProdPdf.cxx:115
 RooProdPdf.cxx:116
 RooProdPdf.cxx:117
 RooProdPdf.cxx:118
 RooProdPdf.cxx:119
 RooProdPdf.cxx:120
 RooProdPdf.cxx:121
 RooProdPdf.cxx:122
 RooProdPdf.cxx:123
 RooProdPdf.cxx:124
 RooProdPdf.cxx:125
 RooProdPdf.cxx:126
 RooProdPdf.cxx:127
 RooProdPdf.cxx:128
 RooProdPdf.cxx:129
 RooProdPdf.cxx:130
 RooProdPdf.cxx:131
 RooProdPdf.cxx:132
 RooProdPdf.cxx:133
 RooProdPdf.cxx:134
 RooProdPdf.cxx:135
 RooProdPdf.cxx:136
 RooProdPdf.cxx:137
 RooProdPdf.cxx:138
 RooProdPdf.cxx:139
 RooProdPdf.cxx:140
 RooProdPdf.cxx:141
 RooProdPdf.cxx:142
 RooProdPdf.cxx:143
 RooProdPdf.cxx:144
 RooProdPdf.cxx:145
 RooProdPdf.cxx:146
 RooProdPdf.cxx:147
 RooProdPdf.cxx:148
 RooProdPdf.cxx:149
 RooProdPdf.cxx:150
 RooProdPdf.cxx:151
 RooProdPdf.cxx:152
 RooProdPdf.cxx:153
 RooProdPdf.cxx:154
 RooProdPdf.cxx:155
 RooProdPdf.cxx:156
 RooProdPdf.cxx:157
 RooProdPdf.cxx:158
 RooProdPdf.cxx:159
 RooProdPdf.cxx:160
 RooProdPdf.cxx:161
 RooProdPdf.cxx:162
 RooProdPdf.cxx:163
 RooProdPdf.cxx:164
 RooProdPdf.cxx:165
 RooProdPdf.cxx:166
 RooProdPdf.cxx:167
 RooProdPdf.cxx:168
 RooProdPdf.cxx:169
 RooProdPdf.cxx:170
 RooProdPdf.cxx:171
 RooProdPdf.cxx:172
 RooProdPdf.cxx:173
 RooProdPdf.cxx:174
 RooProdPdf.cxx:175
 RooProdPdf.cxx:176
 RooProdPdf.cxx:177
 RooProdPdf.cxx:178
 RooProdPdf.cxx:179
 RooProdPdf.cxx:180
 RooProdPdf.cxx:181
 RooProdPdf.cxx:182
 RooProdPdf.cxx:183
 RooProdPdf.cxx:184
 RooProdPdf.cxx:185
 RooProdPdf.cxx:186
 RooProdPdf.cxx:187
 RooProdPdf.cxx:188
 RooProdPdf.cxx:189
 RooProdPdf.cxx:190
 RooProdPdf.cxx:191
 RooProdPdf.cxx:192
 RooProdPdf.cxx:193
 RooProdPdf.cxx:194
 RooProdPdf.cxx:195
 RooProdPdf.cxx:196
 RooProdPdf.cxx:197
 RooProdPdf.cxx:198
 RooProdPdf.cxx:199
 RooProdPdf.cxx:200
 RooProdPdf.cxx:201
 RooProdPdf.cxx:202
 RooProdPdf.cxx:203
 RooProdPdf.cxx:204
 RooProdPdf.cxx:205
 RooProdPdf.cxx:206
 RooProdPdf.cxx:207
 RooProdPdf.cxx:208
 RooProdPdf.cxx:209
 RooProdPdf.cxx:210
 RooProdPdf.cxx:211
 RooProdPdf.cxx:212
 RooProdPdf.cxx:213
 RooProdPdf.cxx:214
 RooProdPdf.cxx:215
 RooProdPdf.cxx:216
 RooProdPdf.cxx:217
 RooProdPdf.cxx:218
 RooProdPdf.cxx:219
 RooProdPdf.cxx:220
 RooProdPdf.cxx:221
 RooProdPdf.cxx:222
 RooProdPdf.cxx:223
 RooProdPdf.cxx:224
 RooProdPdf.cxx:225
 RooProdPdf.cxx:226
 RooProdPdf.cxx:227
 RooProdPdf.cxx:228
 RooProdPdf.cxx:229
 RooProdPdf.cxx:230
 RooProdPdf.cxx:231
 RooProdPdf.cxx:232
 RooProdPdf.cxx:233
 RooProdPdf.cxx:234
 RooProdPdf.cxx:235
 RooProdPdf.cxx:236
 RooProdPdf.cxx:237
 RooProdPdf.cxx:238
 RooProdPdf.cxx:239
 RooProdPdf.cxx:240
 RooProdPdf.cxx:241
 RooProdPdf.cxx:242
 RooProdPdf.cxx:243
 RooProdPdf.cxx:244
 RooProdPdf.cxx:245
 RooProdPdf.cxx:246
 RooProdPdf.cxx:247
 RooProdPdf.cxx:248
 RooProdPdf.cxx:249
 RooProdPdf.cxx:250
 RooProdPdf.cxx:251
 RooProdPdf.cxx:252
 RooProdPdf.cxx:253
 RooProdPdf.cxx:254
 RooProdPdf.cxx:255
 RooProdPdf.cxx:256
 RooProdPdf.cxx:257
 RooProdPdf.cxx:258
 RooProdPdf.cxx:259
 RooProdPdf.cxx:260
 RooProdPdf.cxx:261
 RooProdPdf.cxx:262
 RooProdPdf.cxx:263
 RooProdPdf.cxx:264
 RooProdPdf.cxx:265
 RooProdPdf.cxx:266
 RooProdPdf.cxx:267
 RooProdPdf.cxx:268
 RooProdPdf.cxx:269
 RooProdPdf.cxx:270
 RooProdPdf.cxx:271
 RooProdPdf.cxx:272
 RooProdPdf.cxx:273
 RooProdPdf.cxx:274
 RooProdPdf.cxx:275
 RooProdPdf.cxx:276
 RooProdPdf.cxx:277
 RooProdPdf.cxx:278
 RooProdPdf.cxx:279
 RooProdPdf.cxx:280
 RooProdPdf.cxx:281
 RooProdPdf.cxx:282
 RooProdPdf.cxx:283
 RooProdPdf.cxx:284
 RooProdPdf.cxx:285
 RooProdPdf.cxx:286
 RooProdPdf.cxx:287
 RooProdPdf.cxx:288
 RooProdPdf.cxx:289
 RooProdPdf.cxx:290
 RooProdPdf.cxx:291
 RooProdPdf.cxx:292
 RooProdPdf.cxx:293
 RooProdPdf.cxx:294
 RooProdPdf.cxx:295
 RooProdPdf.cxx:296
 RooProdPdf.cxx:297
 RooProdPdf.cxx:298
 RooProdPdf.cxx:299
 RooProdPdf.cxx:300
 RooProdPdf.cxx:301
 RooProdPdf.cxx:302
 RooProdPdf.cxx:303
 RooProdPdf.cxx:304
 RooProdPdf.cxx:305
 RooProdPdf.cxx:306
 RooProdPdf.cxx:307
 RooProdPdf.cxx:308
 RooProdPdf.cxx:309
 RooProdPdf.cxx:310
 RooProdPdf.cxx:311
 RooProdPdf.cxx:312
 RooProdPdf.cxx:313
 RooProdPdf.cxx:314
 RooProdPdf.cxx:315
 RooProdPdf.cxx:316
 RooProdPdf.cxx:317
 RooProdPdf.cxx:318
 RooProdPdf.cxx:319
 RooProdPdf.cxx:320
 RooProdPdf.cxx:321
 RooProdPdf.cxx:322
 RooProdPdf.cxx:323
 RooProdPdf.cxx:324
 RooProdPdf.cxx:325
 RooProdPdf.cxx:326
 RooProdPdf.cxx:327
 RooProdPdf.cxx:328
 RooProdPdf.cxx:329
 RooProdPdf.cxx:330
 RooProdPdf.cxx:331
 RooProdPdf.cxx:332
 RooProdPdf.cxx:333
 RooProdPdf.cxx:334
 RooProdPdf.cxx:335
 RooProdPdf.cxx:336
 RooProdPdf.cxx:337
 RooProdPdf.cxx:338
 RooProdPdf.cxx:339
 RooProdPdf.cxx:340
 RooProdPdf.cxx:341
 RooProdPdf.cxx:342
 RooProdPdf.cxx:343
 RooProdPdf.cxx:344
 RooProdPdf.cxx:345
 RooProdPdf.cxx:346
 RooProdPdf.cxx:347
 RooProdPdf.cxx:348
 RooProdPdf.cxx:349
 RooProdPdf.cxx:350
 RooProdPdf.cxx:351
 RooProdPdf.cxx:352
 RooProdPdf.cxx:353
 RooProdPdf.cxx:354
 RooProdPdf.cxx:355
 RooProdPdf.cxx:356
 RooProdPdf.cxx:357
 RooProdPdf.cxx:358
 RooProdPdf.cxx:359
 RooProdPdf.cxx:360
 RooProdPdf.cxx:361
 RooProdPdf.cxx:362
 RooProdPdf.cxx:363
 RooProdPdf.cxx:364
 RooProdPdf.cxx:365
 RooProdPdf.cxx:366
 RooProdPdf.cxx:367
 RooProdPdf.cxx:368
 RooProdPdf.cxx:369
 RooProdPdf.cxx:370
 RooProdPdf.cxx:371
 RooProdPdf.cxx:372
 RooProdPdf.cxx:373
 RooProdPdf.cxx:374
 RooProdPdf.cxx:375
 RooProdPdf.cxx:376
 RooProdPdf.cxx:377
 RooProdPdf.cxx:378
 RooProdPdf.cxx:379
 RooProdPdf.cxx:380
 RooProdPdf.cxx:381
 RooProdPdf.cxx:382
 RooProdPdf.cxx:383
 RooProdPdf.cxx:384
 RooProdPdf.cxx:385
 RooProdPdf.cxx:386
 RooProdPdf.cxx:387
 RooProdPdf.cxx:388
 RooProdPdf.cxx:389
 RooProdPdf.cxx:390
 RooProdPdf.cxx:391
 RooProdPdf.cxx:392
 RooProdPdf.cxx:393
 RooProdPdf.cxx:394
 RooProdPdf.cxx:395
 RooProdPdf.cxx:396
 RooProdPdf.cxx:397
 RooProdPdf.cxx:398
 RooProdPdf.cxx:399
 RooProdPdf.cxx:400
 RooProdPdf.cxx:401
 RooProdPdf.cxx:402
 RooProdPdf.cxx:403
 RooProdPdf.cxx:404
 RooProdPdf.cxx:405
 RooProdPdf.cxx:406
 RooProdPdf.cxx:407
 RooProdPdf.cxx:408
 RooProdPdf.cxx:409
 RooProdPdf.cxx:410
 RooProdPdf.cxx:411
 RooProdPdf.cxx:412
 RooProdPdf.cxx:413
 RooProdPdf.cxx:414
 RooProdPdf.cxx:415
 RooProdPdf.cxx:416
 RooProdPdf.cxx:417
 RooProdPdf.cxx:418
 RooProdPdf.cxx:419
 RooProdPdf.cxx:420
 RooProdPdf.cxx:421
 RooProdPdf.cxx:422
 RooProdPdf.cxx:423
 RooProdPdf.cxx:424
 RooProdPdf.cxx:425
 RooProdPdf.cxx:426
 RooProdPdf.cxx:427
 RooProdPdf.cxx:428
 RooProdPdf.cxx:429
 RooProdPdf.cxx:430
 RooProdPdf.cxx:431
 RooProdPdf.cxx:432
 RooProdPdf.cxx:433
 RooProdPdf.cxx:434
 RooProdPdf.cxx:435
 RooProdPdf.cxx:436
 RooProdPdf.cxx:437
 RooProdPdf.cxx:438
 RooProdPdf.cxx:439
 RooProdPdf.cxx:440
 RooProdPdf.cxx:441
 RooProdPdf.cxx:442
 RooProdPdf.cxx:443
 RooProdPdf.cxx:444
 RooProdPdf.cxx:445
 RooProdPdf.cxx:446
 RooProdPdf.cxx:447
 RooProdPdf.cxx:448
 RooProdPdf.cxx:449
 RooProdPdf.cxx:450
 RooProdPdf.cxx:451
 RooProdPdf.cxx:452
 RooProdPdf.cxx:453
 RooProdPdf.cxx:454
 RooProdPdf.cxx:455
 RooProdPdf.cxx:456
 RooProdPdf.cxx:457
 RooProdPdf.cxx:458
 RooProdPdf.cxx:459
 RooProdPdf.cxx:460
 RooProdPdf.cxx:461
 RooProdPdf.cxx:462
 RooProdPdf.cxx:463
 RooProdPdf.cxx:464
 RooProdPdf.cxx:465
 RooProdPdf.cxx:466
 RooProdPdf.cxx:467
 RooProdPdf.cxx:468
 RooProdPdf.cxx:469
 RooProdPdf.cxx:470
 RooProdPdf.cxx:471
 RooProdPdf.cxx:472
 RooProdPdf.cxx:473
 RooProdPdf.cxx:474
 RooProdPdf.cxx:475
 RooProdPdf.cxx:476
 RooProdPdf.cxx:477
 RooProdPdf.cxx:478
 RooProdPdf.cxx:479
 RooProdPdf.cxx:480
 RooProdPdf.cxx:481
 RooProdPdf.cxx:482
 RooProdPdf.cxx:483
 RooProdPdf.cxx:484
 RooProdPdf.cxx:485
 RooProdPdf.cxx:486
 RooProdPdf.cxx:487
 RooProdPdf.cxx:488
 RooProdPdf.cxx:489
 RooProdPdf.cxx:490
 RooProdPdf.cxx:491
 RooProdPdf.cxx:492
 RooProdPdf.cxx:493
 RooProdPdf.cxx:494
 RooProdPdf.cxx:495
 RooProdPdf.cxx:496
 RooProdPdf.cxx:497
 RooProdPdf.cxx:498
 RooProdPdf.cxx:499
 RooProdPdf.cxx:500
 RooProdPdf.cxx:501
 RooProdPdf.cxx:502
 RooProdPdf.cxx:503
 RooProdPdf.cxx:504
 RooProdPdf.cxx:505
 RooProdPdf.cxx:506
 RooProdPdf.cxx:507
 RooProdPdf.cxx:508
 RooProdPdf.cxx:509
 RooProdPdf.cxx:510
 RooProdPdf.cxx:511
 RooProdPdf.cxx:512
 RooProdPdf.cxx:513
 RooProdPdf.cxx:514
 RooProdPdf.cxx:515
 RooProdPdf.cxx:516
 RooProdPdf.cxx:517
 RooProdPdf.cxx:518
 RooProdPdf.cxx:519
 RooProdPdf.cxx:520
 RooProdPdf.cxx:521
 RooProdPdf.cxx:522
 RooProdPdf.cxx:523
 RooProdPdf.cxx:524
 RooProdPdf.cxx:525
 RooProdPdf.cxx:526
 RooProdPdf.cxx:527
 RooProdPdf.cxx:528
 RooProdPdf.cxx:529
 RooProdPdf.cxx:530
 RooProdPdf.cxx:531
 RooProdPdf.cxx:532
 RooProdPdf.cxx:533
 RooProdPdf.cxx:534
 RooProdPdf.cxx:535
 RooProdPdf.cxx:536
 RooProdPdf.cxx:537
 RooProdPdf.cxx:538
 RooProdPdf.cxx:539
 RooProdPdf.cxx:540
 RooProdPdf.cxx:541
 RooProdPdf.cxx:542
 RooProdPdf.cxx:543
 RooProdPdf.cxx:544
 RooProdPdf.cxx:545
 RooProdPdf.cxx:546
 RooProdPdf.cxx:547
 RooProdPdf.cxx:548
 RooProdPdf.cxx:549
 RooProdPdf.cxx:550
 RooProdPdf.cxx:551
 RooProdPdf.cxx:552
 RooProdPdf.cxx:553
 RooProdPdf.cxx:554
 RooProdPdf.cxx:555
 RooProdPdf.cxx:556
 RooProdPdf.cxx:557
 RooProdPdf.cxx:558
 RooProdPdf.cxx:559
 RooProdPdf.cxx:560
 RooProdPdf.cxx:561
 RooProdPdf.cxx:562
 RooProdPdf.cxx:563
 RooProdPdf.cxx:564
 RooProdPdf.cxx:565
 RooProdPdf.cxx:566
 RooProdPdf.cxx:567
 RooProdPdf.cxx:568
 RooProdPdf.cxx:569
 RooProdPdf.cxx:570
 RooProdPdf.cxx:571
 RooProdPdf.cxx:572
 RooProdPdf.cxx:573
 RooProdPdf.cxx:574
 RooProdPdf.cxx:575
 RooProdPdf.cxx:576
 RooProdPdf.cxx:577
 RooProdPdf.cxx:578
 RooProdPdf.cxx:579
 RooProdPdf.cxx:580
 RooProdPdf.cxx:581
 RooProdPdf.cxx:582
 RooProdPdf.cxx:583
 RooProdPdf.cxx:584
 RooProdPdf.cxx:585
 RooProdPdf.cxx:586
 RooProdPdf.cxx:587
 RooProdPdf.cxx:588
 RooProdPdf.cxx:589
 RooProdPdf.cxx:590
 RooProdPdf.cxx:591
 RooProdPdf.cxx:592
 RooProdPdf.cxx:593
 RooProdPdf.cxx:594
 RooProdPdf.cxx:595
 RooProdPdf.cxx:596
 RooProdPdf.cxx:597
 RooProdPdf.cxx:598
 RooProdPdf.cxx:599
 RooProdPdf.cxx:600
 RooProdPdf.cxx:601
 RooProdPdf.cxx:602
 RooProdPdf.cxx:603
 RooProdPdf.cxx:604
 RooProdPdf.cxx:605
 RooProdPdf.cxx:606
 RooProdPdf.cxx:607
 RooProdPdf.cxx:608
 RooProdPdf.cxx:609
 RooProdPdf.cxx:610
 RooProdPdf.cxx:611
 RooProdPdf.cxx:612
 RooProdPdf.cxx:613
 RooProdPdf.cxx:614
 RooProdPdf.cxx:615
 RooProdPdf.cxx:616
 RooProdPdf.cxx:617
 RooProdPdf.cxx:618
 RooProdPdf.cxx:619
 RooProdPdf.cxx:620
 RooProdPdf.cxx:621
 RooProdPdf.cxx:622
 RooProdPdf.cxx:623
 RooProdPdf.cxx:624
 RooProdPdf.cxx:625
 RooProdPdf.cxx:626
 RooProdPdf.cxx:627
 RooProdPdf.cxx:628
 RooProdPdf.cxx:629
 RooProdPdf.cxx:630
 RooProdPdf.cxx:631
 RooProdPdf.cxx:632
 RooProdPdf.cxx:633
 RooProdPdf.cxx:634
 RooProdPdf.cxx:635
 RooProdPdf.cxx:636
 RooProdPdf.cxx:637
 RooProdPdf.cxx:638
 RooProdPdf.cxx:639
 RooProdPdf.cxx:640
 RooProdPdf.cxx:641
 RooProdPdf.cxx:642
 RooProdPdf.cxx:643
 RooProdPdf.cxx:644
 RooProdPdf.cxx:645
 RooProdPdf.cxx:646
 RooProdPdf.cxx:647
 RooProdPdf.cxx:648
 RooProdPdf.cxx:649
 RooProdPdf.cxx:650
 RooProdPdf.cxx:651
 RooProdPdf.cxx:652
 RooProdPdf.cxx:653
 RooProdPdf.cxx:654
 RooProdPdf.cxx:655
 RooProdPdf.cxx:656
 RooProdPdf.cxx:657
 RooProdPdf.cxx:658
 RooProdPdf.cxx:659
 RooProdPdf.cxx:660
 RooProdPdf.cxx:661
 RooProdPdf.cxx:662
 RooProdPdf.cxx:663
 RooProdPdf.cxx:664
 RooProdPdf.cxx:665
 RooProdPdf.cxx:666
 RooProdPdf.cxx:667
 RooProdPdf.cxx:668
 RooProdPdf.cxx:669
 RooProdPdf.cxx:670
 RooProdPdf.cxx:671
 RooProdPdf.cxx:672
 RooProdPdf.cxx:673
 RooProdPdf.cxx:674
 RooProdPdf.cxx:675
 RooProdPdf.cxx:676
 RooProdPdf.cxx:677
 RooProdPdf.cxx:678
 RooProdPdf.cxx:679
 RooProdPdf.cxx:680
 RooProdPdf.cxx:681
 RooProdPdf.cxx:682
 RooProdPdf.cxx:683
 RooProdPdf.cxx:684
 RooProdPdf.cxx:685
 RooProdPdf.cxx:686
 RooProdPdf.cxx:687
 RooProdPdf.cxx:688
 RooProdPdf.cxx:689
 RooProdPdf.cxx:690
 RooProdPdf.cxx:691
 RooProdPdf.cxx:692
 RooProdPdf.cxx:693
 RooProdPdf.cxx:694
 RooProdPdf.cxx:695
 RooProdPdf.cxx:696
 RooProdPdf.cxx:697
 RooProdPdf.cxx:698
 RooProdPdf.cxx:699
 RooProdPdf.cxx:700
 RooProdPdf.cxx:701
 RooProdPdf.cxx:702
 RooProdPdf.cxx:703
 RooProdPdf.cxx:704
 RooProdPdf.cxx:705
 RooProdPdf.cxx:706
 RooProdPdf.cxx:707
 RooProdPdf.cxx:708
 RooProdPdf.cxx:709
 RooProdPdf.cxx:710
 RooProdPdf.cxx:711
 RooProdPdf.cxx:712
 RooProdPdf.cxx:713
 RooProdPdf.cxx:714
 RooProdPdf.cxx:715
 RooProdPdf.cxx:716
 RooProdPdf.cxx:717
 RooProdPdf.cxx:718
 RooProdPdf.cxx:719
 RooProdPdf.cxx:720
 RooProdPdf.cxx:721
 RooProdPdf.cxx:722
 RooProdPdf.cxx:723
 RooProdPdf.cxx:724
 RooProdPdf.cxx:725
 RooProdPdf.cxx:726
 RooProdPdf.cxx:727
 RooProdPdf.cxx:728
 RooProdPdf.cxx:729
 RooProdPdf.cxx:730
 RooProdPdf.cxx:731
 RooProdPdf.cxx:732
 RooProdPdf.cxx:733
 RooProdPdf.cxx:734
 RooProdPdf.cxx:735
 RooProdPdf.cxx:736
 RooProdPdf.cxx:737
 RooProdPdf.cxx:738
 RooProdPdf.cxx:739
 RooProdPdf.cxx:740
 RooProdPdf.cxx:741
 RooProdPdf.cxx:742
 RooProdPdf.cxx:743
 RooProdPdf.cxx:744
 RooProdPdf.cxx:745
 RooProdPdf.cxx:746
 RooProdPdf.cxx:747
 RooProdPdf.cxx:748
 RooProdPdf.cxx:749
 RooProdPdf.cxx:750
 RooProdPdf.cxx:751
 RooProdPdf.cxx:752
 RooProdPdf.cxx:753
 RooProdPdf.cxx:754
 RooProdPdf.cxx:755
 RooProdPdf.cxx:756
 RooProdPdf.cxx:757
 RooProdPdf.cxx:758
 RooProdPdf.cxx:759
 RooProdPdf.cxx:760
 RooProdPdf.cxx:761
 RooProdPdf.cxx:762
 RooProdPdf.cxx:763
 RooProdPdf.cxx:764
 RooProdPdf.cxx:765
 RooProdPdf.cxx:766
 RooProdPdf.cxx:767
 RooProdPdf.cxx:768
 RooProdPdf.cxx:769
 RooProdPdf.cxx:770
 RooProdPdf.cxx:771
 RooProdPdf.cxx:772
 RooProdPdf.cxx:773
 RooProdPdf.cxx:774
 RooProdPdf.cxx:775
 RooProdPdf.cxx:776
 RooProdPdf.cxx:777
 RooProdPdf.cxx:778
 RooProdPdf.cxx:779
 RooProdPdf.cxx:780
 RooProdPdf.cxx:781
 RooProdPdf.cxx:782
 RooProdPdf.cxx:783
 RooProdPdf.cxx:784
 RooProdPdf.cxx:785
 RooProdPdf.cxx:786
 RooProdPdf.cxx:787
 RooProdPdf.cxx:788
 RooProdPdf.cxx:789
 RooProdPdf.cxx:790
 RooProdPdf.cxx:791
 RooProdPdf.cxx:792
 RooProdPdf.cxx:793
 RooProdPdf.cxx:794
 RooProdPdf.cxx:795
 RooProdPdf.cxx:796
 RooProdPdf.cxx:797
 RooProdPdf.cxx:798
 RooProdPdf.cxx:799
 RooProdPdf.cxx:800
 RooProdPdf.cxx:801
 RooProdPdf.cxx:802
 RooProdPdf.cxx:803
 RooProdPdf.cxx:804
 RooProdPdf.cxx:805
 RooProdPdf.cxx:806
 RooProdPdf.cxx:807
 RooProdPdf.cxx:808
 RooProdPdf.cxx:809
 RooProdPdf.cxx:810
 RooProdPdf.cxx:811
 RooProdPdf.cxx:812
 RooProdPdf.cxx:813
 RooProdPdf.cxx:814
 RooProdPdf.cxx:815
 RooProdPdf.cxx:816
 RooProdPdf.cxx:817
 RooProdPdf.cxx:818
 RooProdPdf.cxx:819
 RooProdPdf.cxx:820
 RooProdPdf.cxx:821
 RooProdPdf.cxx:822
 RooProdPdf.cxx:823
 RooProdPdf.cxx:824
 RooProdPdf.cxx:825
 RooProdPdf.cxx:826
 RooProdPdf.cxx:827
 RooProdPdf.cxx:828
 RooProdPdf.cxx:829
 RooProdPdf.cxx:830
 RooProdPdf.cxx:831
 RooProdPdf.cxx:832
 RooProdPdf.cxx:833
 RooProdPdf.cxx:834
 RooProdPdf.cxx:835
 RooProdPdf.cxx:836
 RooProdPdf.cxx:837
 RooProdPdf.cxx:838
 RooProdPdf.cxx:839
 RooProdPdf.cxx:840
 RooProdPdf.cxx:841
 RooProdPdf.cxx:842
 RooProdPdf.cxx:843
 RooProdPdf.cxx:844
 RooProdPdf.cxx:845
 RooProdPdf.cxx:846
 RooProdPdf.cxx:847
 RooProdPdf.cxx:848
 RooProdPdf.cxx:849
 RooProdPdf.cxx:850
 RooProdPdf.cxx:851
 RooProdPdf.cxx:852
 RooProdPdf.cxx:853
 RooProdPdf.cxx:854
 RooProdPdf.cxx:855
 RooProdPdf.cxx:856
 RooProdPdf.cxx:857
 RooProdPdf.cxx:858
 RooProdPdf.cxx:859
 RooProdPdf.cxx:860
 RooProdPdf.cxx:861
 RooProdPdf.cxx:862
 RooProdPdf.cxx:863
 RooProdPdf.cxx:864
 RooProdPdf.cxx:865
 RooProdPdf.cxx:866
 RooProdPdf.cxx:867
 RooProdPdf.cxx:868
 RooProdPdf.cxx:869
 RooProdPdf.cxx:870
 RooProdPdf.cxx:871
 RooProdPdf.cxx:872
 RooProdPdf.cxx:873
 RooProdPdf.cxx:874
 RooProdPdf.cxx:875
 RooProdPdf.cxx:876
 RooProdPdf.cxx:877
 RooProdPdf.cxx:878
 RooProdPdf.cxx:879
 RooProdPdf.cxx:880
 RooProdPdf.cxx:881
 RooProdPdf.cxx:882
 RooProdPdf.cxx:883
 RooProdPdf.cxx:884
 RooProdPdf.cxx:885
 RooProdPdf.cxx:886
 RooProdPdf.cxx:887
 RooProdPdf.cxx:888
 RooProdPdf.cxx:889
 RooProdPdf.cxx:890
 RooProdPdf.cxx:891
 RooProdPdf.cxx:892
 RooProdPdf.cxx:893
 RooProdPdf.cxx:894
 RooProdPdf.cxx:895
 RooProdPdf.cxx:896
 RooProdPdf.cxx:897
 RooProdPdf.cxx:898
 RooProdPdf.cxx:899
 RooProdPdf.cxx:900
 RooProdPdf.cxx:901
 RooProdPdf.cxx:902
 RooProdPdf.cxx:903
 RooProdPdf.cxx:904
 RooProdPdf.cxx:905
 RooProdPdf.cxx:906
 RooProdPdf.cxx:907
 RooProdPdf.cxx:908
 RooProdPdf.cxx:909
 RooProdPdf.cxx:910
 RooProdPdf.cxx:911
 RooProdPdf.cxx:912
 RooProdPdf.cxx:913
 RooProdPdf.cxx:914
 RooProdPdf.cxx:915
 RooProdPdf.cxx:916
 RooProdPdf.cxx:917
 RooProdPdf.cxx:918
 RooProdPdf.cxx:919
 RooProdPdf.cxx:920
 RooProdPdf.cxx:921
 RooProdPdf.cxx:922
 RooProdPdf.cxx:923
 RooProdPdf.cxx:924
 RooProdPdf.cxx:925
 RooProdPdf.cxx:926
 RooProdPdf.cxx:927
 RooProdPdf.cxx:928
 RooProdPdf.cxx:929
 RooProdPdf.cxx:930
 RooProdPdf.cxx:931
 RooProdPdf.cxx:932
 RooProdPdf.cxx:933
 RooProdPdf.cxx:934
 RooProdPdf.cxx:935
 RooProdPdf.cxx:936
 RooProdPdf.cxx:937
 RooProdPdf.cxx:938
 RooProdPdf.cxx:939
 RooProdPdf.cxx:940
 RooProdPdf.cxx:941
 RooProdPdf.cxx:942
 RooProdPdf.cxx:943
 RooProdPdf.cxx:944
 RooProdPdf.cxx:945
 RooProdPdf.cxx:946
 RooProdPdf.cxx:947
 RooProdPdf.cxx:948
 RooProdPdf.cxx:949
 RooProdPdf.cxx:950
 RooProdPdf.cxx:951
 RooProdPdf.cxx:952
 RooProdPdf.cxx:953
 RooProdPdf.cxx:954
 RooProdPdf.cxx:955
 RooProdPdf.cxx:956
 RooProdPdf.cxx:957
 RooProdPdf.cxx:958
 RooProdPdf.cxx:959
 RooProdPdf.cxx:960
 RooProdPdf.cxx:961
 RooProdPdf.cxx:962
 RooProdPdf.cxx:963
 RooProdPdf.cxx:964
 RooProdPdf.cxx:965
 RooProdPdf.cxx:966
 RooProdPdf.cxx:967
 RooProdPdf.cxx:968
 RooProdPdf.cxx:969
 RooProdPdf.cxx:970
 RooProdPdf.cxx:971
 RooProdPdf.cxx:972
 RooProdPdf.cxx:973
 RooProdPdf.cxx:974
 RooProdPdf.cxx:975
 RooProdPdf.cxx:976
 RooProdPdf.cxx:977
 RooProdPdf.cxx:978
 RooProdPdf.cxx:979
 RooProdPdf.cxx:980
 RooProdPdf.cxx:981
 RooProdPdf.cxx:982
 RooProdPdf.cxx:983
 RooProdPdf.cxx:984
 RooProdPdf.cxx:985
 RooProdPdf.cxx:986
 RooProdPdf.cxx:987
 RooProdPdf.cxx:988
 RooProdPdf.cxx:989
 RooProdPdf.cxx:990
 RooProdPdf.cxx:991
 RooProdPdf.cxx:992
 RooProdPdf.cxx:993
 RooProdPdf.cxx:994
 RooProdPdf.cxx:995
 RooProdPdf.cxx:996
 RooProdPdf.cxx:997
 RooProdPdf.cxx:998
 RooProdPdf.cxx:999
 RooProdPdf.cxx:1000
 RooProdPdf.cxx:1001
 RooProdPdf.cxx:1002
 RooProdPdf.cxx:1003
 RooProdPdf.cxx:1004
 RooProdPdf.cxx:1005
 RooProdPdf.cxx:1006
 RooProdPdf.cxx:1007
 RooProdPdf.cxx:1008
 RooProdPdf.cxx:1009
 RooProdPdf.cxx:1010
 RooProdPdf.cxx:1011
 RooProdPdf.cxx:1012
 RooProdPdf.cxx:1013
 RooProdPdf.cxx:1014
 RooProdPdf.cxx:1015
 RooProdPdf.cxx:1016
 RooProdPdf.cxx:1017
 RooProdPdf.cxx:1018
 RooProdPdf.cxx:1019
 RooProdPdf.cxx:1020
 RooProdPdf.cxx:1021
 RooProdPdf.cxx:1022
 RooProdPdf.cxx:1023
 RooProdPdf.cxx:1024
 RooProdPdf.cxx:1025
 RooProdPdf.cxx:1026
 RooProdPdf.cxx:1027
 RooProdPdf.cxx:1028
 RooProdPdf.cxx:1029
 RooProdPdf.cxx:1030
 RooProdPdf.cxx:1031
 RooProdPdf.cxx:1032
 RooProdPdf.cxx:1033
 RooProdPdf.cxx:1034
 RooProdPdf.cxx:1035
 RooProdPdf.cxx:1036
 RooProdPdf.cxx:1037
 RooProdPdf.cxx:1038
 RooProdPdf.cxx:1039
 RooProdPdf.cxx:1040
 RooProdPdf.cxx:1041
 RooProdPdf.cxx:1042
 RooProdPdf.cxx:1043
 RooProdPdf.cxx:1044
 RooProdPdf.cxx:1045
 RooProdPdf.cxx:1046
 RooProdPdf.cxx:1047
 RooProdPdf.cxx:1048
 RooProdPdf.cxx:1049
 RooProdPdf.cxx:1050
 RooProdPdf.cxx:1051
 RooProdPdf.cxx:1052
 RooProdPdf.cxx:1053
 RooProdPdf.cxx:1054
 RooProdPdf.cxx:1055
 RooProdPdf.cxx:1056
 RooProdPdf.cxx:1057
 RooProdPdf.cxx:1058
 RooProdPdf.cxx:1059
 RooProdPdf.cxx:1060
 RooProdPdf.cxx:1061
 RooProdPdf.cxx:1062
 RooProdPdf.cxx:1063
 RooProdPdf.cxx:1064
 RooProdPdf.cxx:1065
 RooProdPdf.cxx:1066
 RooProdPdf.cxx:1067
 RooProdPdf.cxx:1068
 RooProdPdf.cxx:1069
 RooProdPdf.cxx:1070
 RooProdPdf.cxx:1071
 RooProdPdf.cxx:1072
 RooProdPdf.cxx:1073
 RooProdPdf.cxx:1074
 RooProdPdf.cxx:1075
 RooProdPdf.cxx:1076
 RooProdPdf.cxx:1077
 RooProdPdf.cxx:1078
 RooProdPdf.cxx:1079
 RooProdPdf.cxx:1080
 RooProdPdf.cxx:1081
 RooProdPdf.cxx:1082
 RooProdPdf.cxx:1083
 RooProdPdf.cxx:1084
 RooProdPdf.cxx:1085
 RooProdPdf.cxx:1086
 RooProdPdf.cxx:1087
 RooProdPdf.cxx:1088
 RooProdPdf.cxx:1089
 RooProdPdf.cxx:1090
 RooProdPdf.cxx:1091
 RooProdPdf.cxx:1092
 RooProdPdf.cxx:1093
 RooProdPdf.cxx:1094
 RooProdPdf.cxx:1095
 RooProdPdf.cxx:1096
 RooProdPdf.cxx:1097
 RooProdPdf.cxx:1098
 RooProdPdf.cxx:1099
 RooProdPdf.cxx:1100
 RooProdPdf.cxx:1101
 RooProdPdf.cxx:1102
 RooProdPdf.cxx:1103
 RooProdPdf.cxx:1104
 RooProdPdf.cxx:1105
 RooProdPdf.cxx:1106
 RooProdPdf.cxx:1107
 RooProdPdf.cxx:1108
 RooProdPdf.cxx:1109
 RooProdPdf.cxx:1110
 RooProdPdf.cxx:1111
 RooProdPdf.cxx:1112
 RooProdPdf.cxx:1113
 RooProdPdf.cxx:1114
 RooProdPdf.cxx:1115
 RooProdPdf.cxx:1116
 RooProdPdf.cxx:1117
 RooProdPdf.cxx:1118
 RooProdPdf.cxx:1119
 RooProdPdf.cxx:1120
 RooProdPdf.cxx:1121
 RooProdPdf.cxx:1122
 RooProdPdf.cxx:1123
 RooProdPdf.cxx:1124
 RooProdPdf.cxx:1125
 RooProdPdf.cxx:1126
 RooProdPdf.cxx:1127
 RooProdPdf.cxx:1128
 RooProdPdf.cxx:1129
 RooProdPdf.cxx:1130
 RooProdPdf.cxx:1131
 RooProdPdf.cxx:1132
 RooProdPdf.cxx:1133
 RooProdPdf.cxx:1134
 RooProdPdf.cxx:1135
 RooProdPdf.cxx:1136
 RooProdPdf.cxx:1137
 RooProdPdf.cxx:1138
 RooProdPdf.cxx:1139
 RooProdPdf.cxx:1140
 RooProdPdf.cxx:1141
 RooProdPdf.cxx:1142
 RooProdPdf.cxx:1143
 RooProdPdf.cxx:1144
 RooProdPdf.cxx:1145
 RooProdPdf.cxx:1146
 RooProdPdf.cxx:1147
 RooProdPdf.cxx:1148
 RooProdPdf.cxx:1149
 RooProdPdf.cxx:1150
 RooProdPdf.cxx:1151
 RooProdPdf.cxx:1152
 RooProdPdf.cxx:1153
 RooProdPdf.cxx:1154
 RooProdPdf.cxx:1155
 RooProdPdf.cxx:1156
 RooProdPdf.cxx:1157
 RooProdPdf.cxx:1158
 RooProdPdf.cxx:1159
 RooProdPdf.cxx:1160
 RooProdPdf.cxx:1161
 RooProdPdf.cxx:1162
 RooProdPdf.cxx:1163
 RooProdPdf.cxx:1164
 RooProdPdf.cxx:1165
 RooProdPdf.cxx:1166
 RooProdPdf.cxx:1167
 RooProdPdf.cxx:1168
 RooProdPdf.cxx:1169
 RooProdPdf.cxx:1170
 RooProdPdf.cxx:1171
 RooProdPdf.cxx:1172
 RooProdPdf.cxx:1173
 RooProdPdf.cxx:1174
 RooProdPdf.cxx:1175
 RooProdPdf.cxx:1176
 RooProdPdf.cxx:1177
 RooProdPdf.cxx:1178
 RooProdPdf.cxx:1179
 RooProdPdf.cxx:1180
 RooProdPdf.cxx:1181
 RooProdPdf.cxx:1182
 RooProdPdf.cxx:1183
 RooProdPdf.cxx:1184
 RooProdPdf.cxx:1185
 RooProdPdf.cxx:1186
 RooProdPdf.cxx:1187
 RooProdPdf.cxx:1188
 RooProdPdf.cxx:1189
 RooProdPdf.cxx:1190
 RooProdPdf.cxx:1191
 RooProdPdf.cxx:1192
 RooProdPdf.cxx:1193
 RooProdPdf.cxx:1194
 RooProdPdf.cxx:1195
 RooProdPdf.cxx:1196
 RooProdPdf.cxx:1197
 RooProdPdf.cxx:1198
 RooProdPdf.cxx:1199
 RooProdPdf.cxx:1200
 RooProdPdf.cxx:1201
 RooProdPdf.cxx:1202
 RooProdPdf.cxx:1203
 RooProdPdf.cxx:1204
 RooProdPdf.cxx:1205
 RooProdPdf.cxx:1206
 RooProdPdf.cxx:1207
 RooProdPdf.cxx:1208
 RooProdPdf.cxx:1209
 RooProdPdf.cxx:1210
 RooProdPdf.cxx:1211
 RooProdPdf.cxx:1212
 RooProdPdf.cxx:1213
 RooProdPdf.cxx:1214
 RooProdPdf.cxx:1215
 RooProdPdf.cxx:1216
 RooProdPdf.cxx:1217
 RooProdPdf.cxx:1218
 RooProdPdf.cxx:1219
 RooProdPdf.cxx:1220
 RooProdPdf.cxx:1221
 RooProdPdf.cxx:1222
 RooProdPdf.cxx:1223
 RooProdPdf.cxx:1224
 RooProdPdf.cxx:1225
 RooProdPdf.cxx:1226
 RooProdPdf.cxx:1227
 RooProdPdf.cxx:1228
 RooProdPdf.cxx:1229
 RooProdPdf.cxx:1230
 RooProdPdf.cxx:1231
 RooProdPdf.cxx:1232
 RooProdPdf.cxx:1233
 RooProdPdf.cxx:1234
 RooProdPdf.cxx:1235
 RooProdPdf.cxx:1236
 RooProdPdf.cxx:1237
 RooProdPdf.cxx:1238
 RooProdPdf.cxx:1239
 RooProdPdf.cxx:1240
 RooProdPdf.cxx:1241
 RooProdPdf.cxx:1242
 RooProdPdf.cxx:1243
 RooProdPdf.cxx:1244
 RooProdPdf.cxx:1245
 RooProdPdf.cxx:1246
 RooProdPdf.cxx:1247
 RooProdPdf.cxx:1248
 RooProdPdf.cxx:1249
 RooProdPdf.cxx:1250
 RooProdPdf.cxx:1251
 RooProdPdf.cxx:1252
 RooProdPdf.cxx:1253
 RooProdPdf.cxx:1254
 RooProdPdf.cxx:1255
 RooProdPdf.cxx:1256
 RooProdPdf.cxx:1257
 RooProdPdf.cxx:1258
 RooProdPdf.cxx:1259
 RooProdPdf.cxx:1260
 RooProdPdf.cxx:1261
 RooProdPdf.cxx:1262
 RooProdPdf.cxx:1263
 RooProdPdf.cxx:1264
 RooProdPdf.cxx:1265
 RooProdPdf.cxx:1266
 RooProdPdf.cxx:1267
 RooProdPdf.cxx:1268
 RooProdPdf.cxx:1269
 RooProdPdf.cxx:1270
 RooProdPdf.cxx:1271
 RooProdPdf.cxx:1272
 RooProdPdf.cxx:1273
 RooProdPdf.cxx:1274
 RooProdPdf.cxx:1275
 RooProdPdf.cxx:1276
 RooProdPdf.cxx:1277
 RooProdPdf.cxx:1278
 RooProdPdf.cxx:1279
 RooProdPdf.cxx:1280
 RooProdPdf.cxx:1281
 RooProdPdf.cxx:1282
 RooProdPdf.cxx:1283
 RooProdPdf.cxx:1284
 RooProdPdf.cxx:1285
 RooProdPdf.cxx:1286
 RooProdPdf.cxx:1287
 RooProdPdf.cxx:1288
 RooProdPdf.cxx:1289
 RooProdPdf.cxx:1290
 RooProdPdf.cxx:1291
 RooProdPdf.cxx:1292
 RooProdPdf.cxx:1293
 RooProdPdf.cxx:1294
 RooProdPdf.cxx:1295
 RooProdPdf.cxx:1296
 RooProdPdf.cxx:1297
 RooProdPdf.cxx:1298
 RooProdPdf.cxx:1299
 RooProdPdf.cxx:1300
 RooProdPdf.cxx:1301
 RooProdPdf.cxx:1302
 RooProdPdf.cxx:1303
 RooProdPdf.cxx:1304
 RooProdPdf.cxx:1305
 RooProdPdf.cxx:1306
 RooProdPdf.cxx:1307
 RooProdPdf.cxx:1308
 RooProdPdf.cxx:1309
 RooProdPdf.cxx:1310
 RooProdPdf.cxx:1311
 RooProdPdf.cxx:1312
 RooProdPdf.cxx:1313
 RooProdPdf.cxx:1314
 RooProdPdf.cxx:1315
 RooProdPdf.cxx:1316
 RooProdPdf.cxx:1317
 RooProdPdf.cxx:1318
 RooProdPdf.cxx:1319
 RooProdPdf.cxx:1320
 RooProdPdf.cxx:1321
 RooProdPdf.cxx:1322
 RooProdPdf.cxx:1323
 RooProdPdf.cxx:1324
 RooProdPdf.cxx:1325
 RooProdPdf.cxx:1326
 RooProdPdf.cxx:1327
 RooProdPdf.cxx:1328
 RooProdPdf.cxx:1329
 RooProdPdf.cxx:1330
 RooProdPdf.cxx:1331
 RooProdPdf.cxx:1332
 RooProdPdf.cxx:1333
 RooProdPdf.cxx:1334
 RooProdPdf.cxx:1335
 RooProdPdf.cxx:1336
 RooProdPdf.cxx:1337
 RooProdPdf.cxx:1338
 RooProdPdf.cxx:1339
 RooProdPdf.cxx:1340
 RooProdPdf.cxx:1341
 RooProdPdf.cxx:1342
 RooProdPdf.cxx:1343
 RooProdPdf.cxx:1344
 RooProdPdf.cxx:1345
 RooProdPdf.cxx:1346
 RooProdPdf.cxx:1347
 RooProdPdf.cxx:1348
 RooProdPdf.cxx:1349
 RooProdPdf.cxx:1350
 RooProdPdf.cxx:1351
 RooProdPdf.cxx:1352
 RooProdPdf.cxx:1353
 RooProdPdf.cxx:1354
 RooProdPdf.cxx:1355
 RooProdPdf.cxx:1356
 RooProdPdf.cxx:1357
 RooProdPdf.cxx:1358
 RooProdPdf.cxx:1359
 RooProdPdf.cxx:1360
 RooProdPdf.cxx:1361
 RooProdPdf.cxx:1362
 RooProdPdf.cxx:1363
 RooProdPdf.cxx:1364
 RooProdPdf.cxx:1365
 RooProdPdf.cxx:1366
 RooProdPdf.cxx:1367
 RooProdPdf.cxx:1368
 RooProdPdf.cxx:1369
 RooProdPdf.cxx:1370
 RooProdPdf.cxx:1371
 RooProdPdf.cxx:1372
 RooProdPdf.cxx:1373
 RooProdPdf.cxx:1374
 RooProdPdf.cxx:1375
 RooProdPdf.cxx:1376
 RooProdPdf.cxx:1377
 RooProdPdf.cxx:1378
 RooProdPdf.cxx:1379
 RooProdPdf.cxx:1380
 RooProdPdf.cxx:1381
 RooProdPdf.cxx:1382
 RooProdPdf.cxx:1383
 RooProdPdf.cxx:1384
 RooProdPdf.cxx:1385
 RooProdPdf.cxx:1386
 RooProdPdf.cxx:1387
 RooProdPdf.cxx:1388
 RooProdPdf.cxx:1389
 RooProdPdf.cxx:1390
 RooProdPdf.cxx:1391
 RooProdPdf.cxx:1392
 RooProdPdf.cxx:1393
 RooProdPdf.cxx:1394
 RooProdPdf.cxx:1395
 RooProdPdf.cxx:1396
 RooProdPdf.cxx:1397
 RooProdPdf.cxx:1398
 RooProdPdf.cxx:1399
 RooProdPdf.cxx:1400
 RooProdPdf.cxx:1401
 RooProdPdf.cxx:1402
 RooProdPdf.cxx:1403
 RooProdPdf.cxx:1404
 RooProdPdf.cxx:1405
 RooProdPdf.cxx:1406
 RooProdPdf.cxx:1407
 RooProdPdf.cxx:1408
 RooProdPdf.cxx:1409
 RooProdPdf.cxx:1410
 RooProdPdf.cxx:1411
 RooProdPdf.cxx:1412
 RooProdPdf.cxx:1413
 RooProdPdf.cxx:1414
 RooProdPdf.cxx:1415
 RooProdPdf.cxx:1416
 RooProdPdf.cxx:1417
 RooProdPdf.cxx:1418
 RooProdPdf.cxx:1419
 RooProdPdf.cxx:1420
 RooProdPdf.cxx:1421
 RooProdPdf.cxx:1422
 RooProdPdf.cxx:1423
 RooProdPdf.cxx:1424
 RooProdPdf.cxx:1425
 RooProdPdf.cxx:1426
 RooProdPdf.cxx:1427
 RooProdPdf.cxx:1428
 RooProdPdf.cxx:1429
 RooProdPdf.cxx:1430
 RooProdPdf.cxx:1431
 RooProdPdf.cxx:1432
 RooProdPdf.cxx:1433
 RooProdPdf.cxx:1434
 RooProdPdf.cxx:1435
 RooProdPdf.cxx:1436
 RooProdPdf.cxx:1437
 RooProdPdf.cxx:1438
 RooProdPdf.cxx:1439
 RooProdPdf.cxx:1440
 RooProdPdf.cxx:1441
 RooProdPdf.cxx:1442
 RooProdPdf.cxx:1443
 RooProdPdf.cxx:1444
 RooProdPdf.cxx:1445
 RooProdPdf.cxx:1446
 RooProdPdf.cxx:1447
 RooProdPdf.cxx:1448