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

//////////////////////////////////////////////////////////////////////////////
// 
// BEGIN_HTML
// RooFactoryWSTool is a clase like TTree::MakeClass() that generates
// skeleton code for RooAbsPdf and RooAbsReal functions given
// a list of input parameter names. The factory can also compile
// the generated code on the fly, and on request also immediate
// instantiate objects.
// END_HTML
//

#include "RooFit.h"

#include "RooFactoryWSTool.h"
#include "RooAbsReal.h"
#include "RooAbsCategory.h"
#include "RooArgList.h"
#include "RooRealVar.h"
#include "RooCategory.h"
#include "RooMsgService.h"
#include "RooWorkspace.h"
#include "TInterpreter.h"
#include "TClass.h"
#include "TClassTable.h"
#include "RooAbsPdf.h"
#include "RooGaussian.h"
#include <fstream>
#include <vector>
#include <string>
#include "RooGlobalFunc.h"
#include "RooDataSet.h"
#include "RooDataHist.h"
#include "RooCintUtils.h"
#include "RooAddPdf.h"
#include "RooProdPdf.h"
#include "RooSimultaneous.h"
#include "RooFFTConvPdf.h"
#include "RooNumConvPdf.h"
#include "RooResolutionModel.h"
#include "RooProduct.h"
#include "RooAddition.h"
#include "RooChi2Var.h"
#include "RooNLLVar.h"
#include "RooRealSumPdf.h"
#include "RooConstVar.h"
#include "RooDerivative.h"
#include "TROOT.h"

using namespace RooFit ;
using namespace std ;

#define BUFFER_SIZE 64000 

ClassImp(RooFactoryWSTool) 
;

RooFactoryWSTool* RooFactoryWSTool::_of = 0 ;
map<string,RooFactoryWSTool::IFace*>* RooFactoryWSTool::_hooks=0 ;

static Int_t init()
{
  RooFactoryWSTool::IFace* iface = new RooFactoryWSTool::SpecialsIFace ;

  // Operator p.d.f.s
  RooFactoryWSTool::registerSpecial("SUM",iface) ;
  RooFactoryWSTool::registerSpecial("RSUM",iface) ;
  RooFactoryWSTool::registerSpecial("ASUM",iface) ;
  RooFactoryWSTool::registerSpecial("PROD",iface) ;
  RooFactoryWSTool::registerSpecial("SIMUL",iface) ;
  RooFactoryWSTool::registerSpecial("EXPR",iface) ;
  RooFactoryWSTool::registerSpecial("FCONV",iface) ;
  RooFactoryWSTool::registerSpecial("NCONV",iface) ;

  // Operator functions
  RooFactoryWSTool::registerSpecial("sum",iface) ;
  RooFactoryWSTool::registerSpecial("prod",iface) ;
  RooFactoryWSTool::registerSpecial("expr",iface) ;
  RooFactoryWSTool::registerSpecial("nconv",iface) ;

  // Test statistics
  RooFactoryWSTool::registerSpecial("nll",iface) ;
  RooFactoryWSTool::registerSpecial("chi2",iface) ;
  RooFactoryWSTool::registerSpecial("profile",iface) ;

  // Integration and derivation
  RooFactoryWSTool::registerSpecial("int",iface) ;
  RooFactoryWSTool::registerSpecial("deriv",iface) ;
  RooFactoryWSTool::registerSpecial("cdf",iface) ;
  RooFactoryWSTool::registerSpecial("PROJ",iface) ;

  // Miscellaneous
  RooFactoryWSTool::registerSpecial("dataobs",iface) ;
  RooFactoryWSTool::registerSpecial("set",iface) ;

  return 0 ;
}
static Int_t dummy = init() ;


#ifndef _WIN32
#include <strings.h>
#else

static char *strtok_r(char *s1, const char *s2, char **lasts)
{
  char *ret;
  
  if (s1 == NULL)
    s1 = *lasts;
  while(*s1 && strchr(s2, *s1))
    ++s1;
  if(*s1 == '\0')
    return NULL;
  ret = s1;
  while(*s1 && !strchr(s2, *s1))
    ++s1;
  if(*s1)
    *s1++ = '\0';
  *lasts = s1;
  return ret;
}

#endif



//_____________________________________________________________________________
RooFactoryWSTool::RooFactoryWSTool(RooWorkspace& inws) : _ws(&inws), _errorCount(0), _autoClassPostFix("")

{
  // Default constructor  
}



//_____________________________________________________________________________
RooFactoryWSTool::~RooFactoryWSTool() 
{
  // Destructor
}




//_____________________________________________________________________________
RooRealVar* RooFactoryWSTool::createVariable(const char* name, Double_t xmin, Double_t xmax)
{
  // Low-level factory interface for creating a RooRealVar with a given range and initial value

  // First check if variable already exists
  if (_ws->var(name)) {
    coutE(ObjectHandling) << "RooFactoryWSTool::createFactory() ERROR: variable with name '" << name << "' already exists" << endl ;
    logError() ;
    return 0 ;
  }

  // Create variable
  RooRealVar var(name,name,xmin,xmax) ;

  // Put in workspace
  if (_ws->import(var,Silence())) logError() ;

  return _ws->var(name) ;
}



//_____________________________________________________________________________
RooCategory* RooFactoryWSTool::createCategory(const char* name, const char* stateNameList) 
{
  // Low-level factory interface for creating a RooCategory with a given list of state names. The State name list
  // can be of the form 'name1,name2,name3' or of the form 'name1=id1,name2=id2,name3=id3'

  // Create variable
  RooCategory cat(name,name) ;

  // Add listed state names
  if (stateNameList) {
     const size_t tmpSize = strlen(stateNameList)+1;
    char *tmp = new char[tmpSize] ;
    strlcpy(tmp,stateNameList,tmpSize) ;
    char* save ;
    char* tok = strtok_r(tmp,",",&save) ;
    while(tok) {
      char* sep = strchr(tok,'=') ;
      if (sep) {
	*sep = 0 ;
	Int_t id = atoi(sep+1) ;
	cat.defineType(tok,id) ;
	*sep = '=' ;
      } else {
	cat.defineType(tok) ;
      }
      tok = strtok_r(0,",",&save) ;
    }
    delete[] tmp ;
  }

  cat.setStringAttribute("factory_tag",Form("%s[%s]",name,stateNameList)) ;

  // Put in workspace
  if (_ws->import(cat,Silence())) logError() ;  

  return _ws->cat(name) ;
}



