/******************************************************
 * 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
// RooAbsArg is the common abstract base class for objects that
// represent a value (of arbitrary type) and "shape" that in general
// depends on (is a client of) other RooAbsArg subclasses. The only
// state information about a value that is maintained in this base
// class consists of named attributes and flags that track when either
// the value or the shape of this object changes. The meaning of shape
// depends on the client implementation but could be, for example, the
// allowed range of a value. The base class is also responsible for
// managing client/server links and propagating value/shape changes
// through an expression tree. RooAbsArg implements public interfaces
// for inspecting client/server relationships and
// setting/clearing/testing named attributes.
// END_HTML
//
#include "RooFit.h"
#include "Riostream.h"

#include "TClass.h"
#include "TObjString.h"
#include "TVirtualStreamerInfo.h"
// #include "TGraphStruct.h"

#include "RooSecondMoment.h"

#include "RooMsgService.h"
#include "RooAbsArg.h"
#include "RooArgSet.h"
#include "RooArgProxy.h"
#include "RooSetProxy.h"
#include "RooListProxy.h"
#include "RooAbsData.h"
#include "RooAbsCategoryLValue.h"
#include "RooAbsRealLValue.h"
#include "RooTrace.h"
#include "RooStringVar.h"
#include "RooRealIntegral.h"
#include "RooConstVar.h"
#include "RooMsgService.h"
#include "RooExpensiveObjectCache.h"
#include "RooAbsDataStore.h"
#include "RooResolutionModel.h"
#include "RooVectorDataStore.h"
#include "RooTreeDataStore.h"

#include <string.h>
#include <iomanip>
#include <fstream>
#include <algorithm>
#include <sstream>

using namespace std ;

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

ClassImp(RooAbsArg)
;

Bool_t RooAbsArg::_verboseDirty(kFALSE) ;
Bool_t RooAbsArg::_inhibitDirty(kFALSE) ;
Bool_t RooAbsArg::inhibitDirty() const { return _inhibitDirty && !_localNoInhibitDirty; }

std::map<RooAbsArg*,TRefArray*> RooAbsArg::_ioEvoList ;
std::stack<RooAbsArg*> RooAbsArg::_ioReadStack ;


//_____________________________________________________________________________
RooAbsArg::RooAbsArg() :
  TNamed(),
  _deleteWatch(kFALSE),
  _operMode(Auto),
  _fast(kFALSE),
  _ownedComponents(0),
  _prohibitServerRedirect(kFALSE),
  _eocache(0),
  _namePtr(0),
  _isConstant(kFALSE),
  _localNoInhibitDirty(kFALSE)
{
  // Default constructor

  _clientShapeIter = _clientListShape.MakeIterator() ;
  _clientValueIter = _clientListValue.MakeIterator() ;

  _namePtr = (TNamed*) RooNameReg::instance().constPtr(GetName()) ;

}

//_____________________________________________________________________________
RooAbsArg::RooAbsArg(const char *name, const char *title) :
  TNamed(name,title),
  _deleteWatch(kFALSE),
  _valueDirty(kTRUE),
  _shapeDirty(kTRUE),
  _operMode(Auto),
  _fast(kFALSE),
  _ownedComponents(0),
  _prohibitServerRedirect(kFALSE),
  _eocache(0),
  _namePtr(0),
  _isConstant(kFALSE),
  _localNoInhibitDirty(kFALSE)
{
  // Create an object with the specified name and descriptive title.
  // The newly created object has no clients or servers and has its
  // dirty flags set.

  _namePtr = (TNamed*) RooNameReg::instance().constPtr(GetName()) ;

  _clientShapeIter = _clientListShape.MakeIterator() ;
  _clientValueIter = _clientListValue.MakeIterator() ;

}

//_____________________________________________________________________________
RooAbsArg::RooAbsArg(const RooAbsArg& other, const char* name)
  : TNamed(other.GetName(),other.GetTitle()),
    RooPrintable(other),
    _boolAttrib(other._boolAttrib),
    _stringAttrib(other._stringAttrib),
    _deleteWatch(other._deleteWatch),
    _operMode(Auto),
    _fast(kFALSE),
    _ownedComponents(0),
    _prohibitServerRedirect(kFALSE),
    _eocache(other._eocache),
    _namePtr(other._namePtr),
    _isConstant(other._isConstant),
    _localNoInhibitDirty(other._localNoInhibitDirty)
{
  // Copy constructor transfers all boolean and string properties of the original
  // object. Transient properties and client-server links are not copied

  // Use name in argument, if supplied
  if (name) {
    TNamed::SetName(name) ;
    _namePtr = (TNamed*) RooNameReg::instance().constPtr(name) ;
  } else {
    // Same name, Ddon't recalculate name pointer (expensive)
    TNamed::SetName(other.GetName()) ;
    _namePtr = other._namePtr ;
  }

  // Copy server list by hand
  RooFIter sIter = other._serverList.fwdIterator() ;
  RooAbsArg* server ;
  Bool_t valueProp, shapeProp ;
  while ((server = sIter.next())) {
    valueProp = server->_clientListValue.findArg(&other)?kTRUE:kFALSE ;
    shapeProp = server->_clientListShape.findArg(&other)?kTRUE:kFALSE ;
    addServer(*server,valueProp,shapeProp) ;
  }

  _clientShapeIter = _clientListShape.MakeIterator() ;
  _clientValueIter = _clientListValue.MakeIterator() ;

  setValueDirty() ;
  setShapeDirty() ;

  //setAttribute(Form("CloneOf(%08x)",&other)) ;
  //cout << "RooAbsArg::cctor(" << this << ") #bools = " << _boolAttrib.size() << " #strings = " << _stringAttrib.size() << endl ;

}


//_____________________________________________________________________________
RooAbsArg::~RooAbsArg()
{
  // Destructor.

  // Notify all servers that they no longer need to serve us
  RooFIter serverIter = _serverList.fwdIterator() ;
  RooAbsArg* server ;
  while ((server=serverIter.next())) {
    removeServer(*server,kTRUE) ;
  }

  //Notify all client that they are in limbo
  RooFIter clientIter = _clientList.fwdIterator() ;
  RooAbsArg* client = 0;
  Bool_t first(kTRUE) ;
  while ((client=clientIter.next())) {
    client->setAttribute("ServerDied") ;
    TString attr("ServerDied:");
    attr.Append(GetName());
    attr.Append(Form("(%lx)",(ULong_t)this)) ;
    client->setAttribute(attr.Data());
    client->removeServer(*this,kTRUE);

    if (_verboseDirty) {

      if (first) {
	cxcoutD(Tracing) << "RooAbsArg::dtor(" << GetName() << "," << this << ") DeleteWatch: object is being destroyed" << endl ;
	first = kFALSE ;
      }

      cxcoutD(Tracing)  << fName << "::" << ClassName() << ":~RooAbsArg: dependent \""
		       << client->GetName() << "\" should have been deleted first" << endl ;
    }
  }

  delete _clientShapeIter ;
  delete _clientValueIter ;

  if (_ownedComponents) {
    delete _ownedComponents ;
    _ownedComponents = 0 ;
  }

}


//_____________________________________________________________________________
void RooAbsArg::setDirtyInhibit(Bool_t flag)
{
  // Control global dirty inhibit mode. When set to true no value or shape dirty
  // flags are propagated and cache is always considered to be dirty.
  _inhibitDirty = flag ;
}


//_____________________________________________________________________________
void RooAbsArg::verboseDirty(Bool_t flag)
{
  // Activate verbose messaging related to dirty flag propagation
  _verboseDirty = flag ;
}

//_____________________________________________________________________________
Bool_t RooAbsArg::isCloneOf(const RooAbsArg& other) const
{
  // Check if this object was created as a clone of 'other'

  return (getAttribute(Form("CloneOf(%lx)",(ULong_t)&other)) ||
	  other.getAttribute(Form("CloneOf(%lx)",(ULong_t)this))) ;
}


//_____________________________________________________________________________
void RooAbsArg::setAttribute(const Text_t* name, Bool_t value)
{
  // Set (default) or clear a named boolean attribute of this object.

  // Preserve backward compatibility - any strong 
  if(string("Constant")==name) {
    _isConstant = value ;
  }
  
  if (value) {
    _boolAttrib.insert(name) ;
  } else {    
    set<string>::iterator iter = _boolAttrib.find(name) ;
    if (iter != _boolAttrib.end()) {
      _boolAttrib.erase(iter) ;
    }

  }

}


//_____________________________________________________________________________
Bool_t RooAbsArg::getAttribute(const Text_t* name) const
{
  // Check if a named attribute is set. By default, all attributes are unset.

  return (_boolAttrib.find(name) != _boolAttrib.end()) ;
}


//_____________________________________________________________________________
void RooAbsArg::setStringAttribute(const Text_t* key, const Text_t* value)
{
  // Associate string 'value' to this object under key 'key'

  if (value) {
    _stringAttrib[key] = value ;
  } else {
    if (_stringAttrib.find(key)!=_stringAttrib.end()) {
      _stringAttrib.erase(key) ;
    }
  }
}

//_____________________________________________________________________________
const Text_t* RooAbsArg::getStringAttribute(const Text_t* key) const
{
  // Get string attribute mapped under key 'key'. Returns null pointer
  // if no attribute exists under that key

  map<string,string>::const_iterator iter = _stringAttrib.find(key) ;
  if (iter!=_stringAttrib.end()) {
    return iter->second.c_str() ;
  } else {
    return 0 ;
  }
}


//_____________________________________________________________________________
void RooAbsArg::setTransientAttribute(const Text_t* name, Bool_t value)
{
  // Set (default) or clear a named boolean attribute of this object.

  if (value) {

    _boolAttribTransient.insert(name) ;

  } else {

    set<string>::iterator iter = _boolAttribTransient.find(name) ;
    if (iter != _boolAttribTransient.end()) {
      _boolAttribTransient.erase(iter) ;
    }

  }

}


//_____________________________________________________________________________
Bool_t RooAbsArg::getTransientAttribute(const Text_t* name) const
{
  // Check if a named attribute is set. By default, all attributes
  // are unset.

  return (_boolAttribTransient.find(name) != _boolAttribTransient.end()) ;
}




//_____________________________________________________________________________
void RooAbsArg::addServer(RooAbsArg& server, Bool_t valueProp, Bool_t shapeProp)
{
  // Register another RooAbsArg as a server to us, ie, declare that
  // we depend on it. In addition to the basic client-server relationship,
  // we can declare dependence on the server's value and/or shape.

  if (_prohibitServerRedirect) {
    cxcoutF(LinkStateMgmt) << "RooAbsArg::addServer(" << this << "," << GetName()
			   << "): PROHIBITED SERVER ADDITION REQUESTED: adding server " << server.GetName()
			   << "(" << &server << ") for " << (valueProp?"value ":"") << (shapeProp?"shape":"") << endl ;
    assert(0) ;
  }

  cxcoutD(LinkStateMgmt) << "RooAbsArg::addServer(" << this << "," << GetName() << "): adding server " << server.GetName()
			 << "(" << &server << ") for " << (valueProp?"value ":"") << (shapeProp?"shape":"") << endl ;

  if (server.operMode()==ADirty && operMode()!=ADirty && valueProp) {
    setOperMode(ADirty) ;
  }


  // LM: use hash tables for larger lists
  if (_serverList.GetSize() > 999 && _serverList.getHashTableSize() == 0) _serverList.setHashTableSize(1000);
  if (server._clientList.GetSize() > 999 && server._clientList.getHashTableSize() == 0) server._clientList.setHashTableSize(1000);
  if (server._clientListValue.GetSize() >  999 && server._clientListValue.getHashTableSize() == 0) server._clientListValue.setHashTableSize(1000);

  // Add server link to given server
  _serverList.Add(&server) ;

  server._clientList.Add(this) ;
  if (valueProp) server._clientListValue.Add(this) ;
  if (shapeProp) server._clientListShape.Add(this) ;
}



//_____________________________________________________________________________
void RooAbsArg::addServerList(RooAbsCollection& serverList, Bool_t valueProp, Bool_t shapeProp)
{
  // Register a list of RooAbsArg as servers to us by calls
  // addServer() for each arg in the list

  RooAbsArg* arg ;
  RooFIter iter = serverList.fwdIterator() ;
  while ((arg=iter.next())) {
    addServer(*arg,valueProp,shapeProp) ;
  }
}



//_____________________________________________________________________________
void RooAbsArg::removeServer(RooAbsArg& server, Bool_t force)
{
  // Unregister another RooAbsArg as a server to us, ie, declare that
  // we no longer depend on its value and shape.

  if (_prohibitServerRedirect) {
    cxcoutF(LinkStateMgmt) << "RooAbsArg::addServer(" << this << "," << GetName() << "): PROHIBITED SERVER REMOVAL REQUESTED: removing server "
			   << server.GetName() << "(" << &server << ")" << endl ;
    assert(0) ;
  }

  if (_verboseDirty) {
    cxcoutD(LinkStateMgmt) << "RooAbsArg::removeServer(" << GetName() << "): removing server "
			   << server.GetName() << "(" << &server << ")" << endl ;
  }

  // Remove server link to given server
  if (!force) {
    _serverList.Remove(&server) ;

    server._clientList.Remove(this) ;
    server._clientListValue.Remove(this) ;
    server._clientListShape.Remove(this) ;
  } else {
    _serverList.RemoveAll(&server) ;

    server._clientList.RemoveAll(this) ;
    server._clientListValue.RemoveAll(this) ;
    server._clientListShape.RemoveAll(this) ;
  }
}


//_____________________________________________________________________________
void RooAbsArg::replaceServer(RooAbsArg& oldServer, RooAbsArg& newServer, Bool_t propValue, Bool_t propShape)
{
  // Replace 'oldServer' with 'newServer'

  Int_t count = _serverList.refCount(&oldServer) ;
  removeServer(oldServer,kTRUE) ;
  while(count--) {
    addServer(newServer,propValue,propShape) ;
  }
}


//_____________________________________________________________________________
void RooAbsArg::changeServer(RooAbsArg& server, Bool_t valueProp, Bool_t shapeProp)
{
  // Change dirty flag propagation mask for specified server

  if (!_serverList.findArg(&server)) {
    coutE(LinkStateMgmt) << "RooAbsArg::changeServer(" << GetName() << "): Server "
	 << server.GetName() << " not registered" << endl ;
    return ;
  }

  // This condition should not happen, but check anyway
  if (!server._clientList.findArg(this)) {
    coutE(LinkStateMgmt) << "RooAbsArg::changeServer(" << GetName() << "): Server "
			 << server.GetName() << " doesn't have us registered as client" << endl ;
    return ;
  }

  // Remove all propagation links, then reinstall requested ones ;
  Int_t vcount = server._clientListValue.refCount(this) ;
  Int_t scount = server._clientListShape.refCount(this) ;
  server._clientListValue.RemoveAll(this) ;
  server._clientListShape.RemoveAll(this) ;
  if (valueProp) {
    while (vcount--) server._clientListValue.Add(this) ;
  }
  if (shapeProp) {
    while(scount--) server._clientListShape.Add(this) ;
  }
}



//_____________________________________________________________________________
void RooAbsArg::leafNodeServerList(RooAbsCollection* list, const RooAbsArg* arg, Bool_t recurseNonDerived) const
{
  // Fill supplied list with all leaf nodes of the arg tree, starting with
  // ourself as top node. A leaf node is node that has no servers declared.

  treeNodeServerList(list,arg,kFALSE,kTRUE,kFALSE,recurseNonDerived) ;
}



//_____________________________________________________________________________
void RooAbsArg::branchNodeServerList(RooAbsCollection* list, const RooAbsArg* arg, Bool_t recurseNonDerived) const
{
  // Fill supplied list with all branch nodes of the arg tree starting with
  // ourself as top node. A branch node is node that has one or more servers declared.

  treeNodeServerList(list,arg,kTRUE,kFALSE,kFALSE,recurseNonDerived) ;
}


//_____________________________________________________________________________
void RooAbsArg::treeNodeServerList(RooAbsCollection* list, const RooAbsArg* arg, Bool_t doBranch, Bool_t doLeaf, Bool_t valueOnly, Bool_t recurseFundamental) const
{
  // Fill supplied list with nodes of the arg tree, following all server links,
  // starting with ourself as top node.

//   if (arg==0) {
//     cout << "treeNodeServerList(" << GetName() << ") doBranch=" << (doBranch?"T":"F") << " doLeaf = " << (doLeaf?"T":"F") << " valueOnly=" << (valueOnly?"T":"F") << endl ;
//   }

  if (!arg) {
//     if (list->getHashTableSize()==0) {
//       list->setHashTableSize(1000) ;
//     }
    arg=this ;
  }

  // Decide if to add current node
  if ((doBranch&&doLeaf) ||
      (doBranch&&arg->isDerived()) ||
      (doLeaf&&arg->isFundamental()&&(!(recurseFundamental&&arg->isDerived()))) ||
      (doLeaf && !arg->isFundamental() && !arg->isDerived())) {

    list->add(*arg,kTRUE) ;
  }

  // Recurse if current node is derived
  if (arg->isDerived() && (!arg->isFundamental() || recurseFundamental)) {
    RooAbsArg* server ;
    RooFIter sIter = arg->serverMIterator() ;
    while ((server=sIter.next())) {

      // Skip non-value server nodes if requested
      Bool_t isValueSrv = server->_clientListValue.findArg(arg)?kTRUE:kFALSE ;
      if (valueOnly && !isValueSrv) {
	continue ;
      }
      treeNodeServerList(list,server,doBranch,doLeaf,valueOnly,recurseFundamental) ;
    }
  }
}


//_____________________________________________________________________________
RooArgSet* RooAbsArg::getParameters(const RooAbsData* set, Bool_t stripDisconnected) const
{
  // Create a list of leaf nodes in the arg tree starting with
  // ourself as top node that don't match any of the names of the variable list
  // of the supplied data set (the dependents). The caller of this
  // function is responsible for deleting the returned argset.
  // The complement of this function is getObservables()

  return getParameters(set?set->get():0,stripDisconnected) ;
}


//_____________________________________________________________________________
void RooAbsArg::addParameters(RooArgSet& params, const RooArgSet* nset,Bool_t stripDisconnected) const
{
  // INTERNAL helper function for getParameters()

  RooArgSet parList("parameters") ;

  RooFIter siter = serverMIterator() ;
  RooAbsArg* server ;

  RooArgSet nodeParamServers ;
  RooArgSet nodeBranchServers ;
  while((server=siter.next())) {
    if (server->isValueServer(*this)) {
      if (server->isFundamental()) {
	if (!nset || !server->dependsOn(*nset)) {
	  nodeParamServers.add(*server) ;
	}
      } else {
	nodeBranchServers.add(*server) ;
      }
    }
  }

  // Allow pdf to strip parameters from list before adding it
  getParametersHook(nset,&nodeParamServers,stripDisconnected) ;

  // Add parameters of this node to the combined list
  params.add(nodeParamServers,kTRUE) ;

  // Now recurse into branch servers
  RooFIter biter = nodeBranchServers.fwdIterator() ;
  while((server=biter.next())) {
    server->addParameters(params,nset) ;
  }
}


//_____________________________________________________________________________
RooArgSet* RooAbsArg::getParameters(const RooArgSet* nset, Bool_t stripDisconnected) const
{
  // Create a list of leaf nodes in the arg tree starting with
  // ourself as top node that don't match any of the names the args in the
  // supplied argset. The caller of this function is responsible
  // for deleting the returned argset. The complement of this function
  // is getObservables()


  RooArgSet parList("parameters") ;

  addParameters(parList,nset,stripDisconnected) ;

  RooArgList tmp(parList) ;
  tmp.sort() ;
  return new RooArgSet(tmp) ;
}



//_____________________________________________________________________________
RooArgSet* RooAbsArg::getObservables(const RooAbsData* set) const
{
  // Create a list of leaf nodes in the arg tree starting with
  // ourself as top node that match any of the names of the variable list
  // of the supplied data set (the dependents). The caller of this
  // function is responsible for deleting the returned argset.
  // The complement of this function is getObservables()

  if (!set) return new RooArgSet ;

  return getObservables(set->get()) ;
}


//_____________________________________________________________________________
RooArgSet* RooAbsArg::getObservables(const RooArgSet* dataList, Bool_t valueOnly) const
{
  // Create a list of leaf nodes in the arg tree starting with
  // ourself as top node that match any of the names the args in the
  // supplied argset. The caller of this function is responsible
  // for deleting the returned argset. The complement of this function
  // is getObservables()

  //cout << "RooAbsArg::getObservables(" << GetName() << ")" << endl ;

  RooArgSet* depList = new RooArgSet("dependents") ;
  if (!dataList) return depList ;

  // Make iterator over tree leaf node list
  RooArgSet leafList("leafNodeServerList") ;
  treeNodeServerList(&leafList,0,kFALSE,kTRUE,valueOnly) ;
  //leafNodeServerList(&leafList) ;
  RooFIter sIter = leafList.fwdIterator() ;

  RooAbsArg* arg ;
  if (valueOnly) {
    while ((arg=sIter.next())) {
      if (arg->dependsOnValue(*dataList) && arg->isLValue()) {
	depList->add(*arg) ;
      }
    }
  } else {
    while ((arg=sIter.next())) {
      if (arg->dependsOn(*dataList) && arg->isLValue()) {
	depList->add(*arg) ;
      }
    }
  }
  //delete sIter ;

//   // Call hook function for all branch nodes
//   RooArgSet branchList ;
//   branchNodeServerList(&branchList) ;
//   RooAbsArg* branch ;
//   RooLinkedListIter bIter = branchList.iterator() ;
//   while((branch=(RooAbsArg*)bIter.Next())) {
//     branch->getObservablesHook(dataList, depList) ;
//   }
//   //delete bIter ;
  
  return depList ;
}


RooArgSet* RooAbsArg::getComponents() const
{
  // Return a RooArgSet with all component (branch nodes) of the
  // expression tree headed by this object

  TString name(GetName()) ;
  name.Append("_components") ;

  RooArgSet* set = new RooArgSet(name) ;
  branchNodeServerList(set) ;

  return set ;
}



//_____________________________________________________________________________
Bool_t RooAbsArg::checkObservables(const RooArgSet*) const
{
  // Overloadable function in which derived classes can implement
  // consistency checks of the variables. If this function returns
  // true, indicating an error, the fitter or generator will abort.

  return kFALSE ;
}


//_____________________________________________________________________________
Bool_t RooAbsArg::recursiveCheckObservables(const RooArgSet* nset) const
{
  // Recursively call checkObservables on all nodes in the expression tree

  RooArgSet nodeList ;
  treeNodeServerList(&nodeList) ;
  RooFIter iter = nodeList.fwdIterator() ;

  RooAbsArg* arg ;
  Bool_t ret(kFALSE) ;
  while((arg=iter.next())) {
    if (arg->getAttribute("ServerDied")) {
      coutE(LinkStateMgmt) << "RooAbsArg::recursiveCheckObservables(" << GetName() << "): ERROR: one or more servers of node "
			   << arg->GetName() << " no longer exists!" << endl ;
      arg->Print("v") ;
      ret = kTRUE ;
    }
    ret |= arg->checkObservables(nset) ;
  }

  return ret ;
}


//_____________________________________________________________________________
Bool_t RooAbsArg::dependsOn(const RooAbsCollection& serverList, const RooAbsArg* ignoreArg, Bool_t valueOnly) const
{
  // Test whether we depend on (ie, are served by) any object in the
  // specified collection. Uses the dependsOn(RooAbsArg&) member function.

  Bool_t result(kFALSE);
  RooFIter sIter = serverList.fwdIterator();
  RooAbsArg* server ;
  while ((!result && (server=sIter.next()))) {
    if (dependsOn(*server,ignoreArg,valueOnly)) {
      result= kTRUE;
    }
  }
  return result;
}


//_____________________________________________________________________________
Bool_t RooAbsArg::dependsOn(const RooAbsArg& testArg, const RooAbsArg* ignoreArg, Bool_t valueOnly) const
{
  // Test whether we depend on (ie, are served by) the specified object.
  // Note that RooAbsArg objects are considered equivalent if they have
  // the same name.

  if (this==ignoreArg) return kFALSE ;

  // First check if testArg is self    
  //if (!TString(testArg.GetName()).CompareTo(GetName())) return kTRUE ;
  if (testArg.namePtr()==namePtr()) return kTRUE ; 


  // Next test direct dependence
  RooAbsArg* server = findServer(testArg) ;
  if (server!=0) {

    // Return true if valueOnly is FALSE or if server is value server, otherwise keep looking
    if ( !valueOnly || server->isValueServer(*this)) {
      return kTRUE ;
    }
  }

  // If not, recurse
  RooFIter sIter = serverMIterator() ;
  while ((server=sIter.next())) {

    if ( !valueOnly || server->isValueServer(*this)) {
      if (server->dependsOn(testArg,ignoreArg,valueOnly)) {
	return kTRUE ;
      }
    }
  }

  return kFALSE ;
}



//_____________________________________________________________________________
Bool_t RooAbsArg::overlaps(const RooAbsArg& testArg, Bool_t valueOnly) const
{
  // Test if any of the nodes of tree are shared with that of the given tree

  RooArgSet list("treeNodeList") ;
  treeNodeServerList(&list) ;

  return valueOnly ? testArg.dependsOnValue(list) : testArg.dependsOn(list) ;
}



//_____________________________________________________________________________
Bool_t RooAbsArg::observableOverlaps(const RooAbsData* dset, const RooAbsArg& testArg) const
{
  // Test if any of the dependents of the arg tree (as determined by getObservables)
  // overlaps with those of the testArg.

  return observableOverlaps(dset->get(),testArg) ;
}


//_____________________________________________________________________________
Bool_t RooAbsArg::observableOverlaps(const RooArgSet* nset, const RooAbsArg& testArg) const
{
  // Test if any of the dependents of the arg tree (as determined by getObservables)
  // overlaps with those of the testArg.

  RooArgSet* depList = getObservables(nset) ;
  Bool_t ret = testArg.dependsOn(*depList) ;
  delete depList ;
  return ret ;
}



//_____________________________________________________________________________
void RooAbsArg::setValueDirty(const RooAbsArg* source) const
{
  // Mark this object as having changed its value, and propagate this status
  // change to all of our clients. If the object is not in automatic dirty
  // state propagation mode, this call has no effect

  if (_operMode!=Auto || _inhibitDirty) return ;

  // Handle no-propagation scenarios first
  if (_clientListValue.GetSize()==0) {
    _valueDirty = kTRUE ;
    return ;
  }

  // Cyclical dependency interception
  if (source==0) {
    source=this ;
  } else if (source==this) {
    // Cyclical dependency, abort
    coutE(LinkStateMgmt) << "RooAbsArg::setValueDirty(" << GetName()
			 << "): cyclical dependency detected, source = " << source->GetName() << endl ;
    //assert(0) ;
    return ;
  }

  // Propagate dirty flag to all clients if this is a down->up transition
  if (_verboseDirty) {
    cxcoutD(LinkStateMgmt) << "RooAbsArg::setValueDirty(" << (source?source->GetName():"self") << "->" << GetName() << "," << this
			   << "): dirty flag " << (_valueDirty?"already ":"") << "raised" << endl ;
  }

  _valueDirty = kTRUE ;


  RooFIter clientValueIter = _clientListValue.fwdIterator() ;
  RooAbsArg* client ;
  while ((client=clientValueIter.next())) {
    client->setValueDirty(source) ;
  }


}


//_____________________________________________________________________________
void RooAbsArg::setShapeDirty(const RooAbsArg* source) const
{
  // Mark this object as having changed its shape, and propagate this status
  // change to all of our clients.

  if (_verboseDirty) {
    cxcoutD(LinkStateMgmt) << "RooAbsArg::setShapeDirty(" << GetName()
			   << "): dirty flag " << (_shapeDirty?"already ":"") << "raised" << endl ;
  }

  if (_clientListShape.GetSize()==0) {
    _shapeDirty = kTRUE ;
    return ;
  }

  // Set 'dirty' shape state for this object and propagate flag to all its clients
  if (source==0) {
    source=this ;
  } else if (source==this) {
    // Cyclical dependency, abort
    coutE(LinkStateMgmt) << "RooAbsArg::setShapeDirty(" << GetName()
	 << "): cyclical dependency detected" << endl ;
    return ;
  }

  // Propagate dirty flag to all clients if this is a down->up transition
  _shapeDirty=kTRUE ;

  RooFIter clientShapeIter = _clientListShape.fwdIterator() ;
  RooAbsArg* client ;
  while ((client=clientShapeIter.next())) {
    client->setShapeDirty(source) ;
    client->setValueDirty(source) ;
  }

}



//_____________________________________________________________________________
Bool_t RooAbsArg::redirectServers(const RooAbsCollection& newSetOrig, Bool_t mustReplaceAll, Bool_t nameChange, Bool_t isRecursionStep)
{
  // Substitute our servers with those listed in newSet. If nameChange is false, servers and
  // and substitutes are matched by name. If nameChange is true, servers are matched to args
  // in newSet that have the 'ORIGNAME:<servername>' attribute set. If mustReplaceAll is set,
  // a warning is printed and error status is returned if not all servers could be sucessfully
  // substituted.

  // Trivial case, no servers
  if (!_serverList.First()) return kFALSE ;
  if (newSetOrig.getSize()==0) return kFALSE ;

  // Strip any non-matchin removal nodes from newSetOrig
  RooAbsCollection* newSet ;

  if (nameChange) {

    newSet = new RooArgSet ;
    RooFIter iter = newSetOrig.fwdIterator() ;
    RooAbsArg* arg ;
    while((arg=iter.next())) {

      if (string("REMOVAL_DUMMY")==arg->GetName()) {
	
	if (arg->getAttribute("REMOVE_ALL")) {
// 	  cout << "RooAbsArg::redir including remove_all node " << arg->GetName() << endl ;
	  newSet->add(*arg) ;
	} else if (arg->getAttribute(Form("REMOVE_FROM_%s",getStringAttribute("ORIGNAME")))) {
// 	  cout << "RooAbsArg::redir including remove_from_" << GetName() << " node " << arg->GetName() << endl ;
	  newSet->add(*arg) ;
	}
      } else {
	newSet->add(*arg) ;
      }
    }

//     cout << "RooAbsArg::redirect with name change(" << GetName() << ") newSet = " << newSet << " origSet = " << newSetOrig << endl ;

  } else {
    newSet = (RooAbsCollection*) &newSetOrig ;
  }

  // Replace current servers with new servers with the same name from the given list
  Bool_t ret(kFALSE) ;

  //Copy original server list to not confuse the iterator while deleting
  RooLinkedList origServerList, origServerValue, origServerShape ;
  RooAbsArg *oldServer, *newServer ;
  RooFIter sIter = _serverList.fwdIterator() ;
  while ((oldServer=sIter.next())) {
    origServerList.Add(oldServer) ;

    // Retrieve server side link state information
    if (oldServer->_clientListValue.findArg(this)) {
      origServerValue.Add(oldServer) ;
    }
    if (oldServer->_clientListShape.findArg(this)) {
      origServerShape.Add(oldServer) ;
    }
  }

  // Delete all previously registered servers
  sIter = origServerList.fwdIterator() ;
  Bool_t propValue, propShape ;
  while ((oldServer=sIter.next())) {

    newServer= oldServer->findNewServer(*newSet, nameChange);

    if (newServer && _verboseDirty) {
      cxcoutD(LinkStateMgmt) << "RooAbsArg::redirectServers(" << (void*)this << "," << GetName() << "): server " << oldServer->GetName()
			     << " redirected from " << oldServer << " to " << newServer << endl ;
    }
    
    if (!newServer) {
      if (mustReplaceAll) {
	cxcoutD(LinkStateMgmt) << "RooAbsArg::redirectServers(" << (void*)this << "," << GetName() << "): server " << oldServer->GetName()
			       << " (" << (void*)oldServer << ") not redirected" << (nameChange?"[nameChange]":"") << endl ;
	ret = kTRUE ;
      }
      continue ;
    }
    
    propValue=origServerValue.findArg(oldServer)?kTRUE:kFALSE ;
    propShape=origServerShape.findArg(oldServer)?kTRUE:kFALSE ;
    // cout << "replaceServer with name " << oldServer->GetName() << " old=" << oldServer << " new=" << newServer << endl ;
    if (newServer != this) {
      replaceServer(*oldServer,*newServer,propValue,propShape) ;
    }
  }


  setValueDirty() ;
  setShapeDirty() ;

  // Process the proxies
  Bool_t allReplaced=kTRUE ;
  for (int i=0 ; i<numProxies() ; i++) {
    RooAbsProxy* p = getProxy(i) ;
    if (!p) continue ;
    Bool_t ret2 = p->changePointer(*newSet,nameChange,kFALSE) ; 
    allReplaced &= ret2 ;
  }
  
  if (mustReplaceAll && !allReplaced) {
    coutE(LinkStateMgmt) << "RooAbsArg::redirectServers(" << GetName()
			 << "): ERROR, some proxies could not be adjusted" << endl ;
    ret = kTRUE ;
  }

  // Optional subclass post-processing
  for (Int_t i=0 ;i<numCaches() ; i++) {
    ret |= getCache(i)->redirectServersHook(*newSet,mustReplaceAll,nameChange,isRecursionStep) ;
  }
  ret |= redirectServersHook(*newSet,mustReplaceAll,nameChange,isRecursionStep) ;

  if (nameChange) {
    delete newSet ;
  }

  return ret ;
}

//_____________________________________________________________________________
RooAbsArg *RooAbsArg::findNewServer(const RooAbsCollection &newSet, Bool_t nameChange) const
{
  // Find the new server in the specified set that matches the old server.
  // Allow a name change if nameChange is kTRUE, in which case the new
  // server is selected by searching for a new server with an attribute
  // of "ORIGNAME:<oldName>". Return zero if there is not a unique match.

  RooAbsArg *newServer = 0;
  if (!nameChange) {
    newServer = newSet.find(*this) ;
  }
  else {
    // Name changing server redirect:
    // use 'ORIGNAME:<oldName>' attribute instead of name of new server
    TString nameAttrib("ORIGNAME:") ;
    nameAttrib.Append(GetName()) ;

    RooArgSet* tmp = (RooArgSet*) newSet.selectByAttrib(nameAttrib,kTRUE) ;
    if(0 != tmp) {

      // Check if any match was found
      if (tmp->getSize()==0) {
	delete tmp ;
	return 0 ;
      }

      // Check if match is unique
      if(tmp->getSize()>1) {
	coutF(LinkStateMgmt) << "RooAbsArg::redirectServers(" << GetName() << "): FATAL Error, " << tmp->getSize() << " servers with "
			     << nameAttrib << " attribute" << endl ;
	tmp->Print("v") ;
	assert(0) ;
      }

      // use the unique element in the set
      newServer= tmp->first();
      delete tmp ;
    }
  }
  return newServer;
}

Bool_t RooAbsArg::recursiveRedirectServers(const RooAbsCollection& newSet, Bool_t mustReplaceAll, Bool_t nameChange, Bool_t recurseInNewSet)
{
  // Recursively redirect all servers with new server in collection 'newSet'.
  // Substitute our servers with those listed in newSet. If nameChange is false, servers and
  // and substitutes are matched by name. If nameChange is true, servers are matched to args
  // in newSet that have the 'ORIGNAME:<servername>' attribute set. If mustReplaceAll is set,
  // a warning is printed and error status is returned if not all servers could be sucessfully
  // substituted. If recurseInNewSet is true, the recursion algorithm also recursion into
  // expression trees under the arguments in the new servers (i.e. those in newset)


  // Cyclic recursion protection
  static RooLinkedList callStack ;
  if (callStack.findArg(this)) {
    return kFALSE ;
  } else {
    callStack.Add(this) ;
  }

  // Do not recurse into newset if not so specified
//   if (!recurseInNewSet && newSet.contains(*this)) {
//     return kFALSE ;
//   }


  // Apply the redirectServers function recursively on all branch nodes in this argument tree.
  Bool_t ret(kFALSE) ;

  cxcoutD(LinkStateMgmt) << "RooAbsArg::recursiveRedirectServers(" << this << "," << GetName() << ") newSet = " << newSet << " mustReplaceAll = "
			 << (mustReplaceAll?"T":"F") << " nameChange = " << (nameChange?"T":"F") << " recurseInNewSet = " << (recurseInNewSet?"T":"F") << endl ;

  // Do redirect on self (identify operation as recursion step)
  ret |= redirectServers(newSet,mustReplaceAll,nameChange,kTRUE) ;

  // Do redirect on servers
  RooFIter sIter = serverMIterator() ;
  RooAbsArg* server ;
  while((server=sIter.next())) {
    ret |= server->recursiveRedirectServers(newSet,mustReplaceAll,nameChange,recurseInNewSet) ;
  }

  callStack.Remove(this) ;
  return ret ;
}



//_____________________________________________________________________________
void RooAbsArg::registerProxy(RooArgProxy& proxy)
{
  // Register an RooArgProxy in the proxy list. This function is called by owned
  // proxies upon creation. After registration, this arg wil forward pointer
  // changes from serverRedirects and updates in cached normalization sets
  // to the proxies immediately after they occur. The proxied argument is
  // also added as value and/or shape server

  // Every proxy can be registered only once
  if (_proxyList.FindObject(&proxy)) {
    coutE(LinkStateMgmt) << "RooAbsArg::registerProxy(" << GetName() << "): proxy named "
			 << proxy.GetName() << " for arg " << proxy.absArg()->GetName()
			 << " already registered" << endl ;
    return ;
  }

//   cout << (void*)this << " " << GetName() << ": registering proxy "
//        << (void*)&proxy << " with name " << proxy.name() << " in mode "
//        << (proxy.isValueServer()?"V":"-") << (proxy.isShapeServer()?"S":"-") << endl ;

  // Register proxied object as server
  if (proxy.absArg()) {
    addServer(*proxy.absArg(),proxy.isValueServer(),proxy.isShapeServer()) ;
  }

  // Register proxy itself
  _proxyList.Add(&proxy) ;
}


//_____________________________________________________________________________
void RooAbsArg::unRegisterProxy(RooArgProxy& proxy)
{
  // Remove proxy from proxy list. This functions is called by owned proxies
  // upon their destruction.

  _proxyList.Remove(&proxy) ;
  _proxyList.Compress() ;
}



//_____________________________________________________________________________
void RooAbsArg::registerProxy(RooSetProxy& proxy)
{
  // Register an RooSetProxy in the proxy list. This function is called by owned
  // proxies upon creation. After registration, this arg wil forward pointer
  // changes from serverRedirects and updates in cached normalization sets
  // to the proxies immediately after they occur.

  // Every proxy can be registered only once
  if (_proxyList.FindObject(&proxy)) {
    coutE(LinkStateMgmt) << "RooAbsArg::registerProxy(" << GetName() << "): proxy named "
			 << proxy.GetName() << " already registered" << endl ;
    return ;
  }

  // Register proxy itself
  _proxyList.Add(&proxy) ;
}



//_____________________________________________________________________________
void RooAbsArg::unRegisterProxy(RooSetProxy& proxy)
{
  // Remove proxy from proxy list. This functions is called by owned proxies
  // upon their destruction.

  _proxyList.Remove(&proxy) ;
  _proxyList.Compress() ;
}



//_____________________________________________________________________________
void RooAbsArg::registerProxy(RooListProxy& proxy)
{
  // Register an RooListProxy in the proxy list. This function is called by owned
  // proxies upon creation. After registration, this arg wil forward pointer
  // changes from serverRedirects and updates in cached normalization sets
  // to the proxies immediately after they occur.

  // Every proxy can be registered only once
  if (_proxyList.FindObject(&proxy)) {
    coutE(LinkStateMgmt) << "RooAbsArg::registerProxy(" << GetName() << "): proxy named "
			 << proxy.GetName() << " already registered" << endl ;
    return ;
  }

  // Register proxy itself
  Int_t nProxyOld = _proxyList.GetEntries() ;
  _proxyList.Add(&proxy) ;
  if (_proxyList.GetEntries()!=nProxyOld+1) {
    cout << "RooAbsArg::registerProxy(" << GetName() << ") proxy registration failure! nold=" << nProxyOld << " nnew=" << _proxyList.GetEntries() << endl ;
  }
}



//_____________________________________________________________________________
void RooAbsArg::unRegisterProxy(RooListProxy& proxy)
{
  // Remove proxy from proxy list. This functions is called by owned proxies
  // upon their destruction.

  _proxyList.Remove(&proxy) ;
  _proxyList.Compress() ;
}



//_____________________________________________________________________________
RooAbsProxy* RooAbsArg::getProxy(Int_t index) const
{
  // Return the nth proxy from the proxy list.

  // Cross cast: proxy list returns TObject base pointer, we need
  // a RooAbsProxy base pointer. C++ standard requires
  // a dynamic_cast for this.
  return dynamic_cast<RooAbsProxy*> (_proxyList.At(index)) ;
}



//_____________________________________________________________________________
Int_t RooAbsArg::numProxies() const
{
  // Return the number of registered proxies.

  return _proxyList.GetEntries() ;
}



//_____________________________________________________________________________
void RooAbsArg::setProxyNormSet(const RooArgSet* nset)
{
  // Forward a change in the cached normalization argset
  // to all the registered proxies.

  for (int i=0 ; i<numProxies() ; i++) {
    RooAbsProxy* p = getProxy(i) ;
    if (!p) continue ;
    getProxy(i)->changeNormSet(nset) ;
  }
}



//_____________________________________________________________________________
void RooAbsArg::attachToTree(TTree& ,Int_t)
{
  // Overloadable function for derived classes to implement
  // attachment as branch to a TTree

  coutE(Contents) << "RooAbsArg::attachToTree(" << GetName()
		  << "): Cannot be attached to a TTree" << endl ;
}



//_____________________________________________________________________________
Bool_t RooAbsArg::isValid() const
{
  // WVE (08/21/01) Probably obsolete now
  return kTRUE ;
}




//_____________________________________________________________________________
void RooAbsArg::printName(ostream& os) const
{
  // Print object name

  os << GetName() ;
}



//_____________________________________________________________________________
void RooAbsArg::printTitle(ostream& os) const
{
  // Print object title
  os << GetTitle() ;
}



//_____________________________________________________________________________
void RooAbsArg::printClassName(ostream& os) const
{
  // Print object class name
  os << IsA()->GetName() ;
}


void RooAbsArg::printAddress(ostream& os) const
{
  // Print addrss of this RooAbsArg
  os << this ;
}



//_____________________________________________________________________________
void RooAbsArg::printArgs(ostream& os) const
{
  // Print object arguments, ie its proxies

  // Print nothing if there are no dependencies
  if (numProxies()==0) return ;

  os << "[ " ;
  for (Int_t i=0 ; i<numProxies() ; i++) {
    RooAbsProxy* p = getProxy(i) ;
    if (p==0) continue ;
    if (!TString(p->name()).BeginsWith("!")) {
      p->print(os) ;
      os << " " ;
    }
  }
  printMetaArgs(os) ;
  os << "]" ;
}



//_____________________________________________________________________________
Int_t RooAbsArg::defaultPrintContents(Option_t* /*opt*/) const
{
  // Define default contents to print
  return kName|kClassName|kValue|kArgs ;
}



