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

//////////////////////////////////////////////////////////////////////////////
//
// BEGIN_HTML
// RooRealMPFE is the multi-processor front-end for parallel calculation
// of RooAbsReal objects. Each RooRealMPFE forks a process that calculates
// the value of the proxies RooAbsReal object. The (re)calculation of
// the proxied object is started asynchronously with the calculate() option.
// A subsequent call to getVal() will return the calculated value when available
// If the calculation is still in progress when getVal() is called it blocks
// the calling process until the calculation is done. The forked calculation process 
// is terminated when the front-end object is deleted
// Simple use demonstration
//
// <pre>
// RooAbsReal* slowFunc ;
//
// Double_t val = slowFunc->getVal() // Evaluate slowFunc in current process
//
// RooRealMPFE mpfe("mpfe","frontend to slowFunc",*slowFunc) ;
// mpfe.calculate() ;           // Start calculation of slow-func in remote process
//                              // .. do other stuff here ..
// Double_t val = mpfe.getVal() // Wait for remote calculation to finish and retrieve value
// </pre>
//
// END_HTML
//

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

#ifndef _WIN32
#include "BidirMMapPipe.h"
#endif

#include <cstdlib>
#include <sstream>
#include "RooRealMPFE.h"
#include "RooArgSet.h"
#include "RooAbsCategory.h"
#include "RooRealVar.h"
#include "RooCategory.h"
#include "RooMPSentinel.h"
#include "RooMsgService.h"
#include "RooNLLVar.h"
#include "RooTrace.h"

#include "TSystem.h"

RooMPSentinel RooRealMPFE::_sentinel ;

using namespace std;
using namespace RooFit;

ClassImp(RooRealMPFE)
  ;


//_____________________________________________________________________________
RooRealMPFE::RooRealMPFE(const char *name, const char *title, RooAbsReal& arg, Bool_t calcInline) : 
  RooAbsReal(name,title),
  _state(Initialize),
  _arg("arg","arg",this,arg),
  _vars("vars","vars",this),
  _calcInProgress(kFALSE),
  _verboseClient(kFALSE),
  _verboseServer(kFALSE),
  _inlineMode(calcInline),
  _remoteEvalErrorLoggingState(RooAbsReal::PrintErrors),
  _pipe(0),
  _updateMaster(0),
  _retrieveDispatched(kFALSE), _evalCarry(0.)
{  
  // Construct front-end object for object 'arg' whose evaluation will be calculated
  // asynchronously in a separate process. If calcInline is true the value of 'arg'
  // is calculate synchronously in the current process.
#ifdef _WIN32
  _inlineMode = kTRUE;
#endif
  initVars() ;
  _sentinel.add(*this) ;

}



//_____________________________________________________________________________
RooRealMPFE::RooRealMPFE(const RooRealMPFE& other, const char* name) : 
  RooAbsReal(other, name),
  _state(Initialize),
  _arg("arg",this,other._arg),
  _vars("vars",this,other._vars),
  _calcInProgress(kFALSE),
  _verboseClient(other._verboseClient),
  _verboseServer(other._verboseServer),
  _inlineMode(other._inlineMode),
  _forceCalc(other._forceCalc),
  _remoteEvalErrorLoggingState(other._remoteEvalErrorLoggingState),
  _pipe(0),
  _updateMaster(0),
  _retrieveDispatched(kFALSE), _evalCarry(other._evalCarry)
{
  // Copy constructor. Initializes in clean state so that upon eval
  // this instance will create its own server processes

  initVars() ;
  _sentinel.add(*this) ;
}



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

  if (_state==Client) standby();
  _sentinel.remove(*this);
}



//_____________________________________________________________________________
void RooRealMPFE::initVars()
{
  // Initialize list of variables of front-end argument 'arg'

  // Empty current lists
  _vars.removeAll() ;
  _saveVars.removeAll() ;

  // Retrieve non-constant parameters
  RooArgSet* vars = _arg.arg().getParameters(RooArgSet()) ;
  //RooArgSet* ncVars = (RooArgSet*) vars->selectByAttrib("Constant",kFALSE) ;
  RooArgList varList(*vars) ;

  // Save in lists 
  _vars.add(varList) ;
  _saveVars.addClone(varList) ;
  _valueChanged.resize(_vars.getSize()) ;
  _constChanged.resize(_vars.getSize()) ;

  // Force next calculation
  _forceCalc = kTRUE ;

  delete vars ;
  //delete ncVars ;
}

Double_t RooRealMPFE::getCarry() const
{
  if (_inlineMode) {
    RooAbsTestStatistic* tmp = dynamic_cast<RooAbsTestStatistic*>(_arg.absArg());
    if (tmp) return tmp->getCarry();
    else return 0.;
  } else {
    return _evalCarry;
  }
}

//_____________________________________________________________________________
void RooRealMPFE::initialize() 
{
  // Initialize the remote process and message passing
  // pipes between current process and remote process

  // Trivial case: Inline mode 
  if (_inlineMode) {
    _state = Inline ;
    return ;
  }

#ifndef _WIN32
  // Clear eval error log prior to forking
  // to avoid confusions...
  clearEvalErrorLog() ;
  // Fork server process and setup IPC
  _pipe = new BidirMMapPipe();
  
  if (_pipe->isChild()) {
    // Start server loop 
    RooTrace::callgrind_zero() ;
    _state = Server ;
    serverLoop();

    // Kill server at end of service
    if (_verboseServer) ccoutD(Minimization) << "RooRealMPFE::initialize(" <<
	GetName() << ") server process terminating" << endl ;

    delete _arg.absArg();
    delete _pipe;
    _exit(0) ;
  } else {
    // Client process - fork successul
    if (_verboseClient) ccoutD(Minimization) << "RooRealMPFE::initialize(" <<
	GetName() << ") successfully forked server process " <<
	    _pipe->pidOtherEnd() << endl ;
    _state = Client ;
    _calcInProgress = kFALSE ;
  }
#endif // _WIN32
}



