ROOT logo
/***************************************************************************** * Project: RooFit                                                           *
 * Package: RooFitCore                                                       *
 * @(#)root/roofitcore:$Id: RooArgSet.cxx 39912 2011-06-23 16:40:11Z moneta $
 * 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)             *
 *****************************************************************************/

//////////////////////////////////////////////////////////////////////////////
// 
// RooArgSet is a container object that can hold multiple RooAbsArg objects.
// The container has set semantics which means that:
//
//  - Every object it contains must have a unique name returned by GetName().
//
//  - Contained objects are not ordered, although the set can be traversed
//    using an iterator returned by createIterator(). The iterator does not
//    necessarily follow the object insertion order.
//
//  - Objects can be retrieved by name only, and not by index.
//
//
// Ownership of contents. 
//
// Unowned objects are inserted with the add() method. Owned objects
// are added with addOwned() or addClone(). A RooArgSet either owns all 
// of it contents, or none, which is determined by the first <add>
// call. Once an ownership status is selected, inappropriate <add> calls
// will return error status. Clearing the list via removeAll() resets the 
// ownership status. Arguments supplied in the constructor are always added 
// as unowned elements.
//
//

#include "RooFit.h"

#include "Riostream.h"
#include <iomanip>
#include <fstream>
#include <list>
#include "TClass.h"
#include "RooArgSet.h"
#include "RooStreamParser.h"
#include "RooFormula.h"
#include "RooAbsRealLValue.h"
#include "RooAbsCategoryLValue.h"
#include "RooStringVar.h"
#include "RooTrace.h"
#include "RooArgList.h"
#include "RooSentinel.h"
#include "RooMsgService.h"

using namespace std ;

#if (__GNUC__==3&&__GNUC_MINOR__==2&&__GNUC_PATCHLEVEL__==3)
char* operator+( streampos&, char* );
#endif

ClassImp(RooArgSet)
  ;

char* RooArgSet::_poolBegin = 0 ;
char* RooArgSet::_poolCur = 0 ;
char* RooArgSet::_poolEnd = 0 ;
#define POOLSIZE 1048576

struct POOLDATA 
{
  void* _base ;
} ;

static std::list<POOLDATA> _memPoolList ;

//_____________________________________________________________________________
void RooArgSet::cleanup()
{
  // Clear memoery pool on exit to avoid reported memory leaks

  std::list<POOLDATA>::iterator iter = _memPoolList.begin() ;
  while(iter!=_memPoolList.end()) {
    free(iter->_base) ;
    iter->_base=0 ;
    iter++ ;
  }
  _memPoolList.clear() ;
}


#ifdef USEMEMPOOL

//_____________________________________________________________________________
void* RooArgSet::operator new (size_t bytes)
{
  // Overloaded new operator guarantees that all RooArgSets allocated with new
  // have a unique address, a property that is exploited in several places
  // in roofit to quickly index contents on normalization set pointers. 
  // The memory pool only allocates space for the class itself. The elements
  // stored in the set are stored outside the pool.

  //cout << " RooArgSet::operator new(" << bytes << ")" << endl ;

  if (!_poolBegin || _poolCur+(sizeof(RooArgSet)) >= _poolEnd) {

    if (_poolBegin!=0) {
      oocxcoutD((TObject*)0,Caching) << "RooArgSet::operator new(), starting new 1MB memory pool" << endl ;
    }

    // Start pruning empty memory pools if number exceeds 3
    if (_memPoolList.size()>3) {
      
      void* toFree(0) ;

      for (std::list<POOLDATA>::iterator poolIter =  _memPoolList.begin() ; poolIter!=_memPoolList.end() ; ++poolIter) {

	// If pool is empty, delete it and remove it from list
	if ((*(Int_t*)(poolIter->_base))==0) {
	  oocxcoutD((TObject*)0,Caching) << "RooArgSet::operator new(), pruning empty memory pool " << (void*)(poolIter->_base) << endl ;

	  toFree = poolIter->_base ;
	  _memPoolList.erase(poolIter) ;
	  break ;
	}
      }      

      free(toFree) ;      
    }
    
    void* mem = malloc(POOLSIZE) ;

    _poolBegin = (char*)mem ;
    // Reserve space for pool counter at head of pool
    _poolCur = _poolBegin+sizeof(Int_t) ;
    _poolEnd = _poolBegin+(POOLSIZE) ;

    // Clear pool counter
    *((Int_t*)_poolBegin)=0 ;
    
    POOLDATA p ;
    p._base=mem ;
    _memPoolList.push_back(p) ;

    RooSentinel::activate() ;
  }

  char* ptr = _poolCur ;
  _poolCur += bytes ;

  // Increment use counter of pool
  (*((Int_t*)_poolBegin))++ ;

  return ptr ;

}



//_____________________________________________________________________________
void RooArgSet::operator delete (void* ptr)
{
  // Memory is owned by pool, we need to do nothing to release it

  // Decrease use count in pool that ptr is on
  for (std::list<POOLDATA>::iterator poolIter =  _memPoolList.begin() ; poolIter!=_memPoolList.end() ; ++poolIter) {
    if ((char*)ptr > (char*)poolIter->_base && (char*)ptr < (char*)poolIter->_base + POOLSIZE) {
      (*(Int_t*)(poolIter->_base))-- ;
      break ;
    }
  }
  
}

#endif


//_____________________________________________________________________________
RooArgSet::RooArgSet() :
  RooAbsCollection()
{
  // Default constructor
}



//_____________________________________________________________________________
RooArgSet::RooArgSet(const RooArgList& list) :
  RooAbsCollection(list.GetName())
{
  // Constructor from a RooArgList. If the list contains multiple
  // objects with the same name, only the first is store in the set.
  // Warning messages will be printed for dropped items.

  add(list,kTRUE) ; // verbose to catch duplicate errors
}



//_____________________________________________________________________________
RooArgSet::RooArgSet(const RooArgList& list, const RooAbsArg* var1) :
  RooAbsCollection(list.GetName())
{
  // Constructor from a RooArgList. If the list contains multiple
  // objects with the same name, only the first is store in the set.
  // Warning messages will be printed for dropped items.

  if (var1 && !list.contains(*var1)) {
    add(*var1,kTRUE) ;
  }
  add(list,kTRUE) ; // verbose to catch duplicate errors
}



//_____________________________________________________________________________
RooArgSet::RooArgSet(const char *name) :
  RooAbsCollection(name)
{
  // Empty set constructor
}




//_____________________________________________________________________________
RooArgSet::RooArgSet(const RooArgSet& set1, const RooArgSet& set2, const char *name) : RooAbsCollection(name)
{
  // Construct a set from two existing sets
  add(set1) ;
  add(set2) ;
    
}




//_____________________________________________________________________________
RooArgSet::RooArgSet(const RooAbsArg& var1,
		     const char *name) :
  RooAbsCollection(name)
{
  // Constructor for set containing 1 initial object

  add(var1);
}



//_____________________________________________________________________________
RooArgSet::RooArgSet(const RooAbsArg& var1, const RooAbsArg& var2,
		     const char *name) :
  RooAbsCollection(name)
{
  // Constructor for set containing 2 initial objects

  add(var1); add(var2);
}



//_____________________________________________________________________________
RooArgSet::RooArgSet(const RooAbsArg& var1, const RooAbsArg& var2, 
		     const RooAbsArg& var3,
		     const char *name) :
  RooAbsCollection(name)
{
  // Constructor for set containing 3 initial objects

  add(var1); add(var2); add(var3);
}



//_____________________________________________________________________________
RooArgSet::RooArgSet(const RooAbsArg& var1, const RooAbsArg& var2, 
		     const RooAbsArg& var3, const RooAbsArg& var4,
		     const char *name) :
  RooAbsCollection(name)
{
  // Constructor for set containing 4 initial objects

  add(var1); add(var2); add(var3); add(var4);
}



//_____________________________________________________________________________
RooArgSet::RooArgSet(const RooAbsArg& var1,
		     const RooAbsArg& var2, const RooAbsArg& var3,
		     const RooAbsArg& var4, const RooAbsArg& var5,
		     const char *name) :
  RooAbsCollection(name)
{
  // Constructor for set containing 5 initial objects

  add(var1); add(var2); add(var3); add(var4); add(var5);
}