//_____________________________________________________________________________
RooAbsArg* RooFactoryWSTool::createArg(const char* className, const char* objName, const char* varList) 
{
  // Low-level factory interface for creating a RooAbsPdf of a given class with a given list of input variables
  // The variable list varList should be of the form "a,b,c" where the interpretation of the argument is
  // dependent on the p.d.f. Set and List arguments can be passed by substituting a single argument with
  // the form (a,b,c), i.e. one can set varList to "x,(a0,a1,a2)" to pass a RooAbsReal and a RooArgSet as arguments.
  
  // Find class in ROOT class table
  TClass* tc = resolveClassName(className) ;
  if (!tc) {
    coutE(ObjectHandling) << "RooFactoryWSTool::createArg() ERROR class " << className << " not found in factory alias table, nor in ROOT class table" << endl ;
    logError() ;
    return 0 ;
  }

  className = tc->GetName() ;

  // Check that class inherits from RooAbsPdf
  if (!tc->InheritsFrom(RooAbsArg::Class())) {
    coutE(ObjectHandling) << "RooFactoryWSTool::createArg() ERROR class " << className << " does not inherit from RooAbsArg" << endl ;
    logError() ;
    return 0 ;
  }


  _args.clear() ;
  char tmp[BUFFER_SIZE] ;
  strlcpy(tmp,varList,BUFFER_SIZE) ;
  char* p=tmp ;
  char* tok=tmp ;
  Int_t blevel(0) ;
  Bool_t litmode(kFALSE) ;
  while(*p) {

    // Keep track of opening and closing brackets
    if (*p=='{' || *p=='(' || *p=='[') blevel++ ;
    if (*p=='}' || *p==')' || *p==']') blevel-- ;

    // Keep track of string literals
    if (*p=='"' || *p=='\'') litmode = !litmode ;
    
    // If we encounter a comma at zero bracket level
    // finalize the current token as a completed argument
    // and start the next token
    if (!litmode && blevel==0 && ((*p)==',')) {
      *p = 0 ;
      _args.push_back(tok) ;
      tok = p+1 ;
    }

    p++ ;
  }
  _args.push_back(tok) ;


  // Try CINT interface
  pair<list<string>,unsigned int> ca = RooCintUtils::ctorArgs(className,_args.size()+2) ;
  if (ca.first.size()==0) {
    coutE(ObjectHandling) << "RooFactoryWSTool::createArg() ERROR no suitable constructor found for class " << className << endl ;
    logError() ;
    return 0 ;
  }  


  // Check if number of provided args is in valid range (add two to accomodate name and title strings)
  if (_args.size()+2<ca.second || _args.size()+2>ca.first.size()) {
    if (ca.second==ca.first.size()) {
      coutE(ObjectHandling) << "RooFactoryWSTool::createArg() ERROR number of arguments provided (" << _args.size() << ") for class is invalid, " << className 
			    << " expects " << ca.first.size()-2 << endl ;
      logError() ;
    } else {
      coutE(ObjectHandling) << "RooFactoryWSTool::createArg() ERROR number of arguments provided (" << _args.size() << ") for class is invalid " << className 
			    << " expect number between " << ca.second-2 << " and " << ca.first.size()-2 << endl ;
      logError() ;
    }
    return 0 ;
  }

  // Now construct CINT constructor spec, start with mandatory name and title args
  string cintExpr(Form("new %s(\"%s\",\"%s\"",className,objName,objName)) ;

  // Install argument in static data member to be accessed below through static CINT interface functions  
  _of = this ;

  
  try {
    Int_t i(0) ;
    list<string>::iterator ti = ca.first.begin() ; ti++ ; ti++ ;
    for (vector<string>::iterator ai = _args.begin() ; ai != _args.end() ; ai++,ti++,i++) {
      if ((*ti)=="RooAbsReal&" || (*ti)=="const RooAbsReal&") {
	RooFactoryWSTool::as_FUNC(i) ;
	cintExpr += Form(",RooFactoryWSTool::as_FUNC(%d)",i) ;
      } else if ((*ti)=="RooAbsArg&" || (*ti)=="const RooAbsArg&") {
	RooFactoryWSTool::as_ARG(i) ;
	cintExpr += Form(",RooFactoryWSTool::as_ARG(%d)",i) ;
      } else if ((*ti)=="RooRealVar&" || (*ti)=="const RooRealVar&") {
	RooFactoryWSTool::as_VAR(i) ;
	cintExpr += Form(",RooFactoryWSTool::as_VAR(%d)",i) ;
      } else if ((*ti)=="RooAbsRealLValue&" || (*ti)=="const RooAbsRealLValue&") {
	RooFactoryWSTool::as_VARLV(i) ;
	cintExpr += Form(",RooFactoryWSTool::as_VARLV(%d)",i) ;
      } else if ((*ti)=="RooCategory&" || (*ti)=="const RooCategory&") {
	RooFactoryWSTool::as_CAT(i) ;
	cintExpr += Form(",RooFactoryWSTool::as_CAT(%d)",i) ;
      } else if ((*ti)=="RooAbsCategory&" || (*ti)=="const RooAbsCategory&") {
	RooFactoryWSTool::as_CATFUNC(i) ;
	cintExpr += Form(",RooFactoryWSTool::as_CATFUNC(%d)",i) ;
      } else if ((*ti)=="RooAbsCategoryLValue&" || (*ti)=="const RooAbsCategoryLValue&") {
	RooFactoryWSTool::as_CATLV(i) ;
	cintExpr += Form(",RooFactoryWSTool::as_CATLV(%d)",i) ;
      } else if ((*ti)=="RooAbsPdf&" || (*ti)=="const RooAbsPdf&") {
	RooFactoryWSTool::as_PDF(i) ;
	cintExpr += Form(",RooFactoryWSTool::as_PDF(%d)",i) ;
      } else if ((*ti)=="RooResolutionModel&" || (*ti)=="const RooResolutionModel&") {
	RooFactoryWSTool::as_RMODEL(i) ;
	cintExpr += Form(",RooFactoryWSTool::as_RMODEL(%d)",i) ;
      } else if ((*ti)=="RooAbsData&" || (*ti)=="const RooAbsData&") {
	RooFactoryWSTool::as_DATA(i) ;
	cintExpr += Form(",RooFactoryWSTool::as_DATA(%d)",i) ;
      } else if ((*ti)=="RooDataSet&" || (*ti)=="const RooDataSet&") {
	RooFactoryWSTool::as_DSET(i) ;
	cintExpr += Form(",RooFactoryWSTool::as_DSET(%d)",i) ;
      } else if ((*ti)=="RooDataHist&" || (*ti)=="const RooDataHist&") {
	RooFactoryWSTool::as_DHIST(i) ;
	cintExpr += Form(",RooFactoryWSTool::as_DHIST(%d)",i) ;
      } else if ((*ti)=="const RooArgSet&") {
	RooFactoryWSTool::as_SET(i) ;
	cintExpr += Form(",RooFactoryWSTool::as_SET(%d)",i) ;
      } else if ((*ti)=="const RooArgList&") {
	RooFactoryWSTool::as_LIST(i) ;
	cintExpr += Form(",RooFactoryWSTool::as_LIST(%d)",i) ;
      } else if ((*ti)=="const char*") {
	RooFactoryWSTool::as_STRING(i) ;
	cintExpr += Form(",RooFactoryWSTool::as_STRING(%d)",i) ;	
      } else if ((*ti)=="Int_t" || (*ti)=="int" || (*ti)=="Bool_t" || (*ti)=="bool") {
	RooFactoryWSTool::as_INT(i) ;
	cintExpr += Form(",RooFactoryWSTool::as_INT(%d)",i) ;	
      } else if ((*ti)=="Double_t") {
	RooFactoryWSTool::as_DOUBLE(i) ;
	cintExpr += Form(",RooFactoryWSTool::as_DOUBLE(%d)",i) ;	
      } else if (RooCintUtils::isEnum(ti->c_str())) {	  	  

	string qualvalue ;
	if (_args[i].find(Form("%s::",className)) != string::npos) {		    
	  qualvalue = _args[i].c_str() ;
	} else {	
	  qualvalue =  Form("%s::%s",className,_args[i].c_str()) ;	    
	}
	if (RooCintUtils::isValidEnumValue(ti->c_str(),qualvalue.c_str())) {
	  cintExpr += Form(",(%s)%s",ti->c_str(),qualvalue.c_str()) ;
	} else {
	  throw string(Form("Supplied argument %s does not represent a valid state of enum %s",_args[i].c_str(),ti->c_str())) ;
	  }
      } else {
	// Check if generic object store has argument of given name and type
	TObject& obj = RooFactoryWSTool::as_OBJ(i) ;

	// Strip argument type to bare type (i.e. const X& -> X)
	string btype ;
	if (ti->find("const ")==0) {
	  btype = ti->c_str()+6 ;
	} else {
	  btype = *ti ;
	}
	if (btype.find("&")) {
	  btype.erase(btype.size()-1,btype.size()) ;
	}

	// If btype if a typedef, substitute it by the true type name
	btype = RooCintUtils::trueName(btype.c_str()) ;

	if (obj.InheritsFrom(btype.c_str())) {
	  cintExpr += Form(",(%s&)RooFactoryWSTool::as_OBJ(%d)",ti->c_str(),i) ;
	} else {
	  throw string(Form("Required argument with name %s of type '%s' is not in the workspace",_args[i].c_str(),ti->c_str())) ;
	}
      }
    }
    cintExpr += ") ;" ;
  } catch (string err) {
    coutE(ObjectHandling) << "RooFactoryWSTool::createArg() ERROR constructing " << className << "::" << objName << ": " << err << endl ;
    logError() ;
    return 0 ;
  }
  
  cxcoutD(ObjectHandling) << "RooFactoryWSTool::createArg() Construct expression is " << cintExpr << endl ;

  // Call CINT to perform constructor call. Catch any error thrown by argument conversion method
  RooAbsArg* arg = (RooAbsArg*) gROOT->ProcessLineFast(cintExpr.c_str()) ;

  if (arg) {    
    if (string(className)=="RooGenericPdf") {
      arg->setStringAttribute("factory_tag",Form("EXPR::%s(%s)",objName,varList)) ;
    } else if (string(className)=="RooFormulaVar") {
      arg->setStringAttribute("factory_tag",Form("expr::%s(%s)",objName,varList)) ;
    } else {
      arg->setStringAttribute("factory_tag",Form("%s::%s(%s)",className,objName,varList)) ;
    }
    if (_ws->import(*arg,Silence())) logError() ;
    RooAbsArg* ret = _ws->arg(objName) ;
    delete arg ;
    return ret ;
  } else {
    coutE(ObjectHandling) << "RooFactoryWSTool::createArg() ERROR in CINT constructor call to create object" << endl ;
    logError() ;
    return 0 ;
  }
}



//_____________________________________________________________________________
vector<string> RooFactoryWSTool::ctorArgs(const char* /*className*/) 
{
  return vector<string>() ;
}




//_____________________________________________________________________________
RooAddPdf* RooFactoryWSTool::add(const char *objName, const char* specList, Bool_t recursiveCoefs)
{

  // Spec list is of form a*A,b*B,c*C,D [ *d]

  RooArgList pdfList ;
  RooArgList coefList ;
  RooArgList pdfList2 ;

  try {

    char buf[BUFFER_SIZE] ;
    strlcpy(buf,specList,BUFFER_SIZE) ;
    char* save ;
    char* tok = strtok_r(buf,",",&save) ;
    while(tok) {
      char* star=strchr(tok,'*') ;
      if (star) {
	*star=0 ;
	pdfList.add(asPDF(star+1)) ;
	coefList.add(asFUNC(tok)) ;
      } else {
	pdfList2.add(asPDF(tok)) ;
      }
      tok = strtok_r(0,",",&save) ;
    }
    pdfList.add(pdfList2) ;

  } catch (string err) {
    coutE(ObjectHandling) << "RooFactoryWSTool::add(" << objName << ") ERROR creating RooAddPdf: " << err << endl ;    
    logError() ;
    return 0 ;
  }
  
  RooAddPdf* pdf =  new RooAddPdf(objName,objName,pdfList,coefList,recursiveCoefs) ;
  pdf->setStringAttribute("factory_tag",Form("SUM::%s(%s)",objName,specList)) ;
  if (_ws->import(*pdf,Silence())) logError() ;
  return (RooAddPdf*) _ws->pdf(objName) ;
}