//_____________________________________________________________________________
void RooAbsArg::printMultiline(ostream& os, Int_t /*contents*/, Bool_t /*verbose*/, TString indent) const
{
  // Implement multi-line detailed printing

  os << indent << "--- RooAbsArg ---" << endl;
  // dirty state flags
  os << indent << "  Value State: " ;
  switch(_operMode) {
  case ADirty: os << "FORCED DIRTY" ; break ;
  case AClean: os << "FORCED clean" ; break ;
  case Auto: os << (isValueDirty() ? "DIRTY":"clean") ; break ;
  }
  os << endl
     << indent << "  Shape State: " << (isShapeDirty() ? "DIRTY":"clean") << endl;
  // attribute list
  os << indent << "  Attributes: " ;
  printAttribList(os) ;
  os << endl ;
  // our memory address (for x-referencing with client addresses of other args)
  os << indent << "  Address: " << (void*)this << endl;
  // client list
  os << indent << "  Clients: " << endl;
  RooFIter clientIter= _clientList.fwdIterator();
  RooAbsArg* client ;
  while ((client=clientIter.next())) {
    os << indent << "    (" << (void*)client  << ","
       << (_clientListValue.findArg(client)?"V":"-")
       << (_clientListShape.findArg(client)?"S":"-")
       << ") " ;
    client->printStream(os,kClassName|kTitle|kName,kSingleLine);
  }

  // server list
  os << indent << "  Servers: " << endl;
  RooFIter serverIter= _serverList.fwdIterator();
  RooAbsArg* server ;
  while ((server=serverIter.next())) {
    os << indent << "    (" << (void*)server << ","
       << (server->_clientListValue.findArg(this)?"V":"-")
       << (server->_clientListShape.findArg(this)?"S":"-")
       << ") " ;
    server->printStream(os,kClassName|kName|kTitle,kSingleLine);
  }

  // proxy list
  os << indent << "  Proxies: " << endl ;
  for (int i=0 ; i<numProxies() ; i++) {
    RooAbsProxy* proxy=getProxy(i) ;
    if (!proxy) continue ;
    if (proxy->IsA()->InheritsFrom(RooArgProxy::Class())) {
      os << indent << "    " << proxy->name() << " -> " ;
      RooAbsArg* parg = ((RooArgProxy*)proxy)->absArg() ;
      if (parg) {
	parg->printStream(os,kName,kSingleLine) ;
      } else {
	os << " (empty)" << endl ; ;
      }
    } else {
      os << indent << "    " << proxy->name() << " -> " ;
      os << endl ;
      TString moreIndent(indent) ;
      moreIndent.Append("    ") ;
      ((RooSetProxy*)proxy)->printStream(os,kName,kStandard,moreIndent.Data()) ;
    }
  }
}


