/*****************************************************************************
 * Project: RooFit                                                           *
 * Package: RooFitCore                                                       *
 * @(#)root/roofitcore:$Id$
 * Authors:                                                                  *
 *   WV, Wouter Verkerke, UC Santa Barbara, verkerke@slac.stanford.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
// The RooWorkspace is a persistable container for RooFit projects. A workspace
// can contain and own variables, p.d.f.s, functions and datasets. All objects
// that live in the workspace are owned by the workspace. The import() method
// enforces consistency of objects upon insertion into the workspace (e.g. no
// duplicate object with the same name are allowed) and makes sure all objects
// in the workspace are connected to each other. Easy accessor methods like
// pdf(), var() and data() allow to refer to the contents of the workspace by
// object name. The entire RooWorkspace can be saved into a ROOT TFile and organises
// the consistent streaming of its contents without duplication.
// <p>
// If a RooWorkspace contains custom classes, i.e. classes not in the 
// ROOT distribution, portability of workspaces can be enhanced by
// storing the source code of those classes in the workspace as well.
// This process is also organized by the workspace through the
// importClassCode() method.
// END_HTML
//

#include "RooFit.h"
#include "RooWorkspace.h"
#include "RooAbsPdf.h"
#include "RooRealVar.h"
#include "RooCategory.h"
#include "RooAbsData.h"
#include "RooCmdConfig.h"
#include "RooMsgService.h"
#include "RooConstVar.h"
#include "RooResolutionModel.h"
#include "RooPlot.h"
#include "RooRandom.h"
#include "TInterpreter.h"
#include "TClassTable.h"
#include "TBaseClass.h"
#include "TSystem.h"
#include "TRegexp.h"
#include "RooFactoryWSTool.h"
#include "RooAbsStudy.h"
#include "RooTObjWrap.h"
#include "RooAbsOptTestStatistic.h"
#include "TROOT.h"
#include "TFile.h"
#include "TH1.h"
#include <map>
#include <string>
#include <list>
#include <set>

using namespace std ;


#if ROOT_VERSION_CODE <= ROOT_VERSION(5,19,02)
#include "Api.h"
#endif


#include "TClass.h"
#include "Riostream.h"
#include <string.h>
#include <assert.h>

ClassImp(RooWorkspace)
;

//_____________________________________________________________________________
ClassImp(RooWorkspace::CodeRepo)
;

//_____________________________________________________________________________
ClassImp(RooWorkspace::WSDir)
;

list<string> RooWorkspace::_classDeclDirList ;
list<string> RooWorkspace::_classImplDirList ;
string RooWorkspace::_classFileExportDir = ".wscode.%s.%s" ;
Bool_t RooWorkspace::_autoClass = kFALSE ;


//_____________________________________________________________________________
void RooWorkspace::addClassDeclImportDir(const char* dir) 
{
  // Add 'dir' to search path for class declaration (header) files, when
  // attempting to import class code with importClassClode()

  _classDeclDirList.push_back(dir) ;
}


//_____________________________________________________________________________
void RooWorkspace::addClassImplImportDir(const char* dir) 
{
  // Add 'dir' to search path for class implementation (.cxx) files, when
  // attempting to import class code with importClassClode()

  _classImplDirList.push_back(dir) ;
}


//_____________________________________________________________________________
void RooWorkspace::setClassFileExportDir(const char* dir) 
{
  // Specify the name of the directory in which embedded source
  // code is unpacked and compiled. The specified string may contain
  // one '%s' token which will be substituted by the workspace name

  if (dir) {
    _classFileExportDir = dir ;
  } else {
    _classFileExportDir = ".wscode.%s.%s" ;
  }
}


//_____________________________________________________________________________
void RooWorkspace::autoImportClassCode(Bool_t flag) 
{
  // If flag is true, source code of classes not the the ROOT distribution
  // is automatically imported if on object of such a class is imported
  // in the workspace
  _autoClass = flag ; 
}



//_____________________________________________________________________________
RooWorkspace::RooWorkspace() : _classes(this), _dir(0), _factory(0), _doExport(kFALSE), _openTrans(kFALSE)
{
  // Default constructor
}



//_____________________________________________________________________________
RooWorkspace::RooWorkspace(const char* name, const char* title) : 
  TNamed(name,title?title:name), _classes(this), _dir(0), _factory(0), _doExport(kFALSE), _openTrans(kFALSE)
{
  // Construct empty workspace with given name and title
}


RooWorkspace::RooWorkspace(const char* name, Bool_t doCINTExport)  : 
  TNamed(name,name), _classes(this), _dir(0), _factory(0), _doExport(kFALSE), _openTrans(kFALSE)
{
  // Construct empty workspace with given name and option to export reference to all workspace contents to a CINT namespace with the same name
  if (doCINTExport) {
    exportToCint(name) ;
  }
}


//_____________________________________________________________________________
RooWorkspace::RooWorkspace(const RooWorkspace& other) : 
  TNamed(other), _uuid(other._uuid), _classes(other._classes,this), _dir(0), _factory(0), _doExport(kFALSE), _openTrans(kFALSE)
{
  // Workspace copy constructor

  // Copy owned nodes
  other._allOwnedNodes.snapshot(_allOwnedNodes,kTRUE) ;

  // Copy datasets
  TIterator* iter = other._dataList.MakeIterator() ;
  TObject* data2 ;
  while((data2=iter->Next())) {
    _dataList.Add(data2->Clone()) ;
  }
  delete iter ;

  // Copy snapshots
  TIterator* iter2 = other._snapshots.MakeIterator() ;
  RooArgSet* snap ;
  while((snap=(RooArgSet*)iter2->Next())) {
    RooArgSet* snapClone = (RooArgSet*) snap->snapshot() ;
    snapClone->setName(snap->GetName()) ;
    _snapshots.Add(snapClone) ;
  }
  delete iter2 ;

  // Copy named sets
  for (map<string,RooArgSet>::const_iterator iter3 = other._namedSets.begin() ; iter3 != other._namedSets.end() ; ++iter3) {
    // Make RooArgSet with equivalent content of this workspace
    RooArgSet* tmp = (RooArgSet*) _allOwnedNodes.selectCommon(iter3->second) ;
    _namedSets[iter3->first].add(*tmp) ;
    delete tmp ;
  }

  // Copy generic objects
  TIterator* iter4 = other._genObjects.MakeIterator() ;
  TObject* gobj ;
  while((gobj=iter4->Next())) {
    _genObjects.Add(gobj->Clone()) ;
  }
  delete iter4 ;
  
}



//_____________________________________________________________________________
RooWorkspace::~RooWorkspace() 
{
  // Workspace destructor

  // Delete references to variables that were declared in CINT 
  if (_doExport) {
    unExport() ;
  }

  // Delete contents
  _dataList.Delete() ;
  if (_dir) {
    delete _dir ;
  }
  _snapshots.Delete() ;

  // WVE named sets too?

  _genObjects.Delete() ;
}


//_____________________________________________________________________________
Bool_t RooWorkspace::import(const char* fileSpec, 
			    const RooCmdArg& arg1, const RooCmdArg& arg2, const RooCmdArg& arg3, 
			    const RooCmdArg& arg4, const RooCmdArg& arg5, const RooCmdArg& arg6, 
			    const RooCmdArg& arg7, const RooCmdArg& arg8, const RooCmdArg& arg9) 
{
  // Import a RooAbsArg or RooAbsData set from a workspace in a file. Filespec should be constructed as "filename:wspacename:objectname"
  // The arguments will be passed on to the relevant RooAbsArg& or RooAbsData& import call

  // Parse file/workspace/objectname specification
  char buf[10240] ;
  strlcpy(buf,fileSpec,10240) ;
  char* filename = strtok(buf,":") ;
  char* wsname = strtok(0,":") ;
  char* objname = strtok(0,":") ;

  // Check that parsing was successful
  if (!filename||!wsname||!objname) {
    coutE(InputArguments) << "RooWorkspace(" << GetName() << ") ERROR in file specification, expecting for 'filename:wsname:objname'" << endl ;
    return kTRUE ;
  }

  // Check that file can be opened
  TFile* f = TFile::Open(filename) ;
  if (f==0) {
    coutE(InputArguments) << "RooWorkspace(" << GetName() << ") ERROR opening file " << filename << endl ;
    return 0 ;
  }

  // That that file contains workspace
  RooWorkspace* w = dynamic_cast<RooWorkspace*>(f->Get(wsname)) ;
  if (w==0) {
    coutE(InputArguments) << "RooWorkspace(" << GetName() << ") ERROR: No object named " << wsname << " in file " << filename 
			  << " or object is not a RooWorkspace" << endl ;
    return 0 ;
  }

  // Check that workspace contains object and forward to appropriate import method
  RooAbsArg* warg = w->arg(objname) ;
  if (warg) {
    Bool_t ret = import(*warg,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9) ;
    delete f ;
    return ret ;    
  }
  RooAbsData* wdata = w->data(objname) ;
  if (wdata) {
    Bool_t ret = import(*wdata,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9) ;
    delete f ;
    return ret ;    
  }

  coutE(InputArguments) << "RooWorkspace(" << GetName() << ") ERROR: No RooAbsArg or RooAbsData object named " << objname 
			<< " in workspace " << wsname << " in file " << filename << endl ;
  return kTRUE ;  
}


//_____________________________________________________________________________
Bool_t RooWorkspace::import(const RooArgSet& args,
			    const RooCmdArg& arg1, const RooCmdArg& arg2, const RooCmdArg& arg3, 
			    const RooCmdArg& arg4, const RooCmdArg& arg5, const RooCmdArg& arg6, 
			    const RooCmdArg& arg7, const RooCmdArg& arg8, const RooCmdArg& arg9) 
{
  // Import multiple RooAbsArg objects into workspace. For details on arguments see documentation
  // of import() method for single RooAbsArg

  TIterator* iter = args.createIterator() ;
  RooAbsArg* oneArg ;
  Bool_t ret(kFALSE) ;
  while((oneArg=(RooAbsArg*)iter->Next())) {
    ret |= import(*oneArg,arg1,arg2,arg3,arg4,arg5,arg6,arg7,arg8,arg9) ;
  }
  return ret ;
}



//_____________________________________________________________________________
Bool_t RooWorkspace::import(const RooAbsArg& inArg,
			    const RooCmdArg& arg1, const RooCmdArg& arg2, const RooCmdArg& arg3, 
			    const RooCmdArg& arg4, const RooCmdArg& arg5, const RooCmdArg& arg6, 
			    const RooCmdArg& arg7, const RooCmdArg& arg8, const RooCmdArg& arg9) 
{
  //  Import a RooAbsArg object, e.g. function, p.d.f or variable into the workspace. This import function clones the input argument and will
  //  own the clone. If a composite object is offered for import, e.g. a p.d.f with parameters and observables, the
  //  complete tree of objects is imported. If any of the _variables_ of a composite object (parameters/observables) are already 
  //  in the workspace the imported p.d.f. is connected to the already existing variables. If any of the _function_ objects (p.d.f, formulas) 
  //  to be imported already exists in the workspace an error message is printed and the import of the entire tree of objects is cancelled. 
  //  Several optional arguments can be provided to modify the import procedure.
  //
  //  Accepted arguments
  //  -------------------------------
  //  RenameConflictNodes(const char* suffix) -- Add suffix to branch node name if name conflicts with existing node in workspace
  //  RenameAllNodes(const char* suffix) -- Add suffix to all branch node names including top level node
  //  RenameAllVariables(const char* suffix) -- Add suffix to all variables names
  //  RenameAllVariablesExcept(const char* suffix, const char* exceptionList) -- Add suffix to all variables names, except ones listed
  //  RenameVariable(const char* inputName, const char* outputName) -- Rename variable as specified upon import.
  //  RecycleConflictNodes() -- If any of the function objects to be imported already exist in the name space, connect the
  //                            imported expression to the already existing nodes. WARNING: use with care! If function definitions
  //                            do not match, this alters the definition of your function upon import
  //  Silence() -- Do not issue any info message
  //
  //  The RenameConflictNodes, RenameNodes and RecycleConflictNodes arguments are mutually exclusive. The RenameVariable argument can be repeated
  //  as often as necessary to rename multiple variables. Alternatively, a single RenameVariable argument can be given with
  //  two comma separated lists.

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

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

  pc.defineString("conflictSuffix","RenameConflictNodes",0) ;
  pc.defineInt("renameConflictOrig","RenameConflictNodes",0,0) ;
  pc.defineString("allSuffix","RenameAllNodes",0) ;
  pc.defineString("allVarsSuffix","RenameAllVariables",0) ;
  pc.defineString("allVarsExcept","RenameAllVariables",1) ;
  pc.defineString("varChangeIn","RenameVar",0,"",kTRUE) ;
  pc.defineString("varChangeOut","RenameVar",1,"",kTRUE) ;
  pc.defineString("factoryTag","FactoryTag",0) ;
  pc.defineInt("useExistingNodes","RecycleConflictNodes",0,0) ;
  pc.defineInt("silence","Silence",0,0) ;
  pc.defineInt("noRecursion","NoRecursion",0,0) ;
  pc.defineMutex("RenameConflictNodes","RenameAllNodes") ;
  pc.defineMutex("RenameConflictNodes","RecycleConflictNodes") ;
  pc.defineMutex("RenameAllNodes","RecycleConflictNodes") ;
  pc.defineMutex("RenameVariable","RenameAllVariables") ;

  // Process and check varargs 
  pc.process(args) ;
  if (!pc.ok(kTRUE)) {
    return kTRUE ;
  }

  // Decode renaming logic into suffix string and boolean for conflictOnly mode
  const char* suffixC = pc.getString("conflictSuffix") ;
  const char* suffixA = pc.getString("allSuffix") ;
  const char* suffixV = pc.getString("allVarsSuffix") ;
  const char* exceptVars = pc.getString("allVarsExcept") ;
  const char* varChangeIn = pc.getString("varChangeIn") ;
  const char* varChangeOut = pc.getString("varChangeOut") ;
  Bool_t renameConflictOrig = pc.getInt("renameConflictOrig") ;
  Int_t useExistingNodes = pc.getInt("useExistingNodes") ;
  Int_t silence = pc.getInt("silence") ;
  Int_t noRecursion = pc.getInt("noRecursion") ;


  // Turn zero length strings into null pointers 
  if (suffixC && strlen(suffixC)==0) suffixC = 0 ;
  if (suffixA && strlen(suffixA)==0) suffixA = 0 ;

  Bool_t conflictOnly = suffixA ? kFALSE : kTRUE ;
  const char* suffix = suffixA ? suffixA : suffixC ;

  // Process any change in variable names 
  map<string,string> varMap ;
  if (strlen(varChangeIn)>0) {
    
    // Parse comma separated lists into map<string,string>
    char tmp[10240] ;
    strlcpy(tmp,varChangeIn,10240) ;
    list<string> tmpIn,tmpOut ;
    char* ptr = strtok(tmp,", ") ;
    while (ptr) {
      tmpIn.push_back(ptr) ;
      ptr = strtok(0,", ") ;
    }
    strlcpy(tmp,varChangeOut,10240) ;
    ptr = strtok(tmp,", ") ;
    while (ptr) {
      tmpOut.push_back(ptr) ;
      ptr = strtok(0,", ") ;
    }    
    list<string>::iterator iin = tmpIn.begin() ;
    list<string>::iterator iout = tmpOut.begin() ;
    for (;iin!=tmpIn.end() ; ++iin,++iout) {
      varMap[*iin]=*iout ;
    }       
  }

  // Process RenameAllVariables argument if specified  
  // First convert exception list if provided
  std::set<string> exceptVarNames ;
  char tmp[10240] ;
  if (exceptVars && strlen(exceptVars)) {
    strlcpy(tmp,exceptVars,10240) ;
    char* ptr = strtok(tmp,", ") ;
    while(ptr) {
      exceptVarNames.insert(ptr) ;
      ptr = strtok(0,", ") ;
    }
  }

  if (suffixV != 0 && strlen(suffixV)>0) {
    RooArgSet* vars = inArg.getVariables() ;
    TIterator* iter = vars->createIterator() ;
    RooAbsArg* v ;
    while((v=(RooAbsArg*)iter->Next())) {
      if (exceptVarNames.find(v->GetName())==exceptVarNames.end()) {
	varMap[v->GetName()] = Form("%s_%s",v->GetName(),suffixV) ;
      }
    }
    delete iter ;
    delete vars ;
  }
  
  // Scan for overlaps with current contents
  RooAbsArg* wsarg = _allOwnedNodes.find(inArg.GetName()) ;

  // Check for factory specification match
  const char* tagIn = inArg.getStringAttribute("factory_tag") ;
  const char* tagWs = wsarg ? wsarg->getStringAttribute("factory_tag") : 0 ;
  Bool_t factoryMatch = (tagIn && tagWs && !strcmp(tagIn,tagWs)) ;
  if (factoryMatch) {
    ((RooAbsArg&)inArg).setAttribute("RooWorkspace::Recycle") ;
  }

  if (!suffix && wsarg && !useExistingNodes && !(inArg.isFundamental() && varMap[inArg.GetName()]!="")) {
    if (!factoryMatch) {
      if (wsarg!=&inArg) {
	coutE(ObjectHandling) << "RooWorkSpace::import(" << GetName() << ") ERROR importing object named " << inArg.GetName() 
			      << ": another instance with same name already in the workspace and no conflict resolution protocol specified" << endl ;
	return kTRUE ;    
      } else {
	if (!silence) {
	  coutI(ObjectHandling) << "RooWorkSpace::import(" << GetName() << ") Object " << inArg.GetName() << " is already in workspace!" << endl ;
	}
	return kTRUE ;    
      }
    } else {
      coutI(ObjectHandling) << "RooWorkSpace::import(" << GetName() << ") Recycling existing object " << inArg.GetName() << " created with identical factory specification" << endl ;
    }
  }

  // Make list of conflicting nodes
  RooArgSet conflictNodes ;
  RooArgSet branchSet ;
  if (noRecursion) {
    branchSet.add(inArg) ;
  } else {
    inArg.branchNodeServerList(&branchSet) ;
  }
  TIterator* iter = branchSet.createIterator() ;
  RooAbsArg* branch ;
  while ((branch=(RooAbsArg*)iter->Next())) {
    RooAbsArg* wsbranch = _allOwnedNodes.find(branch->GetName()) ;
    if (wsbranch && wsbranch!=branch && !branch->getAttribute("RooWorkspace::Recycle") && !useExistingNodes) {
      conflictNodes.add(*branch) ;
    }
  }
  delete iter ;
  
  // Terminate here if there are conflicts and no resolution protocol
  if (conflictNodes.getSize()>0 && !suffix && !useExistingNodes) {
      coutE(ObjectHandling) << "RooWorkSpace::import(" << GetName() << ") ERROR object named " << inArg.GetName() << ": component(s) " 
	   << conflictNodes << " already in the workspace and no conflict resolution protocol specified" << endl ;      
      return kTRUE ;
  }
    
  // Now create a working copy of the incoming object tree
  RooArgSet* cloneSet = (RooArgSet*) RooArgSet(inArg).snapshot(noRecursion==kFALSE) ;
  RooAbsArg* cloneTop = cloneSet->find(inArg.GetName()) ;  

  // Mark all nodes for renaming if we are not in conflictOnly mode
  if (!conflictOnly) {
    conflictNodes.removeAll() ;
    conflictNodes.add(branchSet) ;
  }

  // Mark nodes that are to be renamed with special attribute
  string topName2 = cloneTop->GetName() ;
  if (!renameConflictOrig) {
    // Mark all nodes to be imported for renaming following conflict resolution protocol
    TIterator* citer = conflictNodes.createIterator() ;
    RooAbsArg* cnode ;
    while ((cnode=(RooAbsArg*)citer->Next())) {
      RooAbsArg* cnode2 = cloneSet->find(cnode->GetName()) ;
      string origName = cnode2->GetName() ;
      cnode2->SetName(Form("%s_%s",cnode2->GetName(),suffix)) ;
      cnode2->SetTitle(Form("%s (%s)",cnode2->GetTitle(),suffix)) ;
      string tag = Form("ORIGNAME:%s",origName.c_str()) ;
      cnode2->setAttribute(tag.c_str()) ;
      if (!cnode2->getStringAttribute("origName")) {
	string tag2 = Form("%s",origName.c_str()) ;
	cnode2->setStringAttribute("origName",tag2.c_str()) ;
      }
      
      // Save name of new top level node for later use
      if (cnode2==cloneTop) {
	topName2 = cnode2->GetName() ;      
      }
      
      if (!silence) {
	coutI(ObjectHandling) << "RooWorkspace::import(" << GetName() 
			      << ") Resolving name conflict in workspace by changing name of imported node  " 
			      << origName << " to " << cnode2->GetName() << endl ;
      }
    }  
    delete citer ;
  } else {

    // Rename all nodes already in the workspace to 'clear the way' for the imported nodes
    TIterator* citer = conflictNodes.createIterator() ;
    RooAbsArg* cnode ;
    while ((cnode=(RooAbsArg*)citer->Next())) {

      string origName = cnode->GetName() ;
      RooAbsArg* wsnode = _allOwnedNodes.find(origName.c_str()) ;      
      if (wsnode) {	
	
	if (!wsnode->getStringAttribute("origName")) {
	  wsnode->setStringAttribute("origName",wsnode->GetName()) ;
	}
	
	if (!_allOwnedNodes.find(Form("%s_%s",cnode->GetName(),suffix))) {
	  wsnode->SetName(Form("%s_%s",cnode->GetName(),suffix)) ;
	  wsnode->SetTitle(Form("%s (%s)",cnode->GetTitle(),suffix)) ;
	} else {	  
	  // Name with suffix already taken, add additional suffix
	  Int_t n=1 ;
	  while (true) {
	    string newname = Form("%s_%s_%d",cnode->GetName(),suffix,n) ;
	    if (!_allOwnedNodes.find(newname.c_str())) {
	      wsnode->SetName(newname.c_str()) ;
	      wsnode->SetTitle(Form("%s (%s %d)",cnode->GetTitle(),suffix,n)) ;
	      break ;
	    }
	    n++ ;
	  }
	}
	if (!silence) {
	  coutI(ObjectHandling) << "RooWorkspace::import(" << GetName() 
				<< ") Resolving name conflict in workspace by changing name of original node " 
				<< origName << " to " << wsnode->GetName() << endl ;
	}
      } else {
	coutW(ObjectHandling) << "RooWorkspce::import(" << GetName() << ") Internal error: expected to find existing node " 
			      << origName << " to be renamed, but didn't find it..." << endl ;
      }
      
    }  
    delete citer ;

  }

  // Process any change in variable names 
  if (strlen(varChangeIn)>0 || (suffixV && strlen(suffixV)>0)) {
    
    // Process all changes in variable names
    TIterator* cliter = cloneSet->createIterator() ;
    RooAbsArg* cnode ;
    while ((cnode=(RooAbsArg*)cliter->Next())) {
      
      if (varMap.find(cnode->GetName())!=varMap.end()) { 	
	string origName = cnode->GetName() ;
	cnode->SetName(varMap[cnode->GetName()].c_str()) ;
	string tag = Form("ORIGNAME:%s",origName.c_str()) ;
	cnode->setAttribute(tag.c_str()) ;
	if (!cnode->getStringAttribute("origName")) {
	  string tag2 = Form("%s",origName.c_str()) ;
	  cnode->setStringAttribute("origName",tag2.c_str()) ;
	}

	if (!silence) {
	  coutI(ObjectHandling) << "RooWorkspace::import(" << GetName() << ") Changing name of variable " 
				<< origName << " to " << cnode->GetName() << " on request" << endl ;
	}

	if (cnode==cloneTop) {
	  topName2 = cnode->GetName() ;
	}

      }    
    }
    delete cliter ;
  }
  
  // Now clone again with renaming effective
  RooArgSet* cloneSet2 = (RooArgSet*) RooArgSet(*cloneTop).snapshot(noRecursion==kFALSE) ;
  RooAbsArg* cloneTop2 = cloneSet2->find(topName2.c_str()) ;

  // Make final check list of conflicting nodes
  RooArgSet conflictNodes2 ;
  RooArgSet branchSet2 ;
  //inArg.branchNodeServerList(&branchSet) ; // WVE not needed
  TIterator* iter2 = branchSet2.createIterator() ;
  RooAbsArg* branch2 ;
  while ((branch2=(RooAbsArg*)iter2->Next())) {
    if (_allOwnedNodes.find(branch2->GetName())) {
      conflictNodes2.add(*branch2) ;
    }
  }
  delete iter2 ;

  // Terminate here if there are conflicts and no resolution protocol
  if (conflictNodes2.getSize()) {
    coutE(ObjectHandling) << "RooWorkSpace::import(" << GetName() << ") ERROR object named " << inArg.GetName() << ": component(s) " 
			  << conflictNodes2 << " cause naming conflict after conflict resolution protocol was executed" << endl ;      
    return kTRUE ;
  }
    
  // Print a message for each imported node
  iter = cloneSet2->createIterator() ;
  
  // Perform any auxiliary imports at this point
  RooAbsArg* node ;
  while((node=(RooAbsArg*)iter->Next())) {
    if (node->importWorkspaceHook(*this)) {
      coutE(ObjectHandling) << "RooWorkSpace::import(" << GetName() << ") ERROR object named " << node->GetName() 
			    << " has an error in importing in one or more of its auxiliary objects, aborting" << endl ;
      return kTRUE ;
    }
  }
  iter->Reset() ;

  if (cloneSet2->getSize()+_allOwnedNodes.getSize() > 999) _allOwnedNodes.setHashTableSize(1000);

  RooArgSet recycledNodes ;
  RooArgSet nodesToBeDeleted ;
  while((node=(RooAbsArg*)iter->Next())) {

    if (_autoClass) {
      if (!_classes.autoImportClass(node->IsA())) {
	coutW(ObjectHandling) << "RooWorkspace::import(" << GetName() << ") WARNING: problems import class code of object " 
			      << node->IsA()->GetName() << "::" << node->GetName() << ", reading of workspace will require external definition of class" << endl ;
      }
    }

    // Point expensiveObjectCache to copy in this workspace
    RooExpensiveObjectCache& oldCache = node->expensiveObjectCache() ;
    node->setExpensiveObjectCache(_eocache) ;    
    _eocache.importCacheObjects(oldCache,node->GetName(),kTRUE) ;

    // Check if node is already in workspace (can only happen for variables or identical instances, unless RecycleConflictNodes is specified)
    RooAbsArg* wsnode = _allOwnedNodes.find(node->GetName()) ;

    if (wsnode) {
      // Do not import node, add not to list of nodes that require reconnection
      if (!silence && useExistingNodes) {
	coutI(ObjectHandling) << "RooWorkspace::import(" << GetName() << ") using existing copy of " << node->IsA()->GetName() 
			      << "::" << node->GetName() << " for import of " << cloneTop2->IsA()->GetName() << "::" 
			      << cloneTop2->GetName() << endl ;      
      }
      recycledNodes.add(*_allOwnedNodes.find(node->GetName())) ;

      // Delete clone of incoming node
      nodesToBeDeleted.addOwned(*node) ;

      //cout << "WV: recycling existing node " << existingNode << " = " << existingNode->GetName() << " for imported node " << node << endl ;
      
    } else {
      // Import node
      if (!silence) {
	coutI(ObjectHandling) << "RooWorkspace::import(" << GetName() << ") importing " << node->IsA()->GetName() << "::" 
			      << node->GetName() << endl ;
      }
      _allOwnedNodes.addOwned(*node) ;
      if (_openTrans) {
	_sandboxNodes.add(*node) ;
      } else {
	if (_dir && node->IsA() != RooConstVar::Class()) {	
	  _dir->InternalAppend(node) ;
	}
	if (_doExport && node->IsA() != RooConstVar::Class()) {
	  exportObj(node) ;
	}
      }
    }
  }

  // Release working copy
  // no need to do a safe list since it was generated from a snapshot 
  // just take ownership and delte elements by hand
  cloneSet->releaseOwnership() ;
  RooFIter cloneSet_iter = cloneSet->fwdIterator() ;
  RooAbsArg* cloneNode ;
  while ((cloneNode=(RooAbsArg*)cloneSet_iter.next())) {
     delete cloneNode;
  }
  delete cloneSet ;

  // Reconnect any nodes that need to be
  if (recycledNodes.getSize()>0) {
    iter->Reset() ;
    while((node=(RooAbsArg*)iter->Next())) {
      node->redirectServers(recycledNodes) ;
    }
  }
  delete iter ;

  cloneSet2->releaseOwnership() ;
  delete cloneSet2 ;  

  return kFALSE ;
}



//_____________________________________________________________________________
Bool_t RooWorkspace::import(RooAbsData& inData, 
			    const RooCmdArg& arg1, const RooCmdArg& arg2, const RooCmdArg& arg3, 
			    const RooCmdArg& arg4, const RooCmdArg& arg5, const RooCmdArg& arg6, 
			    const RooCmdArg& arg7, const RooCmdArg& arg8, const RooCmdArg& arg9) 

{
  //  Import a dataset (RooDataSet or RooDataHist) into the work space. The workspace will contain a copy of the data
  //  The dataset and its variables can be renamed upon insertion with the options below
  //
  //  Accepted arguments
  //  -------------------------------
  //  Rename(const char* suffix) -- Rename dataset upon insertion
  //  RenameVariable(const char* inputName, const char* outputName) -- Change names of observables in dataset upon insertion

  coutI(ObjectHandling) << "RooWorkspace::import(" << GetName() << ") importing dataset " << inData.GetName() << endl ;

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

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

  pc.defineString("dsetName","Rename",0,"") ;
  pc.defineString("varChangeIn","RenameVar",0,"",kTRUE) ;
  pc.defineString("varChangeOut","RenameVar",1,"",kTRUE) ;
  pc.defineInt("embedded","Embedded",0,0) ;

  // Process and check varargs 
  pc.process(args) ;
  if (!pc.ok(kTRUE)) {
    return kTRUE ;
  }

  // Decode renaming logic into suffix string and boolean for conflictOnly mode
  const char* dsetName = pc.getString("dsetName") ;
  const char* varChangeIn = pc.getString("varChangeIn") ;
  const char* varChangeOut = pc.getString("varChangeOut") ;
  Bool_t embedded = pc.getInt("embedded") ;

  // Transform emtpy string into null pointer
  if (dsetName && strlen(dsetName)==0) {
    dsetName=0 ;
  }
  
  RooLinkedList& dataList = embedded ? _embeddedDataList : _dataList ;

  // Check that no dataset with target name already exists
  if (dsetName && dataList.FindObject(dsetName)) {
    coutE(ObjectHandling) << "RooWorkspace::import(" << GetName() << ") ERROR dataset with name " << dsetName << " already exists in workspace, import aborted" << endl ;
    return kTRUE ;
  }
  if (!dsetName && dataList.FindObject(inData.GetName())) {
    coutE(ObjectHandling) << "RooWorkspace::import(" << GetName() << ") ERROR dataset with name " << inData.GetName() << " already exists in workspace, import aborted" << endl ;
    return kTRUE ;
  }

  // Rename dataset if required
  RooAbsData* clone ;
  if (dsetName) {
    coutI(ObjectHandling) << "RooWorkSpace::import(" << GetName() << ") changing name of dataset from  " << inData.GetName() << " to " << dsetName << endl ;
    clone = (RooAbsData*) inData.Clone(dsetName) ;
  } else {
    clone = (RooAbsData*) inData.Clone(inData.GetName()) ;
  }


  // Process any change in variable names 
  if (strlen(varChangeIn)>0) {
    
    // Parse comma separated lists of variable name changes
    char tmp[10240] ;
    strlcpy(tmp,varChangeIn,10240) ;
    list<string> tmpIn,tmpOut ;
    char* ptr = strtok(tmp,",") ;
    while (ptr) {
      tmpIn.push_back(ptr) ;
      ptr = strtok(0,",") ;
    }
    strlcpy(tmp,varChangeOut,10240) ;
    ptr = strtok(tmp,",") ;
    while (ptr) {
      tmpOut.push_back(ptr) ;
      ptr = strtok(0,",") ;
    }    
    list<string>::iterator iin = tmpIn.begin() ;
    list<string>::iterator iout = tmpOut.begin() ;

    for (; iin!=tmpIn.end() ; ++iin,++iout) {
      coutI(ObjectHandling) << "RooWorkSpace::import(" << GetName() << ") changing name of dataset observable " << *iin << " to " << *iout << endl ;
      clone->changeObservableName(iin->c_str(),iout->c_str()) ;
    }
  }

  // Now import the dataset observables, unless dataset is embedded
  RooAbsArg* carg ;
  if (!embedded) {
    TIterator* iter = clone->get()->createIterator() ;
    while((carg=(RooAbsArg*)iter->Next())) {
      if (!arg(carg->GetName())) {
	import(*carg) ;
      }
    }
    delete iter ;
  }

  dataList.Add(clone) ;
  if (_dir) {	
    _dir->InternalAppend(clone) ;
  }
  if (_doExport) {
    exportObj(clone) ;
  }

  // Set expensive object cache of dataset internal buffers to that of workspace
  RooFIter iter2 = clone->get()->fwdIterator() ;
  while ((carg=iter2.next())) {
    carg->setExpensiveObjectCache(expensiveObjectCache()) ;
  }


  return kFALSE ;
}




//_____________________________________________________________________________
Bool_t RooWorkspace::defineSet(const char* name, const RooArgSet& aset, Bool_t importMissing) 
{
  // Define a named RooArgSet with given constituents. If importMissing is true, any constituents
  // of aset that are not in the workspace will be imported, otherwise an error is returned
  // for missing components

  // Check if set was previously defined, if so print warning
  map<string,RooArgSet>::iterator i = _namedSets.find(name) ;
  if (i!=_namedSets.end()) {
    coutW(InputArguments) << "RooWorkspace::defineSet(" << GetName() << ") WARNING redefining previously defined named set " << name << endl ;
  }

  RooArgSet wsargs ;

  // Check all constituents of provided set
  TIterator* iter = aset.createIterator() ;
  RooAbsArg* sarg ;
  while((sarg=(RooAbsArg*)iter->Next())) {
    // If missing, either import or report error
    if (!arg(sarg->GetName())) {
      if (importMissing) {
	import(*sarg) ;
      } else {
	coutE(InputArguments) << "RooWorkspace::defineSet(" << GetName() << ") ERROR set constituent \"" << sarg->GetName() 
			      << "\" is not in workspace and importMissing option is disabled" << endl ;
	return kTRUE ;
      }
    }
    wsargs.add(*arg(sarg->GetName())) ;    
  }
  delete iter ;

  // Install named set
  _namedSets[name].removeAll() ;
  _namedSets[name].add(wsargs) ;
   
  return kFALSE ;
}




//_____________________________________________________________________________
Bool_t RooWorkspace::defineSet(const char* name, const char* contentList) 
{
  // Define a named set in the work space through a comma separated list of
  // names of objects already in the workspace

  // Check if set was previously defined, if so print warning
  map<string,RooArgSet>::iterator i = _namedSets.find(name) ;
  if (i!=_namedSets.end()) {
    coutW(InputArguments) << "RooWorkspace::defineSet(" << GetName() << ") WARNING redefining previously defined named set " << name << endl ;
  }

  RooArgSet wsargs ;

  // Check all constituents of provided set
  char buf[10240] ;
  strlcpy(buf,contentList,10240) ;
  char* token = strtok(buf,",") ;
  while(token) {
    // If missing, either import or report error
    if (!arg(token)) {
      coutE(InputArguments) << "RooWorkspace::defineSet(" << GetName() << ") ERROR proposed set constituent \"" << token
			    << "\" is not in workspace" << endl ;
      return kTRUE ;
    }
    wsargs.add(*arg(token)) ;    
    token = strtok(0,",") ;
  }

  // Install named set
  _namedSets[name].removeAll() ;
  _namedSets[name].add(wsargs) ;
   
  return kFALSE ;
}




//_____________________________________________________________________________
Bool_t RooWorkspace::extendSet(const char* name, const char* newContents) 
{
  // Define a named set in the work space through a comma separated list of
  // names of objects already in the workspace

  RooArgSet wsargs ;

  // Check all constituents of provided set
  char buf[10240] ;
  strlcpy(buf,newContents,10240) ;
  char* token = strtok(buf,",") ;
  while(token) {
    // If missing, either import or report error
    if (!arg(token)) {
      coutE(InputArguments) << "RooWorkspace::defineSet(" << GetName() << ") ERROR proposed set constituent \"" << token
			    << "\" is not in workspace" << endl ;
      return kTRUE ;
    }
    wsargs.add(*arg(token)) ;    
    token = strtok(0,",") ;
  }

  // Extend named set
  _namedSets[name].add(wsargs,kTRUE) ;
   
  return kFALSE ;
}



//_____________________________________________________________________________
const RooArgSet* RooWorkspace::set(const char* name) 
{
  // Return pointer to previously defined named set with given nmame
  // If no such set is found a null pointer is returned

  map<string,RooArgSet>::iterator i = _namedSets.find(name) ;
  return (i!=_namedSets.end()) ? &(i->second) : 0 ;
}




//_____________________________________________________________________________
Bool_t RooWorkspace::renameSet(const char* name, const char* newName) 
{
  // Rename set to a new name

  // First check if set exists
  if (!set(name)) {
    coutE(InputArguments) << "RooWorkspace::renameSet(" << GetName() << ") ERROR a set with name " << name
			  << " does not exist" << endl ;
    return kTRUE ;
  }

  // Check if no set exists with new name
  if (set(newName)) {
    coutE(InputArguments) << "RooWorkspace::renameSet(" << GetName() << ") ERROR a set with name " << newName
			  << " already exists" << endl ;
    return kTRUE ;
  }

  // Copy entry under 'name' to 'newName'
  _namedSets[newName].add(_namedSets[name]) ;

  // Remove entry under old name
  _namedSets.erase(name) ;

  return kFALSE ;
}




//_____________________________________________________________________________
Bool_t RooWorkspace::removeSet(const char* name) 
{
  // Remove a named set from the workspace

  // First check if set exists
  if (!set(name)) {
    coutE(InputArguments) << "RooWorkspace::removeSet(" << GetName() << ") ERROR a set with name " << name
			  << " does not exist" << endl ;
    return kTRUE ;
  }

  // Remove set with given name
  _namedSets.erase(name) ;

  return kFALSE ;
}




//_____________________________________________________________________________
Bool_t RooWorkspace::startTransaction() 
{
  // Open an import transaction operations. Returns kTRUE if successful, kFALSE
  // if there is already an ongoing transaction

  // Check that there was no ongoing transaction
  if (_openTrans) {
    return kFALSE ;
  } 

  // Open transaction
  _openTrans = kTRUE ;
  return kTRUE ;
}




//_____________________________________________________________________________
Bool_t RooWorkspace::cancelTransaction() 
{
  // Cancel an ongoing import transaction. All objects imported since startTransaction()
  // will be removed and the transaction will be terminated. Return kTRUE if cancel operation
  // succeeds, return kFALSE if there was no open transaction
  
  // Check that there is an ongoing transaction
  if (!_openTrans) {
    return kFALSE ;
  }

  // Delete all objects in the sandbox
  TIterator* iter = _sandboxNodes.createIterator() ;
  RooAbsArg* tmpArg ;
  while((tmpArg=(RooAbsArg*)iter->Next())) {
    _allOwnedNodes.remove(*tmpArg) ;
  }
  delete iter ;
  _sandboxNodes.removeAll() ;
  
  // Mark transaction as finished
  _openTrans = kFALSE ;

  return kTRUE ;
}

Bool_t RooWorkspace::commitTransaction() 
{
  // Commit an ongoing import transaction. Returns kTRUE if commit succeeded,
  // return kFALSE if there was no ongoing transaction

  // Check that there is an ongoing transaction
  if (!_openTrans) {
    return kFALSE ;
  }

  // Publish sandbox nodes in directory and/or CINT if requested 
  TIterator* iter = _sandboxNodes.createIterator() ;
  RooAbsArg* sarg ;
  while((sarg=(RooAbsArg*)iter->Next())) {
    if (_dir && sarg->IsA() != RooConstVar::Class()) {	
      _dir->InternalAppend(sarg) ;
    }
    if (_doExport && sarg->IsA() != RooConstVar::Class()) {
      exportObj(sarg) ;
    }    
  }
  delete iter ;

  // Remove all committed objects from the sandbox
  _sandboxNodes.removeAll() ;

  // Mark transaction as finished
  _openTrans = kFALSE ;

  return kTRUE ;
}




//_____________________________________________________________________________
Bool_t RooWorkspace::importClassCode(TClass* theClass, Bool_t doReplace) 
{
  return _classes.autoImportClass(theClass,doReplace) ;
}



//_____________________________________________________________________________
Bool_t RooWorkspace::importClassCode(const char* pat, Bool_t doReplace)  
{
  // Inport code of all classes in the workspace that have a class name
  // that matches pattern 'pat' and which are not found to be part of
  // the standard ROOT distribution. If doReplace is true any existing
  // class code saved in the workspace is replaced

  Bool_t ret(kTRUE) ;

  TRegexp re(pat,kTRUE) ;
  TIterator* iter = componentIterator() ;
  RooAbsArg* carg ;
  while((carg=(RooAbsArg*)iter->Next())) {
    TString className = carg->IsA()->GetName() ;
    if (className.Index(re)>=0 && !_classes.autoImportClass(carg->IsA(),doReplace)) {
      coutW(ObjectHandling) << "RooWorkspace::import(" << GetName() << ") WARNING: problems import class code of object " 
			    << carg->IsA()->GetName() << "::" << carg->GetName() << ", reading of workspace will require external definition of class" << endl ;
      ret = kFALSE ;
    }
  }  
  delete iter ;

  return ret ;
}





//_____________________________________________________________________________
Bool_t RooWorkspace::saveSnapshot(const char* name, const char* paramNames) 
{
  // Save snapshot of values and attributes (including "Constant") of parameters 'params'
  // If importValues is FALSE, the present values from the object in the workspace are
  // saved. If importValues is TRUE, the values of the objects passed in the 'params'
  // argument are saved

  return saveSnapshot(name,argSet(paramNames),kFALSE) ;
}





//_____________________________________________________________________________
Bool_t RooWorkspace::saveSnapshot(const char* name, const RooArgSet& params, Bool_t importValues) 
{
  // Save snapshot of values and attributes (including "Constant") of parameters 'params'
  // If importValues is FALSE, the present values from the object in the workspace are
  // saved. If importValues is TRUE, the values of the objects passed in the 'params'
  // argument are saved

  RooArgSet* actualParams = (RooArgSet*) _allOwnedNodes.selectCommon(params) ;
  RooArgSet* snapshot = (RooArgSet*) actualParams->snapshot() ;
  delete actualParams ;

  snapshot->setName(name) ;

  if (importValues) {
    *snapshot = params ;
  }

  RooArgSet* oldSnap = (RooArgSet*) _snapshots.FindObject(name) ;
  if (oldSnap) {
    coutI(ObjectHandling) << "RooWorkspace::saveSnaphot(" << GetName() << ") replacing previous snapshot with name " << name << endl ;
    _snapshots.Remove(oldSnap) ;
    delete oldSnap ;
  }

  _snapshots.Add(snapshot) ;

  return kTRUE ;
}




//_____________________________________________________________________________
Bool_t RooWorkspace::loadSnapshot(const char* name) 
{
  // Load the values and attributes of the parameters in the snapshot saved with
  // the given name

  RooArgSet* snap = (RooArgSet*) _snapshots.find(name) ;
  if (!snap) {
    coutE(ObjectHandling) << "RooWorkspace::loadSnapshot(" << GetName() << ") no snapshot with name " << name << " is available" << endl ;
    return kFALSE ;
  }

  RooArgSet* actualParams = (RooArgSet*) _allOwnedNodes.selectCommon(*snap) ;
  *actualParams = *snap ;
  delete actualParams ;

  return kTRUE ;
}


//_____________________________________________________________________________
const RooArgSet* RooWorkspace::getSnapshot(const char* name) const
{
  // Return the RooArgSet containgin a snapshot of variables contained in the workspace
  //
  // Note that the variables of the objects in the snapshots are _copies_ of the
  // variables in the workspace. To load the values of a snapshot in the workspace
  // variables use loadSnapshot() instead

  RooArgSet* snap = (RooArgSet*) _snapshots.find(name) ;
  if (!snap) {
    coutE(ObjectHandling) << "RooWorkspace::loadSnapshot(" << GetName() << ") no snapshot with name " << name << " is available" << endl ;
    return 0 ;
  }

  return snap ;
}



// //_____________________________________________________________________________
// RooAbsPdf* RooWorkspace::joinPdf(const char* jointPdfName, const char* indexName, const char* inputMapping) 
// {
//   // Join given list of p.d.f.s into a simultaneous p.d.f with given name. If the named index category
//   // does not exist, it is created. 
//   //
//   //  Example : joinPdf("simPdf","expIndex","A=pdfA,B=pdfB") ;
//   //
//   //            will return a RooSimultaneous named 'simPdf' with index category 'expIndex' with
//   //            state names A and B. Pdf 'pdfA' will be associated with state A and pdf 'pdfB'
//   //            will be associated with state B
//   //
//   return 0 ;
// }

// //_____________________________________________________________________________
// RooAbsData* RooWorkspace::joinData(const char* jointDataName, const char* indexName, const char* inputMapping) 
// {
//   // Join given list of dataset into a joint dataset for use with a simultaneous pdf
//   // (as e.g. created by joingPdf"
//   //
//   //  Example : joinData("simData","expIndex","A=dataA,B=dataB") ;
//   //
//   //            will return a RooDataSet named 'simData' that consist of the entries of both
//   //            dataA and dataB. An extra category column 'expIndex' is added that labels
//   //            each entry with state 'A' and 'B' to indicate the originating dataset
//   return 0 ;
// }


//_____________________________________________________________________________
RooAbsPdf* RooWorkspace::pdf(const char* name) const
{ 
  // Retrieve p.d.f (RooAbsPdf) with given name. A null pointer is returned if not found

  return dynamic_cast<RooAbsPdf*>(_allOwnedNodes.find(name)) ; 
}


//_____________________________________________________________________________
RooAbsReal* RooWorkspace::function(const char* name) const 
{ 
  // Retrieve function (RooAbsReal) with given name. Note that all RooAbsPdfs are also RooAbsReals. A null pointer is returned if not found.

  return dynamic_cast<RooAbsReal*>(_allOwnedNodes.find(name)) ; 
}


//_____________________________________________________________________________
RooRealVar* RooWorkspace::var(const char* name) const
{ 
  // Retrieve real-valued variable (RooRealVar) with given name. A null pointer is returned if not found

  return dynamic_cast<RooRealVar*>(_allOwnedNodes.find(name)) ; 
}


//_____________________________________________________________________________
RooCategory* RooWorkspace::cat(const char* name) const
{ 
  // Retrieve discrete variable (RooCategory) with given name. A null pointer is returned if not found

  return dynamic_cast<RooCategory*>(_allOwnedNodes.find(name)) ; 
}


//_____________________________________________________________________________
RooAbsCategory* RooWorkspace::catfunc(const char* name) const
{
  // Retrieve discrete function (RooAbsCategory) with given name. A null pointer is returned if not found
  return dynamic_cast<RooAbsCategory*>(_allOwnedNodes.find(name)) ; 
}



//_____________________________________________________________________________
RooAbsArg* RooWorkspace::arg(const char* name) const
{
  // Return RooAbsArg with given name. A null pointer is returned if none is found.
  return _allOwnedNodes.find(name) ;
}



//_____________________________________________________________________________
RooArgSet RooWorkspace::argSet(const char* nameList) const
{
  // Return set of RooAbsArgs matching to given list of names
  RooArgSet ret ;

  char tmp[10240] ;
  strlcpy(tmp,nameList,10240) ;
  char* token = strtok(tmp,",") ;
  while(token) {
    RooAbsArg* oneArg = arg(token) ;
    if (oneArg) {
      ret.add(*oneArg) ;
    } else {
      coutE(InputArguments) << " RooWorkspace::argSet(" << GetName() << ") no RooAbsArg named \"" << token << "\" in workspace" << endl ;
    }
    token = strtok(0,",") ; 
  }
  return ret ;
}



//_____________________________________________________________________________
RooAbsArg* RooWorkspace::fundArg(const char* name) const
{
  // Return fundamental (i.e. non-derived) RooAbsArg with given name. Fundamental types
  // are e.g. RooRealVar, RooCategory. A null pointer is returned if none is found.
  RooAbsArg* tmp = arg(name) ;
  if (!tmp) {
    return 0 ;
  }
  return tmp->isFundamental() ? tmp : 0 ;
}



//_____________________________________________________________________________
RooAbsData* RooWorkspace::data(const char* name) const
{
  // Retrieve dataset (binned or unbinned) with given name. A null pointer is returned if not found

  return (RooAbsData*)_dataList.FindObject(name) ;
}


//_____________________________________________________________________________
RooAbsData* RooWorkspace::embeddedData(const char* name) const
{
  // Retrieve dataset (binned or unbinned) with given name. A null pointer is returned if not found

  return (RooAbsData*)_embeddedDataList.FindObject(name) ;
}




//_____________________________________________________________________________
RooArgSet RooWorkspace::allVars() const
{
  // Return set with all variable objects
  RooArgSet ret ;

  // Split list of components in pdfs, functions and variables
  TIterator* iter = _allOwnedNodes.createIterator() ;
  RooAbsArg* parg ;
  while((parg=(RooAbsArg*)iter->Next())) {
    if (parg->IsA()->InheritsFrom(RooRealVar::Class())) {
      ret.add(*parg) ;
    }
  }
  delete iter ;

  return ret ;
}


//_____________________________________________________________________________
RooArgSet RooWorkspace::allCats() const
{
  // Return set with all category objects
  RooArgSet ret ;

  // Split list of components in pdfs, functions and variables
  TIterator* iter = _allOwnedNodes.createIterator() ;
  RooAbsArg* parg ;
  while((parg=(RooAbsArg*)iter->Next())) {
    if (parg->IsA()->InheritsFrom(RooCategory::Class())) {
      ret.add(*parg) ;
    }
  }
  delete iter ;

  return ret ;
}



//_____________________________________________________________________________
RooArgSet RooWorkspace::allFunctions() const
{
  // Return set with all function objects
  RooArgSet ret ;

  // Split list of components in pdfs, functions and variables
  TIterator* iter = _allOwnedNodes.createIterator() ;
  RooAbsArg* parg ;
  while((parg=(RooAbsArg*)iter->Next())) {
    if (parg->IsA()->InheritsFrom(RooAbsReal::Class()) && 
	!parg->IsA()->InheritsFrom(RooAbsPdf::Class()) && 
	!parg->IsA()->InheritsFrom(RooConstVar::Class()) && 
	!parg->IsA()->InheritsFrom(RooRealVar::Class())) {
      ret.add(*parg) ;
    }
  }

  return ret ;
}


//_____________________________________________________________________________
RooArgSet RooWorkspace::allCatFunctions() const
{
  // Return set with all category function objects
  RooArgSet ret ;

  // Split list of components in pdfs, functions and variables
  TIterator* iter = _allOwnedNodes.createIterator() ;
  RooAbsArg* parg ;
  while((parg=(RooAbsArg*)iter->Next())) {  
    if (parg->IsA()->InheritsFrom(RooAbsCategory::Class()) && 
	!parg->IsA()->InheritsFrom(RooCategory::Class())) {
      ret.add(*parg) ;
    }
  }
  return ret ;
}



//_____________________________________________________________________________
RooArgSet RooWorkspace::allResolutionModels() const
{
  // Return set with all resolution model objects
  RooArgSet ret ;

  // Split list of components in pdfs, functions and variables
  TIterator* iter = _allOwnedNodes.createIterator() ;
  RooAbsArg* parg ;
  while((parg=(RooAbsArg*)iter->Next())) {  
    if (parg->IsA()->InheritsFrom(RooResolutionModel::Class())) {
      if (!((RooResolutionModel*)parg)->isConvolved()) {
	ret.add(*parg) ;
      }
    }
  }
  return ret ;
}


//_____________________________________________________________________________
RooArgSet RooWorkspace::allPdfs() const
{
  // Return set with all probability density function objects
  RooArgSet ret ;

  // Split list of components in pdfs, functions and variables
  TIterator* iter = _allOwnedNodes.createIterator() ;
  RooAbsArg* parg ;
  while((parg=(RooAbsArg*)iter->Next())) {  
    if (parg->IsA()->InheritsFrom(RooAbsPdf::Class()) &&
	!parg->IsA()->InheritsFrom(RooResolutionModel::Class())) {
      ret.add(*parg) ;
    }
  }
  return ret ;
}



//_____________________________________________________________________________
list<RooAbsData*> RooWorkspace::allData() const 
{
  // Return list of all dataset in the workspace

  list<RooAbsData*> ret ;
  TIterator* iter = _dataList.MakeIterator() ;
  RooAbsData* dat ;
  while((dat=(RooAbsData*)iter->Next())) {
    ret.push_back(dat) ;
  }
  delete iter ;
  return ret ;
}


//_____________________________________________________________________________
list<RooAbsData*> RooWorkspace::allEmbeddedData() const 
{
  // Return list of all dataset in the workspace

  list<RooAbsData*> ret ;
  TIterator* iter = _embeddedDataList.MakeIterator() ;
  RooAbsData* dat ;
  while((dat=(RooAbsData*)iter->Next())) {
    ret.push_back(dat) ;
  }
  delete iter ;
  return ret ;
}



//_____________________________________________________________________________
list<TObject*> RooWorkspace::allGenericObjects() const 
{
  // Return list of all generic objects in the workspace

  list<TObject*> ret ;
  TIterator* iter = _genObjects.MakeIterator() ;
  TObject* gobj ;
  while((gobj=(RooAbsData*)iter->Next())) {    

    // If found object is wrapper, return payload
    if (gobj->IsA()==RooTObjWrap::Class()) {
      ret.push_back(((RooTObjWrap*)gobj)->obj()) ;
    } else {
      ret.push_back(gobj) ;
    }
  }
  delete iter ;
  return ret ;
}




//_____________________________________________________________________________
Bool_t RooWorkspace::CodeRepo::autoImportClass(TClass* tc, Bool_t doReplace) 
{
  // Import code of class 'tc' into the repository. If code is already in repository it is only imported
  // again if doReplace is false. The names and location of the source files is determined from the information
  // in TClass. If no location is found in the TClass information, the files are searched in the workspace
  // search path, defined by addClassDeclImportDir() and addClassImplImportDir() for declaration and implementation
  // files respectively. If files cannot be found, abort with error status, otherwise update the internal
  // class-to-file map and import the contents of the files, if they are not imported yet.


  oocxcoutD(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo(" << _wspace->GetName() << ") request to import code of class " << tc->GetName() << endl ;

  // *** PHASE 1 *** Check if file needs to be imported, or is in ROOT distribution, and check if it can be persisted

  // Check if we already have the class (i.e. it is in the classToFile map)
  if (!doReplace && _c2fmap.find(tc->GetName())!=_c2fmap.end()) {
    oocxcoutD(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo(" << _wspace->GetName() << ") code of class " << tc->GetName() << " already imported, skipping" << endl ;
    return kTRUE ;
  }

  // Check if class is listed in a ROOTMAP file - if so we can skip it because it is in the root distribtion
  const char* mapEntry = gInterpreter->GetClassSharedLibs(tc->GetName()) ;
  if (mapEntry && strlen(mapEntry)>0) {
    oocxcoutD(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo(" << _wspace->GetName() << ") code of class " << tc->GetName() << " is in ROOT distribution, skipping " << endl ;
    return kTRUE ;
  }

  // Retrieve file names through ROOT TClass interface
  string implfile = tc->GetImplFileName() ;
  string declfile = tc->GetDeclFileName() ;

  // Check that file names are not empty
  if (implfile.empty() || declfile.empty()) {
    oocoutE(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo(" << _wspace->GetName() << ") ERROR: cannot retrieve code file names for class " 
				   << tc->GetName() << " through ROOT TClass interface, unable to import code" << endl ;
    return kFALSE ;
  }

  // Check if header filename is found in ROOT distribution, if so, do not import class
  TString rootsys = gSystem->Getenv("ROOTSYS") ;
  if (TString(implfile.c_str()).Index(rootsys)>=0) {
    oocxcoutD(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo(" << _wspace->GetName() << ") code of class " << tc->GetName() << " is in ROOT distribution, skipping " << endl ;
    return kTRUE ;
  }
  const char* implpath=0 ;

  // Require that class meets technical criteria to be persistable (i.e it has a default ctor)
  // (We also need a default ctor of abstract classes, but cannot check that through is interface
  //  as TClass::HasDefaultCtor only returns true for callable default ctors)
  if (!(tc->Property() & kIsAbstract) && !tc->HasDefaultConstructor()) {
    oocoutW(_wspace,ObjectHandling) << "RooWorkspace::autoImportClass(" << _wspace->GetName() << ") WARNING cannot import class " 
				    << tc->GetName() << " : it cannot be persisted because it doesn't have a default constructor. Please fix " << endl ;
    return kFALSE ;      
  }


  // *** PHASE 2 *** Check if declaration and implementation files can be located 

  char* declpath = 0 ;

  // Check if header file can be found in specified location
  // If not, scan through list of 'class declaration' paths in RooWorkspace
  if (gSystem->AccessPathName(declfile.c_str())) {

    // Check list of additional declaration paths
    list<string>::iterator diter = RooWorkspace::_classDeclDirList.begin() ;

    while(diter!= RooWorkspace::_classDeclDirList.end()) {
      
      declpath = gSystem->ConcatFileName(diter->c_str(),declfile.c_str()) ;      
      if (!gSystem->AccessPathName(declpath)) {
	// found declaration file
	break ;
      }
      // cleanup and continue ;
      delete[] declpath ;
      declpath=0 ;

      ++diter ;
    }
    
    // Header file cannot be found anywhere, warn user and abort operation
    if (!declpath) {
      oocoutW(_wspace,ObjectHandling) << "RooWorkspace::autoImportClass(" << _wspace->GetName() << ") WARNING Cannot access code of class " 
				      << tc->GetName() << " because header file " << declfile << " is not found in current directory nor in $ROOTSYS" ;
      if (_classDeclDirList.size()>0) {
	ooccoutW(_wspace,ObjectHandling) << ", nor in the search path " ;
	diter = RooWorkspace::_classDeclDirList.begin() ;

	while(diter!= RooWorkspace::_classDeclDirList.end()) {

	  if (diter!=RooWorkspace::_classDeclDirList.begin()) {
	    ooccoutW(_wspace,ObjectHandling) << "," ;
	  }
	  ooccoutW(_wspace,ObjectHandling) << diter->c_str() ;
	  ++diter ;
	}
      }
      ooccoutW(_wspace,ObjectHandling) << ". To fix this problem add the required directory to the search "
				       << "path using RooWorkspace::addClassDeclDir(const char* dir)" << endl ;
      
      return kFALSE ;
    }
  }

  
  // Check if implementation file can be found in specified location
  // If not, scan through list of 'class implementation' paths in RooWorkspace
  if (gSystem->AccessPathName(implfile.c_str())) {

    // Check list of additional declaration paths
    list<string>::iterator iiter = RooWorkspace::_classImplDirList.begin() ;

    while(iiter!= RooWorkspace::_classImplDirList.end()) {
      
      implpath = gSystem->ConcatFileName(iiter->c_str(),implfile.c_str()) ;      
      if (!gSystem->AccessPathName(implpath)) {
	// found implementation file
	break ;
      }
      // cleanup and continue ;
      delete[] implpath ;
      implpath=0 ;

      ++iiter ;
    }
     
    // Implementation file cannot be found anywhere, warn user and abort operation
    if (!implpath) {
      oocoutW(_wspace,ObjectHandling) << "RooWorkspace::autoImportClass(" << _wspace->GetName() << ") WARNING Cannot access code of class " 
				      << tc->GetName() << " because implementation file " << implfile << " is not found in current directory nor in $ROOTSYS" ;
      if (_classDeclDirList.size()>0) {
	ooccoutW(_wspace,ObjectHandling) << ", nor in the search path " ;
	iiter = RooWorkspace::_classImplDirList.begin() ;

	while(iiter!= RooWorkspace::_classImplDirList.end()) {

	  if (iiter!=RooWorkspace::_classImplDirList.begin()) {
	    ooccoutW(_wspace,ObjectHandling) << "," ;
	  }
	  ooccoutW(_wspace,ObjectHandling) << iiter->c_str() ;
	  ++iiter ;
	}
      }
      ooccoutW(_wspace,ObjectHandling) << ". To fix this problem add the required directory to the search "
				       << "path using RooWorkspace::addClassImplDir(const char* dir)" << endl ;    
      return kFALSE ;
    }
  }
  
  char buf[10240] ;

  // *** Phase 3 *** Prepare to import code from files into STL string buffer
  //
  // Code storage is organized in two linked maps
  //
  // _fmap contains stl strings with code, indexed on declaration file name
  //
  // _c2fmap contains list of declaration file names and list of base classes
  //                  and is indexed on class name
  //
  // Phase 3 is skipped if fmap already contains an entry with given filebasename

  string declfilename = declpath?gSystem->BaseName(declpath):gSystem->BaseName(declfile.c_str()) ;

  // Split in base and extension
  int dotpos2 = strrchr(declfilename.c_str(),'.') - declfilename.c_str() ;
  string declfilebase = declfilename.substr(0,dotpos2) ;
  string declfileext = declfilename.substr(dotpos2+1) ;

  list<string> extraHeaders ;

  // If file has not beed stored yet, enter stl strings with implementation and declaration in file map
  if (_fmap.find(declfilebase) == _fmap.end()) {

    // Open declaration file
    fstream fdecl(declpath?declpath:declfile.c_str()) ;
    
    // Abort import if declaration file cannot be opened
    if (!fdecl) {
      oocoutE(_wspace,ObjectHandling) << "RooWorkspace::autoImportClass(" << _wspace->GetName() 
				      << ") ERROR opening declaration file " <<  declfile << endl ;
      return kFALSE ;      
    }
    
    oocoutI(_wspace,ObjectHandling) << "RooWorkspace::autoImportClass(" << _wspace->GetName() 
				    << ") importing code of class " << tc->GetName() 
				    << " from " << (implpath?implpath:implfile.c_str()) 
				    << " and " << (declpath?declpath:declfile.c_str()) << endl ;
    
    
    // Read entire file into an stl string
    string decl ;
    while(fdecl.getline(buf,1023)) {
      
      // Look for include state of self
      Bool_t processedInclude = kFALSE ;
      char* extincfile = 0 ;
      
      // Look for include of declaration file corresponding to this implementation file
      if (strstr(buf,"#include")) {
	// Process #include statements here
	char tmp[10240] ;
	strlcpy(tmp,buf,10240) ;
	Bool_t stdinclude = strchr(buf,'<') ;
	strtok(tmp," <\"") ;
	char* incfile = strtok(0," <>\"") ;	
	
	if (!stdinclude) {
	  // check if it lives in $ROOTSYS/include
	  TString hpath = gSystem->Getenv("ROOTSYS") ;
	  hpath += "/include/" ;
	  hpath += incfile ;
	  if (gSystem->AccessPathName(hpath.Data())) {
	    oocoutI(_wspace,ObjectHandling)  << "RooWorkspace::autoImportClass(" << _wspace->GetName() << ") scheduling include file " << incfile << " for import" << endl ;
	    extraHeaders.push_back(incfile) ;
	    extincfile = incfile ;
	    processedInclude = kTRUE ;
	  }
	  
	}
      }
      
      if (processedInclude) {
	decl += "// external include file below retrieved from workspace code storage\n" ;
	decl += Form("#include \"%s\"\n",extincfile) ; 
      } else {
	decl += buf ;
	decl += '\n' ;
      }
    }
    
    // Open implementation file
    fstream fimpl(implpath?implpath:implfile.c_str()) ;
    
    // Abort import if implementation file cannot be opened
    if (!fimpl) {
      oocoutE(_wspace,ObjectHandling) << "RooWorkspace::autoImportClass(" << _wspace->GetName() 
				      << ") ERROR opening implementation file " <<  implfile << endl ;
      return kFALSE ;      
    }
    
    
    // Import entire implentation file into stl string
    string impl ;
    while(fimpl.getline(buf,1023)) {
      // Process #include statements here
      
      // Look for include state of self
      Bool_t foundSelfInclude=kFALSE ;
      Bool_t processedInclude = kFALSE ;
      char* extincfile = 0 ;
      
      // Look for include of declaration file corresponding to this implementation file
      if (strstr(buf,"#include")) {
	// Process #include statements here
	char tmp[10240] ;
	strlcpy(tmp,buf,10240) ;
	Bool_t stdinclude = strchr(buf,'<') ;
	strtok(tmp," <\"") ;
	char* incfile = strtok(0," <>\"") ;	

	if (strstr(incfile,declfilename.c_str())) {
	  foundSelfInclude=kTRUE ;
	}

	if (!stdinclude && !foundSelfInclude) {
	  // check if it lives in $ROOTSYS/include
	  TString hpath = gSystem->Getenv("ROOTSYS") ;
	  hpath += "/include/" ;
	  hpath += incfile ;
	  
	  if (gSystem->AccessPathName(hpath.Data())) {
	    oocoutI(_wspace,ObjectHandling)  << "RooWorkspace::autoImportClass(" << _wspace->GetName() << ") scheduling include file " << incfile << " for import" << endl ;
	    extraHeaders.push_back(incfile) ;
	    extincfile = incfile ;
	    processedInclude = kTRUE ;
	  }
	  
	}
      }
      
      // Explicitly rewrite include of own declaration file to string
      // any directory prefixes, copy all other lines verbatim in stl string
      if (foundSelfInclude) {
	// If include of self is found, substitute original include 
	// which may have directory structure with a plain include
	impl += "// class declaration include file below retrieved from workspace code storage\n" ;
	impl += Form("#include \"%s.%s\"\n",declfilebase.c_str(),declfileext.c_str()) ;
      } else if (processedInclude) {
	impl += "// external include file below retrieved from workspace code storage\n" ;
	impl += Form("#include \"%s\"\n",extincfile) ; 
      } else {
	impl += buf ;
	impl += '\n' ;
      }
    }
            
    // Create entry in file map
    _fmap[declfilebase]._hfile = decl ;
    _fmap[declfilebase]._cxxfile = impl ;   
    _fmap[declfilebase]._hext = declfileext ;

    // Process extra includes now
    for (list<string>::iterator ehiter = extraHeaders.begin() ; ehiter != extraHeaders.end() ; ++ehiter ) {
      if (_ehmap.find(*ehiter) == _ehmap.end()) {

	ExtraHeader eh ;
	eh._hname = ehiter->c_str() ;
	fstream fehdr(ehiter->c_str()) ;
	string ehimpl ;
	char buf2[1024] ;
	while(fehdr.getline(buf2,1023)) {	  
	  
	  // Look for include of declaration file corresponding to this implementation file
	  if (strstr(buf2,"#include")) {
	    // Process #include statements here
	    char tmp[10240] ;
	    strlcpy(tmp,buf2,10240) ;
	    Bool_t stdinclude = strchr(buf,'<') ;
	    strtok(tmp," <\"") ;
	    char* incfile = strtok(0," <>\"") ;	

	    if (!stdinclude) {
	      // check if it lives in $ROOTSYS/include
	      TString hpath = gSystem->Getenv("ROOTSYS") ;
	      hpath += "/include/" ;
	      hpath += incfile ;
	      if (gSystem->AccessPathName(hpath.Data())) {
		oocoutI(_wspace,ObjectHandling)  << "RooWorkspace::autoImportClass(" << _wspace->GetName() << ") scheduling recursive include file " << incfile << " for import" << endl ;
		extraHeaders.push_back(incfile) ;
	      }	      
	    }
	  }
      
	  ehimpl += buf2 ;
	  ehimpl += '\n' ;
	}
	eh._hfile = ehimpl.c_str() ;

	_ehmap[ehiter->c_str()] = eh  ;
      }
    }

  } else {

    // Inform that existing file entry is being recycled because it already contained class code
    oocoutI(_wspace,ObjectHandling) << "RooWorkspace::autoImportClass(" << _wspace->GetName() 
				    << ") code of class " << tc->GetName() 
				    << " was already imported from " << (implpath?implpath:implfile.c_str()) 
				    << " and " << (declpath?declpath:declfile.c_str()) << endl ;
    
  }


  // *** PHASE 4 *** Import stl strings with code into workspace 
  //
  // If multiple classes are declared in a single code unit, there will be
  // multiple _c2fmap entries all pointing to the same _fmap entry.  
  
  // Make list of all immediate base classes of this class
  TString baseNameList ;
  TList* bl = tc->GetListOfBases() ;
  TIterator* iter = bl->MakeIterator() ;
  TBaseClass* base ;
  list<TClass*> bases ;
  while((base=(TBaseClass*)iter->Next())) {
    if (baseNameList.Length()>0) {
      baseNameList += "," ;
    }
    baseNameList += base->GetClassPointer()->GetName() ;
    bases.push_back(base->GetClassPointer()) ;
  }
  
  // Map class name to above _fmap entries, along with list of base classes
  // in _c2fmap
  _c2fmap[tc->GetName()]._baseName = baseNameList ;
  _c2fmap[tc->GetName()]._fileBase = declfilebase ;
  
  // Recursive store all base classes.
  list<TClass*>::iterator biter = bases.begin() ;
  while(biter!=bases.end()) {
    autoImportClass(*biter,doReplace) ;
    ++biter ;
  }

  // Cleanup 
  if (implpath) {
    delete[] implpath ;
  }
  if (declpath) {
    delete[] declpath ;
  }


  return kTRUE ;
}


//_____________________________________________________________________________
Bool_t RooWorkspace::makeDir() 
{
  // Create transient TDirectory representation of this workspace. This directory
  // will appear as a subdirectory of the directory that contains the workspace
  // and will have the name of the workspace suffixed with "Dir". The TDirectory
  // interface is read-only. Any attempt to insert objects into the workspace
  // directory representation will result in an error message. Note that some
  // ROOT object like TH1 automatically insert themselves into the current directory
  // when constructed. This will give error messages when done in a workspace
  // directory.

  if (_dir) return kTRUE ;

  TString title= Form("TDirectory representation of RooWorkspace %s",GetName()) ;
  _dir = new WSDir(GetName(),title.Data(),this) ;
  
  TIterator* iter = componentIterator() ;
  RooAbsArg* darg ;
  while((darg=(RooAbsArg*)iter->Next())) {
    if (darg->IsA() != RooConstVar::Class()) {
      _dir->InternalAppend(darg) ;
    }
  }
  
  return kTRUE ;
}
 
 

//_____________________________________________________________________________
Bool_t RooWorkspace::import(TObject& object, Bool_t replaceExisting) 
{
  // Import a clone of a generic TObject into workspace generic object container. Imported
  // object can be retrieved by name through the obj() method. The object is cloned upon
  // importation and the input argument does not need to live beyond the import call
  // 
  // Returns kTRUE if an error has occurred.
  
  // First check if object with given name already exists
  TObject* oldObj = _genObjects.FindObject(object.GetName()) ;
  if (oldObj && !replaceExisting) {
    coutE(InputArguments) << "RooWorkspace::import(" << GetName() << ") generic object with name " 
			  << object.GetName() << " is already in workspace and replaceExisting flag is set to false" << endl ;
    return kTRUE ;
  }  

  // Grab the current state of the directory Auto-Add
  ROOT::DirAutoAdd_t func = object.IsA()->GetDirectoryAutoAdd();
  object.IsA()->SetDirectoryAutoAdd(0);
  Bool_t tmp = RooPlot::setAddDirectoryStatus(kFALSE) ;

  if (oldObj) {
    _genObjects.Replace(oldObj,object.Clone()) ;
    delete oldObj ;
  } else {
    _genObjects.Add(object.Clone()) ;
  }

  // Reset the state of the directory Auto-Add
  object.IsA()->SetDirectoryAutoAdd(func);
  RooPlot::setAddDirectoryStatus(tmp) ;

  return kFALSE ;
}




//_____________________________________________________________________________
Bool_t RooWorkspace::import(TObject& object, const char* aliasName, Bool_t replaceExisting) 
{
  // Import a clone of a generic TObject into workspace generic object container. 
  // The imported object will be stored under the given alias name rather than its
  // own name. Imported object can be retrieved its alias name through the obj() method. 
  // The object is cloned upon importation and the input argument does not need to live beyond the import call
  // This method is mostly useful for importing objects that do not have a settable name such as TMatrix
  // 
  // Returns kTRUE if an error has occurred.
  
  // First check if object with given name already exists
  TObject* oldObj = _genObjects.FindObject(object.GetName()) ;
  if (oldObj && !replaceExisting) {
    coutE(InputArguments) << "RooWorkspace::import(" << GetName() << ") generic object with name " 
			  << object.GetName() << " is already in workspace and replaceExisting flag is set to false" << endl ;
    return kTRUE ;
  }  
  
  TH1::AddDirectory(kFALSE) ;
  RooTObjWrap* wrapper = new RooTObjWrap(object.Clone()) ;
  TH1::AddDirectory(kTRUE) ;
  wrapper->setOwning(kTRUE) ;
  wrapper->SetName(aliasName) ;
  wrapper->SetTitle(aliasName) ;
    
  if (oldObj) {
    _genObjects.Replace(oldObj,wrapper) ;
    delete oldObj ;
  } else {
    _genObjects.Add(wrapper) ;
  }
  return kFALSE ;
}




//_____________________________________________________________________________
Bool_t RooWorkspace::addStudy(RooAbsStudy& study) 
{
  // Insert RooStudyManager module
  RooAbsStudy* clone = (RooAbsStudy*) study.Clone() ;
  _studyMods.Add(clone) ;
  return kFALSE ;
}




//_____________________________________________________________________________
void RooWorkspace::clearStudies() 
{
  // Remove all RooStudyManager modules
  _studyMods.Delete() ;
}




//_____________________________________________________________________________
TObject* RooWorkspace::obj(const char* name) const
{
  // Return any type of object (RooAbsArg, RooAbsData or generic object) with given name)

  // Try RooAbsArg first
  TObject* ret = arg(name) ;
  if (ret) return ret ;

  // Then try RooAbsData
  ret = data(name) ;
  if (ret) return ret ;

  // Finally try generic object store
  return genobj(name) ;
}



//_____________________________________________________________________________
TObject* RooWorkspace::genobj(const char* name)  const
{
  // Return generic object with given name

  // Find object by name
  TObject* gobj = _genObjects.FindObject(name) ;

  // Exit here if not found
  if (!gobj) return 0 ;

  // If found object is wrapper, return payload
  if (gobj->IsA()==RooTObjWrap::Class()) return ((RooTObjWrap*)gobj)->obj() ;

  return gobj ;
}



//_____________________________________________________________________________
Bool_t RooWorkspace::cd(const char* path) 
{
  makeDir() ;
  return _dir->cd(path) ;
}



//_____________________________________________________________________________
Bool_t RooWorkspace::writeToFile(const char* fileName, Bool_t recreate) 
{
  // Save this current workspace into given file
  TFile f(fileName,recreate?"RECREATE":"UPDATE") ;
  Write() ;
  return kFALSE ;
}
 
 

//_____________________________________________________________________________
RooFactoryWSTool& RooWorkspace::factory()
{
  // Return instance to factory tool 

  if (_factory) {
    return *_factory ;  
  }
  cxcoutD(ObjectHandling) << "INFO: Creating RooFactoryWSTool associated with this workspace" << endl ;
  _factory = new RooFactoryWSTool(*this) ;
  return *_factory  ;
}




//_____________________________________________________________________________
RooAbsArg* RooWorkspace::factory(const char* expr)
{
  // Short-hand function for factory()->process(expr) ;
  return factory().process(expr) ;
}




//_____________________________________________________________________________
void RooWorkspace::Print(Option_t* opts) const 
{
  // Print contents of the workspace 

  Bool_t treeMode(kFALSE) ;
  if (TString(opts).Contains("t")) {
    treeMode=kTRUE ;
  }

  cout << endl << "RooWorkspace(" << GetName() << ") " << GetTitle() << " contents" << endl << endl  ;
  
  RooAbsArg* parg ;

  RooArgSet pdfSet ;
  RooArgSet funcSet ;
  RooArgSet varSet ;
  RooArgSet catfuncSet ;
  RooArgSet convResoSet ;
  RooArgSet resoSet ;


  // Split list of components in pdfs, functions and variables
  TIterator* iter = _allOwnedNodes.createIterator() ;
  while((parg=(RooAbsArg*)iter->Next())) {

    //---------------

    if (treeMode) {
      
      // In tree mode, only add nodes with no clients to the print lists

      if (parg->IsA()->InheritsFrom(RooAbsPdf::Class())) {
	if (!parg->hasClients()) {
	  pdfSet.add(*parg) ;
	}
      }
      
      if (parg->IsA()->InheritsFrom(RooAbsReal::Class()) && 
	  !parg->IsA()->InheritsFrom(RooAbsPdf::Class()) && 
	  !parg->IsA()->InheritsFrom(RooConstVar::Class()) && 
	  !parg->IsA()->InheritsFrom(RooRealVar::Class())) {
	if (!parg->hasClients()) {
	  funcSet.add(*parg) ;
	}
      }
      
      
      if (parg->IsA()->InheritsFrom(RooAbsCategory::Class()) && 
	  !parg->IsA()->InheritsFrom(RooCategory::Class())) {
	if (!parg->hasClients()) {	
	  catfuncSet.add(*parg) ;
	}
      }

    } else {

      if (parg->IsA()->InheritsFrom(RooResolutionModel::Class())) {
	if (((RooResolutionModel*)parg)->isConvolved()) {
	  convResoSet.add(*parg) ;
	} else {
	  resoSet.add(*parg) ;
	}
      }
      
      if (parg->IsA()->InheritsFrom(RooAbsPdf::Class()) &&
	  !parg->IsA()->InheritsFrom(RooResolutionModel::Class())) {
	pdfSet.add(*parg) ;
      }
      
      if (parg->IsA()->InheritsFrom(RooAbsReal::Class()) && 
	  !parg->IsA()->InheritsFrom(RooAbsPdf::Class()) && 
	  !parg->IsA()->InheritsFrom(RooConstVar::Class()) && 
	  !parg->IsA()->InheritsFrom(RooRealVar::Class())) {
	funcSet.add(*parg) ;
      }
      
      if (parg->IsA()->InheritsFrom(RooAbsCategory::Class()) && 
	  !parg->IsA()->InheritsFrom(RooCategory::Class())) {
	catfuncSet.add(*parg) ;
      }
    }

    if (parg->IsA()->InheritsFrom(RooRealVar::Class())) {
      varSet.add(*parg) ;
    }

    if (parg->IsA()->InheritsFrom(RooCategory::Class())) {
      varSet.add(*parg) ;
    }

  }
  delete iter ;


  RooFit::MsgLevel oldLevel = RooMsgService::instance().globalKillBelow() ;
  RooMsgService::instance().setGlobalKillBelow(RooFit::WARNING) ;

  if (varSet.getSize()>0) {
    varSet.sort() ;
    cout << "variables" << endl ;
    cout << "---------" << endl ;
    cout << varSet << endl ;
    cout << endl ;
  }

  if (pdfSet.getSize()>0) {
    cout << "p.d.f.s" << endl ;
    cout << "-------" << endl ;
    pdfSet.sort() ;
    iter = pdfSet.createIterator() ;
    while((parg=(RooAbsArg*)iter->Next())) {
      if (treeMode) {
	parg->printComponentTree() ;
      } else {
	parg->Print() ;
      }
    }
    delete iter ;
    cout << endl ;
  }

  if (!treeMode) {
    if (resoSet.getSize()>0) {
      cout << "analytical resolution models" << endl ;
      cout << "----------------------------" << endl ;
      resoSet.sort() ;
      iter = resoSet.createIterator() ;
      while((parg=(RooAbsArg*)iter->Next())) {
	parg->Print() ;
      }
      delete iter ;
      //     iter = convResoSet.createIterator() ;
      //     while((parg=(RooAbsArg*)iter->Next())) {
      //       parg->Print() ;
      //     }
      //     delete iter ;
      cout << endl ;
    }
  }

  if (funcSet.getSize()>0) {
    cout << "functions" << endl ;
    cout << "--------" << endl ;
    funcSet.sort() ;
    iter = funcSet.createIterator() ;
    while((parg=(RooAbsArg*)iter->Next())) {
      if (treeMode) {
	parg->printComponentTree() ;
      } else {
	parg->Print() ;
      }
    }
    delete iter ;
    cout << endl ;
  }

  if (catfuncSet.getSize()>0) {
    cout << "category functions" << endl ;
    cout << "------------------" << endl ;
    catfuncSet.sort() ;
    iter = catfuncSet.createIterator() ;
    while((parg=(RooAbsArg*)iter->Next())) {
      if (treeMode) {
	parg->printComponentTree() ;
      } else {
	parg->Print() ;
      }
    }
    delete iter ;
    cout << endl ;
  }

  if (_dataList.GetSize()>0) {
    cout << "datasets" << endl ;
    cout << "--------" << endl ;
    iter = _dataList.MakeIterator() ;
    RooAbsData* data2 ;
    while((data2=(RooAbsData*)iter->Next())) {
      cout << data2->IsA()->GetName() << "::" << data2->GetName() << *data2->get() << endl ;
    }
    delete iter ;
    cout << endl ;
  }

  if (_embeddedDataList.GetSize()>0) {
    cout << "embedded datasets (in pdfs and functions)" << endl ;
    cout << "-----------------------------------------" << endl ;
    iter = _embeddedDataList.MakeIterator() ;
    RooAbsData* data2 ;
    while((data2=(RooAbsData*)iter->Next())) {
      cout << data2->IsA()->GetName() << "::" << data2->GetName() << *data2->get() << endl ;
    }
    delete iter ;
    cout << endl ;
  }

  if (_snapshots.GetSize()>0) {
    cout << "parameter snapshots" << endl ;
    cout << "-------------------" << endl ;
    iter = _snapshots.MakeIterator() ;
    RooArgSet* snap ;
    while((snap=(RooArgSet*)iter->Next())) {
      cout << snap->GetName() << " = (" ;
      TIterator* aiter = snap->createIterator() ;
      RooAbsArg* a ;
      Bool_t first(kTRUE) ;
      while((a=(RooAbsArg*)aiter->Next())) {
	if (first) { first=kFALSE ; } else { cout << "," ; }
	cout << a->GetName() << "=" ; 
	a->printValue(cout) ;
	if (a->isConstant()) {
	  cout << "[C]" ;
	}
      }
      cout << ")" << endl ;
      delete aiter ;
    }
    delete iter ;
    cout << endl ;
  }


  if (_namedSets.size()>0) {
    cout << "named sets" << endl ;
    cout << "----------" << endl ;
    for (map<string,RooArgSet>::const_iterator it = _namedSets.begin() ; it != _namedSets.end() ; it++) {
      cout << it->first << ":" << it->second << endl ;
    }
    
    cout << endl ;
  }

 
  if (_genObjects.GetSize()>0) {
    cout << "generic objects" << endl ;
    cout << "---------------" << endl ;
    iter = _genObjects.MakeIterator() ;
    TObject* gobj ;
    while((gobj=(TObject*)iter->Next())) {
      if (gobj->IsA()==RooTObjWrap::Class()) {
	cout << ((RooTObjWrap*)gobj)->obj()->IsA()->GetName() << "::" << gobj->GetName() << endl ;
      } else {
	cout << gobj->IsA()->GetName() << "::" << gobj->GetName() << endl ;
      }
    }
    delete iter ;
    cout << endl ;
    
  }

  if (_studyMods.GetSize()>0) {
    cout << "study modules" << endl ;
    cout << "-------------" << endl ;
    iter = _studyMods.MakeIterator() ;
    TObject* smobj ;
    while((smobj=(TObject*)iter->Next())) {
      cout << smobj->IsA()->GetName() << "::" << smobj->GetName() << endl ;
    }
    delete iter ;
    cout << endl ;
    
  }

  if (_classes.listOfClassNames().size()>0) {
    cout << "embedded class code" << endl ;
    cout << "-------------------" << endl ;    
    cout << _classes.listOfClassNames() << endl ;
    cout << endl ;
  }

  if (_eocache.size()>0) {
    cout << "embedded precalculated expensive components" << endl ;
    cout << "-------------------------------------------" << endl ;
    _eocache.print() ;
  }

  RooMsgService::instance().setGlobalKillBelow(oldLevel) ;

  return ;
}


//_____________________________________________________________________________
void RooWorkspace::CodeRepo::Streamer(TBuffer &R__b)
{
  // Custom streamer for the workspace. Stream contents of workspace
  // and code repository. When reading, read code repository first
  // and compile missing classes before proceeding with streaming
  // of workspace contents to avoid errors.

  typedef ::RooWorkspace::CodeRepo thisClass;

   // Stream an object of class RooWorkspace::CodeRepo.
   if (R__b.IsReading()) {

     UInt_t R__s, R__c;
     Version_t R__v =  R__b.ReadVersion(&R__s, &R__c); 

     // Stream contents of ClassFiles map
     Int_t count(0) ;
     R__b >> count ;
     while(count--) {
       TString name ;
       name.Streamer(R__b) ;       
       _fmap[name]._hext.Streamer(R__b) ;
       _fmap[name]._hfile.Streamer(R__b) ;
       _fmap[name]._cxxfile.Streamer(R__b) ;    
     }     
 
     // Stream contents of ClassRelInfo map
     count=0 ;
     R__b >> count ;
     while(count--) {
       TString name ;
       name.Streamer(R__b) ;       
       _c2fmap[name]._baseName.Streamer(R__b) ;
       _c2fmap[name]._fileBase.Streamer(R__b) ;
     }     

     if (R__v==2) {

       count=0 ;
       R__b >> count ;
       while(count--) {
	 TString name ;
	 name.Streamer(R__b) ;       
	 _ehmap[name]._hname.Streamer(R__b) ;
	 _ehmap[name]._hfile.Streamer(R__b) ;
       }                  
     }

     R__b.CheckByteCount(R__s, R__c, thisClass::IsA());

     // Instantiate any classes that are not defined in current session
     _compiledOK = !compileClasses() ;

   } else {
     
     UInt_t R__c;
     R__c = R__b.WriteVersion(thisClass::IsA(), kTRUE);
     
     // Stream contents of ClassFiles map
     UInt_t count = _fmap.size() ;
     R__b << count ;
     map<TString,ClassFiles>::iterator iter = _fmap.begin() ;
     while(iter!=_fmap.end()) {       
       TString key_copy(iter->first) ;
       key_copy.Streamer(R__b) ;
       iter->second._hext.Streamer(R__b) ;
       iter->second._hfile.Streamer(R__b);
       iter->second._cxxfile.Streamer(R__b);

       ++iter ;
     }
     
     // Stream contents of ClassRelInfo map
     count = _c2fmap.size() ;
     R__b << count ;
     map<TString,ClassRelInfo>::iterator iter2 = _c2fmap.begin() ;
     while(iter2!=_c2fmap.end()) {
       TString key_copy(iter2->first) ;
       key_copy.Streamer(R__b) ;
       iter2->second._baseName.Streamer(R__b) ;
       iter2->second._fileBase.Streamer(R__b);
       ++iter2 ;
     }

     // Stream contents of ExtraHeader map
     count = _ehmap.size() ;
     R__b << count ;
     map<TString,ExtraHeader>::iterator iter3 = _ehmap.begin() ;
     while(iter3!=_ehmap.end()) {
       TString key_copy(iter3->first) ;
       key_copy.Streamer(R__b) ;
       iter3->second._hname.Streamer(R__b) ;
       iter3->second._hfile.Streamer(R__b);
       ++iter3 ;
     }

     R__b.SetByteCount(R__c, kTRUE);
     
   }
}


//______________________________________________________________________________
void RooWorkspace::Streamer(TBuffer &R__b)
{
  // Stream an object of class RooWorkspace. This is a standard ROOT streamer for the
  // I/O part. This custom function exists to detach all external client links
  // from the payload prior to writing the payload so that these client links
  // are not persisted. (Client links occur if external function objects use 
  // objects contained in the workspace as input)
  // After the actual writing, these client links are restored.

   if (R__b.IsReading()) {

      R__b.ReadClassBuffer(RooWorkspace::Class(),this);
            
      // Perform any pass-2 schema evolution here
      RooFIter fiter = _allOwnedNodes.fwdIterator() ;
      RooAbsArg* node ;
      while((node=fiter.next())) {
	node->ioStreamerPass2() ;
      }
      RooAbsArg::ioStreamerPass2Finalize() ;
      
      // Make expensive object cache of all objects point to intermal copy.
      // Somehow this doesn't work OK automatically
      TIterator* iter = _allOwnedNodes.createIterator() ;
      while((node=(RooAbsArg*)iter->Next())) {
	node->setExpensiveObjectCache(_eocache) ;
	if (node->IsA()->InheritsFrom(RooAbsOptTestStatistic::Class())) {
	  RooAbsOptTestStatistic* tmp = (RooAbsOptTestStatistic*) node ;
	  if (tmp->isSealed() && tmp->sealNotice() && strlen(tmp->sealNotice())>0) {
	    cout << "RooWorkspace::Streamer(" << GetName() << ") " << node->IsA()->GetName() << "::" << node->GetName() << " : " << tmp->sealNotice() << endl ;
	  }
	}
      }
      delete iter ;


   } else {

     // Make lists of external clients of WS objects, and remove those links temporarily

     map<RooAbsArg*,list<RooAbsArg*> > extClients, extValueClients, extShapeClients ;

     TIterator* iter = _allOwnedNodes.createIterator() ;
     RooAbsArg* tmparg ;
     while((tmparg=(RooAbsArg*)iter->Next())) {

       // Loop over client list of this arg
       TIterator* clientIter = tmparg->_clientList.MakeIterator() ;
       RooAbsArg* client ;
       while((client=(RooAbsArg*)clientIter->Next())) {
	 if (!_allOwnedNodes.containsInstance(*client)) {
	   while(tmparg->_clientList.refCount(client)>0) {
	     tmparg->_clientList.Remove(client) ;
	     extClients[tmparg].push_back(client) ;
	   }
	 }
       }
       delete clientIter ;

       // Loop over value client list of this arg
       TIterator* vclientIter = tmparg->_clientListValue.MakeIterator() ;
       RooAbsArg* vclient ;
       while((vclient=(RooAbsArg*)vclientIter->Next())) {
	 if (!_allOwnedNodes.containsInstance(*vclient)) {
	   cxcoutD(ObjectHandling) << "RooWorkspace::Streamer(" << GetName() << ") element " << tmparg->GetName() 
				   << " has external value client link to " << vclient << " (" << vclient->GetName() << ") with ref count " << tmparg->_clientListValue.refCount(vclient) << endl ;
	   while(tmparg->_clientListValue.refCount(vclient)>0) {
	     tmparg->_clientListValue.Remove(vclient) ;
	     extValueClients[tmparg].push_back(vclient) ;
	   }
	 }
       }
       delete vclientIter ;

       // Loop over shape client list of this arg
       TIterator* sclientIter = tmparg->_clientListShape.MakeIterator() ;
       RooAbsArg* sclient ;
       while((sclient=(RooAbsArg*)sclientIter->Next())) {
	 if (!_allOwnedNodes.containsInstance(*sclient)) {
	   cxcoutD(ObjectHandling) << "RooWorkspace::Streamer(" << GetName() << ") element " << tmparg->GetName() 
				 << " has external shape client link to " << sclient << " (" << sclient->GetName() << ") with ref count " << tmparg->_clientListShape.refCount(sclient) << endl ;
	   while(tmparg->_clientListShape.refCount(sclient)>0) {
	     tmparg->_clientListShape.Remove(sclient) ;
	     extShapeClients[tmparg].push_back(sclient) ;
	   }
	 }
       }
       delete sclientIter ;

     }
     delete iter ;

     R__b.WriteClassBuffer(RooWorkspace::Class(),this);

     // Reinstate clients here

     
     for (map<RooAbsArg*,list<RooAbsArg*> >::iterator iterx = extClients.begin() ; iterx!=extClients.end() ; iterx++) {
       for (list<RooAbsArg*>::iterator citer = iterx->second.begin() ; citer!=iterx->second.end() ; citer++) {
	 iterx->first->_clientList.Add(*citer) ;
       }
     }

     for (map<RooAbsArg*,list<RooAbsArg*> >::iterator iterx = extValueClients.begin() ; iterx!=extValueClients.end() ; iterx++) {
       for (list<RooAbsArg*>::iterator citer = iterx->second.begin() ; citer!=iterx->second.end() ; citer++) {
	 iterx->first->_clientListValue.Add(*citer) ;
       }
     }

     for (map<RooAbsArg*,list<RooAbsArg*> >::iterator iterx = extShapeClients.begin() ; iterx!=extShapeClients.end() ; iterx++) {
       for (list<RooAbsArg*>::iterator citer = iterx->second.begin() ; citer!=iterx->second.end() ; citer++) {
	 iterx->first->_clientListShape.Add(*citer) ;
       }
     }

   }
}




//_____________________________________________________________________________
std::string RooWorkspace::CodeRepo::listOfClassNames() const 
{
  // Return STL string with last of class names contained in the code repository

  string ret ;
  map<TString,ClassRelInfo>::const_iterator iter = _c2fmap.begin() ;
  while(iter!=_c2fmap.end()) {
    if (ret.size()>0) {
      ret += ", " ;
    }
    ret += iter->first ;    
    ++iter ;
  }  
  
  return ret ;
}



//_____________________________________________________________________________
Bool_t RooWorkspace::CodeRepo::compileClasses() 
{
  // For all classes in the workspace for which no class definition is
  // found in the ROOT class table extract source code stored in code
  // repository into temporary directory set by
  // setClassFileExportDir(), compile classes and link them with
  // current ROOT session. If a compilation error occurs print
  // instructions for user how to fix errors and recover workspace and
  // abort import procedure.

  Bool_t haveDir=kFALSE ;

  // Retrieve name of directory in which to export code files
  string dirName = Form(_classFileExportDir.c_str(),_wspace->uuid().AsString(),_wspace->GetName()) ;

  Bool_t writeExtraHeaders(kFALSE) ;

  // Process all class entries in repository
  map<TString,ClassRelInfo>::iterator iter = _c2fmap.begin() ;
  while(iter!=_c2fmap.end()) {

    oocxcoutD(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo::compileClasses() now processing class " << iter->first.Data() << endl ;

    // If class is already known, don't load
    if (gClassTable->GetDict(iter->first.Data())) {
      oocoutI(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo::compileClasses() Embedded class " 
				      << iter->first << " already in ROOT class table, skipping" << endl ;
      ++iter ;
      continue ;
    }

    // Check that export directory exists
    if (!haveDir) {

      // If not, make local directory to extract files 
      if (!gSystem->AccessPathName(dirName.c_str())) {
	oocoutI(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo::compileClasses() reusing code export directory " << dirName.c_str() 
					<< " to extract coded embedded in workspace" << endl ;
      } else {
	if (gSystem->MakeDirectory(dirName.c_str())==0) { 
	  oocoutI(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo::compileClasses() creating code export directory " << dirName.c_str() 
					  << " to extract coded embedded in workspace" << endl ;
	} else {
	  oocoutE(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo::compileClasses() ERROR creating code export directory " << dirName.c_str() 
					  << " to extract coded embedded in workspace" << endl ;
	  return kFALSE ;
	}
      }
      haveDir=kTRUE ;

    }

    // First write any extra header files 
    if (!writeExtraHeaders) {      
      writeExtraHeaders = kTRUE ;
      
      map<TString,ExtraHeader>::iterator eiter = _ehmap.begin() ;
      while(eiter!=_ehmap.end()) {

	// Check if identical declaration file (header) is already written
	Bool_t needEHWrite=kTRUE ;
	string fdname = Form("%s/%s",dirName.c_str(),eiter->second._hname.Data()) ;
	ifstream ifdecl(fdname.c_str()) ;
	if (ifdecl) {
	  TString contents ;
	  char buf[10240] ;
	  while(ifdecl.getline(buf,10240)) {
	    contents += buf ;
	    contents += "\n" ;
	  }      
	  UInt_t crcFile = RooAbsArg::crc32(contents.Data()) ;
	  UInt_t crcWS   = RooAbsArg::crc32(eiter->second._hfile.Data()) ;
	  needEHWrite = (crcFile!=crcWS) ;
	}
	
	// Write declaration file if required 
	if (needEHWrite) {
	  oocoutI(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo::compileClasses() Extracting extra header file " << fdname << endl ;
	  
	  // Extra headers may contain non-existing path - create first to be sure
	  gSystem->MakeDirectory(gSystem->DirName(fdname.c_str())) ;	  

	  ofstream fdecl(fdname.c_str()) ;
	  if (!fdecl) {
	    oocoutE(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo::compileClasses() ERROR opening file " 
					    << fdname << " for writing" << endl ;
	    return kFALSE ;
	  }
	  fdecl << eiter->second._hfile.Data() ;
	  fdecl.close() ;
	}	       
	eiter++ ;
      }
    }
    

    // Navigate from class to file
    ClassFiles& cfinfo = _fmap[iter->second._fileBase] ;

    oocxcoutD(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo::compileClasses() now processing file with base " << iter->second._fileBase << endl ;
    
    // If file is already processed, skip to next class
    if (cfinfo._extracted) {
      oocxcoutD(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo::compileClasses() file with base name " << iter->second._fileBase 
					 << " has already been extracted, skipping to next class" << endl ;
      continue ;
    }

    // Check if identical declaration file (header) is already written
    Bool_t needDeclWrite=kTRUE ;
    string fdname = Form("%s/%s.%s",dirName.c_str(),iter->second._fileBase.Data(),cfinfo._hext.Data()) ;
    ifstream ifdecl(fdname.c_str()) ;
    if (ifdecl) {
      TString contents ;
      char buf[10240] ;
      while(ifdecl.getline(buf,10240)) {
	contents += buf ;
	contents += "\n" ;
      }      
      UInt_t crcFile = RooAbsArg::crc32(contents.Data()) ;
      UInt_t crcWS   = RooAbsArg::crc32(cfinfo._hfile.Data()) ;
      needDeclWrite = (crcFile!=crcWS) ;
    }

    // Write declaration file if required 
    if (needDeclWrite) {
      oocoutI(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo::compileClasses() Extracting declaration code of class " << iter->first << ", file " << fdname << endl ;
      ofstream fdecl(fdname.c_str()) ;
      if (!fdecl) {
	oocoutE(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo::compileClasses() ERROR opening file " 
					<< fdname << " for writing" << endl ;
	return kFALSE ;
      }
      fdecl << cfinfo._hfile ;
      fdecl.close() ;
    }

    // Check if identical implementation file is already written
    Bool_t needImplWrite=kTRUE ;
    string finame = Form("%s/%s.cxx",dirName.c_str(),iter->second._fileBase.Data()) ;
    ifstream ifimpl(finame.c_str()) ;
    if (ifimpl) {
      TString contents ;
      char buf[10240] ;
      while(ifimpl.getline(buf,10240)) {
	contents += buf ;
	contents += "\n" ;
      }      
      UInt_t crcFile = RooAbsArg::crc32(contents.Data()) ;
      UInt_t crcWS   = RooAbsArg::crc32(cfinfo._cxxfile.Data()) ;
      needImplWrite = (crcFile!=crcWS) ;
    }

    // Write implementation file if required
    if (needImplWrite) {
      oocoutI(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo::compileClasses() Extracting implementation code of class " << iter->first << ", file " << finame << endl ;
      ofstream fimpl(finame.c_str()) ;
      if (!fimpl) {
	oocoutE(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo::compileClasses() ERROR opening file" 
					<< finame << " for writing" << endl ;
	return kFALSE ;
      }
      fimpl << cfinfo._cxxfile ;
      fimpl.close() ;
    }

    // Mark this file as extracted
    cfinfo._extracted = kTRUE ;
    oocxcoutD(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo::compileClasses() marking code unit  " << iter->second._fileBase << " as extracted" << endl ;

    // Compile class
    oocoutI(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo::compileClasses() Compiling code unit " << iter->second._fileBase.Data() << " to define class " << iter->first << endl ;
    Bool_t ok = gSystem->CompileMacro(finame.c_str(),"k") ;
    
    if (!ok) {
      oocoutE(_wspace,ObjectHandling) << "RooWorkspace::CodeRepo::compileClasses() ERROR compiling class " << iter->first.Data() << ", to fix this you can do the following: " << endl 
				      << "  1) Fix extracted source code files in directory " << dirName.c_str() << "/" << endl 
				      << "  2) In clean ROOT session compiled fixed classes by hand using '.x " << dirName.c_str() << "/ClassName.cxx+'" << endl
				      << "  3) Reopen file with RooWorkspace with broken source code in UPDATE mode. Access RooWorkspace to force loading of class" << endl
				      << "     Broken instances in workspace will _not_ be compiled, instead precompiled fixed instances will be used." << endl
				      << "  4) Reimport fixed code in workspace using 'RooWorkspace::importClassCode(\"*\",kTRUE)' method, Write() updated workspace to file and close file" << endl
				      << "  5) Reopen file in clean ROOT session to confirm that problems are fixed" << endl ;
	return kFALSE ;
    }
    
    ++iter ;
  }

  return kTRUE ;
}



//_____________________________________________________________________________
void RooWorkspace::WSDir::InternalAppend(TObject* obj) 
{
  // Internal access to TDirectory append method

#if ROOT_VERSION_CODE <= ROOT_VERSION(5,19,02)
  TDirectory::Append(obj) ;
#else
  TDirectory::Append(obj,kFALSE) ;
#endif

}


//_____________________________________________________________________________
#if ROOT_VERSION_CODE <= ROOT_VERSION(5,19,02)
void RooWorkspace::WSDir::Add(TObject* obj) 
#else
void RooWorkspace::WSDir::Add(TObject* obj,Bool_t) 
#endif
{
  // Overload TDirectory interface method to prohibit insertion of objects in read-only directory workspace representation
  if (dynamic_cast<RooAbsArg*>(obj) || dynamic_cast<RooAbsData*>(obj)) {
    coutE(ObjectHandling) << "RooWorkspace::WSDir::Add(" << GetName() << ") ERROR: Directory is read-only representation of a RooWorkspace, use RooWorkspace::import() to add objects" << endl ;
  } else {
    InternalAppend(obj) ;
  }
} 


//_____________________________________________________________________________
#if ROOT_VERSION_CODE <= ROOT_VERSION(5,19,02)
void RooWorkspace::WSDir::Append(TObject* obj) 
#else
void RooWorkspace::WSDir::Append(TObject* obj,Bool_t) 
#endif
{
  // Overload TDirectory interface method to prohibit insertion of objects in read-only directory workspace representation
  if (dynamic_cast<RooAbsArg*>(obj) || dynamic_cast<RooAbsData*>(obj)) {
    coutE(ObjectHandling) << "RooWorkspace::WSDir::Add(" << GetName() << ") ERROR: Directory is read-only representation of a RooWorkspace, use RooWorkspace::import() to add objects" << endl ;
  } else {
    InternalAppend(obj) ;
  }
}



//_____________________________________________________________________________
void RooWorkspace::exportToCint(const char* nsname) 
{
  // Activate export of workspace symbols to CINT in a namespace with given name. If no name
  // is given the namespace will have the same name as the workspace

  // If export is already active, do nothing
  if (_doExport) {
    coutE(ObjectHandling) << "RooWorkspace::exportToCint(" << GetName() << ") WARNING: repeated calls to exportToCint() have no effect" << endl ;
    return ;
  }

  // Set flag so that future import to workspace are automatically exported to CINT
  _doExport = kTRUE ;

  // If no name is provided choose name of workspace
  if (!nsname) nsname = GetName() ;
  _exportNSName = nsname ;

  coutI(ObjectHandling) << "RooWorkspace::exportToCint(" << GetName() 
			<< ") INFO: references to all objects in this workspace will be created in CINT in 'namespace " << _exportNSName << "'" << endl ;

  // Export present contents of workspace to CINT
  TIterator* iter = _allOwnedNodes.createIterator() ;
  TObject* wobj ;
  while((wobj=iter->Next())) {
    exportObj(wobj) ;
  }  
  delete iter ;
  iter = _dataList.MakeIterator() ;
  while((wobj=iter->Next())) {
    exportObj(wobj) ;
  }  
  delete iter ;
}


//_____________________________________________________________________________
void RooWorkspace::exportObj(TObject* wobj)
{
  // Export reference to given workspace object to CINT

  // Do nothing if export flag is not set
  if (!_doExport) return ;

  // Do not export RooConstVars
  if (wobj->IsA() == RooConstVar::Class()) {
    return ;
  }


  // Determine if object name is a valid C++ identifier name

  // Do not export objects that have names that are not valid C++ identifiers
  if (!isValidCPPID(wobj->GetName())) {
    cxcoutD(ObjectHandling) << "RooWorkspace::exportObj(" << GetName() << ") INFO: Workspace object name " << wobj->GetName() << " is not a valid C++ identifier and is not exported to CINT" << endl ;
    return ;
  }

  // Declare correctly typed reference to object in CINT in the namespace associated with this workspace
  string cintExpr = Form("namespace %s { %s& %s = *(%s *)0x%lx ; }",_exportNSName.c_str(),wobj->IsA()->GetName(),wobj->GetName(),wobj->IsA()->GetName(),(ULong_t)wobj) ;
  gROOT->ProcessLine(cintExpr.c_str()) ;  
}



//_____________________________________________________________________________
Bool_t RooWorkspace::isValidCPPID(const char* name)   
{
  // Return true if given name is a valid C++ identifier name

  string oname(name) ;
  if (isdigit(oname[0])) {
    return kFALSE ;
  } else {
    for (UInt_t i=0 ; i<oname.size() ; i++) {
      char c = oname[i] ;
      if (!isalnum(c) && (c!='_')) {
	return kFALSE ;
      }    
    }
  }
  return kTRUE ;
}

//_____________________________________________________________________________
void RooWorkspace::unExport()
{
  // Delete exported reference in CINT namespace 
  char buf[10240] ;
  TIterator* iter = _allOwnedNodes.createIterator() ;
  TObject* wobj ;
  while((wobj=iter->Next())) {
    if (isValidCPPID(wobj->GetName())) {
      strlcpy(buf,Form("%s::%s",_exportNSName.c_str(),wobj->GetName()),10240) ;
      gInterpreter->DeleteVariable(buf);
    }
  }
  delete iter ;
}

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