//_____________________________________________________________________________
RooRealSumPdf* RooFactoryWSTool::amplAdd(const char *objName, const char* specList)
{

  // Spec list is of form a*A,b*B,c*C,D [ *d]

  RooArgList amplList ;
  RooArgList coefList ;
  RooArgList amplList2 ;

  try {

    char buf[BUFFER_SIZE] ;
    strlcpy(buf,specList,BUFFER_SIZE) ;
    char* save ;
    char* tok = strtok_r(buf,",",&save) ;
    while(tok) {
      char* star=strchr(tok,'*') ;
      if (star) {
	*star=0 ;
	amplList.add(asFUNC(star+1)) ;
	coefList.add(asFUNC(tok)) ;
      } else {
	amplList2.add(asFUNC(tok)) ;
      }
      tok = strtok_r(0,",",&save) ;
    }
    amplList.add(amplList2) ;

  } catch (string err) {
    coutE(ObjectHandling) << "RooFactoryWSTool::add(" << objName << ") ERROR creating RooRealSumPdf: " << err << endl ;    
    logError() ;
    return 0 ;
  }
  
  RooRealSumPdf* pdf =  new RooRealSumPdf(objName,objName,amplList,coefList,(amplList.getSize()==coefList.getSize())) ;
  pdf->setStringAttribute("factory_tag",Form("ASUM::%s(%s)",objName,specList)) ;
  if (_ws->import(*pdf,Silence())) logError() ;
  return (RooRealSumPdf*) _ws->pdf(objName) ;
}


//_____________________________________________________________________________
RooProdPdf* RooFactoryWSTool::prod(const char *objName, const char* pdfList) 
{
  _of = this ;

  // Separate conditional and non-conditional p.d.f terms
  RooLinkedList cmdList ;
  string regPdfList="{" ;
  char buf[BUFFER_SIZE] ;
  strlcpy(buf,pdfList,BUFFER_SIZE) ;
  char* save ;
  char* tok = strtok_r(buf,",",&save) ;
  while(tok) {
    char *sep = strchr(tok,'|') ;
    if (sep) {
      // Conditional term
      *sep=0 ;
      sep++ ;

      // |x is conditional on x, |~x is conditional on all but x
      Bool_t invCond(kFALSE) ;
      if (*sep=='~') {
	invCond=kTRUE ;
	sep++ ;
      }
      
      try {
 	cmdList.Add(Conditional(asSET(tok),asSET(sep),!invCond).Clone()) ;
      } catch (string err) {
	coutE(ObjectHandling) << "RooFactoryWSTool::prod(" << objName << ") ERROR creating RooProdPdf Conditional argument: " << err << endl ;
	logError() ;
	return 0 ;
      }
      
    } else {
      // Regular term
      if (regPdfList.size()>1) {
	regPdfList += "," ;
      }
      regPdfList += tok ;
    }
    tok = strtok_r(0,",",&save) ;
  }
  regPdfList += "}" ;
  
  RooProdPdf* pdf = 0 ;
  try {
    pdf = new RooProdPdf(objName,objName,asSET(regPdfList.c_str()),cmdList) ;
  } catch (string err) {
    coutE(ObjectHandling) << "RooFactoryWSTool::prod(" << objName << ") ERROR creating RooProdPdf input set of regular p.d.f.s: " << err << endl ;
    logError() ;
    pdf = 0 ;
  }
  cmdList.Delete() ;
  
  if (pdf) {
    pdf->setStringAttribute("factory_tag",Form("PROD::%s(%s)",objName,pdfList)) ;
    if (_ws->import(*pdf,Silence())) logError() ;
    delete pdf ;
    return (RooProdPdf*) _ws->pdf(objName) ;
  } else {
    return 0 ;
  }
}



//_____________________________________________________________________________
RooSimultaneous* RooFactoryWSTool::simul(const char* objName, const char* indexCat, const char* pdfMap)
{
  map<string,RooAbsPdf*> theMap ;
  // Add p.d.f. to index state mappings
  char buf[BUFFER_SIZE] ;
  strlcpy(buf,pdfMap,BUFFER_SIZE) ;
  char* save ;
  char* tok = strtok_r(buf,",",&save) ;
  while(tok) {
    char* eq = strchr(tok,'=') ;
    if (!eq) {
      coutE(ObjectHandling) << "RooFactoryWSTool::simul(" << objName << ") ERROR creating RooSimultaneous::" << objName 
			    << " expect mapping token of form 'state=pdfName', but found '" << tok << "'" << endl ;
      logError() ;
      return 0 ;
    } else {
      *eq = 0 ;

      try {
	theMap[tok] = &asPDF(eq+1) ;
      } catch ( string err ) {
	coutE(ObjectHandling) << "RooFactoryWSTool::simul(" << objName << ") ERROR creating RooSimultaneous: " << err << endl ;
	logError() ;
      }
    }
    tok = strtok_r(0,",",&save) ;
  }


  // Create simultaneous p.d.f.
  RooSimultaneous* pdf(0) ;
  try {
    pdf = new RooSimultaneous(objName,objName,theMap,asCATLV(indexCat)) ;
  } catch (string err) {
    coutE(ObjectHandling) << "RooFactoryWSTool::simul(" << objName << ") ERROR creating RooSimultaneous::" << objName << " " << err << endl ;
    logError() ;
  }

  // Import p.d.f into workspace
  pdf->setStringAttribute("factory_tag",Form("SIMUL::%s(%s,%s)",objName,indexCat,pdfMap)) ;
  if (_ws->import(*pdf,Silence())) logError() ;
  return (RooSimultaneous*) _ws->pdf(objName) ;
}




//_____________________________________________________________________________
RooAddition* RooFactoryWSTool::addfunc(const char *objName, const char* specList) 
{

  RooArgList sumlist1 ;
  RooArgList sumlist2 ;

  try {

    char buf[BUFFER_SIZE] ;
    strlcpy(buf,specList,BUFFER_SIZE) ;
    char* save ;
    char* tok = strtok_r(buf,",",&save) ;
    while(tok) {
      char* star=strchr(tok,'*') ;
      if (star) {
	*star=0 ;
	sumlist2.add(asFUNC(star+1)) ;
	sumlist1.add(asFUNC(tok)) ;
      } else {
	sumlist1.add(asFUNC(tok)) ;
      }
      tok = strtok_r(0,",",&save) ;
    }

  } catch (string err) {
    coutE(ObjectHandling) << "RooFactoryWSTool::addfunc(" << objName << ") ERROR creating RooAddition: " << err << endl ;
    logError() ;
    return 0 ;
  }

  if (sumlist2.getSize()>0 && (sumlist1.getSize()!=sumlist2.getSize())) {
    coutE(ObjectHandling) << "RooFactoryWSTool::addfunc(" << objName << ") ERROR creating RooAddition: syntax error: either all sum terms must be products or none" << endl ;
    logError() ;
    return 0 ;
  }


  RooAddition* sum ;
  if (sumlist2.getSize()>0) {
    sum = new RooAddition(objName,objName,sumlist1,sumlist2) ;
  } else {
    sum = new RooAddition(objName,objName,sumlist1) ;
  }

  sum->setStringAttribute("factory_tag",Form("sum::%s(%s)",objName,specList)) ;
  if (_ws->import(*sum,Silence())) logError() ;
  delete sum ;
  return (RooAddition*) _ws->pdf(objName) ;
  
}




//_____________________________________________________________________________
RooProduct* RooFactoryWSTool::prodfunc(const char *objName, const char* pdfList) 
{
  return (RooProduct*) createArg("RooProduct",objName,Form("{%s}",pdfList)) ;
}