//_____________________________________________________________________________
RooArgSet::RooArgSet(const RooAbsArg& var1, const RooAbsArg& var2, 
		     const RooAbsArg& var3, const RooAbsArg& var4, 
		     const RooAbsArg& var5, const RooAbsArg& var6,
		     const char *name) :
  RooAbsCollection(name)
{
  // Constructor for set containing 6 initial objects

  add(var1); add(var2); add(var3); add(var4); add(var5); add(var6);
}



//_____________________________________________________________________________
RooArgSet::RooArgSet(const RooAbsArg& var1, const RooAbsArg& var2, 
		     const RooAbsArg& var3, const RooAbsArg& var4, 
		     const RooAbsArg& var5, const RooAbsArg& var6, 
		     const RooAbsArg& var7,
		     const char *name) :
  RooAbsCollection(name)
{
  // Constructor for set containing 7 initial objects

  add(var1); add(var2); add(var3); add(var4); add(var5); add(var6); add(var7) ;
}



//_____________________________________________________________________________
RooArgSet::RooArgSet(const RooAbsArg& var1, const RooAbsArg& var2, 
		     const RooAbsArg& var3, const RooAbsArg& var4, 
		     const RooAbsArg& var5, const RooAbsArg& var6, 
		     const RooAbsArg& var7, const RooAbsArg& var8,
		     const char *name) :
  RooAbsCollection(name)
{
  // Constructor for set containing 8 initial objects

  add(var1); add(var2); add(var3); add(var4); add(var5); add(var6); add(var7) ;add(var8) ;
}



//_____________________________________________________________________________
RooArgSet::RooArgSet(const RooAbsArg& var1, const RooAbsArg& var2, 
		     const RooAbsArg& var3, const RooAbsArg& var4, 
		     const RooAbsArg& var5, const RooAbsArg& var6, 
		     const RooAbsArg& var7, const RooAbsArg& var8,
		     const RooAbsArg& var9, const char *name) :
  RooAbsCollection(name)
{
  // Constructor for set containing 9 initial objects

  add(var1); add(var2); add(var3); add(var4); add(var5); add(var6); add(var7); add(var8); add(var9);
}



//_____________________________________________________________________________
RooArgSet::RooArgSet(const TCollection& tcoll, const char* name) :
  RooAbsCollection(name)
{
  // Constructor from a root TCollection. Elements in the collection that
  // do not inherit from RooAbsArg will be skipped. A warning message
  // will be printed for every skipped item.

  TIterator* iter = tcoll.MakeIterator() ;
  TObject* obj ;
  while((obj=iter->Next())) {
    if (!dynamic_cast<RooAbsArg*>(obj)) {
      coutW(InputArguments) << "RooArgSet::RooArgSet(TCollection) element " << obj->GetName() 
			    << " is not a RooAbsArg, ignored" << endl ;
      continue ;
    }
    add(*(RooAbsArg*)obj) ;
  }
  delete iter ;
}



//_____________________________________________________________________________
RooArgSet::RooArgSet(const RooArgSet& other, const char *name) 
  : RooAbsCollection(other,name)
{
  // Copy constructor. Note that a copy of a set is always non-owning,
  // even the source set is owning. To create an owning copy of
  // a set (owning or not), use the snaphot() method.
}



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



//_____________________________________________________________________________
Bool_t RooArgSet::add(const RooAbsArg& var, Bool_t silent) 
{
  // Add element to non-owning set. The operation will fail if
  // a similarly named object already exists in the set, or
  // the set is specified to own its elements. Eventual error messages
  // can be suppressed with the silent flag

  return checkForDup(var,silent)? kFALSE : RooAbsCollection::add(var,silent) ;
}



//_____________________________________________________________________________
Bool_t RooArgSet::addOwned(RooAbsArg& var, Bool_t silent)
{
  // Add element to an owning set. The operation will fail if
  // a similarly named object already exists in the set, or
  // the set is not specified to own its elements. Eventual error messages
  // can be suppressed with the silent flag

  return checkForDup(var,silent)? kFALSE : RooAbsCollection::addOwned(var,silent) ;
}



//_____________________________________________________________________________
RooAbsArg* RooArgSet::addClone(const RooAbsArg& var, Bool_t silent) 
{
  // Add clone of specified element to an owning set. If sucessful, the
  // set will own the clone, not the original. The operation will fail if
  // a similarly named object already exists in the set, or
  // the set is not specified to own its elements. Eventual error messages
  // can be suppressed with the silent flag

  return checkForDup(var,silent)? 0 : RooAbsCollection::addClone(var,silent) ;
}



//_____________________________________________________________________________
RooAbsArg& RooArgSet::operator[](const char* name) const 
{     
  // Array operator. Named element must exist in set, otherwise
  // code will abort. 
  //
  // When used as lvalue in assignment operations, the element contained in
  // the list will not be changed, only the value of the existing element!

  RooAbsArg* arg = find(name) ;
  if (!arg) {
    coutE(InputArguments) << "RooArgSet::operator[](" << GetName() << ") ERROR: no element named " << name << " in set" << endl ;
    RooErrorHandler::softAbort() ;
  }
  return *arg ; 
}



//_____________________________________________________________________________
Bool_t RooArgSet::checkForDup(const RooAbsArg& var, Bool_t silent) const 
{
  // Check if element with var's name is already in set

  RooAbsArg *other = 0;
  if((other= find(var.GetName()))) {
    if(other != &var) {
      if (!silent)
	// print a warning if this variable is not the same one we
	// already have
	coutE(InputArguments) << "RooArgSet::checkForDup: ERROR argument with name " << var.GetName() << " is already in this set" << endl;
    }
    // don't add duplicates
    return kTRUE;
  }

  return kFALSE ;
}



//_____________________________________________________________________________
Double_t RooArgSet::getRealValue(const char* name, Double_t defVal, Bool_t verbose) const
{
  // Get value of a RooAbsReal stored in set with given name. If none is found, value of defVal is returned.
  // No error messages are printed unless the verbose flag is set

  RooAbsArg* raa = find(name) ;
  if (!raa) {
    if (verbose) coutE(InputArguments) << "RooArgSet::getRealValue(" << GetName() << ") ERROR no object with name '" << name << "' found" << endl ;
    return defVal ;
  }
  RooAbsReal* rar = dynamic_cast<RooAbsReal*>(raa) ;
  if (!rar) {
    if (verbose) coutE(InputArguments) << "RooArgSet::getRealValue(" << GetName() << ") ERROR object '" << name << "' is not of type RooAbsReal" << endl ;
    return defVal ;
  }
  return rar->getVal() ;
}



//_____________________________________________________________________________
Bool_t RooArgSet::setRealValue(const char* name, Double_t newVal, Bool_t verbose) 
{
  // Set value of a RooAbsRealLValye stored in set with given name to newVal
  // No error messages are printed unless the verbose flag is set

  RooAbsArg* raa = find(name) ;
  if (!raa) {
    if (verbose) coutE(InputArguments) << "RooArgSet::setRealValue(" << GetName() << ") ERROR no object with name '" << name << "' found" << endl ;
    return kTRUE ;
  }
  RooAbsRealLValue* rar = dynamic_cast<RooAbsRealLValue*>(raa) ;
  if (!rar) {
    if (verbose) coutE(InputArguments) << "RooArgSet::setRealValue(" << GetName() << ") ERROR object '" << name << "' is not of type RooAbsRealLValue" << endl ;
    return kTRUE;
  }
  rar->setVal(newVal) ;
  return kFALSE ;
}



//_____________________________________________________________________________
const char* RooArgSet::getCatLabel(const char* name, const char* defVal, Bool_t verbose) const
{
  // Get state name of a RooAbsCategory stored in set with given name. If none is found, value of defVal is returned.
  // No error messages are printed unless the verbose flag is set

  RooAbsArg* raa = find(name) ;
  if (!raa) {
    if (verbose) coutE(InputArguments) << "RooArgSet::getCatLabel(" << GetName() << ") ERROR no object with name '" << name << "' found" << endl ;
    return defVal ;
  }
  RooAbsCategory* rac = dynamic_cast<RooAbsCategory*>(raa) ;
  if (!rac) {
    if (verbose) coutE(InputArguments) << "RooArgSet::getCatLabel(" << GetName() << ") ERROR object '" << name << "' is not of type RooAbsCategory" << endl ;
    return defVal ;
  }
  return rac->getLabel() ;
}