//_____________________________________________________________________________
void RooAbsArg::printTree(ostream& os, TString /*indent*/) const
{
  // Print object tree structure
  const_cast<RooAbsArg*>(this)->printCompactTree(os) ;
}


//_____________________________________________________________________________
ostream& operator<<(ostream& os, RooAbsArg &arg)
{
  // Ostream operator
  arg.writeToStream(os,kTRUE) ;
  return os ;
}

//_____________________________________________________________________________
istream& operator>>(istream& is, RooAbsArg &arg)
{
  // Istream operator
  arg.readFromStream(is,kTRUE,kFALSE) ;
  return is ;
}

//_____________________________________________________________________________
void RooAbsArg::printAttribList(ostream& os) const
{
  // Print the attribute list

  set<string>::const_iterator iter = _boolAttrib.begin() ;
  Bool_t first(kTRUE) ;
  while (iter != _boolAttrib.end()) {
    os << (first?" [":",") << *iter ;
    first=kFALSE ;
    ++iter ;
  }
  if (!first) os << "] " ;
}

//_____________________________________________________________________________
void RooAbsArg::attachDataSet(const RooAbsData &data)
{
  // Replace server nodes with names matching the dataset variable names
  // with those data set variables, making this PDF directly dependent on the dataset

  const RooArgSet* set = data.get() ;
  RooArgSet branches ;
  branchNodeServerList(&branches,0,kTRUE) ;

  RooFIter iter = branches.fwdIterator() ;
  RooAbsArg* branch ;
  while((branch=iter.next())) {
    branch->redirectServers(*set,kFALSE,kFALSE) ;
  }
}