//_____________________________________________________________________________
RooAbsArg* RooFactoryWSTool::process(const char* expr) 
{
  // Process high-level object creation syntax
  // Accepted forms of syntax are
  //
  //
  // Creating variables
  //
  // x[-10,10]             -  Create variable x with given range and put it in workspace
  // x[3,-10,10]           -  Create variable x with given range and initial value and put it in workspace
  // x[3]                  -  Create variable x with given constant value
  //
  // <numeric literal>     - Numeric literal expressions (0.5, -3 etc..) are converted to a RooConst(<numeric literal>) 
  //                         where ever a RooAbsReal or RooAbsArg argument is expected
  //
  // Creating categories
  //
  // c[lep,kao,nt1,nt2]    -  Create category c with given state names
  // tag[B0=1,B0bar=-1]    -  Create category tag with given state names and index assignments
  //
  //
  // Creating functions and p.d.f.s
  //
  // MyPdf::g(x,m,s)       - Create p.d.f or function of type MyPdf with name g with argument x,m,s
  //                         Interpretation and number of arguments are mapped to the constructor arguments of the class 
  //                         (after the name and title).
  //
  // MyPdf(x,m,s)          - As above, but with an implicitly defined (unique) object name
  // 
  //
  // Creating sets and lists (to be used as inputs above)
  //
  // {a,b,c}               - Create RooArgSet or RooArgList (as determined by context) from given contents
  //
  //
  //
  // Objects that are not created, are assumed to exist in the workspace
  // Object creation expressions as shown above can be nested, e.g. one can do
  //
  //   RooGaussian::g(x[-10,10],m[0],3) 
  //
  // to create a p.d.f and its variables in one go. This nesting can be applied recursively e.g.
  //
  //   SUM::model( f[0.5,0,1] * RooGaussian::g( x[-10,10], m[0], 3] ),
  //                            RooChebychev::c( x, {a0[0.1],a1[0.2],a2[-0.3]} ))
  //
  // creates the sum of a Gaussian and a Chebychev and all its variables
  //
  //
  // A seperate series of operator meta-type exists to simplify the construction of composite expressions
  // meta-types in all capitals (SUM) create p.d.f.s, meta types in lower case (sum) create
  // functions.
  //
  //
  // SUM::name(f1*pdf1,f2*pdf2,pdf3]  -- Create sum p.d.f name with value f1*pdf1+f2*pdf2+(1-f1-f2)*pdf3
  // RSUM::name(f1*pdf1,f2*pdf2,pdf3] -- Create recursive sum p.d.f. name with value f1*pdf1 + (1-f1)(f2*pdf2 + (1-f2)pdf3)
  // ASUM::name(f1*amp1,f2*amp2,amp3] -- Create sum p.d.f. name with value f1*amp1+f2*amp2+(1-f1-f2)*amp3 where amplX are amplitudes of type RooAbsReal
  // sum::name(a1,a2,a3]              -- Create sum function with value a1+a2+a3
  // sum::name(a1*b1,a2*b2,a3*b 3]    -- Create sum function with value a1*b1+a2*b2+a3*b3
  //
  // PROD::name(pdf1,pdf2]            -- Create product of p.d.f with 'name' with given input p.d.fs
  // PROD::name(pdf1|x,pdf2]          -- Create product of conditional p.d.f. pdf1 given x and pdf2
  // prod::name(a,b,c]                -- Create production function with value a*b*c
  //
  // SIMUL::name(cat,a=pdf1,b=pdf2]   -- Create simultaneous p.d.f index category cat. Make pdf1 to state a, pdf2 to state b
  //
  // EXPR::name('expr',var,...]       -- Create an generic p.d.f that interprets the given expression 
  // expr::name('expr',var,...]       -- Create an generic function that interprets the given expression 
  //
  //
  // The functionality of high level object creation tools like RooSimWSTool, RooCustomizer and RooClassFactory
  // is also interfaced through meta-types in the factory
  //
  //
  // Interface to RooSimWSTool
  //
  // SIMCLONE::name( modelPdf, $ParamSplit(...), 
  //                 $ParamSplitConstrained(...), $Restrict(...) ]            -- Clone-and-customize modelPdf according to ParamSplit and ParamSplitConstrained()
  //                                                                             specifications and return a RooSimultaneous p.d.f. of all built clones
  //
  // MSIMCLONE::name( masterIndex, 
  //                  $AddPdf(mstate1, modelPdf1, $ParamSplit(...)), 
  //                  $AddPdf(mstate2,modelPdf2),...) ]                       -- Clone-and-customize multiple models (modelPdf1,modelPdf2) according to ParamSplit and 
  //                                                                             ParamSplitConstrained() specifications and return a RooSimultaneous p.d.f. of all built clones,
  //                                                                             using the specified master index to map prototype p.d.f.s to master states
  // Interface to RooCustomizer
  //
  // EDIT::name( orig, substNode=origNode), ... ]                             -- Create a clone of input object orig, with the specified replacements operations executed
  // EDIT::name( orig, origNode=$REMOVE(), ... ]                              -- Create clone of input removing term origNode from all PROD() terms that contained it
  // EDIT::name( orig, origNode=$REMOVE(prodname,...), ... ]                  -- As above, but restrict removal of origNode to PROD term(s) prodname,...
  //
  //
  // Interface to RooClassFactory
  //
  // CEXPR::name('expr',var,...]       -- Create an custom compiled p.d.f that evaluates the given expression 
  // cexpr::name('expr',var,...]       -- Create an custom compiled function that evaluates the given expression 
  //
  //
  // $MetaType(...)        - Meta argument that does not result in construction of an object but is used logically organize 
  //                         input arguments in certain operator p.d.f. constructions. The defined meta arguments are context dependent.
  //
  //                         The only meta argument that is defined globally is $Alias(typeName,aliasName) to  
  //                         define aliases for type names. For the definition of meta arguments in operator p.d.f.s
  //                         see the definitions below


//   cout << "RooFactoryWSTool::process() " << expr << endl ;

  // First perform basic syntax check
  if (checkSyntax(expr)) {
    return 0 ;
  }

  // Allocate work buffer
  char* buf = new char[strlen(expr)+1] ;

  // Copy to buffer while absorbing white space and newlines
  char* buftmp = buf ;
  while(*expr) {
    if (!isspace(*expr)) {
      *buftmp = *expr ;
      buftmp++ ;
    }
    expr++ ;
  }
  *buftmp=0 ;


  // Clear error count and start a transaction in the workspace
  clearError() ;
  ws().startTransaction() ;

  // Process buffer
  string out ;
  try {
    out = processExpression(buf) ;
  } catch (string error) {
    coutE(ObjectHandling) << "RooFactoryWSTool::processExpression() ERROR in parsing: " << error << endl ;
    logError() ;
  }

  // If there were no errors commit the transaction, cancel it otherwise
  if (errorCount()>0) {
    coutE(ObjectHandling) << "RooFactoryWSTool::processExpression() ERRORS detected, transaction to workspace aborted, no objects committed" << endl ;
    ws().cancelTransaction() ;
  } else {
    ws().commitTransaction() ;
  }

  
  // Delete buffer 
  delete[] buf ;

  return out.size() ? ws().arg(out.c_str()) : 0 ;
}




//_____________________________________________________________________________
std::string RooFactoryWSTool::processExpression(const char* token) 
{
  // Process a single high-level expression or list of
  // expressions. The returned string a the reduced expression where
  // all inline object creations have been executed and substituted
  // with the name of the created object
  //
  // e.g. 'RooGaussian::g(x,m,s)' --> 'g'
  //      '{x(-10,10),s}          --> '{x,s}'

  // Delegate handling to list processor if token starts with {, otherwise
  // call single expression processor
  if (string(token).find("$Alias(")==0) {
    processAliasExpression(token) ;
  }

  if (token[0]=='{') {    
    // Process token as list if it starts with '{'
    return processListExpression(token) ;
  } else {
    // Process token as single item otherwise
    return processCompositeExpression(token) ;
  }
}



//_____________________________________________________________________________
std::string RooFactoryWSTool::processCompositeExpression(const char* token) 
{
  // Process a single composite expression 
  //
  // e.g. 'A=RooGaussian::g[x,m,s]' --> 'A=g'
  // e.g. 'f[0,1]*RooGaussian::g[x,m,s]' --> 'f*g'
  // e.g. 'RooGaussian::g(x,y,s)|x' --> g|x'
  // e.g. '$MetaArg(RooGaussian::g[x,m,s],blah)' --> '$MetaArg(g,blah)'

  // Allocate and fill work buffer
   const size_t bufBaseSize = strlen(token)+1;
  char* buf_base = new char[bufBaseSize] ;
  char* buf = buf_base ;
  strlcpy(buf,token,bufBaseSize) ;
  char* p = buf ;

  list<string> singleExpr ;
  list<char> separator ;
  Int_t blevel(0) ;
  Bool_t litmode(kFALSE) ;
  while(*p) {

    // Keep track of opening and closing brackets
    if (*p=='{' || *p=='(' || *p=='[') blevel++ ;
    if (*p=='}' || *p==')' || *p==']') blevel-- ;
    
    // Keep track of string literals
    if (*p=='"' || *p=='\'') litmode = !litmode ;

    // If we are zero-bracket level and encounter a |, store
    // the remainder of the string as suffix and exit loop
    if (!litmode && blevel==0 && ( (*p)=='=' || (*p) == '|' || (*p) == '*')) {
      separator.push_back(*p) ;
      *p=0 ;
      singleExpr.push_back(buf) ;
      buf = p+1 ;
    }
    p++ ;
  }
  if (*buf) {
    singleExpr.push_back(buf) ;
  }
  if (singleExpr.size()==1) {    
    string ret = processSingleExpression(token) ;
    delete[] buf_base ;
    return ret ;
  }

  string ret ;
  list<char>::iterator ic = separator.begin() ;
  for (list<string>::iterator ii = singleExpr.begin() ; ii!=singleExpr.end() ; ii++) {
    ret += processSingleExpression(ii->c_str()) ;
    if (ic != separator.end()) {
      ret += *ic ;
      ic++ ;
    }
  }

  delete[] buf_base ;
  return ret ;
}