//_____________________________________________________________________________
void RooRealMPFE::serverLoop() 
{
  // Server loop of remote processes. This function will return
  // only when an incoming TERMINATE message is received.

#ifndef _WIN32
  int msg ;

  Int_t idx, index, numErrors ;
  Double_t value ;
  Bool_t isConst ;
  
  clearEvalErrorLog() ;

  while(*_pipe && !_pipe->eof()) {
    *_pipe >> msg;
    if (Terminate == msg) {
      if (_verboseServer) cout << "RooRealMPFE::serverLoop(" << GetName() 
			       << ") IPC fromClient> Terminate" << endl; 
      // send terminate acknowledged to client
      *_pipe << msg << BidirMMapPipe::flush;
      break;
    }

    switch (msg) {
    case SendReal:
      {
	*_pipe >> idx >> value >> isConst;
	if (_verboseServer) cout << "RooRealMPFE::serverLoop(" << GetName() 
				 << ") IPC fromClient> SendReal [" << idx << "]=" << value << endl ;       
	RooRealVar* rvar = (RooRealVar*)_vars.at(idx) ;
	rvar->setVal(value) ;
	if (rvar->isConstant() != isConst) {
	  rvar->setConstant(isConst) ;
	}
      }
      break ;

    case SendCat:
      {
	*_pipe >> idx >> index;
	if (_verboseServer) cout << "RooRealMPFE::serverLoop(" << GetName() 
				 << ") IPC fromClient> SendCat [" << idx << "]=" << index << endl ; 
	((RooCategory*)_vars.at(idx))->setIndex(index) ;
      }
      break ;

    case Calculate:
      if (_verboseServer) cout << "RooRealMPFE::serverLoop(" << GetName() 
			       << ") IPC fromClient> Calculate" << endl ;       
      _value = _arg ;
      break ;

    case CalculateNoOffset:
      if (_verboseServer) cout << "RooRealMPFE::serverLoop(" << GetName() 
			       << ") IPC fromClient> Calculate" << endl ; 

      RooAbsReal::setHideOffset(kFALSE) ;
      _value = _arg ; 
      RooAbsReal::setHideOffset(kTRUE) ;
      break ;

    case Retrieve:
      {
	if (_verboseServer) cout << "RooRealMPFE::serverLoop(" << GetName() 
				 << ") IPC fromClient> Retrieve" << endl ; 
	msg = ReturnValue;
	numErrors = numEvalErrors();
	*_pipe << msg << _value << getCarry() << numErrors;

	if (_verboseServer) cout << "RooRealMPFE::serverLoop(" << GetName() 
				 << ") IPC toClient> ReturnValue " << _value << " NumError " << numErrors << endl ; 

	if (numErrors) {
	  // Loop over errors
	  std::string objidstr;
	  {
	    ostringstream oss2;
	    // Format string with object identity as this cannot be evaluated on the other side
	    oss2 << "PID" << gSystem->GetPid() << "/";
	    printStream(oss2,kName|kClassName|kArgs,kInline);
	    objidstr = oss2.str();
	  }
	  std::map<const RooAbsArg*,pair<string,list<EvalError> > >::const_iterator iter = evalErrorIter();
	  const RooAbsArg* ptr = 0;
	  for (int i = 0; i < numEvalErrorItems(); ++i) {
	    list<EvalError>::const_iterator iter2 = iter->second.second.begin();
	    for (; iter->second.second.end() != iter2; ++iter2) {
	      ptr = iter->first;
	      *_pipe << ptr << iter2->_msg << iter2->_srvval << objidstr;
	      if (_verboseServer) cout << "RooRealMPFE::serverLoop(" << GetName() 
		<< ") IPC toClient> sending error log Arg " << iter->first << " Msg " << iter2->_msg << endl ; 
	    }
	  } 
	  // let other end know that we're done with the list of errors
	  ptr = 0;
	  *_pipe << ptr;
	  // Clear error list on local side
	  clearEvalErrorLog();
	}
	*_pipe << BidirMMapPipe::flush;
      }
      break;

    case ConstOpt:
      {
	Bool_t doTrack ;
	int code;
	*_pipe >> code >> doTrack;
	if (_verboseServer) cout << "RooRealMPFE::serverLoop(" << GetName() 
				 << ") IPC fromClient> ConstOpt " << code << " doTrack = " << (doTrack?"T":"F") << endl ; 
	((RooAbsReal&)_arg.arg()).constOptimizeTestStatistic(static_cast<RooAbsArg::ConstOpCode>(code),doTrack) ;
	break ;
      }

    case Verbose:
      {
      Bool_t flag ;
      *_pipe >> flag;
      if (_verboseServer) cout << "RooRealMPFE::serverLoop(" << GetName() 
			       << ") IPC fromClient> Verbose " << (flag?1:0) << endl ; 
      _verboseServer = flag ;
      }
      break ;

      
    case ApplyNLLW2:
      {
      Bool_t flag ;
      *_pipe >> flag;
      if (_verboseServer) cout << "RooRealMPFE::serverLoop(" << GetName() 
			       << ") IPC fromClient> ApplyNLLW2 " << (flag?1:0) << endl ; 
      
      // Do application of weight-squared here
      doApplyNLLW2(flag) ;
      }
      break ;

    case EnableOffset:
      {
      Bool_t flag ;
      *_pipe >> flag;
      if (_verboseServer) cout << "RooRealMPFE::serverLoop(" << GetName() 
			       << ") IPC fromClient> EnableOffset " << (flag?1:0) << endl ; 
      
      // Enable likelihoof offsetting here
      ((RooAbsReal&)_arg.arg()).enableOffsetting(flag) ;
      }
      break ;

    case LogEvalError:
      {
	int iflag2;
	*_pipe >> iflag2;
	RooAbsReal::ErrorLoggingMode flag2 = static_cast<RooAbsReal::ErrorLoggingMode>(iflag2);
	RooAbsReal::setEvalErrorLoggingMode(flag2) ;
	if (_verboseServer) cout << "RooRealMPFE::serverLoop(" << GetName() 
				 << ") IPC fromClient> LogEvalError flag = " << flag2 << endl ;       
      }
      break ;


    default:
      if (_verboseServer) cout << "RooRealMPFE::serverLoop(" << GetName() 
			       << ") IPC fromClient> Unknown message (code = " << msg << ")" << endl ; 
      break ;
    }
  }

#endif // _WIN32
}