//_____________________________________________________________________________
void RooAbsArg::attachDataStore(const RooAbsDataStore &dstore)
{
  // Replace server nodes with names matching the dataset variable names
  // with those data set variables, making this PDF directly dependent on the dataset

  const RooArgSet* set = dstore.get() ;
  RooArgSet branches ;
  branchNodeServerList(&branches,0,kTRUE) ;

  RooFIter iter = branches.fwdIterator() ;
  RooAbsArg* branch ;
  while((branch=iter.next())) {
    branch->redirectServers(*set,kFALSE,kFALSE) ;
  }
}



//_____________________________________________________________________________
Int_t RooAbsArg::Compare(const TObject* other) const
{
  // Utility function used by TCollection::Sort to compare contained TObjects
  // We implement comparison by name, resulting in alphabetical sorting by object name.

  return strcmp(GetName(),other->GetName()) ;
}



//_____________________________________________________________________________
void RooAbsArg::printDirty(Bool_t depth) const
{
  // Print information about current value dirty state information.
  // If depth flag is true, information is recursively printed for
  // all nodes in this arg tree.

  if (depth) {

    RooArgSet branchList ;
    branchNodeServerList(&branchList) ;
    RooFIter bIter = branchList.fwdIterator() ;
    RooAbsArg* branch ;
    while((branch=bIter.next())) {
      branch->printDirty(kFALSE) ;
    }

  } else {
    cout << GetName() << " : " ;
    switch (_operMode) {
    case AClean: cout << "FORCED clean" ; break ;
    case ADirty: cout << "FORCED DIRTY" ; break ;
    case Auto:   cout << "Auto  " << (isValueDirty()?"DIRTY":"clean") ;
    }
    cout << endl ;
  }
}