//_____________________________________________________________________________
std::string RooFactoryWSTool::processSingleExpression(const char* arg) 
{
  // Process a single high-level expression. The returned string a the reduced
  // expression where all inline object creations have been executed and substituted
  // with the name of the created object
  //
  // e.g. 'RooGaussian::g(x,m,s)' --> 'g'
  // e.g. 'x[-10,10]' --> 'x'

  // Handle empty strings here
  if (strlen(arg)==0) {
    return string("") ;
  }

  // Handle string literal case
  if (arg[0]=='\'' || arg[0]=='"') {
    return string(arg) ;
  }

  // Allocate and fill work buffer
  const size_t bufSize = strlen(arg)+1;
  char* buf = new char[bufSize] ;
  strlcpy(buf,arg,bufSize) ;
  char* bufptr = buf ;

  string func,prefix ;
  vector<string> args ;

  // Process token into arguments
  char* save ;
  char* tmpx = strtok_r(buf,"([",&save) ;
  func = tmpx ? tmpx : "" ;
  char* p = strtok_r(0,"",&save) ;
  
  // Return here if token is fundamental
  if (!p) {
    delete[] buf ;
    return arg ;
  }
    

  char* tok = p ;
  Int_t blevel=0 ;
  Bool_t litmode(kFALSE) ;
  while(*p) {

    // Keep track of opening and closing brackets
    if (*p=='{' || *p=='(' || *p=='[') blevel++ ;
    if (*p=='}' || *p==')' || *p==']') blevel-- ;

    // Keep track of string literals
    if (*p=='"' || *p=='\'') litmode = !litmode ;


    // If we encounter a comma at zero bracket level
    // finalize the current token as a completed argument
    // and start the next token
    if (!litmode && blevel==0 && ((*p)==',')) {
      *p = 0 ;
      args.push_back(tok) ;
      tok = p+1 ;
    }

    p++ ;
  }

  // If the last character was a closing bracket, kill
  // it in the buffer
  if (p>bufptr && (*(p-1)==')'||*(p-1)==']')) {
    *(p-1)=0 ;
  }

  // Finalize last token as argument
  string tmp = tok ;
  
  // If there is a suffix left in the work buffer attach it to 
  // this argument
  p = strtok_r(0,"",&save) ;
  if (p) tmp += p ;
  args.push_back(tmp) ;

  // Delete the work buffer
  delete[] buf ;

  // If function contains :: then call createArg to process this arg, otherwise
  // call createVariable
  string ret ;

  // Determine type of leading bracket
  char lb = ' ' ;  
  for(const char* pp=arg ; *pp!=0 ; pp++) {
    if (*pp=='(' || *pp=='[' || *pp=='{') {
      lb = *pp ;
      break ;
    }
  }

  if (strstr(func.c_str(),"::")) {
    if (lb=='(') {
      // Create function argument with instance name
      ret= processCreateArg(func,args) ;
    } else {
      coutE(ObjectHandling) << "RooFactoryWSTool::processSingleExpression(" << arg << "): ERROR: Syntax error: Class::Instance must be followed by (...)" << endl ;
      logError() ;
    }
  } else if (func[0]!='$'){    
    if (lb=='[') {
      // Create variable argument
      ret= processCreateVar(func,args) ;
    } else if (lb=='(') {

      // Create function argument with autoname
      string autoname ;
      if (!_autoNamePrefix.empty()) {
	// If we're inside a function creation call to a higher level object, use its
	// name as base for the autoname
	autoname = (Form("%s::%s",func.c_str(),_autoNamePrefix.top().c_str())) ;
      } else {
	// Otherwise find a free global_%d name
	static Int_t globCounter = 0 ;
	while(true) {
	  autoname = Form("gobj%d",globCounter) ;
	  globCounter++ ;
	  if (!ws().arg(autoname.c_str())) {
	    break ;
	  }
	}
	autoname = Form("%s::%s",func.c_str(),autoname.c_str()) ;
      }
      ret= processCreateArg(autoname,args) ;
    } else {
      coutE(ObjectHandling) << "RooFactoryWSTool::processSingleExpression(" << arg << "): ERROR: Syntax error: expect either Class(...) or Instance[...]" << endl ;
      logError() ;
    }
  } else {
    if (lb=='(') {
      // Process meta function (compile arguments, but not meta-function itself)
      ret= processMetaArg(func,args) ;
    } else {
      coutE(ObjectHandling) << "RooFactoryWSTool::processSingleExpression(" << arg << "): ERROR: Syntax error: $MetaClass must be followed by (...)" << endl ;
      logError() ;
    }
  }

  // Return reduced token with suffix
  return ret ;
}


//_____________________________________________________________________________
string RooFactoryWSTool::processListExpression(const char* arg) 
{
  // Process a list of high-level expression. The returned string a the reduced
  // expression list where all inline object creations have been executed and substituted
  // with the name of the created object
  //
  // E.g.   '{x(-10,10),s}  --> '{x,s}'

  // Allocate and fill work buffer
  const size_t bufSize = strlen(arg)+1;
  char* buf = new char[bufSize] ;
  strlcpy(buf,arg,bufSize) ;

  vector<string> args ;

  // Start running pointer at position 1 to skip opening bracket
  char* tok = buf+1 ;
  char* p = buf+1 ;
  
  // Processing look
  Int_t level(0) ;
  while(*p) {

    // Track bracketing level
    if (*p=='{' || *p=='(' || *p=='[') level++ ;
    if (*p=='}' || *p==')' || *p==']') level-- ;

    
    // If we encounter a comma at zero bracket level
    // finalize the current token as a completed argument
    // and start the next token
    if (level==0 && ((*p)==',')) {
      *p = 0 ;
      args.push_back(tok) ;
      tok = p+1 ;
    }

    p++ ;
  }

  // Finalize token as last argument
  if (p>buf && *(p-1)=='}') {
    *(p-1)=0 ;
  }
  args.push_back(tok) ;

  // Delete work buffer
  delete[] buf ;

  // Process each argument in list and construct reduced 
  // expression to be returned
  string ret("{") ;
  vector<string>::iterator iter = args.begin() ;
  Int_t i(0) ;
  while(iter!= args.end()) {
    if (strlen(ret.c_str())>1) ret += "," ;
    if (!_autoNamePrefix.empty()) {
      _autoNamePrefix.push(Form("%s%d",_autoNamePrefix.top().c_str(),i+1)) ;
    }
    ret += processSingleExpression(iter->c_str()) ;
    if (!_autoNamePrefix.empty()) {
      _autoNamePrefix.pop() ;
    }
    iter++ ;
    i++ ;
  }
  ret += "}" ;

  return ret ;
}



//_____________________________________________________________________________
string RooFactoryWSTool::processAliasExpression(const char* token) 
{
  // Parse token
  vector<string> args = splitFunctionArgs(token) ;
  if (args.size()!=2) {
    coutE(ObjectHandling) << "RooFactorWSTool::processAliasExpression() ERROR $Alias() takes exactly two arguments, " << args.size() << " args found" << endl ;
    logError() ;
    return string() ;
  }

  // Insert alias in table
  _typeAliases[args[1]] = args[0] ;
  
  return string() ;
}




//_____________________________________________________________________________
TClass* RooFactoryWSTool::resolveClassName(const char* className) 
{

  // First do recursive alias expansion
  while (true) {
    map<string,string>::iterator item = _typeAliases.find(className) ;
    
    // If an alias is found, recurse
    if (item != _typeAliases.end()) {
      className = item->second.c_str() ;
    } else {
      break ;
    }
  }

  // Now find dealiased class in ROOT class table
  TClass* tc =  TClass::GetClass(className,kTRUE,kTRUE) ;

  // If its not there, try prefixing with Roo
  if (!tc) {
    tc = TClass::GetClass(Form("Roo%s",className)) ;
    if (!tc) {
      coutE(ObjectHandling) << "RooFactoryWSTool::createArg() ERROR class " << className << " not defined in ROOT class table" << endl ;
      logError() ;
      return 0 ;
    } 
  }
  return tc ;
}



//_____________________________________________________________________________
string RooFactoryWSTool::varTag(string& func, vector<string>& args)
{
  string ret ;
  ret += func ;
  ret += "[" ;
  for (vector<string>::iterator iter = args.begin() ; iter!=args.end() ; ++iter) {
    if (iter!=args.begin()) {
      ret += "," ;
    }
    ret += *iter ;
  }
  ret += "]" ;
  return ret ;
}




//_____________________________________________________________________________
string RooFactoryWSTool::processCreateVar(string& func, vector<string>& args)
{  
  // Glue function between high-level syntax and low-level factory call to createVariable:
  // Process a parsed call to create a variable named 'func'
  // 
  // If initial token is non-numeric, a RooCategory will be created, and the args are interpreted
  // as either state names or 'name=id' assignments. Otherwise a RooRealvar is created and the
  // arg list is interpreted as follows:
  // If list has two args, these are interpreted as xmin,xmax
  // If list has three args, these are interpreted as xinit,xmin,xmax
  // If list has one arg, this is interpreted as xinit and the variable is set as constant


  // Determine if first arg is numeric
  string first = *(args.begin()) ;
  if (isdigit(first[0]) || first[0]=='.' || first[0]=='+' || first[0]=='-') {
    
    // Create a RooRealVar
    vector<string>::iterator ai = args.begin() ;
    if (args.size()==1) {

      // One argument, create constant variable with given value
      Double_t xinit = atof((ai)->c_str()) ;
      cxcoutD(ObjectHandling) << "CREATE variable " << func << " xinit = " << xinit << endl ;
      RooRealVar tmp(func.c_str(),func.c_str(),xinit) ;
      tmp.setStringAttribute("factory_tag",varTag(func,args).c_str()) ;
      if (_ws->import(tmp,Silence())) {
	logError() ;
      }

    } else if (args.size()==2) {

      // Two arguments, create variable with given range
      Double_t xlo = atof((ai++)->c_str()) ;
      Double_t xhi = atof(ai->c_str()) ;
      cxcoutD(ObjectHandling) << "CREATE variable " << func << " xlo = " << xlo << " xhi = " << xhi << endl ;
      RooRealVar tmp(func.c_str(),func.c_str(),xlo,xhi) ;
      tmp.setStringAttribute("factory_tag",varTag(func,args).c_str()) ;
      if (_ws->import(tmp,Silence())) {
	logError() ;
      }

    } else if (args.size()==3) {

      // Three arguments, create variable with given initial value and range
      Double_t xinit = atof((ai++)->c_str()) ;
      Double_t xlo = atof((ai++)->c_str()) ;
      Double_t xhi = atof(ai->c_str()) ;
      cxcoutD(ObjectHandling) << "CREATE variable " << func << " xinit = " << xinit << " xlo = " << xlo << " xhi = " << xhi << endl ;
      RooRealVar tmp(func.c_str(),func.c_str(),xinit,xlo,xhi) ;
      tmp.setStringAttribute("factory_tag",varTag(func,args).c_str()) ;
      if (_ws->import(tmp,Silence())) {
	logError() ;
      }
    }
  } else {

    // Create a RooAbsCategory
    string allStates ;
    for (vector<string>::iterator ai = args.begin() ; ai!=args.end() ; ai++) {
      if (allStates.size()>0) {
	allStates += "," ;
      }
      allStates += *ai ;
    }
    createCategory(func.c_str(),allStates.c_str()) ;

  }
  return func ;
}
      