//_____________________________________________________________________________
Bool_t RooArgSet::setCatLabel(const char* name, const char* newVal, Bool_t verbose) 
{
  // Set state name of a RooAbsCategoryLValue stored in set with given name to newVal.
  // No error messages are printed unless the verbose flag is set

  RooAbsArg* raa = find(name) ;
  if (!raa) {
    if (verbose) coutE(InputArguments) << "RooArgSet::setCatLabel(" << GetName() << ") ERROR no object with name '" << name << "' found" << endl ;
    return kTRUE ;
  }
  RooAbsCategoryLValue* rac = dynamic_cast<RooAbsCategoryLValue*>(raa) ;
  if (!rac) {
    if (verbose) coutE(InputArguments) << "RooArgSet::setCatLabel(" << GetName() << ") ERROR object '" << name << "' is not of type RooAbsCategory" << endl ;
    return kTRUE ;
  }
  rac->setLabel(newVal) ;
  return kFALSE ;
}



//_____________________________________________________________________________
Int_t RooArgSet::getCatIndex(const char* name, Int_t defVal, Bool_t verbose) const
{
  // Get index value of a RooAbsCategory stored in set with given name. If none is found, value of defVal is returned.
  // No error messages are printed unless the verbose flag is set

  RooAbsArg* raa = find(name) ;
  if (!raa) {
    if (verbose) coutE(InputArguments) << "RooArgSet::getCatLabel(" << GetName() << ") ERROR no object with name '" << name << "' found" << endl ;
    return defVal ;
  }
  RooAbsCategory* rac = dynamic_cast<RooAbsCategory*>(raa) ;
  if (!rac) {
    if (verbose) coutE(InputArguments) << "RooArgSet::getCatLabel(" << GetName() << ") ERROR object '" << name << "' is not of type RooAbsCategory" << endl ;
    return defVal ;
  }
  return rac->getIndex() ;
}



//_____________________________________________________________________________
Bool_t RooArgSet::setCatIndex(const char* name, Int_t newVal, Bool_t verbose) 
{
  // Set index value of a RooAbsCategoryLValue stored in set with given name to newVal.
  // No error messages are printed unless the verbose flag is set

  RooAbsArg* raa = find(name) ;
  if (!raa) {
    if (verbose) coutE(InputArguments) << "RooArgSet::setCatLabel(" << GetName() << ") ERROR no object with name '" << name << "' found" << endl ;
    return kTRUE ;
  }
  RooAbsCategoryLValue* rac = dynamic_cast<RooAbsCategoryLValue*>(raa) ;
  if (!rac) {
    if (verbose) coutE(InputArguments) << "RooArgSet::setCatLabel(" << GetName() << ") ERROR object '" << name << "' is not of type RooAbsCategory" << endl ;
    return kTRUE ;
  }
  rac->setIndex(newVal) ;
  return kFALSE ;
}



//_____________________________________________________________________________
const char* RooArgSet::getStringValue(const char* name, const char* defVal, Bool_t verbose) const
{
  // Get string value of a RooAbsString stored in set with given name. If none is found, value of defVal is returned.
  // No error messages are printed unless the verbose flag is set

  RooAbsArg* raa = find(name) ;
  if (!raa) {
    if (verbose) coutE(InputArguments) << "RooArgSet::getStringValue(" << GetName() << ") ERROR no object with name '" << name << "' found" << endl ;
    return defVal ;
  }
  RooAbsString* ras = dynamic_cast<RooAbsString*>(raa) ;
  if (!ras) {
    if (verbose) coutE(InputArguments) << "RooArgSet::getStringValue(" << GetName() << ") ERROR object '" << name << "' is not of type RooAbsString" << endl ;
    return defVal ;
  }
  return ras->getVal() ;
}



//_____________________________________________________________________________
Bool_t RooArgSet::setStringValue(const char* name, const char* newVal, Bool_t verbose) 
{
  // Set string value of a RooStringVar stored in set with given name to newVal.
  // No error messages are printed unless the verbose flag is set

  RooAbsArg* raa = find(name) ;
  if (!raa) {
    if (verbose) coutE(InputArguments) << "RooArgSet::setStringValue(" << GetName() << ") ERROR no object with name '" << name << "' found" << endl ;
    return kTRUE ;
  }
  RooStringVar* ras = dynamic_cast<RooStringVar*>(raa) ;
  if (!ras) {
    if (verbose) coutE(InputArguments) << "RooArgSet::setStringValue(" << GetName() << ") ERROR object '" << name << "' is not of type RooAbsString" << endl ;
    return kTRUE ;
  }
  ras->setVal(newVal) ;
  return kFALSE ;
}



//_____________________________________________________________________________
void RooArgSet::writeToFile(const char* fileName) const
{
  // Write contents of the argset to specified file.
  // See writeToStream() for details

  ofstream ofs(fileName) ;
  if (ofs.fail()) {
    coutE(InputArguments) << "RooArgSet::writeToFile(" << GetName() << ") error opening file " << fileName << endl ;
    return ;
  }
  writeToStream(ofs,kFALSE) ;
}



//_____________________________________________________________________________
Bool_t RooArgSet::readFromFile(const char* fileName, const char* flagReadAtt, const char* section, Bool_t verbose) 
{
  // Read contents of the argset from specified file.
  // See readFromStream() for details

  ifstream ifs(fileName) ;
  if (ifs.fail()) {
    coutE(InputArguments) << "RooArgSet::readFromFile(" << GetName() << ") error opening file " << fileName << endl ;
    return kTRUE ;
  }
  return readFromStream(ifs,kFALSE,flagReadAtt,section,verbose) ;
}




//_____________________________________________________________________________
void RooArgSet::writeToStream(ostream& os, Bool_t compact, const char* /*section*/) const
{
  // Write the contents of the argset in ASCII form to given stream.
  // 
  // A line is written for each element contained in the form
  // <argName> = <argValue>
  // 
  // The <argValue> part of each element is written by the arguments' 
  // writeToStream() function.

  if (compact) {
    coutE(InputArguments) << "RooArgSet::writeToStream(" << GetName() << ") compact mode not supported" << endl ;
    return ;
  }

  TIterator *iterat= createIterator();
  RooAbsArg *next = 0;
  while((0 != (next= (RooAbsArg*)iterat->Next()))) {
    os << next->GetName() << " = " ;
    next->writeToStream(os,kFALSE) ;
    os << endl ;
  }
  delete iterat;  
}