//_____________________________________________________________________________
void RooAbsArg::optimizeCacheMode(const RooArgSet& observables)
{
  // Activate cache mode optimization with given definition of observables.
  // The cache operation mode of all objects in the expression tree will
  // modified such that all nodes that depend directly or indirectly on
  // any of the listed observables will be set to ADirty, as they are
  // expected to change every time. This save change tracking overhead for
  // nodes that are a priori known to change every time

  RooLinkedList proc;
  RooArgSet opt ;
  optimizeCacheMode(observables,opt,proc) ;

  coutI(Optimization) << "RooAbsArg::optimizeCacheMode(" << GetName() << ") nodes " << opt << " depend on observables, "
			<< "changing cache operation mode from change tracking to unconditional evaluation" << endl ;
}


//_____________________________________________________________________________
void RooAbsArg::optimizeCacheMode(const RooArgSet& observables, RooArgSet& optimizedNodes, RooLinkedList& processedNodes)
{
  // Activate cache mode optimization with given definition of observables.
  // The cache operation mode of all objects in the expression tree will
  // modified such that all nodes that depend directly or indirectly on
  // any of the listed observables will be set to ADirty, as they are
  // expected to change every time. This save change tracking overhead for
  // nodes that are a priori known to change every time

  // Optimization applies only to branch nodes, not to leaf nodes
  if (!isDerived()) {
    return ;
  }


  // Terminate call if this node was already processed (tree structure may be cyclical)
  if (processedNodes.findArg(this)) {
    return ;
  } else {
    processedNodes.Add(this) ;
  }

  // Set cache mode operator to 'AlwaysDirty' if we depend on any of the given observables
  if (dependsOnValue(observables)) {

    if (dynamic_cast<RooRealIntegral*>(this)) {
      cxcoutI(Integration) << "RooAbsArg::optimizeCacheMode(" << GetName() << ") integral depends on value of one or more observables and will be evaluated for every event" << endl ;
    }
    optimizedNodes.add(*this,kTRUE) ;
    if (operMode()==AClean) {
    } else {
      setOperMode(ADirty,kTRUE) ; // WVE propagate flag recursively to top of tree
    }
  } else {
  }
  // Process any RooAbsArgs contained in any of the caches of this object
  for (Int_t i=0 ;i<numCaches() ; i++) {
    getCache(i)->optimizeCacheMode(observables,optimizedNodes,processedNodes) ;
  }

  // Forward calls to all servers
  RooFIter sIter = serverMIterator() ;
  RooAbsArg* server ;
  while((server=sIter.next())) {
    server->optimizeCacheMode(observables,optimizedNodes,processedNodes) ;
  }

}

//_____________________________________________________________________________
Bool_t RooAbsArg::findConstantNodes(const RooArgSet& observables, RooArgSet& cacheList)
{
  // Find branch nodes with all-constant parameters, and add them to the list of
  // nodes that can be cached with a dataset in a test statistic calculation

  RooLinkedList proc ;
  Bool_t ret = findConstantNodes(observables,cacheList,proc) ;

  // If node can be optimized and hasn't been identified yet, add it to the list
  coutI(Optimization) << "RooAbsArg::findConstantNodes(" << GetName() << "): components "
			<< cacheList << " depend exclusively on constant parameters and will be precalculated and cached" << endl ;

  return ret ;
}