//_____________________________________________________________________________
string RooFactoryWSTool::processCreateArg(string& func, vector<string>& args)
{  
  // Glue function between high-level syntax and low-level factory call to createArg:
  // Process a parsed call to create a p.d.f named func
  //
  // The func arg is interpreted as ClassName::ObjectName and the arglist is passed
  // verbatim to createArg. The received arglist is expected to be fully reduced (i.e.
  // all inline object creations must have been compiled)

  // Allocate and fill work buffer
  char buf[BUFFER_SIZE] ;
  strlcpy(buf,func.c_str(),BUFFER_SIZE) ;

  // Split function part in class name and instance name
  char* save ;
  const char *className = strtok_r(buf,":",&save) ;
  const char *instName = strtok_r(0,":",&save) ;
  if (!className) className = "";
  if (!instName) instName = "" ;

  // Concatenate list of args into comma separated string
  char pargs[BUFFER_SIZE] ;
  pargs[0] = 0 ;
  vector<string>::iterator iter = args.begin() ;
  vector<string> pargv ;
  Int_t iarg(0) ;
  while(iter!=args.end()) {
    if (strlen(pargs)>0) strlcat(pargs,",",BUFFER_SIZE) ;
    _autoNamePrefix.push(Form("%s_%d",instName,iarg+1)) ;
    string tmp = processExpression(iter->c_str()) ;
    _autoNamePrefix.pop() ;
    strlcat(pargs,tmp.c_str(),BUFFER_SIZE) ;
    pargv.push_back(tmp) ;
    iter++ ;
    iarg++ ;
  }

  // Look up if func is a special
  for (map<string,IFace*>::iterator ii=hooks().begin() ; ii!=hooks().end() ; ii++) {
  }
  if (hooks().find(className) != hooks().end()) {
    IFace* iface = hooks()[className] ;
    return iface->create(*this, className,instName,pargv) ;
  }

  createArg(className,instName,pargs) ;

  return string(instName) ;
}
      


//_____________________________________________________________________________
std::string RooFactoryWSTool::processMetaArg(std::string& func, std::vector<std::string>& args) 
{
  // Concatenate list of args into comma separated string
  char pargs[BUFFER_SIZE] ;
  pargs[0] = 0 ;
  vector<string>::iterator iter = args.begin() ;
  vector<string> pargv ;
  while(iter!=args.end()) {
    if (strlen(pargs)>0) strlcat(pargs,",",BUFFER_SIZE) ;
    string tmp = processExpression(iter->c_str()) ;
    strlcat(pargs,tmp.c_str(),BUFFER_SIZE) ;
    pargv.push_back(tmp) ;
    iter++ ;
  }

  string ret = func+"("+pargs+")" ;  
  return ret ;
}




//_____________________________________________________________________________
vector<string> RooFactoryWSTool::splitFunctionArgs(const char* funcExpr) 
{
  // Allocate and fill work buffer
  const size_t bufSize = strlen(funcExpr)+1;
  char* buf = new char[bufSize] ;
  strlcpy(buf,funcExpr,bufSize) ;
  char* bufptr = buf ;

  string func ;
  vector<string> args ;

  // Process token into arguments
  char* save ;
  char* tmpx = strtok_r(buf,"(",&save) ;  
  func = tmpx ? tmpx : "" ;
  char* p = strtok_r(0,"",&save) ;
  
  // Return here if token is fundamental
  if (!p) {
    delete[] buf ;
    return args ;
  }

  char* tok = p ;
  Int_t blevel=0 ;
  Bool_t litmode(kFALSE) ;
  while(*p) {

    // Keep track of opening and closing brackets
    if (*p=='{' || *p=='(' || *p=='[') blevel++ ;
    if (*p=='}' || *p==')' || *p==']') blevel-- ;

    // Keep track of string literals
    if (*p=='"' || *p=='\'') litmode = !litmode ;


    // If we encounter a comma at zero bracket level
    // finalize the current token as a completed argument
    // and start the next token
    if (!litmode && blevel==0 && ((*p)==',')) {
      *p = 0 ;
      args.push_back(tok) ;
      tok = p+1 ;
    }

    p++ ;
  }

  // If the last character was a closing bracket, kill
  // it in the buffer
  if (p>bufptr && *(p-1)==')') {
    *(p-1)=0 ;
  }

  // Finalize last token as argument
  string tmp = tok ;
  
  // If there is a suffix left in the work buffer attach it to 
  // this argument
  p = strtok_r(0,"",&save) ;
  if (p) tmp += p ;
  args.push_back(tmp) ;

  // Delete the work buffer
  delete[] buf ;
  
  return args ;
}





//_____________________________________________________________________________
Bool_t RooFactoryWSTool::checkSyntax(const char* arg) 
{
  // Perform basic syntax on given factory expression. If function returns
  // true syntax errors are found.
  
  // Count parentheses
  Int_t nParentheses(0), nBracket(0), nAccolade(0) ;
  const char* ptr = arg ;
  while(*ptr) {
    if (*ptr=='(') nParentheses++ ;
    if (*ptr==')') nParentheses-- ;
    if (*ptr=='[') nBracket++ ;
    if (*ptr==']') nBracket-- ;
    if (*ptr=='{') nAccolade++ ;
    if (*ptr=='}') nAccolade-- ;
    ptr++ ;
  }
  if (nParentheses!=0) {
    coutE(ObjectHandling) << "RooFactoryWSTool::checkSyntax ERROR non-matching '" << (nParentheses>0?"(":")") << "' in expression" << endl ;
    return kTRUE ;
  }
  if (nBracket!=0) {
    coutE(ObjectHandling) << "RooFactoryWSTool::checkSyntax ERROR non-matching '" << (nBracket>0?"[":"]") << "' in expression" << endl ;
    return kTRUE ;
  }
  if (nAccolade!=0) {
    coutE(ObjectHandling) << "RooFactoryWSTool::checkSyntax ERROR non-matching '" << (nAccolade>0?"{":"}") << "' in expression" << endl ;
    return kTRUE ;
  }
  return kFALSE ;
}



//_____________________________________________________________________________
void RooFactoryWSTool::checkIndex(UInt_t idx) 
{
  if (idx>_of->_args.size()-1) {
    throw string(Form("Need argument number %d, but only %d args are provided",idx,(Int_t)_of->_args.size())) ;
  }
}



//_____________________________________________________________________________
RooAbsArg& RooFactoryWSTool::asARG(const char* arg) 
  {
  // CINT constructor interface, return constructor string argument #idx as RooAbsArg reference found in workspace

  // If arg is a numeric string, make a RooConst() of it here
  if (arg[0]=='.' || arg[0]=='+' || arg[0] == '-' || isdigit(arg[0])) {
    return RooConst(atof(arg)) ;
  }

  // Otherwise look it up by name in the workspace
  RooAbsArg* rarg = ws().arg(arg) ;
  if (!rarg) {
    throw string(Form("RooAbsArg named %s not found",arg)) ;
  }
  return *rarg ;
}



//_____________________________________________________________________________
RooAbsReal& RooFactoryWSTool::asFUNC(const char* arg) 
{
  // CINT constructor interface, return constructor string argument #idx as RooAbsReal reference found in workspace

  // If arg is a numeric string, make a RooConst() of it here
  if (arg[0]=='.' || arg[0]=='+' || arg[0] == '-' || isdigit(arg[0])) {
    return RooConst(atof(arg)) ;
  }

  RooAbsArg* rarg = ws().arg(arg) ;
  if (!rarg) {
    throw string(Form("RooAbsReal named %s not found",arg)) ;
  }
  RooAbsReal* real = dynamic_cast<RooAbsReal*>(rarg) ;
  if (!real) {
    throw string(Form("Object named %s is not of type RooAbsReal",arg)) ;
  }
  return *real ;
}



//_____________________________________________________________________________
RooAbsRealLValue& RooFactoryWSTool::asVARLV(const char* arg) 
{
  // CINT constructor interface, return constructor string argument #idx as RooAbsRealLValue reference found in workspace

  // If arg is a numeric string, throw error as lvalue is required
  if (arg[0]=='.' || arg[0]=='+' || arg[0] == '-' || isdigit(arg[0])) {
    throw string(Form("Numeric literal provided for argument (%s), but lvalue is required",arg)) ;
  }

  RooAbsArg* rarg = ws().arg(arg) ;
  if (!rarg) {
    throw string(Form("RooAbsRealLValue named %s not found",arg)) ;
  }
  RooAbsRealLValue* reallv = dynamic_cast<RooAbsRealLValue*>(rarg) ;
  if (!reallv) {
    throw string(Form("Object named %s is not of type RooAbsRealLValue",arg)) ;
  }
  return *reallv ;
}