//_____________________________________________________________________________
Bool_t RooArgSet::readFromStream(istream& is, Bool_t compact, const char* flagReadAtt, const char* section, Bool_t verbose) 
{
  // Read the contents of the argset in ASCII form from given stream.
  // 
  // The stream is read to end-of-file and each line is assumed to be
  // of the form
  //
  // <argName> = <argValue>
  // 
  // Lines starting with argNames not matching any element in the list
  // will be ignored with a warning message. In addition limited C++ style 
  // preprocessing and flow control is provided. The following constructions 
  // are recognized:
  //
  // > #include "include.file"       
  // 
  // Include given file, recursive inclusion OK
  // 
  // > if (<boolean_expression>)
  // >   <name> = <value>
  // >   ....
  // > else if (<boolean_expression>)
  //     ....
  // > else
  //     ....
  // > endif
  //
  // All expressions are evaluated by RooFormula, and may involve any of
  // the sets variables. 
  //
  // > echo <Message>
  //
  // Print console message while reading from stream
  //
  // > abort
  //
  // Force termination of read sequence with error status 
  //
  // The value of each argument is read by the arguments readFromStream
  // function.

  if (compact) {
    coutE(InputArguments) << "RooArgSet::readFromStream(" << GetName() << ") compact mode not supported" << endl ;
    return kTRUE ;
  }

  RooStreamParser parser(is) ;
  parser.setPunctuation("=") ;
  TString token ;
  Bool_t retVal(kFALSE) ;
  
  // Conditional stack and related state variables
  // coverity[UNINIT]
  Bool_t anyCondTrue[100] ;
  Bool_t condStack[100] ;
  Bool_t lastLineWasElse=kFALSE ;
  Int_t condStackLevel=0 ;
  condStack[0]=kTRUE ;
  
  // Prepare section processing
  TString sectionHdr("[") ;
  if (section) sectionHdr.Append(section) ;
  sectionHdr.Append("]") ;
  Bool_t inSection(section?kFALSE:kTRUE) ;

  Bool_t reprocessToken = kFALSE ;
  while (1) {

    if (is.eof() || is.fail() || parser.atEOF()) {
      break ;
    }
    
    // Read next token until end of file
    if (!reprocessToken) {
      token = parser.readToken() ;
    }
    reprocessToken = kFALSE ;

    // Skip empty lines 
    if (token.IsNull()) {
      continue ;
    }

    // Process include directives
    if (!token.CompareTo("include")) {
      if (parser.atEOL()) {
	coutE(InputArguments) << "RooArgSet::readFromStream(" << GetName() 
			      << "): no filename found after include statement" << endl ;
	return kTRUE ;
      }
      TString filename = parser.readLine() ;
      ifstream incfs(filename) ;
      if (!incfs.good()) {
	coutE(InputArguments) << "RooArgSet::readFromStream(" << GetName() << "): cannot open include file " << filename << endl ;
	return kTRUE ;
      }
      coutI(InputArguments) << "RooArgSet::readFromStream(" << GetName() << "): processing include file " 
			    << filename << endl ;
      if (readFromStream(incfs,compact,flagReadAtt,inSection?0:section,verbose)) return kTRUE ;
      continue ;
    }

    // Process section headers if requested
    if (*token.Data()=='[') {
      TString hdr(token) ;
      const char* last = token.Data() + token.Length() -1 ;
      if (*last != ']') {
	hdr.Append(" ") ;
	hdr.Append(parser.readLine()) ;
      }
//       parser.putBackToken(token) ;
//       token = parser.readLine() ;
      if (section) {
	inSection = !sectionHdr.CompareTo(hdr) ;
      }
      continue ;
    }

    // If section is specified, ignore all data outside specified section
    if (!inSection) {
      parser.zapToEnd(kTRUE) ;
      continue ;
    }

    // Conditional statement evaluation
    if (!token.CompareTo("if")) {
      
      // Extract conditional expressions and check validity
      TString expr = parser.readLine() ;
      RooFormula form(expr,expr,*this) ;
      if (!form.ok()) return kTRUE ;
      
      // Evaluate expression
      Bool_t status = form.eval()?kTRUE:kFALSE ;
      if (lastLineWasElse) {
	anyCondTrue[condStackLevel] |= status ;
	lastLineWasElse=kFALSE ;
      } else {
	condStackLevel++ ;
	anyCondTrue[condStackLevel] = status ;
      }
      condStack[condStackLevel] = status ;
      
      if (verbose) cxcoutD(Eval) << "RooArgSet::readFromStream(" << GetName() 
				 << "): conditional expression " << expr << " = " 
				 << (condStack[condStackLevel]?"true":"false") << endl ;
      continue ; // go to next line
    }
    
    if (!token.CompareTo("else")) {
      // Must have seen an if statement before
      if (condStackLevel==0) {
	coutE(InputArguments) << "RooArgSet::readFromStream(" << GetName() << "): unmatched 'else'" << endl ;
      }
      
      if (parser.atEOL()) {
	// simple else: process if nothing else was true
	condStack[condStackLevel] = !anyCondTrue[condStackLevel] ; 
	parser.zapToEnd(kFALSE) ;
	continue ;
      } else {
	// if anything follows it should be 'if'
	token = parser.readToken() ;
	if (token.CompareTo("if")) {
	  coutE(InputArguments) << "RooArgSet::readFromStream(" << GetName() << "): syntax error: 'else " << token << "'" << endl ;
	  return kTRUE ;
	} else {
	  if (anyCondTrue[condStackLevel]) {
	    // No need for further checking, true conditional already processed
	    condStack[condStackLevel] = kFALSE ;
	    parser.zapToEnd(kFALSE) ;
	    continue ;
	  } else {
	    // Process as normal 'if' no true conditional was encountered 
	    reprocessToken = kTRUE ;
	    lastLineWasElse=kTRUE ;
	    continue ;
	  }
	}
      }	
    }
    
    if (!token.CompareTo("endif")) {
      // Must have seen an if statement before
      if (condStackLevel==0) {
	coutE(InputArguments) << "RooArgSet::readFromStream(" << GetName() << "): unmatched 'endif'" << endl ;
	return kTRUE ;
      }
      
      // Decrease stack by one
      condStackLevel-- ;
      continue ;
    } 
    
    // If current conditional is true
    if (condStack[condStackLevel]) {
      
      // Process echo statements
      if (!token.CompareTo("echo")) {
	TString message = parser.readLine() ;
	coutE(InputArguments) << "RooArgSet::readFromStream(" << GetName() << "): >> " << message << endl ;
	continue ;
      } 
      
      // Process abort statements
      if (!token.CompareTo("abort")) {
	TString message = parser.readLine() ;
	coutE(InputArguments) << "RooArgSet::readFromStream(" << GetName() << "): USER ABORT" << endl ;
	return kTRUE ;
      } 
      
      // Interpret the rest as <arg> = <value_expr> 
      RooAbsArg *arg ;

      if ((arg = find(token)) && !arg->getAttribute("Dynamic")) {
	if (parser.expectToken("=",kTRUE)) {
	  parser.zapToEnd(kTRUE) ;
	  retVal=kTRUE ;
	  coutE(InputArguments) << "RooArgSet::readFromStream(" << GetName() 
				<< "): missing '=' sign: " << arg << endl ;
	  continue ;
	}
	Bool_t argRet = arg->readFromStream(is,kFALSE,verbose) ;	
	if (!argRet && flagReadAtt) arg->setAttribute(flagReadAtt,kTRUE) ;
	retVal |= argRet ;
      } else {
	if (verbose) {
	  coutE(InputArguments) << "RooArgSet::readFromStream(" << GetName() << "): argument " 
				<< token << " not in list, ignored" << endl ;
	}
	parser.zapToEnd(kTRUE) ;
      }
    } else {
      parser.readLine() ;
    }
  }
  
  // Did we fully unwind the conditional stack?
  if (condStackLevel!=0) {
    coutE(InputArguments) << "RooArgSet::readFromStream(" << GetName() << "): missing 'endif'" << endl ;
    return kTRUE ;
  }
  
  return retVal ;
}