//_____________________________________________________________________________
void RooRealMPFE::calculate() const 
{
  // Client-side function that instructs server process to start
  // asynchronuous (re)calculation of function value. This function
  // returns immediately. The calculated value can be retrieved
  // using getVal()


  // Start asynchronous calculation of arg value
  if (_state==Initialize) {
    //     cout << "RooRealMPFE::calculate(" << GetName() << ") initializing" << endl ;
    const_cast<RooRealMPFE*>(this)->initialize() ;
  }

  // Inline mode -- Calculate value now
  if (_state==Inline) {
    //     cout << "RooRealMPFE::calculate(" << GetName() << ") performing Inline calculation NOW" << endl ;
    _value = _arg ;
    clearValueDirty() ;
  }

#ifndef _WIN32
  // Compare current value of variables with saved values and send changes to server
  if (_state==Client) {
    //     cout << "RooRealMPFE::calculate(" << GetName() << ") state is Client trigger remote calculation" << endl ;
    Int_t i(0) ;
    RooFIter viter = _vars.fwdIterator() ;
    RooFIter siter = _saveVars.fwdIterator() ;
    
    //for (i=0 ; i<_vars.getSize() ; i++) {
    RooAbsArg *var, *saveVar ;
    while((var = viter.next())) {
      saveVar = siter.next() ;

      //Bool_t valChanged = !(*var==*saveVar) ;      
      Bool_t valChanged,constChanged  ;
      if (!_updateMaster) {
	valChanged = !var->isIdentical(*saveVar,kTRUE) ;
	constChanged = (var->isConstant() != saveVar->isConstant()) ;	       
	_valueChanged[i] = valChanged ; 
	_constChanged[i] = constChanged ; 
      } else {
	valChanged = _updateMaster->_valueChanged[i] ;
	constChanged = _updateMaster->_constChanged[i] ;
      }

      if ( valChanged || constChanged || _forceCalc) {	
	//cout << "RooRealMPFE::calculate(" << GetName() << " variable " << var->GetName() << " changed " << endl ;
	if (_verboseClient) cout << "RooRealMPFE::calculate(" << GetName()
				 << ") variable " << _vars.at(i)->GetName() << " changed" << endl ;
	if (constChanged) {
	  ((RooRealVar*)saveVar)->setConstant(var->isConstant()) ;
	}
	saveVar->copyCache(var) ;
	
	// send message to server
	if (dynamic_cast<RooAbsReal*>(var)) {
	  int msg = SendReal ;
	  Double_t val = ((RooAbsReal*)var)->getVal() ;
	  Bool_t isC = var->isConstant() ;
	  *_pipe << msg << i << val << isC;

	  if (_verboseServer) cout << "RooRealMPFE::calculate(" << GetName() 
				   << ") IPC toServer> SendReal [" << i << "]=" << val << (isC?" (Constant)":"") <<  endl ;
	} else if (dynamic_cast<RooAbsCategory*>(var)) {
	  int msg = SendCat ;
	  UInt_t idx = ((RooAbsCategory*)var)->getIndex() ;
	  *_pipe << msg << i << idx;
	  if (_verboseServer) cout << "RooRealMPFE::calculate(" << GetName() 
				   << ") IPC toServer> SendCat [" << i << "]=" << idx << endl ;
	}
      }
      i++ ;
    }

    int msg = hideOffset() ? Calculate : CalculateNoOffset;
    *_pipe << msg;
    if (_verboseServer) cout << "RooRealMPFE::calculate(" << GetName() 
			     << ") IPC toServer> Calculate " << endl ;

    // Clear dirty state and mark that calculation request was dispatched
    clearValueDirty() ;
    _calcInProgress = kTRUE ;
    _forceCalc = kFALSE ;

    msg = Retrieve ;
    *_pipe << msg << BidirMMapPipe::flush;
    if (_verboseServer) cout << "RooRealMPFE::evaluate(" << GetName() 
			     << ") IPC toServer> Retrieve " << endl ;    
    _retrieveDispatched = kTRUE ;        

  } else if (_state!=Inline) {
    cout << "RooRealMPFE::calculate(" << GetName() 
	 << ") ERROR not in Client or Inline mode" << endl ;
  }

  
#endif // _WIN32
}




//_____________________________________________________________________________
Double_t RooRealMPFE::getValV(const RooArgSet* /*nset*/) const 
{
  // If value needs recalculation and calculation has not beed started
  // with a call to calculate() start it now. This function blocks
  // until remote process has finished calculation and returns
  // remote value
  

  if (isValueDirty()) {
    // Cache is dirty, no calculation has been started yet
    //cout << "RooRealMPFE::getValF(" << GetName() << ") cache is dirty, caling calculate and evaluate" << endl ;
    calculate() ;
    _value = evaluate() ;
  } else if (_calcInProgress) {
    //cout << "RooRealMPFE::getValF(" << GetName() << ") calculation in progress, calling evaluate" << endl ;
    // Cache is clean and calculation is in progress
    _value = evaluate() ;    
  } else {
    //cout << "RooRealMPFE::getValF(" << GetName() << ") cache is clean, doing nothing" << endl ;
    // Cache is clean and calculated value is in cache
  }

//   cout << "RooRealMPFE::getValV(" << GetName() << ") value = " << Form("%5.10f",_value) << endl ;
  return _value ;  
}



//_____________________________________________________________________________
Double_t RooRealMPFE::evaluate() const
{
  // Send message to server process to retrieve output value
  // If error were logged use logEvalError() on remote side
  // transfer those errors to the local eval error queue.

  // Retrieve value of arg
  Double_t return_value = 0;
  if (_state==Inline) {
    return_value = _arg ; 
  } else if (_state==Client) {
#ifndef _WIN32
    bool needflush = false;
    int msg;
    Double_t value;

    // If current error loggin state is not the same as remote state
    // update the remote state
    if (evalErrorLoggingMode() != _remoteEvalErrorLoggingState) {
      msg = LogEvalError ;
      RooAbsReal::ErrorLoggingMode flag = evalErrorLoggingMode() ;
      *_pipe << msg << flag;
      needflush = true;
      _remoteEvalErrorLoggingState = evalErrorLoggingMode() ;
    }

    if (!_retrieveDispatched) {
      msg = Retrieve ;
      *_pipe << msg;
      needflush = true;
      if (_verboseServer) cout << "RooRealMPFE::evaluate(" << GetName() 
			       << ") IPC toServer> Retrieve " << endl ;    
    }
    if (needflush) *_pipe << BidirMMapPipe::flush;
    _retrieveDispatched = kFALSE ;


    Int_t numError;

    *_pipe >> msg >> value >> _evalCarry >> numError;
    
    if (msg!=ReturnValue) {
      cout << "RooRealMPFE::evaluate(" << GetName() 
	   << ") ERROR: unexpected message from server process: " << msg << endl ;
      return 0 ;
    }
    if (_verboseServer) cout << "RooRealMPFE::evaluate(" << GetName() 
			     << ") IPC fromServer> ReturnValue " << value << endl ;

    if (_verboseServer) cout << "RooRealMPFE::evaluate(" << GetName() 
			     << ") IPC fromServer> NumErrors " << numError << endl ;
    if (numError) {
      // Retrieve remote errors and feed into local error queue
      char *msgbuf1 = 0, *msgbuf2 = 0, *msgbuf3 = 0;
      RooAbsArg *ptr = 0;
      while (true) {
	*_pipe >> ptr;
	if (!ptr) break;
	*_pipe >> msgbuf1 >> msgbuf2 >> msgbuf3;
	if (_verboseServer) cout << "RooRealMPFE::evaluate(" << GetName() 
	  << ") IPC fromServer> retrieving error log Arg " << ptr << " Msg " << msgbuf1 << endl ;    

	logEvalError(reinterpret_cast<RooAbsReal*>(ptr),msgbuf3,msgbuf1,msgbuf2) ;
      }
      std::free(msgbuf1);
      std::free(msgbuf2);
      std::free(msgbuf3);
    }

    // Mark end of calculation in progress 
    _calcInProgress = kFALSE ;
    return_value = value ;
#endif // _WIN32
  }

  return return_value;
}