//_____________________________________________________________________________
RooRealVar& RooFactoryWSTool::asVAR(const char* arg) 
{
  // CINT constructor interface, return constructor string argument #idx as RooRealVar reference found in workspace

  RooRealVar* var = ws().var(arg) ;
  if (!var) {
    throw string(Form("RooRealVar named %s not found",arg)) ;
  }
  return *var ;
}




//_____________________________________________________________________________
RooAbsPdf& RooFactoryWSTool::asPDF(const char* arg) 
{
  // CINT constructor interface, return constructor string argument #idx as RooAbsPdf reference found in workspace

  RooAbsPdf* pdf = ws().pdf(arg) ;
  if (!pdf) {
    throw string(Form("RooAbsPdf named %s not found",arg)) ;
  }
  return *pdf ;
}




//_____________________________________________________________________________
RooResolutionModel& RooFactoryWSTool::asRMODEL(const char* arg) 
{
  // CINT constructor interface, return constructor string argument #idx as RooResolutionModel reference found in workspace

  RooAbsArg* rarg = ws().arg(arg) ;
  if (!rarg) {
    throw string(Form("RooResolutionModel named %s not found",arg)) ;
  }
  RooResolutionModel * rmodel = dynamic_cast<RooResolutionModel*>(rarg) ;
  if (!rmodel) {
    throw string(Form("Object named %s is not of type RooResolutionModel",arg)) ;
  }
  return *rmodel ;
}




//_____________________________________________________________________________
RooAbsCategory& RooFactoryWSTool::asCATFUNC(const char* arg) 
{
  // CINT constructor interface, return constructor string argument #idx as RooAbsCategory reference found in workspace

  RooAbsArg* rarg = ws().arg(arg) ;
  if (!rarg) {
    throw string(Form("RooAbsCategory named %s not found",arg)) ;
  }
  RooAbsCategory* catf = dynamic_cast<RooAbsCategory*>(rarg) ;
  if (!catf) {
    throw string(Form("Object named %s is not of type RooAbsCategory",arg)) ;
  }
  return *catf ;
}



//_____________________________________________________________________________
RooAbsCategoryLValue& RooFactoryWSTool::asCATLV(const char* arg) 
{
  // CINT constructor interface, return constructor string argument #idx as RooAbsCategoryLValue reference found in workspace

  RooAbsArg* rarg = ws().arg(arg) ;
  if (!rarg) {
    throw string(Form("RooAbsCategoryLValue named %s not found",arg)) ;
  }

  RooAbsCategoryLValue* catlv = dynamic_cast<RooAbsCategoryLValue*>(rarg) ;
  if (!catlv) {
    throw string(Form("Object named %s is not of type RooAbsCategoryLValue",arg)) ;
  }
  return *catlv ;
}



//_____________________________________________________________________________
RooCategory& RooFactoryWSTool::asCAT(const char* arg) 
{
  // CINT constructor interface, return constructor string argument #idx as RooCategory reference found in workspace

  RooCategory* cat = ws().cat(arg) ;
  if (!cat) {
    throw string(Form("RooCategory named %s not found",arg)) ;
  }
  return *cat ;
}





//_____________________________________________________________________________
RooArgSet RooFactoryWSTool::asSET(const char* arg) 
{
  // CINT constructor interface, return constructor string argument #idx as RooArgSet of objects found in workspace

  char tmp[BUFFER_SIZE] ;
  strlcpy(tmp,arg,BUFFER_SIZE) ;

  RooArgSet s ;
  
  // If given object is not of {,,,} form, interpret given string as name of defined set
  if (arg[0]!='{') {
    // cout << "asSet(arg='" << arg << "') parsing as defined set" << endl ;
    const RooArgSet* defSet = ws().set(arg) ;
    if (defSet) {
      // cout << "found defined set: " << *defSet << endl ;
      s.add(*defSet) ;
      return s ;
    }
  }

  char* save ;
  char* tok = strtok_r(tmp,",{}",&save) ;
  while(tok) {

    // If arg is a numeric string, make a RooConst() of it here
    if (tok[0]=='.' || tok[0]=='+' || tok[0] == '-' || isdigit(tok[0])) {
      s.add(RooConst(atof(tok))) ;
    } else {
      RooAbsArg* aarg = ws().arg(tok) ;
      if (aarg) {
	s.add(*aarg)  ;
      } else {
	throw string(Form("RooAbsArg named %s not found",tok)) ;
      }
    }
    tok = strtok_r(0,",{}",&save) ;
  }

  return s ;
}



//_____________________________________________________________________________
RooArgList RooFactoryWSTool::asLIST(const char* arg) 
{
  // CINT constructor interface, return constructor string argument #idx as RooArgList of objects found in workspace

  char tmp[BUFFER_SIZE] ;
  strlcpy(tmp,arg,BUFFER_SIZE) ;

  RooArgList l ;
  char* save ;
  char* tok = strtok_r(tmp,",{}",&save) ;
  while(tok) {

    // If arg is a numeric string, make a RooConst() of it here
    if (tok[0]=='.' || tok[0]=='+' || tok[0] == '-' || isdigit(tok[0])) {
      l.add(RooConst(atof(tok))) ;
    } else {
      RooAbsArg* aarg = ws().arg(tok) ;
      if (aarg) {
	l.add(*aarg)  ;
      } else {
	throw string(Form("RooAbsArg named %s not found",tok)) ;
      }
    }
    tok = strtok_r(0,",{}",&save) ;
  }
  
  return l ;
}



//_____________________________________________________________________________
RooAbsData& RooFactoryWSTool::asDATA(const char* arg) 
{
  // CINT constructor interface, return constructor string argument #idx as RooAbsData object found in workspace

  RooAbsData* data = ws().data(arg) ;
  if (!data) {
      throw string(Form("RooAbsData named %s not found",arg)) ;    
  }
  return *data ;
}



//_____________________________________________________________________________
RooDataHist& RooFactoryWSTool::asDHIST(const char* arg) 
{
  // CINT constructor interface, return constructor string argument #idx as RooDataHist object found in workspace

  RooAbsData* data = ws().data(arg) ;
  if (!data) {
    throw string(Form("RooAbsData named %s not found",arg)) ;    
  }
  RooDataHist* hist = dynamic_cast<RooDataHist*>(data) ;
  if (!hist) {
    throw string(Form("Dataset named %s is not of type RooDataHist",arg)) ;    
  }
  return *hist ;
}


//_____________________________________________________________________________
RooDataSet& RooFactoryWSTool::asDSET(const char* arg) 
{
  // CINT constructor interface, return constructor string argument #idx as RooDataSet object found in workspace

  RooAbsData* data = ws().data(arg) ;
  if (!data) {
    throw string(Form("RooAbsData named %s not found",arg)) ;    
  }
  RooDataSet* dset = dynamic_cast<RooDataSet*>(data) ;
  if (!dset) {
    throw string(Form("Dataset named %s is not of type RooDataSet",arg)) ;    
  }
  return *dset ;
}



//_____________________________________________________________________________
TObject& RooFactoryWSTool::asOBJ(const char* arg)
{
  TObject* obj = ws().obj(arg) ;
  if (!obj) {
    throw string(Form("Object named %s not found",arg)) ;    
  }
  return *obj ;
}



//_____________________________________________________________________________
const char* RooFactoryWSTool::asSTRING(const char* arg) 
{
  // CINT constructor interface, return constructor string argument #idx as const char* 

  static vector<string> cbuf(10) ;
  static unsigned int cbuf_idx = 0 ;

  // Handle empty string case: return null pointer
  if (arg==0 || strlen(arg)==0) {
    return 0 ;
  }
  
  // Fill cyclical buffer entry with quotation marked stripped version of string literal
  // and return pointer to stripped buffer
  cbuf[cbuf_idx].clear() ;
  const char* p = arg+1 ;
  while(*p && (*p) != '"' && (*p) !='\'' ) {
    cbuf[cbuf_idx] += *(p++) ;
  }  
  const char* ret = cbuf[cbuf_idx].c_str() ;

  // Increment buffer pointer by one
  cbuf_idx++ ;
  if (cbuf_idx==cbuf.size()) cbuf_idx=0 ;

  return ret ;
}


//_____________________________________________________________________________
Int_t RooFactoryWSTool::asINT(const char* arg) 
{
  // CINT constructor interface, return constructor string argument #idx as Int_t

  return atoi(arg) ;
}


//_____________________________________________________________________________
Double_t RooFactoryWSTool::asDOUBLE(const char* arg) 
{
  // CINT constructor interface, return constructor string argument #idx as Double_t

  return atof(arg) ;
}


//_____________________________________________________________________________
void RooFactoryWSTool::registerSpecial(const char* typeName, RooFactoryWSTool::IFace* iface) 
{
  // Register foreign special objects in factory
  hooks()[typeName] = iface ;
}



//_____________________________________________________________________________
std::map<std::string,RooFactoryWSTool::IFace*>& RooFactoryWSTool::hooks() 
{
  if (_hooks) return *_hooks ;
  _hooks = new map<string,IFace*> ;
  return *_hooks ;
}