Bool_t RooArgSet::isInRange(const char* rangeSpec) 
{
  char buf[1024] ;
  strlcpy(buf,rangeSpec,1024) ;
  char* token = strtok(buf,",") ;
  
  TIterator* iter = createIterator() ;

  while(token) {

    Bool_t accept=kTRUE ;
    iter->Reset() ;
    RooAbsArg* arg ;
    while((arg=(RooAbsArg*)iter->Next())) {
      RooAbsRealLValue* lvarg = dynamic_cast<RooAbsRealLValue*>(arg) ;
      if (lvarg) {
	if (!lvarg->inRange(token)) {
	  accept=kFALSE ;
	  break ;
	}
      }
      // WVE MUST HANDLE RooAbsCategoryLValue ranges as well
    }
    if (accept) {
      delete iter ;
      return kTRUE ;
    }

    token = strtok(0,",") ;
  }

  delete iter ;
  return kFALSE ;
}



 RooArgSet.cxx:1
 RooArgSet.cxx:2
 RooArgSet.cxx:3
 RooArgSet.cxx:4
 RooArgSet.cxx:5
 RooArgSet.cxx:6
 RooArgSet.cxx:7
 RooArgSet.cxx:8
 RooArgSet.cxx:9
 RooArgSet.cxx:10
 RooArgSet.cxx:11
 RooArgSet.cxx:12
 RooArgSet.cxx:13
 RooArgSet.cxx:14
 RooArgSet.cxx:15
 RooArgSet.cxx:16
 RooArgSet.cxx:17
 RooArgSet.cxx:18
 RooArgSet.cxx:19
 RooArgSet.cxx:20
 RooArgSet.cxx:21
 RooArgSet.cxx:22
 RooArgSet.cxx:23
 RooArgSet.cxx:24
 RooArgSet.cxx:25
 RooArgSet.cxx:26
 RooArgSet.cxx:27
 RooArgSet.cxx:28
 RooArgSet.cxx:29
 RooArgSet.cxx:30
 RooArgSet.cxx:31
 RooArgSet.cxx:32
 RooArgSet.cxx:33
 RooArgSet.cxx:34
 RooArgSet.cxx:35
 RooArgSet.cxx:36
 RooArgSet.cxx:37
 RooArgSet.cxx:38
 RooArgSet.cxx:39
 RooArgSet.cxx:40
 RooArgSet.cxx:41
 RooArgSet.cxx:42
 RooArgSet.cxx:43
 RooArgSet.cxx:44
 RooArgSet.cxx:45
 RooArgSet.cxx:46
 RooArgSet.cxx:47
 RooArgSet.cxx:48
 RooArgSet.cxx:49
 RooArgSet.cxx:50
 RooArgSet.cxx:51
 RooArgSet.cxx:52
 RooArgSet.cxx:53
 RooArgSet.cxx:54
 RooArgSet.cxx:55
 RooArgSet.cxx:56
 RooArgSet.cxx:57
 RooArgSet.cxx:58
 RooArgSet.cxx:59
 RooArgSet.cxx:60
 RooArgSet.cxx:61
 RooArgSet.cxx:62
 RooArgSet.cxx:63
 RooArgSet.cxx:64
 RooArgSet.cxx:65
 RooArgSet.cxx:66
 RooArgSet.cxx:67
 RooArgSet.cxx:68
 RooArgSet.cxx:69
 RooArgSet.cxx:70
 RooArgSet.cxx:71
 RooArgSet.cxx:72
 RooArgSet.cxx:73
 RooArgSet.cxx:74
 RooArgSet.cxx:75
 RooArgSet.cxx:76
 RooArgSet.cxx:77
 RooArgSet.cxx:78
 RooArgSet.cxx:79
 RooArgSet.cxx:80
 RooArgSet.cxx:81
 RooArgSet.cxx:82
 RooArgSet.cxx:83
 RooArgSet.cxx:84
 RooArgSet.cxx:85
 RooArgSet.cxx:86
 RooArgSet.cxx:87
 RooArgSet.cxx:88
 RooArgSet.cxx:89
 RooArgSet.cxx:90
 RooArgSet.cxx:91
 RooArgSet.cxx:92
 RooArgSet.cxx:93
 RooArgSet.cxx:94
 RooArgSet.cxx:95
 RooArgSet.cxx:96
 RooArgSet.cxx:97
 RooArgSet.cxx:98
 RooArgSet.cxx:99
 RooArgSet.cxx:100
 RooArgSet.cxx:101
 RooArgSet.cxx:102
 RooArgSet.cxx:103
 RooArgSet.cxx:104
 RooArgSet.cxx:105
 RooArgSet.cxx:106
 RooArgSet.cxx:107
 RooArgSet.cxx:108
 RooArgSet.cxx:109
 RooArgSet.cxx:110
 RooArgSet.cxx:111
 RooArgSet.cxx:112
 RooArgSet.cxx:113
 RooArgSet.cxx:114
 RooArgSet.cxx:115
 RooArgSet.cxx:116
 RooArgSet.cxx:117
 RooArgSet.cxx:118
 RooArgSet.cxx:119
 RooArgSet.cxx:120
 RooArgSet.cxx:121
 RooArgSet.cxx:122
 RooArgSet.cxx:123
 RooArgSet.cxx:124
 RooArgSet.cxx:125
 RooArgSet.cxx:126
 RooArgSet.cxx:127
 RooArgSet.cxx:128
 RooArgSet.cxx:129
 RooArgSet.cxx:130
 RooArgSet.cxx:131
 RooArgSet.cxx:132
 RooArgSet.cxx:133
 RooArgSet.cxx:134
 RooArgSet.cxx:135
 RooArgSet.cxx:136
 RooArgSet.cxx:137
 RooArgSet.cxx:138
 RooArgSet.cxx:139
 RooArgSet.cxx:140
 RooArgSet.cxx:141
 RooArgSet.cxx:142
 RooArgSet.cxx:143
 RooArgSet.cxx:144
 RooArgSet.cxx:145
 RooArgSet.cxx:146
 RooArgSet.cxx:147
 RooArgSet.cxx:148
 RooArgSet.cxx:149
 RooArgSet.cxx:150
 RooArgSet.cxx:151
 RooArgSet.cxx:152
 RooArgSet.cxx:153
 RooArgSet.cxx:154
 RooArgSet.cxx:155
 RooArgSet.cxx:156
 RooArgSet.cxx:157
 RooArgSet.cxx:158
 RooArgSet.cxx:159
 RooArgSet.cxx:160
 RooArgSet.cxx:161
 RooArgSet.cxx:162
 RooArgSet.cxx:163
 RooArgSet.cxx:164
 RooArgSet.cxx:165
 RooArgSet.cxx:166
 RooArgSet.cxx:167
 RooArgSet.cxx:168
 RooArgSet.cxx:169
 RooArgSet.cxx:170
 RooArgSet.cxx:171
 RooArgSet.cxx:172
 RooArgSet.cxx:173
 RooArgSet.cxx:174
 RooArgSet.cxx:175
 RooArgSet.cxx:176
 RooArgSet.cxx:177
 RooArgSet.cxx:178
 RooArgSet.cxx:179
 RooArgSet.cxx:180
 RooArgSet.cxx:181
 RooArgSet.cxx:182
 RooArgSet.cxx:183
 RooArgSet.cxx:184
 RooArgSet.cxx:185
 RooArgSet.cxx:186
 RooArgSet.cxx:187
 RooArgSet.cxx:188
 RooArgSet.cxx:189
 RooArgSet.cxx:190
 RooArgSet.cxx:191
 RooArgSet.cxx:192
 RooArgSet.cxx:193
 RooArgSet.cxx:194
 RooArgSet.cxx:195
 RooArgSet.cxx:196
 RooArgSet.cxx:197
 RooArgSet.cxx:198
 RooArgSet.cxx:199
 RooArgSet.cxx:200
 RooArgSet.cxx:201
 RooArgSet.cxx:202
 RooArgSet.cxx:203
 RooArgSet.cxx:204
 RooArgSet.cxx:205
 RooArgSet.cxx:206
 RooArgSet.cxx:207
 RooArgSet.cxx:208
 RooArgSet.cxx:209
 RooArgSet.cxx:210
 RooArgSet.cxx:211
 RooArgSet.cxx:212
 RooArgSet.cxx:213
 RooArgSet.cxx:214
 RooArgSet.cxx:215
 RooArgSet.cxx:216
 RooArgSet.cxx:217
 RooArgSet.cxx:218
 RooArgSet.cxx:219
 RooArgSet.cxx:220
 RooArgSet.cxx:221
 RooArgSet.cxx:222
 RooArgSet.cxx:223
 RooArgSet.cxx:224
 RooArgSet.cxx:225
 RooArgSet.cxx:226
 RooArgSet.cxx:227
 RooArgSet.cxx:228
 RooArgSet.cxx:229
 RooArgSet.cxx:230
 RooArgSet.cxx:231
 RooArgSet.cxx:232
 RooArgSet.cxx:233
 RooArgSet.cxx:234
 RooArgSet.cxx:235
 RooArgSet.cxx:236
 RooArgSet.cxx:237
 RooArgSet.cxx:238
 RooArgSet.cxx:239
 RooArgSet.cxx:240
 RooArgSet.cxx:241
 RooArgSet.cxx:242
 RooArgSet.cxx:243
 RooArgSet.cxx:244
 RooArgSet.cxx:245
 RooArgSet.cxx:246
 RooArgSet.cxx:247
 RooArgSet.cxx:248
 RooArgSet.cxx:249
 RooArgSet.cxx:250
 RooArgSet.cxx:251
 RooArgSet.cxx:252
 RooArgSet.cxx:253
 RooArgSet.cxx:254
 RooArgSet.cxx:255
 RooArgSet.cxx:256
 RooArgSet.cxx:257
 RooArgSet.cxx:258
 RooArgSet.cxx:259
 RooArgSet.cxx:260
 RooArgSet.cxx:261
 RooArgSet.cxx:262
 RooArgSet.cxx:263
 RooArgSet.cxx:264
 RooArgSet.cxx:265
 RooArgSet.cxx:266
 RooArgSet.cxx:267
 RooArgSet.cxx:268
 RooArgSet.cxx:269
 RooArgSet.cxx:270
 RooArgSet.cxx:271
 RooArgSet.cxx:272
 RooArgSet.cxx:273
 RooArgSet.cxx:274
 RooArgSet.cxx:275
 RooArgSet.cxx:276
 RooArgSet.cxx:277
 RooArgSet.cxx:278
 RooArgSet.cxx:279
 RooArgSet.cxx:280
 RooArgSet.cxx:281
 RooArgSet.cxx:282
 RooArgSet.cxx:283
 RooArgSet.cxx:284
 RooArgSet.cxx:285
 RooArgSet.cxx:286
 RooArgSet.cxx:287
 RooArgSet.cxx:288
 RooArgSet.cxx:289
 RooArgSet.cxx:290
 RooArgSet.cxx:291
 RooArgSet.cxx:292
 RooArgSet.cxx:293
 RooArgSet.cxx:294
 RooArgSet.cxx:295
 RooArgSet.cxx:296
 RooArgSet.cxx:297
 RooArgSet.cxx:298
 RooArgSet.cxx:299
 RooArgSet.cxx:300
 RooArgSet.cxx:301
 RooArgSet.cxx:302
 RooArgSet.cxx:303
 RooArgSet.cxx:304
 RooArgSet.cxx:305
 RooArgSet.cxx:306
 RooArgSet.cxx:307
 RooArgSet.cxx:308
 RooArgSet.cxx:309
 RooArgSet.cxx:310
 RooArgSet.cxx:311
 RooArgSet.cxx:312
 RooArgSet.cxx:313
 RooArgSet.cxx:314
 RooArgSet.cxx:315
 RooArgSet.cxx:316
 RooArgSet.cxx:317
 RooArgSet.cxx:318
 RooArgSet.cxx:319
 RooArgSet.cxx:320
 RooArgSet.cxx:321
 RooArgSet.cxx:322
 RooArgSet.cxx:323
 RooArgSet.cxx:324
 RooArgSet.cxx:325
 RooArgSet.cxx:326
 RooArgSet.cxx:327
 RooArgSet.cxx:328
 RooArgSet.cxx:329
 RooArgSet.cxx:330
 RooArgSet.cxx:331
 RooArgSet.cxx:332
 RooArgSet.cxx:333
 RooArgSet.cxx:334
 RooArgSet.cxx:335
 RooArgSet.cxx:336
 RooArgSet.cxx:337
 RooArgSet.cxx:338
 RooArgSet.cxx:339
 RooArgSet.cxx:340
 RooArgSet.cxx:341
 RooArgSet.cxx:342
 RooArgSet.cxx:343
 RooArgSet.cxx:344
 RooArgSet.cxx:345
 RooArgSet.cxx:346
 RooArgSet.cxx:347
 RooArgSet.cxx:348
 RooArgSet.cxx:349
 RooArgSet.cxx:350
 RooArgSet.cxx:351
 RooArgSet.cxx:352
 RooArgSet.cxx:353
 RooArgSet.cxx:354
 RooArgSet.cxx:355
 RooArgSet.cxx:356
 RooArgSet.cxx:357
 RooArgSet.cxx:358
 RooArgSet.cxx:359
 RooArgSet.cxx:360
 RooArgSet.cxx:361
 RooArgSet.cxx:362
 RooArgSet.cxx:363
 RooArgSet.cxx:364
 RooArgSet.cxx:365
 RooArgSet.cxx:366
 RooArgSet.cxx:367
 RooArgSet.cxx:368
 RooArgSet.cxx:369
 RooArgSet.cxx:370
 RooArgSet.cxx:371
 RooArgSet.cxx:372
 RooArgSet.cxx:373
 RooArgSet.cxx:374
 RooArgSet.cxx:375
 RooArgSet.cxx:376
 RooArgSet.cxx:377
 RooArgSet.cxx:378
 RooArgSet.cxx:379
 RooArgSet.cxx:380
 RooArgSet.cxx:381
 RooArgSet.cxx:382
 RooArgSet.cxx:383
 RooArgSet.cxx:384
 RooArgSet.cxx:385
 RooArgSet.cxx:386
 RooArgSet.cxx:387
 RooArgSet.cxx:388
 RooArgSet.cxx:389
 RooArgSet.cxx:390
 RooArgSet.cxx:391
 RooArgSet.cxx:392
 RooArgSet.cxx:393
 RooArgSet.cxx:394
 RooArgSet.cxx:395
 RooArgSet.cxx:396
 RooArgSet.cxx:397
 RooArgSet.cxx:398
 RooArgSet.cxx:399
 RooArgSet.cxx:400
 RooArgSet.cxx:401
 RooArgSet.cxx:402
 RooArgSet.cxx:403
 RooArgSet.cxx:404
 RooArgSet.cxx:405
 RooArgSet.cxx:406
 RooArgSet.cxx:407
 RooArgSet.cxx:408
 RooArgSet.cxx:409
 RooArgSet.cxx:410
 RooArgSet.cxx:411
 RooArgSet.cxx:412
 RooArgSet.cxx:413
 RooArgSet.cxx:414
 RooArgSet.cxx:415
 RooArgSet.cxx:416
 RooArgSet.cxx:417
 RooArgSet.cxx:418
 RooArgSet.cxx:419
 RooArgSet.cxx:420
 RooArgSet.cxx:421
 RooArgSet.cxx:422
 RooArgSet.cxx:423
 RooArgSet.cxx:424
 RooArgSet.cxx:425
 RooArgSet.cxx:426
 RooArgSet.cxx:427
 RooArgSet.cxx:428
 RooArgSet.cxx:429
 RooArgSet.cxx:430
 RooArgSet.cxx:431
 RooArgSet.cxx:432
 RooArgSet.cxx:433
 RooArgSet.cxx:434
 RooArgSet.cxx:435
 RooArgSet.cxx:436
 RooArgSet.cxx:437
 RooArgSet.cxx:438
 RooArgSet.cxx:439
 RooArgSet.cxx:440
 RooArgSet.cxx:441
 RooArgSet.cxx:442
 RooArgSet.cxx:443
 RooArgSet.cxx:444
 RooArgSet.cxx:445
 RooArgSet.cxx:446
 RooArgSet.cxx:447
 RooArgSet.cxx:448
 RooArgSet.cxx:449
 RooArgSet.cxx:450
 RooArgSet.cxx:451
 RooArgSet.cxx:452
 RooArgSet.cxx:453
 RooArgSet.cxx:454
 RooArgSet.cxx:455
 RooArgSet.cxx:456
 RooArgSet.cxx:457
 RooArgSet.cxx:458
 RooArgSet.cxx:459
 RooArgSet.cxx:460
 RooArgSet.cxx:461
 RooArgSet.cxx:462
 RooArgSet.cxx:463
 RooArgSet.cxx:464
 RooArgSet.cxx:465
 RooArgSet.cxx:466
 RooArgSet.cxx:467
 RooArgSet.cxx:468
 RooArgSet.cxx:469
 RooArgSet.cxx:470
 RooArgSet.cxx:471
 RooArgSet.cxx:472
 RooArgSet.cxx:473
 RooArgSet.cxx:474
 RooArgSet.cxx:475
 RooArgSet.cxx:476
 RooArgSet.cxx:477
 RooArgSet.cxx:478
 RooArgSet.cxx:479
 RooArgSet.cxx:480
 RooArgSet.cxx:481
 RooArgSet.cxx:482
 RooArgSet.cxx:483
 RooArgSet.cxx:484
 RooArgSet.cxx:485
 RooArgSet.cxx:486
 RooArgSet.cxx:487
 RooArgSet.cxx:488
 RooArgSet.cxx:489
 RooArgSet.cxx:490
 RooArgSet.cxx:491
 RooArgSet.cxx:492
 RooArgSet.cxx:493
 RooArgSet.cxx:494
 RooArgSet.cxx:495
 RooArgSet.cxx:496
 RooArgSet.cxx:497
 RooArgSet.cxx:498
 RooArgSet.cxx:499
 RooArgSet.cxx:500
 RooArgSet.cxx:501
 RooArgSet.cxx:502
 RooArgSet.cxx:503
 RooArgSet.cxx:504
 RooArgSet.cxx:505
 RooArgSet.cxx:506
 RooArgSet.cxx:507
 RooArgSet.cxx:508
 RooArgSet.cxx:509
 RooArgSet.cxx:510
 RooArgSet.cxx:511
 RooArgSet.cxx:512
 RooArgSet.cxx:513
 RooArgSet.cxx:514
 RooArgSet.cxx:515
 RooArgSet.cxx:516
 RooArgSet.cxx:517
 RooArgSet.cxx:518
 RooArgSet.cxx:519
 RooArgSet.cxx:520
 RooArgSet.cxx:521
 RooArgSet.cxx:522
 RooArgSet.cxx:523
 RooArgSet.cxx:524
 RooArgSet.cxx:525
 RooArgSet.cxx:526
 RooArgSet.cxx:527
 RooArgSet.cxx:528
 RooArgSet.cxx:529
 RooArgSet.cxx:530
 RooArgSet.cxx:531
 RooArgSet.cxx:532
 RooArgSet.cxx:533
 RooArgSet.cxx:534
 RooArgSet.cxx:535
 RooArgSet.cxx:536
 RooArgSet.cxx:537
 RooArgSet.cxx:538
 RooArgSet.cxx:539
 RooArgSet.cxx:540
 RooArgSet.cxx:541
 RooArgSet.cxx:542
 RooArgSet.cxx:543
 RooArgSet.cxx:544
 RooArgSet.cxx:545
 RooArgSet.cxx:546
 RooArgSet.cxx:547
 RooArgSet.cxx:548
 RooArgSet.cxx:549
 RooArgSet.cxx:550
 RooArgSet.cxx:551
 RooArgSet.cxx:552
 RooArgSet.cxx:553
 RooArgSet.cxx:554
 RooArgSet.cxx:555
 RooArgSet.cxx:556
 RooArgSet.cxx:557
 RooArgSet.cxx:558
 RooArgSet.cxx:559
 RooArgSet.cxx:560
 RooArgSet.cxx:561
 RooArgSet.cxx:562
 RooArgSet.cxx:563
 RooArgSet.cxx:564
 RooArgSet.cxx:565
 RooArgSet.cxx:566
 RooArgSet.cxx:567
 RooArgSet.cxx:568
 RooArgSet.cxx:569
 RooArgSet.cxx:570
 RooArgSet.cxx:571
 RooArgSet.cxx:572
 RooArgSet.cxx:573
 RooArgSet.cxx:574
 RooArgSet.cxx:575
 RooArgSet.cxx:576
 RooArgSet.cxx:577
 RooArgSet.cxx:578
 RooArgSet.cxx:579
 RooArgSet.cxx:580
 RooArgSet.cxx:581
 RooArgSet.cxx:582
 RooArgSet.cxx:583
 RooArgSet.cxx:584
 RooArgSet.cxx:585
 RooArgSet.cxx:586
 RooArgSet.cxx:587
 RooArgSet.cxx:588
 RooArgSet.cxx:589
 RooArgSet.cxx:590
 RooArgSet.cxx:591
 RooArgSet.cxx:592
 RooArgSet.cxx:593
 RooArgSet.cxx:594
 RooArgSet.cxx:595
 RooArgSet.cxx:596
 RooArgSet.cxx:597
 RooArgSet.cxx:598
 RooArgSet.cxx:599
 RooArgSet.cxx:600
 RooArgSet.cxx:601
 RooArgSet.cxx:602
 RooArgSet.cxx:603
 RooArgSet.cxx:604
 RooArgSet.cxx:605
 RooArgSet.cxx:606
 RooArgSet.cxx:607
 RooArgSet.cxx:608
 RooArgSet.cxx:609
 RooArgSet.cxx:610
 RooArgSet.cxx:611
 RooArgSet.cxx:612
 RooArgSet.cxx:613
 RooArgSet.cxx:614
 RooArgSet.cxx:615
 RooArgSet.cxx:616
 RooArgSet.cxx:617
 RooArgSet.cxx:618
 RooArgSet.cxx:619
 RooArgSet.cxx:620
 RooArgSet.cxx:621
 RooArgSet.cxx:622
 RooArgSet.cxx:623
 RooArgSet.cxx:624
 RooArgSet.cxx:625
 RooArgSet.cxx:626
 RooArgSet.cxx:627
 RooArgSet.cxx:628
 RooArgSet.cxx:629
 RooArgSet.cxx:630
 RooArgSet.cxx:631
 RooArgSet.cxx:632
 RooArgSet.cxx:633
 RooArgSet.cxx:634
 RooArgSet.cxx:635
 RooArgSet.cxx:636
 RooArgSet.cxx:637
 RooArgSet.cxx:638
 RooArgSet.cxx:639
 RooArgSet.cxx:640
 RooArgSet.cxx:641
 RooArgSet.cxx:642
 RooArgSet.cxx:643
 RooArgSet.cxx:644
 RooArgSet.cxx:645
 RooArgSet.cxx:646
 RooArgSet.cxx:647
 RooArgSet.cxx:648
 RooArgSet.cxx:649
 RooArgSet.cxx:650
 RooArgSet.cxx:651
 RooArgSet.cxx:652
 RooArgSet.cxx:653
 RooArgSet.cxx:654
 RooArgSet.cxx:655
 RooArgSet.cxx:656
 RooArgSet.cxx:657
 RooArgSet.cxx:658
 RooArgSet.cxx:659
 RooArgSet.cxx:660
 RooArgSet.cxx:661
 RooArgSet.cxx:662
 RooArgSet.cxx:663
 RooArgSet.cxx:664
 RooArgSet.cxx:665
 RooArgSet.cxx:666
 RooArgSet.cxx:667
 RooArgSet.cxx:668
 RooArgSet.cxx:669
 RooArgSet.cxx:670
 RooArgSet.cxx:671
 RooArgSet.cxx:672
 RooArgSet.cxx:673
 RooArgSet.cxx:674
 RooArgSet.cxx:675
 RooArgSet.cxx:676
 RooArgSet.cxx:677
 RooArgSet.cxx:678
 RooArgSet.cxx:679
 RooArgSet.cxx:680
 RooArgSet.cxx:681
 RooArgSet.cxx:682
 RooArgSet.cxx:683
 RooArgSet.cxx:684
 RooArgSet.cxx:685
 RooArgSet.cxx:686
 RooArgSet.cxx:687
 RooArgSet.cxx:688
 RooArgSet.cxx:689
 RooArgSet.cxx:690
 RooArgSet.cxx:691
 RooArgSet.cxx:692
 RooArgSet.cxx:693
 RooArgSet.cxx:694
 RooArgSet.cxx:695
 RooArgSet.cxx:696
 RooArgSet.cxx:697
 RooArgSet.cxx:698
 RooArgSet.cxx:699
 RooArgSet.cxx:700
 RooArgSet.cxx:701
 RooArgSet.cxx:702
 RooArgSet.cxx:703
 RooArgSet.cxx:704
 RooArgSet.cxx:705
 RooArgSet.cxx:706
 RooArgSet.cxx:707
 RooArgSet.cxx:708
 RooArgSet.cxx:709
 RooArgSet.cxx:710
 RooArgSet.cxx:711
 RooArgSet.cxx:712
 RooArgSet.cxx:713
 RooArgSet.cxx:714
 RooArgSet.cxx:715
 RooArgSet.cxx:716
 RooArgSet.cxx:717
 RooArgSet.cxx:718
 RooArgSet.cxx:719
 RooArgSet.cxx:720
 RooArgSet.cxx:721
 RooArgSet.cxx:722
 RooArgSet.cxx:723
 RooArgSet.cxx:724
 RooArgSet.cxx:725
 RooArgSet.cxx:726
 RooArgSet.cxx:727
 RooArgSet.cxx:728
 RooArgSet.cxx:729
 RooArgSet.cxx:730
 RooArgSet.cxx:731
 RooArgSet.cxx:732
 RooArgSet.cxx:733
 RooArgSet.cxx:734
 RooArgSet.cxx:735
 RooArgSet.cxx:736
 RooArgSet.cxx:737
 RooArgSet.cxx:738
 RooArgSet.cxx:739
 RooArgSet.cxx:740
 RooArgSet.cxx:741
 RooArgSet.cxx:742
 RooArgSet.cxx:743
 RooArgSet.cxx:744
 RooArgSet.cxx:745
 RooArgSet.cxx:746
 RooArgSet.cxx:747
 RooArgSet.cxx:748
 RooArgSet.cxx:749
 RooArgSet.cxx:750
 RooArgSet.cxx:751
 RooArgSet.cxx:752
 RooArgSet.cxx:753
 RooArgSet.cxx:754
 RooArgSet.cxx:755
 RooArgSet.cxx:756
 RooArgSet.cxx:757
 RooArgSet.cxx:758
 RooArgSet.cxx:759
 RooArgSet.cxx:760
 RooArgSet.cxx:761
 RooArgSet.cxx:762
 RooArgSet.cxx:763
 RooArgSet.cxx:764
 RooArgSet.cxx:765
 RooArgSet.cxx:766
 RooArgSet.cxx:767
 RooArgSet.cxx:768
 RooArgSet.cxx:769
 RooArgSet.cxx:770
 RooArgSet.cxx:771
 RooArgSet.cxx:772
 RooArgSet.cxx:773
 RooArgSet.cxx:774
 RooArgSet.cxx:775
 RooArgSet.cxx:776
 RooArgSet.cxx:777
 RooArgSet.cxx:778
 RooArgSet.cxx:779
 RooArgSet.cxx:780
 RooArgSet.cxx:781
 RooArgSet.cxx:782
 RooArgSet.cxx:783
 RooArgSet.cxx:784
 RooArgSet.cxx:785
 RooArgSet.cxx:786
 RooArgSet.cxx:787
 RooArgSet.cxx:788
 RooArgSet.cxx:789
 RooArgSet.cxx:790
 RooArgSet.cxx:791
 RooArgSet.cxx:792
 RooArgSet.cxx:793
 RooArgSet.cxx:794
 RooArgSet.cxx:795
 RooArgSet.cxx:796
 RooArgSet.cxx:797
 RooArgSet.cxx:798
 RooArgSet.cxx:799
 RooArgSet.cxx:800
 RooArgSet.cxx:801
 RooArgSet.cxx:802
 RooArgSet.cxx:803
 RooArgSet.cxx:804
 RooArgSet.cxx:805
 RooArgSet.cxx:806
 RooArgSet.cxx:807
 RooArgSet.cxx:808
 RooArgSet.cxx:809
 RooArgSet.cxx:810
 RooArgSet.cxx:811
 RooArgSet.cxx:812
 RooArgSet.cxx:813
 RooArgSet.cxx:814
 RooArgSet.cxx:815
 RooArgSet.cxx:816
 RooArgSet.cxx:817
 RooArgSet.cxx:818
 RooArgSet.cxx:819
 RooArgSet.cxx:820
 RooArgSet.cxx:821
 RooArgSet.cxx:822
 RooArgSet.cxx:823
 RooArgSet.cxx:824
 RooArgSet.cxx:825
 RooArgSet.cxx:826
 RooArgSet.cxx:827
 RooArgSet.cxx:828
 RooArgSet.cxx:829
 RooArgSet.cxx:830
 RooArgSet.cxx:831
 RooArgSet.cxx:832
 RooArgSet.cxx:833
 RooArgSet.cxx:834
 RooArgSet.cxx:835
 RooArgSet.cxx:836
 RooArgSet.cxx:837
 RooArgSet.cxx:838
 RooArgSet.cxx:839
 RooArgSet.cxx:840
 RooArgSet.cxx:841
 RooArgSet.cxx:842
 RooArgSet.cxx:843
 RooArgSet.cxx:844
 RooArgSet.cxx:845
 RooArgSet.cxx:846
 RooArgSet.cxx:847
 RooArgSet.cxx:848
 RooArgSet.cxx:849
 RooArgSet.cxx:850
 RooArgSet.cxx:851
 RooArgSet.cxx:852
 RooArgSet.cxx:853
 RooArgSet.cxx:854
 RooArgSet.cxx:855
 RooArgSet.cxx:856
 RooArgSet.cxx:857
 RooArgSet.cxx:858
 RooArgSet.cxx:859
 RooArgSet.cxx:860
 RooArgSet.cxx:861
 RooArgSet.cxx:862
 RooArgSet.cxx:863
 RooArgSet.cxx:864
 RooArgSet.cxx:865
 RooArgSet.cxx:866
 RooArgSet.cxx:867
 RooArgSet.cxx:868
 RooArgSet.cxx:869
 RooArgSet.cxx:870
 RooArgSet.cxx:871
 RooArgSet.cxx:872
 RooArgSet.cxx:873
 RooArgSet.cxx:874
 RooArgSet.cxx:875
 RooArgSet.cxx:876
 RooArgSet.cxx:877
 RooArgSet.cxx:878
 RooArgSet.cxx:879
 RooArgSet.cxx:880
 RooArgSet.cxx:881
 RooArgSet.cxx:882
 RooArgSet.cxx:883
 RooArgSet.cxx:884
 RooArgSet.cxx:885
 RooArgSet.cxx:886
 RooArgSet.cxx:887
 RooArgSet.cxx:888
 RooArgSet.cxx:889
 RooArgSet.cxx:890
 RooArgSet.cxx:891
 RooArgSet.cxx:892
 RooArgSet.cxx:893
 RooArgSet.cxx:894
 RooArgSet.cxx:895
 RooArgSet.cxx:896
 RooArgSet.cxx:897
 RooArgSet.cxx:898
 RooArgSet.cxx:899
 RooArgSet.cxx:900
 RooArgSet.cxx:901
 RooArgSet.cxx:902
 RooArgSet.cxx:903
 RooArgSet.cxx:904
 RooArgSet.cxx:905
 RooArgSet.cxx:906
 RooArgSet.cxx:907
 RooArgSet.cxx:908
 RooArgSet.cxx:909
 RooArgSet.cxx:910
 RooArgSet.cxx:911
 RooArgSet.cxx:912
 RooArgSet.cxx:913
 RooArgSet.cxx:914
 RooArgSet.cxx:915
 RooArgSet.cxx:916
 RooArgSet.cxx:917
 RooArgSet.cxx:918
 RooArgSet.cxx:919
 RooArgSet.cxx:920
 RooArgSet.cxx:921
 RooArgSet.cxx:922
 RooArgSet.cxx:923
 RooArgSet.cxx:924
 RooArgSet.cxx:925
 RooArgSet.cxx:926
 RooArgSet.cxx:927
 RooArgSet.cxx:928
 RooArgSet.cxx:929
 RooArgSet.cxx:930
 RooArgSet.cxx:931
 RooArgSet.cxx:932
 RooArgSet.cxx:933
 RooArgSet.cxx:934
 RooArgSet.cxx:935
 RooArgSet.cxx:936
 RooArgSet.cxx:937
 RooArgSet.cxx:938
 RooArgSet.cxx:939
 RooArgSet.cxx:940
 RooArgSet.cxx:941
 RooArgSet.cxx:942
 RooArgSet.cxx:943
 RooArgSet.cxx:944
 RooArgSet.cxx:945
 RooArgSet.cxx:946
 RooArgSet.cxx:947
 RooArgSet.cxx:948
 RooArgSet.cxx:949
 RooArgSet.cxx:950
 RooArgSet.cxx:951
 RooArgSet.cxx:952
 RooArgSet.cxx:953
 RooArgSet.cxx:954
 RooArgSet.cxx:955
 RooArgSet.cxx:956
 RooArgSet.cxx:957
 RooArgSet.cxx:958
 RooArgSet.cxx:959
 RooArgSet.cxx:960
 RooArgSet.cxx:961
 RooArgSet.cxx:962
 RooArgSet.cxx:963
 RooArgSet.cxx:964
 RooArgSet.cxx:965
 RooArgSet.cxx:966
 RooArgSet.cxx:967
 RooArgSet.cxx:968
 RooArgSet.cxx:969
 RooArgSet.cxx:970
 RooArgSet.cxx:971
 RooArgSet.cxx:972
 RooArgSet.cxx:973
 RooArgSet.cxx:974
 RooArgSet.cxx:975
 RooArgSet.cxx:976
 RooArgSet.cxx:977
 RooArgSet.cxx:978
 RooArgSet.cxx:979
 RooArgSet.cxx:980
 RooArgSet.cxx:981
 RooArgSet.cxx:982
 RooArgSet.cxx:983
 RooArgSet.cxx:984
 RooArgSet.cxx:985
 RooArgSet.cxx:986
 RooArgSet.cxx:987
 RooArgSet.cxx:988
 RooArgSet.cxx:989
 RooArgSet.cxx:990
 RooArgSet.cxx:991
 RooArgSet.cxx:992
 RooArgSet.cxx:993
 RooArgSet.cxx:994
 RooArgSet.cxx:995
 RooArgSet.cxx:996
 RooArgSet.cxx:997
 RooArgSet.cxx:998
 RooArgSet.cxx:999
 RooArgSet.cxx:1000
 RooArgSet.cxx:1001
 RooArgSet.cxx:1002
 RooArgSet.cxx:1003
 RooArgSet.cxx:1004
 RooArgSet.cxx:1005
 RooArgSet.cxx:1006
 RooArgSet.cxx:1007