//_____________________________________________________________________________
void RooRealMPFE::standby()
{
  // Terminate remote server process and return front-end class
  // to standby mode. Calls to calculate() or evaluate() after
  // this call will automatically recreated the server process.

#ifndef _WIN32
  if (_state==Client) {
    if (_pipe->good()) {
      // Terminate server process ;
      if (_verboseServer) cout << "RooRealMPFE::standby(" << GetName() 
	<< ") IPC toServer> Terminate " << endl; 
      int msg = Terminate;
      *_pipe << msg << BidirMMapPipe::flush;
      // read handshake
      msg = 0;
      *_pipe >> msg;
      if (Terminate != msg || 0 != _pipe->close()) {
	std::cerr << "In " << __func__ << "(" << __FILE__ ", " << __LINE__ <<
	  "): Server shutdown failed." << std::endl;
      }
    } else {
      if (_verboseServer) {
	std::cerr << "In " << __func__ << "(" << __FILE__ ", " <<
	  __LINE__ << "): Pipe has already shut down, not sending "
	  "Terminate to server." << std::endl;
      }
    }
    // Close pipes
    delete _pipe;
    _pipe = 0;
    
    // Revert to initialize state 
    _state = Initialize;
  }
#endif // _WIN32
}



//_____________________________________________________________________________
void RooRealMPFE::constOptimizeTestStatistic(ConstOpCode opcode, Bool_t doAlsoTracking) 
{
  // Intercept call to optimize constant term in test statistics
  // and forward it to object on server side.

#ifndef _WIN32
  if (_state==Client) {

    int msg = ConstOpt ;
    int op = opcode;
    *_pipe << msg << op << doAlsoTracking;
    if (_verboseServer) cout << "RooRealMPFE::constOptimize(" << GetName() 
			     << ") IPC toServer> ConstOpt " << opcode << endl ;  

    initVars() ;
  }
#endif // _WIN32

  if (_state==Inline) {
    ((RooAbsReal&)_arg.arg()).constOptimizeTestStatistic(opcode,doAlsoTracking) ;
  }
}



//_____________________________________________________________________________
void RooRealMPFE::setVerbose(Bool_t clientFlag, Bool_t serverFlag) 
{
  // Control verbose messaging related to inter process communication
  // on both client and server side

#ifndef _WIN32
  if (_state==Client) {
    int msg = Verbose ;
    *_pipe << msg << serverFlag;
    if (_verboseServer) cout << "RooRealMPFE::setVerbose(" << GetName() 
			     << ") IPC toServer> Verbose " << (serverFlag?1:0) << endl ;      
  }
#endif // _WIN32
  _verboseClient = clientFlag ; _verboseServer = serverFlag ;
}


//_____________________________________________________________________________
void RooRealMPFE::applyNLLWeightSquared(Bool_t flag) 
{
  // Control verbose messaging related to inter process communication
  // on both client and server side

#ifndef _WIN32
  if (_state==Client) {
    int msg = ApplyNLLW2 ;
    *_pipe << msg << flag;
    if (_verboseServer) cout << "RooRealMPFE::applyNLLWeightSquared(" << GetName() 
			     << ") IPC toServer> ApplyNLLW2 " << (flag?1:0) << endl ;      
  } 
#endif // _WIN32
  doApplyNLLW2(flag) ;
}


//_____________________________________________________________________________
void RooRealMPFE::doApplyNLLW2(Bool_t flag) 
{
  RooNLLVar* nll = dynamic_cast<RooNLLVar*>(_arg.absArg()) ;
  if (nll) {
    nll->applyWeightSquared(flag) ;
  }  
}