//_____________________________________________________________________________
Bool_t RooAbsArg::findConstantNodes(const RooArgSet& observables, RooArgSet& cacheList, RooLinkedList& processedNodes)
{
  // Find branch nodes with all-constant parameters, and add them to the list of
  // nodes that can be cached with a dataset in a test statistic calculation

  // Caching only applies to branch nodes
  if (!isDerived()) {
    return kFALSE;
  }

  // Terminate call if this node was already processed (tree structure may be cyclical)
  if (processedNodes.findArg(this)) {
    return kFALSE ;
  } else {
    processedNodes.Add(this) ;
  }

  // Check if node depends on any non-constant parameter
  Bool_t canOpt(kTRUE) ;
  RooArgSet* paramSet = getParameters(observables) ;
  RooFIter iter = paramSet->fwdIterator() ;
  RooAbsArg* param ;
  while((param = iter.next())) {
    if (!param->isConstant()) {
      canOpt=kFALSE ;
      break ;
    }
  }
  delete paramSet ;


  if (getAttribute("NeverConstant")) {
    canOpt = kFALSE ;
  }

  if (canOpt) {
    setAttribute("ConstantExpression") ;
  }

  // If yes, list node eligible for caching, if not test nodes one level down
  if (canOpt||getAttribute("CacheAndTrack")) {
    
    if (!cacheList.find(*this) && dependsOnValue(observables) && !observables.find(*this) ) {
      
      // Add to cache list
      cxcoutD(Optimization) << "RooAbsArg::findConstantNodes(" << GetName() << ") adding self to list of constant nodes" << endl ;

      if (canOpt) setAttribute("ConstantExpressionCached") ;
      cacheList.add(*this,kFALSE) ;
    }
  }

  if (!canOpt) {
    
    // If not, see if next level down can be cached
    RooFIter sIter = serverMIterator() ;
    RooAbsArg* server ;
    while((server=sIter.next())) {
      if (server->isDerived()) {
	server->findConstantNodes(observables,cacheList,processedNodes) ;
      }
    }
  }
  
  // Forward call to all cached contained in current object
  for (Int_t i=0 ;i<numCaches() ; i++) {
    getCache(i)->findConstantNodes(observables,cacheList,processedNodes) ;
  }

  return kFALSE ;
}




//_____________________________________________________________________________
void RooAbsArg::constOptimizeTestStatistic(ConstOpCode opcode, Bool_t doAlsoTrackingOpt)
{
  // Interface function signaling a request to perform constant term
  // optimization. This default implementation takes no action other than to
  // forward the calls to all servers

  RooFIter sIter = serverMIterator() ;
  RooAbsArg* server ;
  while((server=sIter.next())) {
    server->constOptimizeTestStatistic(opcode,doAlsoTrackingOpt) ;
  }
}


//_____________________________________________________________________________
void RooAbsArg::setOperMode(OperMode mode, Bool_t recurseADirty)
{
  // Change cache operation mode to given mode. If recurseAdirty
  // is true, then a mode change to AlwaysDirty will automatically
  // be propagated recursively to all client nodes

  // Prevent recursion loops
  if (mode==_operMode) return ;

  _operMode = mode ;
  _fast = ((mode==AClean) || dynamic_cast<RooRealVar*>(this)!=0 || dynamic_cast<RooConstVar*>(this)!=0 ) ;
  for (Int_t i=0 ;i<numCaches() ; i++) {
    getCache(i)->operModeHook() ;
  }
  operModeHook() ;

  // Propagate to all clients
  if (mode==ADirty && recurseADirty) {
    RooFIter iter = valueClientMIterator() ;
    RooAbsArg* client ;
    while((client=iter.next())) {
      client->setOperMode(mode) ;
    }
  }
}


//_____________________________________________________________________________
void RooAbsArg::printCompactTree(const char* indent, const char* filename, const char* namePat, RooAbsArg* client)
{
  // Print tree structure of expression tree on stdout, or to file if filename is specified.
  // If namePat is not "*", only nodes with names matching the pattern will be printed.
  // The client argument is used in recursive calls to properly display the value or shape nature
  // of the client-server links. It should be zero in calls initiated by users.

  if (filename) {
    ofstream ofs(filename) ;
    printCompactTree(ofs,indent,namePat,client) ;
  } else {
    printCompactTree(cout,indent,namePat,client) ;
  }
}


//_____________________________________________________________________________
void RooAbsArg::printCompactTree(ostream& os, const char* indent, const char* namePat, RooAbsArg* client)
{
  // Print tree structure of expression tree on given ostream.
  // If namePat is not "*", only nodes with names matching the pattern will be printed.
  // The client argument is used in recursive calls to properly display the value or shape nature
  // of the client-server links. It should be zero in calls initiated by users.

  if ( !namePat || TString(GetName()).Contains(namePat)) {
    os << indent << this ;
    if (client) {
      os << "/" ;
      if (isValueServer(*client)) os << "V" ; else os << "-" ;
      if (isShapeServer(*client)) os << "S" ; else os << "-" ;
    }
    os << " " ;

    os << IsA()->GetName() << "::" << GetName() <<  " = " ;
    printValue(os) ;

    if (_serverList.GetSize()>0) {
      switch(operMode()) {
      case Auto:   os << " [Auto," << (isValueDirty()?"Dirty":"Clean") << "] "  ; break ;
      case AClean: os << " [ACLEAN] " ; break ;
      case ADirty: os << " [ADIRTY] " ; break ;
      }
    }
    os << endl ;

    for (Int_t i=0 ;i<numCaches() ; i++) {
      getCache(i)->printCompactTreeHook(os,indent) ;
    }
    printCompactTreeHook(os,indent) ;
  }

  TString indent2(indent) ;
  indent2 += "  " ;
  RooFIter iter = serverMIterator() ;
  RooAbsArg* arg ;
  while((arg=iter.next())) {
    arg->printCompactTree(os,indent2,namePat,this) ;
  }
}


//_____________________________________________________________________________
void RooAbsArg::printComponentTree(const char* indent, const char* namePat, Int_t nLevel)
{
  // Print tree structure of expression tree on given ostream, only branch nodes are printed.
  // Lead nodes (variables) will not be shown
  //
  // If namePat is not "*", only nodes with names matching the pattern will be printed.

  if (nLevel==0) return ;
  if (isFundamental()) return ;
  RooResolutionModel* rmodel = dynamic_cast<RooResolutionModel*>(this) ;
  if (rmodel && rmodel->isConvolved()) return ;
  if (InheritsFrom("RooConstVar")) return ;

  if ( !namePat || TString(GetName()).Contains(namePat)) {
    cout << indent ;
    Print() ;
  }

  TString indent2(indent) ;
  indent2 += "  " ;
  RooFIter iter = serverMIterator() ;
  RooAbsArg* arg ;
  while((arg=iter.next())) {
    arg->printComponentTree(indent2.Data(),namePat,nLevel-1) ;
  }
}


//_____________________________________________________________________________
TString RooAbsArg::cleanBranchName() const
{
  // Construct a mangled name from the actual name that
  // is free of any math symbols that might be interpreted by TTree

  // Check for optional alternate name of branch for this argument
  TString rawBranchName = GetName() ;
  if (getStringAttribute("BranchName")) {
    rawBranchName = getStringAttribute("BranchName") ;
  }

  TString cleanName(rawBranchName) ;
  cleanName.ReplaceAll("/","D") ;
  cleanName.ReplaceAll("-","M") ;
  cleanName.ReplaceAll("+","P") ;
  cleanName.ReplaceAll("*","X") ;
  cleanName.ReplaceAll("[","L") ;
  cleanName.ReplaceAll("]","R") ;
  cleanName.ReplaceAll("(","L") ;
  cleanName.ReplaceAll(")","R") ;
  cleanName.ReplaceAll("{","L") ;
  cleanName.ReplaceAll("}","R") ;

  if (cleanName.Length()<=60) return cleanName ;

  // Name is too long, truncate and include CRC32 checksum of full name in clean name
  static char buf[1024] ;
  strlcpy(buf,cleanName.Data(),1024) ;
  snprintf(buf+46,1024-46,"_CRC%08x",crc32(cleanName.Data())) ;

  return TString(buf) ;
}





UInt_t RooAbsArg::crc32(const char* data)
{
  // Calculate crc32 checksum on given string
  unsigned long sz = strlen(data);
  switch (strlen(data)) {
    case 0:
      return 0;
    case 1:
      return data[0];
    case 2:
      return (data[0] << 8) | data[1];
    case 3:
      return (data[0] << 16) | (data[1] << 8) | data[2];
    case 4:
      return (data[0] << 24) | (data[1] << 16) | (data[2] << 8) | data[3];
    default:
      return crc32(data + 4, sz - 4, (data[0] << 24) | (data[1] << 16) |
	  (data[2] << 8) | data[3]);
  }
}