//_____________________________________________________________________________
std::string RooFactoryWSTool::SpecialsIFace::create(RooFactoryWSTool& ft, const char* typeName, const char* instName, std::vector<std::string> args)
{
  // Concatenate list of args into comma separated string
  char pargs[BUFFER_SIZE] ;
  pargs[0] = 0 ;
  vector<string>::iterator iter = args.begin() ;
  vector<string> pargv ;
  while(iter!=args.end()) {
    if (strlen(pargs)>0) strlcat(pargs,",",BUFFER_SIZE) ;
    string tmp = ft.processExpression(iter->c_str()) ;
    strlcat(pargs,tmp.c_str(),BUFFER_SIZE) ;
    pargv.push_back(tmp) ;
    iter++ ;
  }

  // Handling of special operator pdf class names
  string cl(typeName) ;
  if (cl=="SUM") {

    // SUM::name[a*A,b*B,C]
    ft.add(instName,pargs,kFALSE) ;

  } else if (cl=="RSUM") {

    // RSUM::name[a*A,b*B,C]
    ft.add(instName,pargs,kTRUE) ;

  } else if (cl=="ASUM") {

    // ASUM::name[a*A,b*B,C]
    ft.amplAdd(instName,pargs) ;

  } else if (cl=="PROD") {

    // PROD::name[A,B,C]
    ft.prod(instName,pargs) ;

  } else if (cl=="SIMUL") {

    // PROD::name[cat,state=Pdf,...]
    if (pargv.size()>1) {
      ft.simul(instName,pargv[0].c_str(),strchr(pargs,',')+1) ;
    } else {
      throw string(Form("Need at least two arguments in call to SIMUL::%s, have %d: %s",instName,(Int_t)pargv.size(),pargs)) ;
    }

  } else if (cl=="EXPR") {
    
    // EXPR::name['expr',var,var,...]
    if (args.size()<=2) {
      ft.createArg("RooGenericPdf",instName,pargs) ;
    } else {      
      char genargs[BUFFER_SIZE] ;
      strlcpy(genargs,args[0].c_str(),BUFFER_SIZE) ;      
      strlcat(genargs,",{",BUFFER_SIZE) ;
      for (UInt_t i=1 ; i<args.size() ; i++) {
	if (i!=1) strlcat(genargs,",",BUFFER_SIZE) ;
	strlcat(genargs,args[i].c_str(),BUFFER_SIZE) ;
      }
      strlcat(genargs,"}",BUFFER_SIZE) ;
      ft.createArg("RooGenericPdf",instName,genargs) ;
    }
  
  } else if (cl=="FCONV") {

    // FCONV::name[var,pdf1,pdf2]
    ft.createArg("RooFFTConvPdf",instName,pargs) ;
  
  } else if (cl=="NCONV") {

    // NCONV::name[var,pdf1,pdf2]
    ft.createArg("RooNumConvPdf",instName,pargs) ;
  
  } else if (cl=="sum") {
    
    // sum::name[a,b,c]
    ft.addfunc(instName,pargs) ;

  } else if (cl=="prod") {

    // prod::name[a,b,c]
    ft.prodfunc(instName,pargs) ;
    
  } else if (cl=="expr") {

    // expr::name['expr',var,var,...]
    if (args.size()<=2) {
      ft.createArg("RooFormulaVar",instName,pargs) ;
    } else {      
      char genargs[BUFFER_SIZE] ;
      strlcpy(genargs,args[0].c_str(),BUFFER_SIZE) ;      
      strlcat(genargs,",{",BUFFER_SIZE) ;
      for (UInt_t i=1 ; i<args.size() ; i++) {
	if (i!=1) strlcat(genargs,",",BUFFER_SIZE) ;
	strlcat(genargs,args[i].c_str(),BUFFER_SIZE) ;
      }
      strlcat(genargs,"}",BUFFER_SIZE) ;
      ft.createArg("RooFormulaVar",instName,genargs) ;
    }

  } else if (cl=="nconv") {

    // nconv::name[var,pdf1,pdf2]
    ft.createArg("RooNumConvolution",instName,pargs) ;
  
  } else if (cl=="nll") {

    // nll::name[pdf,data]
    RooNLLVar nll(instName,instName,ft.asPDF(pargv[0].c_str()),ft.asDATA(pargv[1].c_str())) ;
    if (ft.ws().import(nll,Silence())) ft.logError() ;
    
  } else if (cl=="chi2") {

    // chi2::name[pdf,data]
    RooChi2Var nll(instName,instName,ft.asPDF(pargv[0].c_str()),ft.asDHIST(pargv[1].c_str())) ;
    if (ft.ws().import(nll,Silence())) ft.logError() ;
    
  } else if (cl=="profile") {

    // profile::name[func,vars]
    ft.createArg("RooProfileLL",instName,pargs) ;

  } else if (cl=="dataobs") {

    // dataobs::name[dset,func]
    RooAbsArg* funcClone = static_cast<RooAbsArg*>(ft.asARG(pargv[1].c_str()).clone(instName)) ;
    RooAbsArg* arg = ft.asDSET(pargv[0].c_str()).addColumn(*funcClone) ;
    if (!ft.ws().fundArg(arg->GetName())) {
      if (ft.ws().import(*arg,Silence())) ft.logError() ;
    }
    delete funcClone ;

  } else if (cl=="int") {    
    
    // int::name[func,intobs]
    // int::name[func,intobs|range]
    // int::name[func,intobs,normobs]
    // int::name[func,intobs|range,normobs]

    if (pargv.size()<2 || pargv.size()>3) {
      throw string(Form("int::%s, requires 2 or 3 arguments, have %d arguments",instName,(Int_t)pargv.size())) ;
    }

    RooAbsReal& func = ft.asFUNC(pargv[0].c_str()) ;

    char buf[256] ;
    strlcpy(buf,pargv[1].c_str(),256) ;
    char* save ;
    const char* intobs = strtok_r(buf,"|",&save) ;
    if (!intobs) intobs="" ;

    const char* range = strtok_r(0,"",&save) ;
    if (!range) range="" ;

    RooAbsReal* integral = 0 ;
    if (pargv.size()==2) {
      if (range && strlen(range)) {
	integral = func.createIntegral(ft.asSET(intobs),Range(range)) ;
      } else {
	integral = func.createIntegral(ft.asSET(intobs)) ;
      }
    } else {
      if (range && strlen(range)) {
	integral = func.createIntegral(ft.asSET(intobs),Range(range),NormSet(ft.asSET(pargv[2].c_str()))) ;
      } else {
	integral = func.createIntegral(ft.asSET(intobs),NormSet(ft.asSET(pargv[2].c_str()))) ;
      }
    }

    integral->SetName(instName) ;
    if (ft.ws().import(*integral,Silence())) ft.logError() ;
    
  } else if (cl=="deriv") {
    
    // derive::name[func,obs,order]

    if (pargv.size()<2 || pargv.size()>3) {
      throw string(Form("deriv::%s, requires 2 or 3 arguments, have %d arguments",instName,(Int_t)pargv.size())) ;
    }

    RooAbsReal& func = ft.asFUNC(pargv[0].c_str()) ;

    RooAbsReal* derivative(0) ;
    if (pargv.size()==2) {
      derivative = func.derivative(ft.asVAR(pargv[1].c_str()),1) ;
    } else {
      derivative = func.derivative(ft.asVAR(pargv[1].c_str()),ft.asINT(pargv[2].c_str())) ;
    }

    derivative->SetName(instName) ;
    if (ft.ws().import(*derivative,Silence())) ft.logError() ;

  } else if (cl=="cdf") {

    // cdf::name[pdf,obs,extranormobs]

    if (pargv.size()<2 || pargv.size()>3) {
      throw string(Form("cdf::%s, requires 2 or 3 arguments, have %d arguments",instName,(Int_t)pargv.size())) ;
    }

    RooAbsPdf& pdf = ft.asPDF(pargv[0].c_str()) ;

    RooAbsReal* cdf(0) ;
    if (pargv.size()==2) {
      cdf = pdf.createCdf(ft.asSET(pargv[1].c_str())) ;
    } else {
      cdf = pdf.createCdf(ft.asSET(pargv[1].c_str()),ft.asSET(pargv[2].c_str())) ;
    }

    cdf->SetName(instName) ;
    if (ft.ws().import(*cdf,Silence())) ft.logError() ;


  } else if (cl=="PROJ") {

    // PROJ::name(pdf,intobs)
    if (pargv.size()!=2) {
      throw string(Form("PROJ::%s, requires 2 arguments, have %d arguments",instName,(Int_t)pargv.size())) ;
    }

    RooAbsPdf& pdf = ft.asPDF(pargv[0].c_str()) ;
    RooAbsPdf* projection = pdf.createProjection(ft.asSET(pargv[1].c_str())) ;
    projection->SetName(instName) ;

    if (ft.ws().import(*projection,Silence())) ft.logError() ;

  } else if (cl=="set") {

    // set::name(arg,arg,...)
    if (ft.ws().defineSet(instName,pargs)) {
      ft.logError() ;
      return string(instName) ;
    }
    
  } else {

    throw string(Form("RooFactoryWSTool::SpecialsIFace::create() ERROR: Unknown meta-type %s",typeName)) ;

  }
  return string(instName) ;    
}


RooFactoryWSTool* RooFactoryWSTool::of() 
{
  return _of ;
}

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