//_____________________________________________________________________________
void RooRealMPFE::enableOffsetting(Bool_t flag) 
{
  // Control verbose messaging related to inter process communication
  // on both client and server side

#ifndef _WIN32
  if (_state==Client) {
    int msg = EnableOffset ;
    *_pipe << msg << flag;
    if (_verboseServer) cout << "RooRealMPFE::enableOffsetting(" << GetName() 
			     << ") IPC toServer> EnableOffset " << (flag?1:0) << endl ;      
  } 
#endif // _WIN32
  ((RooAbsReal&)_arg.arg()).enableOffsetting(flag) ;
}



 RooRealMPFE.cxx:1
 RooRealMPFE.cxx:2
 RooRealMPFE.cxx:3
 RooRealMPFE.cxx:4
 RooRealMPFE.cxx:5
 RooRealMPFE.cxx:6
 RooRealMPFE.cxx:7
 RooRealMPFE.cxx:8
 RooRealMPFE.cxx:9
 RooRealMPFE.cxx:10
 RooRealMPFE.cxx:11
 RooRealMPFE.cxx:12
 RooRealMPFE.cxx:13
 RooRealMPFE.cxx:14
 RooRealMPFE.cxx:15
 RooRealMPFE.cxx:16
 RooRealMPFE.cxx:17
 RooRealMPFE.cxx:18
 RooRealMPFE.cxx:19
 RooRealMPFE.cxx:20
 RooRealMPFE.cxx:21
 RooRealMPFE.cxx:22
 RooRealMPFE.cxx:23
 RooRealMPFE.cxx:24
 RooRealMPFE.cxx:25
 RooRealMPFE.cxx:26
 RooRealMPFE.cxx:27
 RooRealMPFE.cxx:28
 RooRealMPFE.cxx:29
 RooRealMPFE.cxx:30
 RooRealMPFE.cxx:31
 RooRealMPFE.cxx:32
 RooRealMPFE.cxx:33
 RooRealMPFE.cxx:34
 RooRealMPFE.cxx:35
 RooRealMPFE.cxx:36
 RooRealMPFE.cxx:37
 RooRealMPFE.cxx:38
 RooRealMPFE.cxx:39
 RooRealMPFE.cxx:40
 RooRealMPFE.cxx:41
 RooRealMPFE.cxx:42
 RooRealMPFE.cxx:43
 RooRealMPFE.cxx:44
 RooRealMPFE.cxx:45
 RooRealMPFE.cxx:46
 RooRealMPFE.cxx:47
 RooRealMPFE.cxx:48
 RooRealMPFE.cxx:49
 RooRealMPFE.cxx:50
 RooRealMPFE.cxx:51
 RooRealMPFE.cxx:52
 RooRealMPFE.cxx:53
 RooRealMPFE.cxx:54
 RooRealMPFE.cxx:55
 RooRealMPFE.cxx:56
 RooRealMPFE.cxx:57
 RooRealMPFE.cxx:58
 RooRealMPFE.cxx:59
 RooRealMPFE.cxx:60
 RooRealMPFE.cxx:61
 RooRealMPFE.cxx:62
 RooRealMPFE.cxx:63
 RooRealMPFE.cxx:64
 RooRealMPFE.cxx:65
 RooRealMPFE.cxx:66
 RooRealMPFE.cxx:67
 RooRealMPFE.cxx:68
 RooRealMPFE.cxx:69
 RooRealMPFE.cxx:70
 RooRealMPFE.cxx:71
 RooRealMPFE.cxx:72
 RooRealMPFE.cxx:73
 RooRealMPFE.cxx:74
 RooRealMPFE.cxx:75
 RooRealMPFE.cxx:76
 RooRealMPFE.cxx:77
 RooRealMPFE.cxx:78
 RooRealMPFE.cxx:79
 RooRealMPFE.cxx:80
 RooRealMPFE.cxx:81
 RooRealMPFE.cxx:82
 RooRealMPFE.cxx:83
 RooRealMPFE.cxx:84
 RooRealMPFE.cxx:85
 RooRealMPFE.cxx:86
 RooRealMPFE.cxx:87
 RooRealMPFE.cxx:88
 RooRealMPFE.cxx:89
 RooRealMPFE.cxx:90
 RooRealMPFE.cxx:91
 RooRealMPFE.cxx:92
 RooRealMPFE.cxx:93
 RooRealMPFE.cxx:94
 RooRealMPFE.cxx:95
 RooRealMPFE.cxx:96
 RooRealMPFE.cxx:97
 RooRealMPFE.cxx:98
 RooRealMPFE.cxx:99
 RooRealMPFE.cxx:100
 RooRealMPFE.cxx:101
 RooRealMPFE.cxx:102
 RooRealMPFE.cxx:103
 RooRealMPFE.cxx:104
 RooRealMPFE.cxx:105
 RooRealMPFE.cxx:106
 RooRealMPFE.cxx:107
 RooRealMPFE.cxx:108
 RooRealMPFE.cxx:109
 RooRealMPFE.cxx:110
 RooRealMPFE.cxx:111
 RooRealMPFE.cxx:112
 RooRealMPFE.cxx:113
 RooRealMPFE.cxx:114
 RooRealMPFE.cxx:115
 RooRealMPFE.cxx:116
 RooRealMPFE.cxx:117
 RooRealMPFE.cxx:118
 RooRealMPFE.cxx:119
 RooRealMPFE.cxx:120
 RooRealMPFE.cxx:121
 RooRealMPFE.cxx:122
 RooRealMPFE.cxx:123
 RooRealMPFE.cxx:124
 RooRealMPFE.cxx:125
 RooRealMPFE.cxx:126
 RooRealMPFE.cxx:127
 RooRealMPFE.cxx:128
 RooRealMPFE.cxx:129
 RooRealMPFE.cxx:130
 RooRealMPFE.cxx:131
 RooRealMPFE.cxx:132
 RooRealMPFE.cxx:133
 RooRealMPFE.cxx:134
 RooRealMPFE.cxx:135
 RooRealMPFE.cxx:136
 RooRealMPFE.cxx:137
 RooRealMPFE.cxx:138
 RooRealMPFE.cxx:139
 RooRealMPFE.cxx:140
 RooRealMPFE.cxx:141
 RooRealMPFE.cxx:142
 RooRealMPFE.cxx:143
 RooRealMPFE.cxx:144
 RooRealMPFE.cxx:145
 RooRealMPFE.cxx:146
 RooRealMPFE.cxx:147
 RooRealMPFE.cxx:148
 RooRealMPFE.cxx:149
 RooRealMPFE.cxx:150
 RooRealMPFE.cxx:151
 RooRealMPFE.cxx:152
 RooRealMPFE.cxx:153
 RooRealMPFE.cxx:154
 RooRealMPFE.cxx:155
 RooRealMPFE.cxx:156
 RooRealMPFE.cxx:157
 RooRealMPFE.cxx:158
 RooRealMPFE.cxx:159
 RooRealMPFE.cxx:160
 RooRealMPFE.cxx:161
 RooRealMPFE.cxx:162
 RooRealMPFE.cxx:163
 RooRealMPFE.cxx:164
 RooRealMPFE.cxx:165
 RooRealMPFE.cxx:166
 RooRealMPFE.cxx:167
 RooRealMPFE.cxx:168
 RooRealMPFE.cxx:169
 RooRealMPFE.cxx:170
 RooRealMPFE.cxx:171
 RooRealMPFE.cxx:172
 RooRealMPFE.cxx:173
 RooRealMPFE.cxx:174
 RooRealMPFE.cxx:175
 RooRealMPFE.cxx:176
 RooRealMPFE.cxx:177
 RooRealMPFE.cxx:178
 RooRealMPFE.cxx:179
 RooRealMPFE.cxx:180
 RooRealMPFE.cxx:181
 RooRealMPFE.cxx:182
 RooRealMPFE.cxx:183
 RooRealMPFE.cxx:184
 RooRealMPFE.cxx:185
 RooRealMPFE.cxx:186
 RooRealMPFE.cxx:187
 RooRealMPFE.cxx:188
 RooRealMPFE.cxx:189
 RooRealMPFE.cxx:190
 RooRealMPFE.cxx:191
 RooRealMPFE.cxx:192
 RooRealMPFE.cxx:193
 RooRealMPFE.cxx:194
 RooRealMPFE.cxx:195
 RooRealMPFE.cxx:196
 RooRealMPFE.cxx:197
 RooRealMPFE.cxx:198
 RooRealMPFE.cxx:199
 RooRealMPFE.cxx:200
 RooRealMPFE.cxx:201
 RooRealMPFE.cxx:202
 RooRealMPFE.cxx:203
 RooRealMPFE.cxx:204
 RooRealMPFE.cxx:205
 RooRealMPFE.cxx:206
 RooRealMPFE.cxx:207
 RooRealMPFE.cxx:208
 RooRealMPFE.cxx:209
 RooRealMPFE.cxx:210
 RooRealMPFE.cxx:211
 RooRealMPFE.cxx:212
 RooRealMPFE.cxx:213
 RooRealMPFE.cxx:214
 RooRealMPFE.cxx:215
 RooRealMPFE.cxx:216
 RooRealMPFE.cxx:217
 RooRealMPFE.cxx:218
 RooRealMPFE.cxx:219
 RooRealMPFE.cxx:220
 RooRealMPFE.cxx:221
 RooRealMPFE.cxx:222
 RooRealMPFE.cxx:223
 RooRealMPFE.cxx:224
 RooRealMPFE.cxx:225
 RooRealMPFE.cxx:226
 RooRealMPFE.cxx:227
 RooRealMPFE.cxx:228
 RooRealMPFE.cxx:229
 RooRealMPFE.cxx:230
 RooRealMPFE.cxx:231
 RooRealMPFE.cxx:232
 RooRealMPFE.cxx:233
 RooRealMPFE.cxx:234
 RooRealMPFE.cxx:235
 RooRealMPFE.cxx:236
 RooRealMPFE.cxx:237
 RooRealMPFE.cxx:238
 RooRealMPFE.cxx:239
 RooRealMPFE.cxx:240
 RooRealMPFE.cxx:241
 RooRealMPFE.cxx:242
 RooRealMPFE.cxx:243
 RooRealMPFE.cxx:244
 RooRealMPFE.cxx:245
 RooRealMPFE.cxx:246
 RooRealMPFE.cxx:247
 RooRealMPFE.cxx:248
 RooRealMPFE.cxx:249
 RooRealMPFE.cxx:250
 RooRealMPFE.cxx:251
 RooRealMPFE.cxx:252
 RooRealMPFE.cxx:253
 RooRealMPFE.cxx:254
 RooRealMPFE.cxx:255
 RooRealMPFE.cxx:256
 RooRealMPFE.cxx:257
 RooRealMPFE.cxx:258
 RooRealMPFE.cxx:259
 RooRealMPFE.cxx:260
 RooRealMPFE.cxx:261
 RooRealMPFE.cxx:262
 RooRealMPFE.cxx:263
 RooRealMPFE.cxx:264
 RooRealMPFE.cxx:265
 RooRealMPFE.cxx:266
 RooRealMPFE.cxx:267
 RooRealMPFE.cxx:268
 RooRealMPFE.cxx:269
 RooRealMPFE.cxx:270
 RooRealMPFE.cxx:271
 RooRealMPFE.cxx:272
 RooRealMPFE.cxx:273
 RooRealMPFE.cxx:274
 RooRealMPFE.cxx:275
 RooRealMPFE.cxx:276
 RooRealMPFE.cxx:277
 RooRealMPFE.cxx:278
 RooRealMPFE.cxx:279
 RooRealMPFE.cxx:280
 RooRealMPFE.cxx:281
 RooRealMPFE.cxx:282
 RooRealMPFE.cxx:283
 RooRealMPFE.cxx:284
 RooRealMPFE.cxx:285
 RooRealMPFE.cxx:286
 RooRealMPFE.cxx:287
 RooRealMPFE.cxx:288
 RooRealMPFE.cxx:289
 RooRealMPFE.cxx:290
 RooRealMPFE.cxx:291
 RooRealMPFE.cxx:292
 RooRealMPFE.cxx:293
 RooRealMPFE.cxx:294
 RooRealMPFE.cxx:295
 RooRealMPFE.cxx:296
 RooRealMPFE.cxx:297
 RooRealMPFE.cxx:298
 RooRealMPFE.cxx:299
 RooRealMPFE.cxx:300
 RooRealMPFE.cxx:301
 RooRealMPFE.cxx:302
 RooRealMPFE.cxx:303
 RooRealMPFE.cxx:304
 RooRealMPFE.cxx:305
 RooRealMPFE.cxx:306
 RooRealMPFE.cxx:307
 RooRealMPFE.cxx:308
 RooRealMPFE.cxx:309
 RooRealMPFE.cxx:310
 RooRealMPFE.cxx:311
 RooRealMPFE.cxx:312
 RooRealMPFE.cxx:313
 RooRealMPFE.cxx:314
 RooRealMPFE.cxx:315
 RooRealMPFE.cxx:316
 RooRealMPFE.cxx:317
 RooRealMPFE.cxx:318
 RooRealMPFE.cxx:319
 RooRealMPFE.cxx:320
 RooRealMPFE.cxx:321
 RooRealMPFE.cxx:322
 RooRealMPFE.cxx:323
 RooRealMPFE.cxx:324
 RooRealMPFE.cxx:325
 RooRealMPFE.cxx:326
 RooRealMPFE.cxx:327
 RooRealMPFE.cxx:328
 RooRealMPFE.cxx:329
 RooRealMPFE.cxx:330
 RooRealMPFE.cxx:331
 RooRealMPFE.cxx:332
 RooRealMPFE.cxx:333
 RooRealMPFE.cxx:334
 RooRealMPFE.cxx:335
 RooRealMPFE.cxx:336
 RooRealMPFE.cxx:337
 RooRealMPFE.cxx:338
 RooRealMPFE.cxx:339
 RooRealMPFE.cxx:340
 RooRealMPFE.cxx:341
 RooRealMPFE.cxx:342
 RooRealMPFE.cxx:343
 RooRealMPFE.cxx:344
 RooRealMPFE.cxx:345
 RooRealMPFE.cxx:346
 RooRealMPFE.cxx:347
 RooRealMPFE.cxx:348
 RooRealMPFE.cxx:349
 RooRealMPFE.cxx:350
 RooRealMPFE.cxx:351
 RooRealMPFE.cxx:352
 RooRealMPFE.cxx:353
 RooRealMPFE.cxx:354
 RooRealMPFE.cxx:355
 RooRealMPFE.cxx:356
 RooRealMPFE.cxx:357
 RooRealMPFE.cxx:358
 RooRealMPFE.cxx:359
 RooRealMPFE.cxx:360
 RooRealMPFE.cxx:361
 RooRealMPFE.cxx:362
 RooRealMPFE.cxx:363
 RooRealMPFE.cxx:364
 RooRealMPFE.cxx:365
 RooRealMPFE.cxx:366
 RooRealMPFE.cxx:367
 RooRealMPFE.cxx:368
 RooRealMPFE.cxx:369
 RooRealMPFE.cxx:370
 RooRealMPFE.cxx:371
 RooRealMPFE.cxx:372
 RooRealMPFE.cxx:373
 RooRealMPFE.cxx:374
 RooRealMPFE.cxx:375
 RooRealMPFE.cxx:376
 RooRealMPFE.cxx:377
 RooRealMPFE.cxx:378
 RooRealMPFE.cxx:379
 RooRealMPFE.cxx:380
 RooRealMPFE.cxx:381
 RooRealMPFE.cxx:382
 RooRealMPFE.cxx:383
 RooRealMPFE.cxx:384
 RooRealMPFE.cxx:385
 RooRealMPFE.cxx:386
 RooRealMPFE.cxx:387
 RooRealMPFE.cxx:388
 RooRealMPFE.cxx:389
 RooRealMPFE.cxx:390
 RooRealMPFE.cxx:391
 RooRealMPFE.cxx:392
 RooRealMPFE.cxx:393
 RooRealMPFE.cxx:394
 RooRealMPFE.cxx:395
 RooRealMPFE.cxx:396
 RooRealMPFE.cxx:397
 RooRealMPFE.cxx:398
 RooRealMPFE.cxx:399
 RooRealMPFE.cxx:400
 RooRealMPFE.cxx:401
 RooRealMPFE.cxx:402
 RooRealMPFE.cxx:403
 RooRealMPFE.cxx:404
 RooRealMPFE.cxx:405
 RooRealMPFE.cxx:406
 RooRealMPFE.cxx:407
 RooRealMPFE.cxx:408
 RooRealMPFE.cxx:409
 RooRealMPFE.cxx:410
 RooRealMPFE.cxx:411
 RooRealMPFE.cxx:412
 RooRealMPFE.cxx:413
 RooRealMPFE.cxx:414
 RooRealMPFE.cxx:415
 RooRealMPFE.cxx:416
 RooRealMPFE.cxx:417
 RooRealMPFE.cxx:418
 RooRealMPFE.cxx:419
 RooRealMPFE.cxx:420
 RooRealMPFE.cxx:421
 RooRealMPFE.cxx:422
 RooRealMPFE.cxx:423
 RooRealMPFE.cxx:424
 RooRealMPFE.cxx:425
 RooRealMPFE.cxx:426
 RooRealMPFE.cxx:427
 RooRealMPFE.cxx:428
 RooRealMPFE.cxx:429
 RooRealMPFE.cxx:430
 RooRealMPFE.cxx:431
 RooRealMPFE.cxx:432
 RooRealMPFE.cxx:433
 RooRealMPFE.cxx:434
 RooRealMPFE.cxx:435
 RooRealMPFE.cxx:436
 RooRealMPFE.cxx:437
 RooRealMPFE.cxx:438
 RooRealMPFE.cxx:439
 RooRealMPFE.cxx:440
 RooRealMPFE.cxx:441
 RooRealMPFE.cxx:442
 RooRealMPFE.cxx:443
 RooRealMPFE.cxx:444
 RooRealMPFE.cxx:445
 RooRealMPFE.cxx:446
 RooRealMPFE.cxx:447
 RooRealMPFE.cxx:448
 RooRealMPFE.cxx:449
 RooRealMPFE.cxx:450
 RooRealMPFE.cxx:451
 RooRealMPFE.cxx:452
 RooRealMPFE.cxx:453
 RooRealMPFE.cxx:454
 RooRealMPFE.cxx:455
 RooRealMPFE.cxx:456
 RooRealMPFE.cxx:457
 RooRealMPFE.cxx:458
 RooRealMPFE.cxx:459
 RooRealMPFE.cxx:460
 RooRealMPFE.cxx:461
 RooRealMPFE.cxx:462
 RooRealMPFE.cxx:463
 RooRealMPFE.cxx:464
 RooRealMPFE.cxx:465
 RooRealMPFE.cxx:466
 RooRealMPFE.cxx:467
 RooRealMPFE.cxx:468
 RooRealMPFE.cxx:469
 RooRealMPFE.cxx:470
 RooRealMPFE.cxx:471
 RooRealMPFE.cxx:472
 RooRealMPFE.cxx:473
 RooRealMPFE.cxx:474
 RooRealMPFE.cxx:475
 RooRealMPFE.cxx:476
 RooRealMPFE.cxx:477
 RooRealMPFE.cxx:478
 RooRealMPFE.cxx:479
 RooRealMPFE.cxx:480
 RooRealMPFE.cxx:481
 RooRealMPFE.cxx:482
 RooRealMPFE.cxx:483
 RooRealMPFE.cxx:484
 RooRealMPFE.cxx:485
 RooRealMPFE.cxx:486
 RooRealMPFE.cxx:487
 RooRealMPFE.cxx:488
 RooRealMPFE.cxx:489
 RooRealMPFE.cxx:490
 RooRealMPFE.cxx:491
 RooRealMPFE.cxx:492
 RooRealMPFE.cxx:493
 RooRealMPFE.cxx:494
 RooRealMPFE.cxx:495
 RooRealMPFE.cxx:496
 RooRealMPFE.cxx:497
 RooRealMPFE.cxx:498
 RooRealMPFE.cxx:499
 RooRealMPFE.cxx:500
 RooRealMPFE.cxx:501
 RooRealMPFE.cxx:502
 RooRealMPFE.cxx:503
 RooRealMPFE.cxx:504
 RooRealMPFE.cxx:505
 RooRealMPFE.cxx:506
 RooRealMPFE.cxx:507
 RooRealMPFE.cxx:508
 RooRealMPFE.cxx:509
 RooRealMPFE.cxx:510
 RooRealMPFE.cxx:511
 RooRealMPFE.cxx:512
 RooRealMPFE.cxx:513
 RooRealMPFE.cxx:514
 RooRealMPFE.cxx:515
 RooRealMPFE.cxx:516
 RooRealMPFE.cxx:517
 RooRealMPFE.cxx:518
 RooRealMPFE.cxx:519
 RooRealMPFE.cxx:520
 RooRealMPFE.cxx:521
 RooRealMPFE.cxx:522
 RooRealMPFE.cxx:523
 RooRealMPFE.cxx:524
 RooRealMPFE.cxx:525
 RooRealMPFE.cxx:526
 RooRealMPFE.cxx:527
 RooRealMPFE.cxx:528
 RooRealMPFE.cxx:529
 RooRealMPFE.cxx:530
 RooRealMPFE.cxx:531
 RooRealMPFE.cxx:532
 RooRealMPFE.cxx:533
 RooRealMPFE.cxx:534
 RooRealMPFE.cxx:535
 RooRealMPFE.cxx:536
 RooRealMPFE.cxx:537
 RooRealMPFE.cxx:538
 RooRealMPFE.cxx:539
 RooRealMPFE.cxx:540
 RooRealMPFE.cxx:541
 RooRealMPFE.cxx:542
 RooRealMPFE.cxx:543
 RooRealMPFE.cxx:544
 RooRealMPFE.cxx:545
 RooRealMPFE.cxx:546
 RooRealMPFE.cxx:547
 RooRealMPFE.cxx:548
 RooRealMPFE.cxx:549
 RooRealMPFE.cxx:550
 RooRealMPFE.cxx:551
 RooRealMPFE.cxx:552
 RooRealMPFE.cxx:553
 RooRealMPFE.cxx:554
 RooRealMPFE.cxx:555
 RooRealMPFE.cxx:556
 RooRealMPFE.cxx:557
 RooRealMPFE.cxx:558
 RooRealMPFE.cxx:559
 RooRealMPFE.cxx:560
 RooRealMPFE.cxx:561
 RooRealMPFE.cxx:562
 RooRealMPFE.cxx:563
 RooRealMPFE.cxx:564
 RooRealMPFE.cxx:565
 RooRealMPFE.cxx:566
 RooRealMPFE.cxx:567
 RooRealMPFE.cxx:568
 RooRealMPFE.cxx:569
 RooRealMPFE.cxx:570
 RooRealMPFE.cxx:571
 RooRealMPFE.cxx:572
 RooRealMPFE.cxx:573
 RooRealMPFE.cxx:574
 RooRealMPFE.cxx:575
 RooRealMPFE.cxx:576
 RooRealMPFE.cxx:577
 RooRealMPFE.cxx:578
 RooRealMPFE.cxx:579
 RooRealMPFE.cxx:580
 RooRealMPFE.cxx:581
 RooRealMPFE.cxx:582
 RooRealMPFE.cxx:583
 RooRealMPFE.cxx:584
 RooRealMPFE.cxx:585
 RooRealMPFE.cxx:586
 RooRealMPFE.cxx:587
 RooRealMPFE.cxx:588
 RooRealMPFE.cxx:589
 RooRealMPFE.cxx:590
 RooRealMPFE.cxx:591
 RooRealMPFE.cxx:592
 RooRealMPFE.cxx:593
 RooRealMPFE.cxx:594
 RooRealMPFE.cxx:595
 RooRealMPFE.cxx:596
 RooRealMPFE.cxx:597
 RooRealMPFE.cxx:598
 RooRealMPFE.cxx:599
 RooRealMPFE.cxx:600
 RooRealMPFE.cxx:601
 RooRealMPFE.cxx:602
 RooRealMPFE.cxx:603
 RooRealMPFE.cxx:604
 RooRealMPFE.cxx:605
 RooRealMPFE.cxx:606
 RooRealMPFE.cxx:607
 RooRealMPFE.cxx:608
 RooRealMPFE.cxx:609
 RooRealMPFE.cxx:610
 RooRealMPFE.cxx:611
 RooRealMPFE.cxx:612
 RooRealMPFE.cxx:613
 RooRealMPFE.cxx:614
 RooRealMPFE.cxx:615
 RooRealMPFE.cxx:616
 RooRealMPFE.cxx:617
 RooRealMPFE.cxx:618
 RooRealMPFE.cxx:619
 RooRealMPFE.cxx:620
 RooRealMPFE.cxx:621
 RooRealMPFE.cxx:622
 RooRealMPFE.cxx:623
 RooRealMPFE.cxx:624
 RooRealMPFE.cxx:625
 RooRealMPFE.cxx:626
 RooRealMPFE.cxx:627
 RooRealMPFE.cxx:628
 RooRealMPFE.cxx:629
 RooRealMPFE.cxx:630
 RooRealMPFE.cxx:631
 RooRealMPFE.cxx:632
 RooRealMPFE.cxx:633
 RooRealMPFE.cxx:634
 RooRealMPFE.cxx:635
 RooRealMPFE.cxx:636
 RooRealMPFE.cxx:637
 RooRealMPFE.cxx:638
 RooRealMPFE.cxx:639
 RooRealMPFE.cxx:640
 RooRealMPFE.cxx:641
 RooRealMPFE.cxx:642
 RooRealMPFE.cxx:643
 RooRealMPFE.cxx:644
 RooRealMPFE.cxx:645
 RooRealMPFE.cxx:646
 RooRealMPFE.cxx:647
 RooRealMPFE.cxx:648
 RooRealMPFE.cxx:649
 RooRealMPFE.cxx:650
 RooRealMPFE.cxx:651
 RooRealMPFE.cxx:652
 RooRealMPFE.cxx:653
 RooRealMPFE.cxx:654
 RooRealMPFE.cxx:655
 RooRealMPFE.cxx:656
 RooRealMPFE.cxx:657
 RooRealMPFE.cxx:658
 RooRealMPFE.cxx:659
 RooRealMPFE.cxx:660
 RooRealMPFE.cxx:661
 RooRealMPFE.cxx:662
 RooRealMPFE.cxx:663
 RooRealMPFE.cxx:664
 RooRealMPFE.cxx:665
 RooRealMPFE.cxx:666
 RooRealMPFE.cxx:667
 RooRealMPFE.cxx:668
 RooRealMPFE.cxx:669
 RooRealMPFE.cxx:670
 RooRealMPFE.cxx:671
 RooRealMPFE.cxx:672
 RooRealMPFE.cxx:673
 RooRealMPFE.cxx:674
 RooRealMPFE.cxx:675
 RooRealMPFE.cxx:676
 RooRealMPFE.cxx:677
 RooRealMPFE.cxx:678
 RooRealMPFE.cxx:679
 RooRealMPFE.cxx:680
 RooRealMPFE.cxx:681
 RooRealMPFE.cxx:682
 RooRealMPFE.cxx:683
 RooRealMPFE.cxx:684
 RooRealMPFE.cxx:685
 RooRealMPFE.cxx:686
 RooRealMPFE.cxx:687
 RooRealMPFE.cxx:688
 RooRealMPFE.cxx:689
 RooRealMPFE.cxx:690
 RooRealMPFE.cxx:691
 RooRealMPFE.cxx:692
 RooRealMPFE.cxx:693
 RooRealMPFE.cxx:694
 RooRealMPFE.cxx:695
 RooRealMPFE.cxx:696
 RooRealMPFE.cxx:697
 RooRealMPFE.cxx:698
 RooRealMPFE.cxx:699
 RooRealMPFE.cxx:700
 RooRealMPFE.cxx:701
 RooRealMPFE.cxx:702
 RooRealMPFE.cxx:703
 RooRealMPFE.cxx:704
 RooRealMPFE.cxx:705
 RooRealMPFE.cxx:706
 RooRealMPFE.cxx:707
 RooRealMPFE.cxx:708
 RooRealMPFE.cxx:709
 RooRealMPFE.cxx:710
 RooRealMPFE.cxx:711
 RooRealMPFE.cxx:712
 RooRealMPFE.cxx:713
 RooRealMPFE.cxx:714
 RooRealMPFE.cxx:715
 RooRealMPFE.cxx:716
 RooRealMPFE.cxx:717
 RooRealMPFE.cxx:718
 RooRealMPFE.cxx:719
 RooRealMPFE.cxx:720
 RooRealMPFE.cxx:721
 RooRealMPFE.cxx:722
 RooRealMPFE.cxx:723
 RooRealMPFE.cxx:724
 RooRealMPFE.cxx:725
 RooRealMPFE.cxx:726
 RooRealMPFE.cxx:727
 RooRealMPFE.cxx:728
 RooRealMPFE.cxx:729
 RooRealMPFE.cxx:730
 RooRealMPFE.cxx:731
 RooRealMPFE.cxx:732
 RooRealMPFE.cxx:733
 RooRealMPFE.cxx:734
 RooRealMPFE.cxx:735
 RooRealMPFE.cxx:736
 RooRealMPFE.cxx:737
 RooRealMPFE.cxx:738
 RooRealMPFE.cxx:739
 RooRealMPFE.cxx:740
 RooRealMPFE.cxx:741