UInt_t RooAbsArg::crc32(const char* data, ULong_t sz, UInt_t crc)
{
  // update CRC32 with new data

  // use precomputed table, rather than computing it on the fly
  static const UInt_t crctab[256] = { 0x00000000,
    0x04c11db7, 0x09823b6e, 0x0d4326d9, 0x130476dc, 0x17c56b6b,
    0x1a864db2, 0x1e475005, 0x2608edb8, 0x22c9f00f, 0x2f8ad6d6,
    0x2b4bcb61, 0x350c9b64, 0x31cd86d3, 0x3c8ea00a, 0x384fbdbd,
    0x4c11db70, 0x48d0c6c7, 0x4593e01e, 0x4152fda9, 0x5f15adac,
    0x5bd4b01b, 0x569796c2, 0x52568b75, 0x6a1936c8, 0x6ed82b7f,
    0x639b0da6, 0x675a1011, 0x791d4014, 0x7ddc5da3, 0x709f7b7a,
    0x745e66cd, 0x9823b6e0, 0x9ce2ab57, 0x91a18d8e, 0x95609039,
    0x8b27c03c, 0x8fe6dd8b, 0x82a5fb52, 0x8664e6e5, 0xbe2b5b58,
    0xbaea46ef, 0xb7a96036, 0xb3687d81, 0xad2f2d84, 0xa9ee3033,
    0xa4ad16ea, 0xa06c0b5d, 0xd4326d90, 0xd0f37027, 0xddb056fe,
    0xd9714b49, 0xc7361b4c, 0xc3f706fb, 0xceb42022, 0xca753d95,
    0xf23a8028, 0xf6fb9d9f, 0xfbb8bb46, 0xff79a6f1, 0xe13ef6f4,
    0xe5ffeb43, 0xe8bccd9a, 0xec7dd02d, 0x34867077, 0x30476dc0,
    0x3d044b19, 0x39c556ae, 0x278206ab, 0x23431b1c, 0x2e003dc5,
    0x2ac12072, 0x128e9dcf, 0x164f8078, 0x1b0ca6a1, 0x1fcdbb16,
    0x018aeb13, 0x054bf6a4, 0x0808d07d, 0x0cc9cdca, 0x7897ab07,
    0x7c56b6b0, 0x71159069, 0x75d48dde, 0x6b93dddb, 0x6f52c06c,
    0x6211e6b5, 0x66d0fb02, 0x5e9f46bf, 0x5a5e5b08, 0x571d7dd1,
    0x53dc6066, 0x4d9b3063, 0x495a2dd4, 0x44190b0d, 0x40d816ba,
    0xaca5c697, 0xa864db20, 0xa527fdf9, 0xa1e6e04e, 0xbfa1b04b,
    0xbb60adfc, 0xb6238b25, 0xb2e29692, 0x8aad2b2f, 0x8e6c3698,
    0x832f1041, 0x87ee0df6, 0x99a95df3, 0x9d684044, 0x902b669d,
    0x94ea7b2a, 0xe0b41de7, 0xe4750050, 0xe9362689, 0xedf73b3e,
    0xf3b06b3b, 0xf771768c, 0xfa325055, 0xfef34de2, 0xc6bcf05f,
    0xc27dede8, 0xcf3ecb31, 0xcbffd686, 0xd5b88683, 0xd1799b34,
    0xdc3abded, 0xd8fba05a, 0x690ce0ee, 0x6dcdfd59, 0x608edb80,
    0x644fc637, 0x7a089632, 0x7ec98b85, 0x738aad5c, 0x774bb0eb,
    0x4f040d56, 0x4bc510e1, 0x46863638, 0x42472b8f, 0x5c007b8a,
    0x58c1663d, 0x558240e4, 0x51435d53, 0x251d3b9e, 0x21dc2629,
    0x2c9f00f0, 0x285e1d47, 0x36194d42, 0x32d850f5, 0x3f9b762c,
    0x3b5a6b9b, 0x0315d626, 0x07d4cb91, 0x0a97ed48, 0x0e56f0ff,
    0x1011a0fa, 0x14d0bd4d, 0x19939b94, 0x1d528623, 0xf12f560e,
    0xf5ee4bb9, 0xf8ad6d60, 0xfc6c70d7, 0xe22b20d2, 0xe6ea3d65,
    0xeba91bbc, 0xef68060b, 0xd727bbb6, 0xd3e6a601, 0xdea580d8,
    0xda649d6f, 0xc423cd6a, 0xc0e2d0dd, 0xcda1f604, 0xc960ebb3,
    0xbd3e8d7e, 0xb9ff90c9, 0xb4bcb610, 0xb07daba7, 0xae3afba2,
    0xaafbe615, 0xa7b8c0cc, 0xa379dd7b, 0x9b3660c6, 0x9ff77d71,
    0x92b45ba8, 0x9675461f, 0x8832161a, 0x8cf30bad, 0x81b02d74,
    0x857130c3, 0x5d8a9099, 0x594b8d2e, 0x5408abf7, 0x50c9b640,
    0x4e8ee645, 0x4a4ffbf2, 0x470cdd2b, 0x43cdc09c, 0x7b827d21,
    0x7f436096, 0x7200464f, 0x76c15bf8, 0x68860bfd, 0x6c47164a,
    0x61043093, 0x65c52d24, 0x119b4be9, 0x155a565e, 0x18197087,
    0x1cd86d30, 0x029f3d35, 0x065e2082, 0x0b1d065b, 0x0fdc1bec,
    0x3793a651, 0x3352bbe6, 0x3e119d3f, 0x3ad08088, 0x2497d08d,
    0x2056cd3a, 0x2d15ebe3, 0x29d4f654, 0xc5a92679, 0xc1683bce,
    0xcc2b1d17, 0xc8ea00a0, 0xd6ad50a5, 0xd26c4d12, 0xdf2f6bcb,
    0xdbee767c, 0xe3a1cbc1, 0xe760d676, 0xea23f0af, 0xeee2ed18,
    0xf0a5bd1d, 0xf464a0aa, 0xf9278673, 0xfde69bc4, 0x89b8fd09,
    0x8d79e0be, 0x803ac667, 0x84fbdbd0, 0x9abc8bd5, 0x9e7d9662,
    0x933eb0bb, 0x97ffad0c, 0xafb010b1, 0xab710d06, 0xa6322bdf,
    0xa2f33668, 0xbcb4666d, 0xb8757bda, 0xb5365d03, 0xb1f740b4
  };

  crc = ~crc;
  while (sz--) crc = (crc << 8) ^ UInt_t(*data++) ^ crctab[crc >> 24];

  return ~crc;
}

UInt_t RooAbsArg::fnv1a32(const char* data)
{
  // calculate 32 bit FNV1A hash of string
  return fnv1a32(data, strlen(data));
}

UInt_t RooAbsArg::fnv1a32(const char* data, ULong_t sz, UInt_t hash)
{
  // update 32 bit FNV1A hash
  const UInt_t fnv1a32mult = 16777619u;
  while (sz--) {
    hash ^= *data++;
    hash *= fnv1a32mult;
  }
  return hash;
}

ULong64_t RooAbsArg::fnv1a64(const char* data)
{
  // calculate 64 bit FNV1A hash of string
  return fnv1a64(data, strlen(data));
}

ULong64_t RooAbsArg::fnv1a64(const char* data, ULong_t sz, ULong64_t hash)
{
  // update 64 bit FNV1A hash
  const ULong64_t fnv1a64mult = (ULong64_t(1) << 40) | ULong64_t(435);
  while (sz--) {
    hash ^= *data++;
    hash *= fnv1a64mult;
  }
  return hash;
}

//_____________________________________________________________________________
void RooAbsArg::printCompactTreeHook(ostream&, const char *)
{
  // Hook function interface for object to insert additional information
  // when printed in the context of a tree structure. This default
  // implementation prints nothing
}


//_____________________________________________________________________________
void RooAbsArg::registerCache(RooAbsCache& cache)
{
  // Register RooAbsCache with this object. This function is called
  // by RooAbsCache constructors for objects that are a datamember
  // of this RooAbsArg. By registering itself the RooAbsArg is aware
  // of all its cache data members and will forward server change
  // and cache mode change calls to the cache objects, which in turn
  // can forward them their contents

  _cacheList.push_back(&cache) ;
}


//_____________________________________________________________________________
void RooAbsArg::unRegisterCache(RooAbsCache& cache)
{
  // Unregister a RooAbsCache. Called from the RooAbsCache destructor
  std::remove(_cacheList.begin(), _cacheList.end(), &cache);
}


//_____________________________________________________________________________
Int_t RooAbsArg::numCaches() const
{
  // Return number of registered caches

  return _cacheList.size() ;
}


//_____________________________________________________________________________
RooAbsCache* RooAbsArg::getCache(Int_t index) const
{
  // Return registered cache object by index

  return _cacheList[index] ;
}


//_____________________________________________________________________________
RooArgSet* RooAbsArg::getVariables(Bool_t stripDisconnected) const
{
  // Return RooArgSet with all variables (tree leaf nodes of expresssion tree)

  return getParameters(RooArgSet(),stripDisconnected) ;
}


//_____________________________________________________________________________
RooLinkedList RooAbsArg::getCloningAncestors() const
{
  // Return ancestors in cloning chain of this RooAbsArg. NOTE: Returned pointers
  // are not guaranteed to be 'live', so do not dereference without proper caution

  RooLinkedList retVal ;

  set<string>::const_iterator iter= _boolAttrib.begin() ;
  while(iter != _boolAttrib.end()) {
    if (TString(*iter).BeginsWith("CloneOf(")) {
      char buf[128] ;
      strlcpy(buf,iter->c_str(),128) ;
      strtok(buf,"(") ;
      char* ptrToken = strtok(0,")") ;
      RooAbsArg* ptr = (RooAbsArg*) strtol(ptrToken,0,16) ;
      retVal.Add(ptr) ;
    }
  }

  return retVal ;
}


//_____________________________________________________________________________
void RooAbsArg::graphVizTree(const char* fileName, const char* delimiter, bool useTitle, bool useLatex)
{
  // Create a GraphViz .dot file visualizing the expression tree headed by
  // this RooAbsArg object. Use the GraphViz tool suite to make e.g. a gif
  // or ps file from the .dot file
  //
  // Based on concept developed by Kyle Cranmer

  ofstream ofs(fileName) ;
  if (!ofs) {
    coutE(InputArguments) << "RooAbsArg::graphVizTree() ERROR: Cannot open graphViz output file with name " << fileName << endl ;
    return ;
  }
  graphVizTree(ofs, delimiter, useTitle, useLatex) ;
}

//_____________________________________________________________________________
void RooAbsArg::graphVizTree(ostream& os, const char* delimiter, bool useTitle, bool useLatex)
{
  // Write the GraphViz representation of the expression tree headed by
  // this RooAbsArg object to the given ostream.
  //
  // Based on concept developed by Kyle Cranmer

  if (!os) {
    coutE(InputArguments) << "RooAbsArg::graphVizTree() ERROR: output stream provided as input argument is in invalid state" << endl ;
  }

  // Write header
  os << "digraph " << GetName() << "{" << endl ;

  // First list all the tree nodes
  RooArgSet nodeSet ;
  treeNodeServerList(&nodeSet) ;
  RooFIter iter = nodeSet.fwdIterator() ;
  RooAbsArg* node ;

  // iterate over nodes
  while((node=iter.next())) {
    string nodeName = node->GetName();
    string nodeTitle = node->GetTitle();
    string nodeLabel = (useTitle && !nodeTitle.empty()) ? nodeTitle : nodeName;

    // if using latex, replace ROOT's # with normal latex backslash
    string::size_type position = nodeLabel.find("#") ;
    while(useLatex && position!=nodeLabel.npos){
      nodeLabel.replace(position, 1, "\\");
    }

    string typeFormat = "\\texttt{";
    string nodeType = (useLatex) ? typeFormat+node->IsA()->GetName()+"}" : node->IsA()->GetName();

    os << "\"" << nodeName << "\" [ color=" << (node->isFundamental()?"blue":"red")
       << ", label=\"" << nodeType << delimiter << nodeLabel << "\"];" << endl ;

  }

  // Get set of all server links
  set<pair<RooAbsArg*,RooAbsArg*> > links ;
  graphVizAddConnections(links) ;

  // And write them out
  set<pair<RooAbsArg*,RooAbsArg*> >::iterator liter = links.begin() ;
  for( ; liter != links.end() ; ++liter ) {
    os << "\"" << liter->first->GetName() << "\" -> \"" << liter->second->GetName() << "\";" << endl ;
  }

  // Write trailer
  os << "}" << endl ;

}

//_____________________________________________________________________________
void RooAbsArg::graphVizAddConnections(set<pair<RooAbsArg*,RooAbsArg*> >& linkSet)
{
  // Utility function that inserts all point-to-point client-server connections
  // between any two RooAbsArgs in the expression tree headed by this object
  // in the linkSet argument.

  RooFIter sIter = serverMIterator() ;
  RooAbsArg* server ;
  while((server=sIter.next())) {
    linkSet.insert(make_pair(this,server)) ;
    server->graphVizAddConnections(linkSet) ;
  }
}



// //_____________________________________________________________________________
// TGraphStruct* RooAbsArg::graph(Bool_t useFactoryTag, Double_t textSize)
// {
//   // Return a TGraphStruct object filled with the tree structure of the pdf object

//   TGraphStruct* theGraph = new TGraphStruct() ;

//   // First list all the tree nodes
//   RooArgSet nodeSet ;
//   treeNodeServerList(&nodeSet) ;
//   TIterator* iter = nodeSet.createIterator() ;
//   RooAbsArg* node ;


//   // iterate over nodes
//   while((node=(RooAbsArg*)iter->Next())) {

//     // Skip node that represent numeric constants
//     if (node->IsA()->InheritsFrom(RooConstVar::Class())) continue ;

//     string nodeName ;
//     if (useFactoryTag && node->getStringAttribute("factory_tag")) {
//       nodeName  = node->getStringAttribute("factory_tag") ;
//     } else {
//       if (node->isFundamental()) {
// 	nodeName = node->GetName();
//       } else {
// 	ostringstream oss ;
// 	node->printStream(oss,(node->defaultPrintContents(0)&(~kValue)),node->defaultPrintStyle(0)) ;
// 	nodeName= oss.str() ;
// // 	nodeName = Form("%s::%s",node->IsA()->GetName(),node->GetName());

//       }
//     }
//     if (strncmp(nodeName.c_str(),"Roo",3)==0) {
//       nodeName = string(nodeName.c_str()+3) ;
//     }
//     node->setStringAttribute("graph_name",nodeName.c_str()) ;

//     TGraphNode* gnode = theGraph->AddNode(nodeName.c_str(),nodeName.c_str()) ;
//     gnode->SetLineWidth(2) ;
//     gnode->SetTextColor(node->isFundamental()?kBlue:kRed) ;
//     gnode->SetTextSize(textSize) ;
//   }
//   delete iter ;

//   // Get set of all server links
//   set<pair<RooAbsArg*,RooAbsArg*> > links ;
//   graphVizAddConnections(links) ;

//   // And insert them into the graph
//   set<pair<RooAbsArg*,RooAbsArg*> >::iterator liter = links.begin() ;
//   for( ; liter != links.end() ; ++liter ) {

//     TGraphNode* n1 = (TGraphNode*)theGraph->GetListOfNodes()->FindObject(liter->first->getStringAttribute("graph_name")) ;
//     TGraphNode* n2 = (TGraphNode*)theGraph->GetListOfNodes()->FindObject(liter->second->getStringAttribute("graph_name")) ;
//     if (n1 && n2) {
//       TGraphEdge* edge = theGraph->AddEdge(n1,n2) ;
//       edge->SetLineWidth(2) ;
//     }
//   }

//   return theGraph ;
// }



// //_____________________________________________________________________________
// Bool_t RooAbsArg::inhibitDirty()
// {
//   // Return current status of the inhibitDirty global flag. If true
//   // no dirty state change tracking occurs and all caches are considered
//   // to be always dirty.
//   return _inhibitDirty ;
// }


//_____________________________________________________________________________
Bool_t RooAbsArg::addOwnedComponents(const RooArgSet& comps)
{
  // Take ownership of the contents of 'comps'

  if (!_ownedComponents) {
    _ownedComponents = new RooArgSet("owned components") ;
  }
  return _ownedComponents->addOwned(comps) ;
}



//_____________________________________________________________________________
RooAbsArg* RooAbsArg::cloneTree(const char* newname) const
{
  // Clone tree expression of objects. All tree nodes will be owned by
  // the head node return by cloneTree()

  // Clone tree using snapshot
  RooArgSet* clonedNodes = (RooArgSet*) RooArgSet(*this).snapshot(kTRUE) ;

  // Find the head node in the cloneSet
  RooAbsArg* head = clonedNodes->find(*this) ;

  // Remove the head node from the cloneSet
  // To release it from the set ownership
  clonedNodes->remove(*head) ;

  // Add the set as owned component of the head
  head->addOwnedComponents(*clonedNodes) ;

  // Delete intermediate container
  clonedNodes->releaseOwnership() ;
  delete clonedNodes ;

  // Adjust name of head node if requested
  if (newname) {
    head->TNamed::SetName(newname) ;
    head->_namePtr = (TNamed*) RooNameReg::instance().constPtr(newname) ;
  }

  // Return the head
  return head ;
}



//_____________________________________________________________________________
void RooAbsArg::attachToStore(RooAbsDataStore& store) 
{
  if (dynamic_cast<RooTreeDataStore*>(&store)) {
    attachToTree(((RooTreeDataStore&)store).tree()) ;
  } else if (dynamic_cast<RooVectorDataStore*>(&store)) {
    attachToVStore((RooVectorDataStore&)store) ;
  }
}



//_____________________________________________________________________________
RooExpensiveObjectCache& RooAbsArg::expensiveObjectCache() const
{
  if (_eocache) {
    return *_eocache ;
  } else {
    return RooExpensiveObjectCache::instance() ;
  }
}


//_____________________________________________________________________________
const char* RooAbsArg::aggregateCacheUniqueSuffix() const
{
  string suffix ;

  RooArgSet branches ;
  branchNodeServerList(&branches) ;
  RooFIter iter = branches.fwdIterator();
  RooAbsArg* arg ;
  while((arg=iter.next())) {
    const char* tmp = arg->cacheUniqueSuffix() ;
    if (tmp) suffix += tmp ;
  }
  return Form("%s",suffix.c_str()) ;
}


//_____________________________________________________________________________
void RooAbsArg::wireAllCaches() 
{
  RooArgSet branches ;
  branchNodeServerList(&branches) ;
  RooFIter iter = branches.fwdIterator() ;
  RooAbsArg* arg ;
  while((arg=iter.next())) {
//     cout << "wiring caches on node " << arg->GetName() << endl ;
    for (deque<RooAbsCache*>::iterator iter2 = arg->_cacheList.begin() ; iter2 != arg->_cacheList.end() ; ++iter2) {
      (*iter2)->wireCache() ;
    }
  }
}



//_____________________________________________________________________________
void RooAbsArg::SetName(const char* name) 
{
  TNamed::SetName(name) ;
  TNamed* newPtr = (TNamed*) RooNameReg::instance().constPtr(GetName()) ;
  if (newPtr != _namePtr) {
    //cout << "Rename '" << _namePtr->GetName() << "' to '" << name << "' (set flag in new name)" << endl;
    _namePtr = newPtr;
    _namePtr->SetBit(RooNameReg::kRenamedArg);
  }
}




//_____________________________________________________________________________
void RooAbsArg::SetNameTitle(const char *name, const char *title)
{
  TNamed::SetNameTitle(name,title) ;
  TNamed* newPtr = (TNamed*) RooNameReg::instance().constPtr(GetName()) ;
  if (newPtr != _namePtr) {
    //cout << "Rename '" << _namePtr->GetName() << "' to '" << name << "' (set flag in new name)" << endl;
    _namePtr = newPtr;
    _namePtr->SetBit(RooNameReg::kRenamedArg);
  }
}


//______________________________________________________________________________
void RooAbsArg::Streamer(TBuffer &R__b)
{
   // Stream an object of class RooAbsArg.

   if (R__b.IsReading()) {
     _ioReadStack.push(this) ;
     R__b.ReadClassBuffer(RooAbsArg::Class(),this);
     _ioReadStack.pop() ;
     _namePtr = (TNamed*) RooNameReg::instance().constPtr(GetName()) ;  
     _isConstant = getAttribute("Constant") ;
   } else {
     R__b.WriteClassBuffer(RooAbsArg::Class(),this);
   }
}

//______________________________________________________________________________
void RooAbsArg::ioStreamerPass2() 
{
  // Method called by workspace container to finalize schema evolution issues
  // that cannot be handled in a single ioStreamer pass.
  //
  // A second pass is typically needed when evolving data member of RooAbsArg-derived
  // classes that are container classes with references to other members, which may
  // not yet be 'live' in the first ioStreamer() evolution pass.
  //
  // Classes may overload this function, but must call the base method in the
  // overloaded call to ensure base evolution is handled properly


  // Handling of v5-v6 migration (TRefArray _proxyList --> RooRefArray _proxyList)
  map<RooAbsArg*,TRefArray*>::iterator iter = _ioEvoList.find(this) ;
  if (iter != _ioEvoList.end()) {

    // Transfer contents of saved TRefArray to RooRefArray now
    for (int i=0 ; i < iter->second->GetEntries() ; i++) {
      _proxyList.Add(iter->second->At(i)) ;
    }
    // Delete TRefArray and remove from list
    delete iter->second ;
    _ioEvoList.erase(iter) ;
  }
}




//______________________________________________________________________________
void RooAbsArg::ioStreamerPass2Finalize() 
{
  // Method called by workspace container to finalize schema evolution issues
  // that cannot be handled in a single ioStreamer pass. This static finalize method
  // is called after ioStreamerPass2() is called on each directly listed object 
  // in the workspace. It's purpose is to complete schema evolution of any
  // objects in the workspace that are not directly listed as content elements
  // (e.g. analytical convolution tokens )
  

  // Handling of v5-v6 migration (TRefArray _proxyList --> RooRefArray _proxyList)
  map<RooAbsArg*,TRefArray*>::iterator iter = _ioEvoList.begin() ;
  while (iter != _ioEvoList.end()) {
    
    // Transfer contents of saved TRefArray to RooRefArray now
    for (int i=0 ; i < iter->second->GetEntries() ; i++) {
      iter->first->_proxyList.Add(iter->second->At(i)) ;
    }

    // Save iterator position for deletion after increment
    map<RooAbsArg*,TRefArray*>::iterator iter_tmp = iter ;
    
    iter++ ;
    
    // Delete TRefArray and remove from list
    delete iter_tmp->second ;
    _ioEvoList.erase(iter_tmp) ;
    
  }

}


//______________________________________________________________________________
void RooRefArray::Streamer(TBuffer &R__b)
{
   // Stream an object of class RooRefArray.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {

      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }      

      // Make temporary refArray and read that from the streamer 
      TRefArray* refArray = new TRefArray ;
      refArray->Streamer(R__b) ;
      R__b.CheckByteCount(R__s, R__c, refArray->IsA());
      
      // Schedule deferred processing of TRefArray into proxy list
      RooAbsArg::_ioEvoList[RooAbsArg::_ioReadStack.top()] = refArray ;
      
   } else {

     R__c = R__b.WriteVersion(RooRefArray::IsA(), kTRUE);

     // Make a temporary refArray and write that to the streamer
     TRefArray refArray ;
     TIterator* iter = MakeIterator() ; 
     TObject* tmpObj ; while ((tmpObj = iter->Next())) { 
       refArray.Add(tmpObj) ; 
     } 
     delete iter ; 

     refArray.Streamer(R__b) ;
     R__b.SetByteCount(R__c, kTRUE) ;
     
   }
}


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