// @(#)root/tmva $Id$
// Author: Andreas Hoecker, Peter Speckmayer, Joerg Stelzer, Helge Voss, Kai Voss, Eckhard von Toerne, Jan Therhaag

/**********************************************************************************
 * Project: TMVA - a Root-integrated toolkit for multivariate data analysis       *
 * Package: TMVA                                                                  *
 * Class  : MethodBase                                                            *
 * Web    : http://tmva.sourceforge.net                                           *
 *                                                                                *
 * Description:                                                                   *
 *      Implementation (see header for description)                               *
 *                                                                                *
 * Authors (alphabetical):                                                        *
 *      Andreas Hoecker <Andreas.Hocker@cern.ch> - CERN, Switzerland              *
 *      Joerg Stelzer   <Joerg.Stelzer@cern.ch>  - CERN, Switzerland              *
 *      Peter Speckmayer  <Peter.Speckmayer@cern.ch>  - CERN, Switzerland         *
 *      Helge Voss      <Helge.Voss@cern.ch>     - MPI-K Heidelberg, Germany      *
 *      Kai Voss        <Kai.Voss@cern.ch>       - U. of Victoria, Canada         *
 *      Jan Therhaag       <Jan.Therhaag@cern.ch>     - U of Bonn, Germany        *
 *      Eckhard v. Toerne  <evt@uni-bonn.de>          - U of Bonn, Germany        *
 *                                                                                *
 * Copyright (c) 2005-2011:                                                       *
 *      CERN, Switzerland                                                         *
 *      U. of Victoria, Canada                                                    *
 *      MPI-K Heidelberg, Germany                                                 *
 *      U. of Bonn, Germany                                                       *
 *                                                                                *
 * Redistribution and use in source and binary forms, with or without             *
 * modification, are permitted according to the terms listed in LICENSE           *
 * (http://tmva.sourceforge.net/LICENSE)                                          *
 *                                                                                *
 **********************************************************************************/

//_______________________________________________________________________
/* Begin_Html
   Virtual base Class for all MVA method

   MethodBase hosts several specific evaluation methods.

   The kind of MVA that provides optimal performance in an analysis strongly
   depends on the particular application. The evaluation factory provides a
   number of numerical benchmark results to directly assess the performance
   of the MVA training on the independent test sample. These are:
   <ul>
   <li> The <i>signal efficiency</i> at three representative background efficiencies
   (which is 1 &minus; rejection).</li>
   <li> The <i>significance</I> of an MVA estimator, defined by the difference
   between the MVA mean values for signal and background, divided by the
   quadratic sum of their root mean squares.</li>
   <li> The <i>separation</i> of an MVA <i>x</i>, defined by the integral
   &frac12;&int;(S(x) &minus; B(x))<sup>2</sup>/(S(x) + B(x))dx, where
   S(x) and B(x) are the signal and background distributions, respectively.
   The separation is zero for identical signal and background MVA shapes,
   and it is one for disjunctive shapes.
   <li> <a name="mu_transform">
   The average, &int;x &mu;(S(x))dx, of the signal &mu;-transform.
   The &mu;-transform of an MVA denotes the transformation that yields
   a uniform background distribution. In this way, the signal distributions
   S(x) can be directly compared among the various MVAs. The stronger S(x)
   peaks towards one, the better is the discrimination of the MVA. The
   &mu;-transform is
   <a href=http://tel.ccsd.cnrs.fr/documents/archives0/00/00/29/91/index_fr.html>documented here</a>.
   </ul>
   The MVA standard output also prints the linear correlation coefficients between
   signal and background, which can be useful to eliminate variables that exhibit too
   strong correlations.

   End_Html */
//_______________________________________________________________________

#include <iomanip>
#include <iostream>
#include <fstream>
#include <sstream>
#include <cstdlib>
#include <algorithm>
#include <limits>

#include "TROOT.h"
#include "TSystem.h"
#include "TObjString.h"
#include "TQObject.h"
#include "TSpline.h"
#include "TMatrix.h"
#include "TMath.h"
#include "TFile.h"
#include "TKey.h"
#include "TGraph.h"
#include "Riostream.h"
#include "TXMLEngine.h"

#include "TMVA/MsgLogger.h"
#include "TMVA/MethodBase.h"
#include "TMVA/Config.h"
#include "TMVA/Timer.h"
#include "TMVA/RootFinder.h"
#include "TMVA/PDF.h"
#include "TMVA/VariableIdentityTransform.h"
#include "TMVA/VariableDecorrTransform.h"
#include "TMVA/VariablePCATransform.h"
#include "TMVA/VariableGaussTransform.h"
#include "TMVA/VariableNormalizeTransform.h"
#include "TMVA/Version.h"
#include "TMVA/TSpline1.h"
#include "TMVA/Ranking.h"
#include "TMVA/Factory.h"
#include "TMVA/Tools.h"
#include "TMVA/ResultsClassification.h"
#include "TMVA/ResultsRegression.h"
#include "TMVA/ResultsMulticlass.h"

ClassImp(TMVA::MethodBase)

using std::endl;
using std::atof;

//const Int_t    MethodBase_MaxIterations_ = 200;
const Bool_t   Use_Splines_for_Eff_      = kTRUE;

//const Int_t    NBIN_HIST_PLOT = 100;
const Int_t    NBIN_HIST_HIGH = 10000;

#ifdef _WIN32
/* Disable warning C4355: 'this' : used in base member initializer list */
#pragma warning ( disable : 4355 )
#endif

//_______________________________________________________________________
TMVA::MethodBase::MethodBase( const TString& jobName,
                              Types::EMVA methodType,
                              const TString& methodTitle,
                              DataSetInfo& dsi,
                              const TString& theOption,
                              TDirectory* theBaseDir) :
   IMethod(),
   Configurable               ( theOption ),
   fTmpEvent                  ( 0 ),
   fRanking                   ( 0 ),
   fInputVars                 ( 0 ),
   fAnalysisType              ( Types::kNoAnalysisType ),
   fRegressionReturnVal       ( 0 ),
   fMulticlassReturnVal       ( 0 ),
   fDisableWriting            ( kFALSE ),
   fDataSetInfo               ( dsi ),
   fSignalReferenceCut        ( 0.5 ),
   fSignalReferenceCutOrientation( 1. ),
   fVariableTransformType     ( Types::kSignal ),
   fJobName                   ( jobName ),
   fMethodName                ( methodTitle ),
   fMethodType                ( methodType ),
   fTestvar                   ( "" ),
   fTMVATrainingVersion       ( TMVA_VERSION_CODE ),
   fROOTTrainingVersion       ( ROOT_VERSION_CODE ),
   fConstructedFromWeightFile ( kFALSE ),
   fBaseDir                   ( 0 ),
   fMethodBaseDir             ( theBaseDir ),
   fWeightFile                ( "" ),
   fEffS                      ( 0 ),
   fDefaultPDF                ( 0 ),
   fMVAPdfS                   ( 0 ),
   fMVAPdfB                   ( 0 ),
   fSplS                      ( 0 ),
   fSplB                      ( 0 ),
   fSpleffBvsS                ( 0 ),
   fSplTrainS                 ( 0 ),
   fSplTrainB                 ( 0 ),
   fSplTrainEffBvsS           ( 0 ),
   fVarTransformString        ( "None" ),
   fTransformationPointer     ( 0 ),
   fTransformation            ( dsi, methodTitle ),
   fVerbose                   ( kFALSE ),
   fVerbosityLevelString      ( "Default" ),
   fHelp                      ( kFALSE ),
   fHasMVAPdfs                ( kFALSE ),
   fIgnoreNegWeightsInTraining( kFALSE ),
   fSignalClass               ( 0 ),
   fBackgroundClass           ( 0 ),
   fSplRefS                   ( 0 ),
   fSplRefB                   ( 0 ),
   fSplTrainRefS              ( 0 ),
   fSplTrainRefB              ( 0 ),
   fSetupCompleted            (kFALSE)
{
   // standard constructur
   SetTestvarName();

   // default extension for weight files
   SetWeightFileDir( gConfig().GetIONames().fWeightFileDir );
   gSystem->MakeDirectory( GetWeightFileDir() );
}

//_______________________________________________________________________
TMVA::MethodBase::MethodBase( Types::EMVA methodType,
                              DataSetInfo& dsi,
                              const TString& weightFile,
                              TDirectory* theBaseDir ) :
   IMethod(),
   Configurable(""),
   fTmpEvent                  ( 0 ),
   fRanking                   ( 0 ),
   fInputVars                 ( 0 ),
   fAnalysisType              ( Types::kNoAnalysisType ),
   fRegressionReturnVal       ( 0 ),
   fMulticlassReturnVal       ( 0 ),
   fDataSetInfo               ( dsi ),
   fSignalReferenceCut        ( 0.5 ),
   fVariableTransformType     ( Types::kSignal ),
   fJobName                   ( "" ),
   fMethodName                ( "MethodBase"  ),
   fMethodType                ( methodType ),
   fTestvar                   ( "" ),
   fTMVATrainingVersion       ( 0 ),
   fROOTTrainingVersion       ( 0 ),
   fConstructedFromWeightFile ( kTRUE ),
   fBaseDir                   ( theBaseDir ),
   fMethodBaseDir             ( 0 ),
   fWeightFile                ( weightFile ),
   fEffS                      ( 0 ),
   fDefaultPDF                ( 0 ),
   fMVAPdfS                   ( 0 ),
   fMVAPdfB                   ( 0 ),
   fSplS                      ( 0 ),
   fSplB                      ( 0 ),
   fSpleffBvsS                ( 0 ),
   fSplTrainS                 ( 0 ),
   fSplTrainB                 ( 0 ),
   fSplTrainEffBvsS           ( 0 ),
   fVarTransformString        ( "None" ),
   fTransformationPointer     ( 0 ),
   fTransformation            ( dsi, "" ),
   fVerbose                   ( kFALSE ),
   fVerbosityLevelString      ( "Default" ),
   fHelp                      ( kFALSE ),
   fHasMVAPdfs                ( kFALSE ),
   fIgnoreNegWeightsInTraining( kFALSE ),
   fSignalClass               ( 0 ),
   fBackgroundClass           ( 0 ),
   fSplRefS                   ( 0 ),
   fSplRefB                   ( 0 ),
   fSplTrainRefS              ( 0 ),
   fSplTrainRefB              ( 0 ),
   fSetupCompleted            (kFALSE)
{
   // constructor used for Testing + Application of the MVA,
   // only (no training), using given WeightFiles
}

//_______________________________________________________________________
TMVA::MethodBase::~MethodBase( void )
{
   // destructor
   if (!fSetupCompleted) Log() << kFATAL << "Calling destructor of method which got never setup" << Endl;

   // destructor
   if (fInputVars != 0)  { fInputVars->clear(); delete fInputVars; }
   if (fRanking   != 0)  delete fRanking;

   // PDFs
   if (fDefaultPDF!= 0)  { delete fDefaultPDF; fDefaultPDF = 0; }
   if (fMVAPdfS   != 0)  { delete fMVAPdfS; fMVAPdfS = 0; }
   if (fMVAPdfB   != 0)  { delete fMVAPdfB; fMVAPdfB = 0; }

   // Splines
   if (fSplS)            { delete fSplS; fSplS = 0; }
   if (fSplB)            { delete fSplB; fSplB = 0; }
   if (fSpleffBvsS)      { delete fSpleffBvsS; fSpleffBvsS = 0; }
   if (fSplRefS)         { delete fSplRefS; fSplRefS = 0; }
   if (fSplRefB)         { delete fSplRefB; fSplRefB = 0; }
   if (fSplTrainRefS)    { delete fSplTrainRefS; fSplTrainRefS = 0; }
   if (fSplTrainRefB)    { delete fSplTrainRefB; fSplTrainRefB = 0; }
   if (fSplTrainEffBvsS) { delete fSplTrainEffBvsS; fSplTrainEffBvsS = 0; }

   for (Int_t i = 0; i < 2; i++ ) {
      if (fEventCollections.at(i)) {
         for (std::vector<Event*>::const_iterator it = fEventCollections.at(i)->begin();
              it != fEventCollections.at(i)->end(); it++) {
            delete (*it);
         }
         delete fEventCollections.at(i);
         fEventCollections.at(i) = 0;
      }
   }

   if (fRegressionReturnVal) delete fRegressionReturnVal;
   if (fMulticlassReturnVal) delete fMulticlassReturnVal;
}

//_______________________________________________________________________
void TMVA::MethodBase::SetupMethod()
{
   // setup of methods

   if (fSetupCompleted) Log() << kFATAL << "Calling SetupMethod for the second time" << Endl;
   InitBase();
   DeclareBaseOptions();
   Init();
   DeclareOptions();
   fSetupCompleted = kTRUE;
}

//_______________________________________________________________________
void TMVA::MethodBase::ProcessSetup()
{
   // process all options
   // the "CheckForUnusedOptions" is done in an independent call, since it may be overridden by derived class
   // (sometimes, eg, fitters are used which can only be implemented during training phase)
   ProcessBaseOptions();
   ProcessOptions();
}

//_______________________________________________________________________
void TMVA::MethodBase::CheckSetup()
{
   // check may be overridden by derived class
   // (sometimes, eg, fitters are used which can only be implemented during training phase)
   CheckForUnusedOptions();
}

//_______________________________________________________________________
void TMVA::MethodBase::InitBase()
{
   // default initialization called by all constructors
   SetConfigDescription( "Configuration options for classifier architecture and tuning" );

   fNbins              = gConfig().fVariablePlotting.fNbinsXOfROCCurve;
   fNbinsMVAoutput     = gConfig().fVariablePlotting.fNbinsMVAoutput;
   fNbinsH             = NBIN_HIST_HIGH;

   fSplTrainS          = 0;
   fSplTrainB          = 0;
   fSplTrainEffBvsS    = 0;
   fMeanS              = -1;
   fMeanB              = -1;
   fRmsS               = -1;
   fRmsB               = -1;
   fXmin               = DBL_MAX;
   fXmax               = -DBL_MAX;
   fTxtWeightsOnly     = kTRUE;
   fSplRefS            = 0;
   fSplRefB            = 0;

   fTrainTime          = -1.;
   fTestTime           = -1.;

   fRanking            = 0;

   // temporary until the move to DataSet is complete
   fInputVars = new std::vector<TString>;
   for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
      fInputVars->push_back(DataInfo().GetVariableInfo(ivar).GetLabel());
   }
   fRegressionReturnVal = 0;
   fMulticlassReturnVal = 0;

   fEventCollections.resize( 2 );
   fEventCollections.at(0) = 0;
   fEventCollections.at(1) = 0;

   // define "this" pointer
   ResetThisBase();

   // retrieve signal and background class index
   if (DataInfo().GetClassInfo("Signal") != 0) {
      fSignalClass = DataInfo().GetClassInfo("Signal")->GetNumber();
   }
   if (DataInfo().GetClassInfo("Background") != 0) {
      fBackgroundClass = DataInfo().GetClassInfo("Background")->GetNumber();
   }

   SetConfigDescription( "Configuration options for MVA method" );
   SetConfigName( TString("Method") + GetMethodTypeName() );
}

//_______________________________________________________________________
void TMVA::MethodBase::DeclareBaseOptions()
{
   // define the options (their key words) that can be set in the option string
   // here the options valid for ALL MVA methods are declared.
   // know options: VariableTransform=None,Decorrelated,PCA  to use transformed variables
   //                                                        instead of the original ones
   //               VariableTransformType=Signal,Background  which decorrelation matrix to use
   //                                                        in the method. Only the Likelihood
   //                                                        Method can make proper use of independent
   //                                                        transformations of signal and background
   //               fNbinsMVAPdf   = 50 Number of bins used to create a PDF of MVA
   //               fNsmoothMVAPdf =  2 Number of times a histogram is smoothed before creating the PDF
   //               fHasMVAPdfs         create PDFs for the MVA outputs
   //               V                   for Verbose output (!V) for non verbos
   //               H                   for Help message

   DeclareOptionRef( fVerbose, "V", "Verbose output (short form of \"VerbosityLevel\" below - overrides the latter one)" );

   DeclareOptionRef( fVerbosityLevelString="Default", "VerbosityLevel", "Verbosity level" );
   AddPreDefVal( TString("Default") ); // uses default defined in MsgLogger header
   AddPreDefVal( TString("Debug")   );
   AddPreDefVal( TString("Verbose") );
   AddPreDefVal( TString("Info")    );
   AddPreDefVal( TString("Warning") );
   AddPreDefVal( TString("Error")   );
   AddPreDefVal( TString("Fatal")   );

   // If True (default): write all training results (weights) as text files only;
   // if False: write also in ROOT format (not available for all methods - will abort if not
   fTxtWeightsOnly = kTRUE;  // OBSOLETE !!!
   fNormalise      = kFALSE; // OBSOLETE !!!

   DeclareOptionRef( fVarTransformString, "VarTransform", "List of variable transformations performed before training, e.g., \"D_Background,P_Signal,G,N_AllClasses\" for: \"Decorrelation, PCA-transformation, Gaussianisation, Normalisation, each for the given class of events ('AllClasses' denotes all events of all classes, if no class indication is given, 'All' is assumed)\"" );

   DeclareOptionRef( fHelp, "H", "Print method-specific help message" );

   DeclareOptionRef( fHasMVAPdfs, "CreateMVAPdfs", "Create PDFs for classifier outputs (signal and background)" );

   DeclareOptionRef( fIgnoreNegWeightsInTraining, "IgnoreNegWeightsInTraining",
                     "Events with negative weights are ignored in the training (but are included for testing and performance evaluation)" );
}

//_______________________________________________________________________
void TMVA::MethodBase::ProcessBaseOptions()
{
   // the option string is decoded, for availabel options see "DeclareOptions"

   if (HasMVAPdfs()) {
      // setting the default bin num... maybe should be static ? ==> Please no static (JS)
      // You can't use the logger in the constructor!!! Log() << kINFO << "Create PDFs" << Endl;
      // reading every PDF's definition and passing the option string to the next one to be read and marked
      fDefaultPDF = new PDF( TString(GetName())+"_PDF", GetOptions(), "MVAPdf" );
      fDefaultPDF->DeclareOptions();
      fDefaultPDF->ParseOptions();
      fDefaultPDF->ProcessOptions();
      fMVAPdfB = new PDF( TString(GetName())+"_PDFBkg", fDefaultPDF->GetOptions(), "MVAPdfBkg", fDefaultPDF );
      fMVAPdfB->DeclareOptions();
      fMVAPdfB->ParseOptions();
      fMVAPdfB->ProcessOptions();
      fMVAPdfS = new PDF( TString(GetName())+"_PDFSig", fMVAPdfB->GetOptions(),    "MVAPdfSig", fDefaultPDF );
      fMVAPdfS->DeclareOptions();
      fMVAPdfS->ParseOptions();
      fMVAPdfS->ProcessOptions();

      // the final marked option string is written back to the original methodbase
      SetOptions( fMVAPdfS->GetOptions() );
   }

   TMVA::MethodBase::CreateVariableTransforms( fVarTransformString,
                                               DataInfo(),
                                               GetTransformationHandler(),
                                               Log() );

   if (!HasMVAPdfs()) {
      if (fDefaultPDF!= 0) { delete fDefaultPDF; fDefaultPDF = 0; }
      if (fMVAPdfS   != 0) { delete fMVAPdfS; fMVAPdfS = 0; }
      if (fMVAPdfB   != 0) { delete fMVAPdfB; fMVAPdfB = 0; }
   }

   if (fVerbose) { // overwrites other settings
      fVerbosityLevelString = TString("Verbose");
      Log().SetMinType( kVERBOSE );
   }
   else if (fVerbosityLevelString == "Debug"   ) Log().SetMinType( kDEBUG );
   else if (fVerbosityLevelString == "Verbose" ) Log().SetMinType( kVERBOSE );
   else if (fVerbosityLevelString == "Info"    ) Log().SetMinType( kINFO );
   else if (fVerbosityLevelString == "Warning" ) Log().SetMinType( kWARNING );
   else if (fVerbosityLevelString == "Error"   ) Log().SetMinType( kERROR );
   else if (fVerbosityLevelString == "Fatal"   ) Log().SetMinType( kFATAL );
   else if (fVerbosityLevelString != "Default" ) {
      Log() << kFATAL << "<ProcessOptions> Verbosity level type '"
            << fVerbosityLevelString << "' unknown." << Endl;
   }
   Event::SetIgnoreNegWeightsInTraining(fIgnoreNegWeightsInTraining);
}

//_______________________________________________________________________
void TMVA::MethodBase::CreateVariableTransforms( const TString& trafoDefinitionIn,
                                                 TMVA::DataSetInfo& dataInfo,
                                                 TMVA::TransformationHandler& transformationHandler,
                                                 TMVA::MsgLogger& log )
{
   // create variable transformations

   TString trafoDefinition(trafoDefinitionIn);
   if (trafoDefinition == "None") return; // no transformations

   // workaround for transformations to complicated to be handled by makeclass
   // count number of transformations with incomplete set of variables
   TString trafoDefinitionCheck(trafoDefinitionIn);
   int npartial = 0, ntrafo=0;
   for (Int_t pos = 0, siz = trafoDefinition.Sizeof(); pos < siz; ++pos) {
      TString ch = trafoDefinition(pos,1);
      if ( ch == "(" ) npartial++;
      if ( ch == "+" || ch == ",") ntrafo++;
   }
   if (npartial>1) {
      log << kWARNING << "The use of multiple partial variable transformations during the application phase can be properly invoked via the \"Reader\", but it is not yet implemented in \"MakeClass\", the creation mechanism for standalone C++ application classes. The standalone C++ class produced by this training job is thus INCOMPLETE AND MUST NOT BE USED! The transformation in question is: " << trafoDefinitionIn << Endl; // ToDo make info and do not write the standalone class
      //
      // this does not work since this function is static
      // fDisableWriting=true; // disable creation of stand-alone class
      // ToDo we need to tell the transformation that it cannot write itself
   }
   // workaround end

   Int_t parenthesisCount = 0;
   for (Int_t position = 0, size = trafoDefinition.Sizeof(); position < size; ++position) {
      TString ch = trafoDefinition(position,1);
      if      (ch == "(")                          ++parenthesisCount;
      else if (ch == ")")                          --parenthesisCount;
      else if (ch == "," && parenthesisCount == 0) trafoDefinition.Replace(position,1,'+');
   }

   TList* trList = gTools().ParseFormatLine( trafoDefinition, "+" );
   TListIter trIt(trList);
   while (TObjString* os = (TObjString*)trIt()) {
      TString tdef = os->GetString();
      Int_t idxCls = -1;

      TString variables = "";
      if (tdef.Contains("(")) { // contains selection of variables
         Ssiz_t parStart = tdef.Index( "(" );
         Ssiz_t parLen   = tdef.Index( ")", parStart )-parStart+1;

         variables = tdef(parStart,parLen);
         tdef.Remove(parStart,parLen);
         variables.Remove(parLen-1,1);
         variables.Remove(0,1);
      }

      TList* trClsList = gTools().ParseFormatLine( tdef, "_" ); // split entry to get trf-name and class-name
      TListIter trClsIt(trClsList);
      if (trClsList->GetSize() < 1) log << kFATAL << "Incorrect transformation string provided." << Endl;
      const TString& trName = ((TObjString*)trClsList->At(0))->GetString();

      if (trClsList->GetEntries() > 1) {
         TString trCls = "AllClasses";
         ClassInfo *ci = NULL;
         trCls  = ((TObjString*)trClsList->At(1))->GetString();
         if (trCls != "AllClasses") {
            ci = dataInfo.GetClassInfo( trCls );
            if (ci == NULL)
               log << kFATAL << "Class " << trCls << " not known for variable transformation "
                   << trName << ", please check." << Endl;
            else
               idxCls = ci->GetNumber();
         }
      }

      VariableTransformBase* transformation = NULL;
      if      (trName == "I" || trName == "Ident" || trName == "Identity") {
         if (variables.Length() == 0) variables = "_V_";
         transformation = new VariableIdentityTransform( dataInfo);
      }
      else if (trName == "D" || trName == "Deco" || trName == "Decorrelate") {
         if (variables.Length() == 0) variables = "_V_";
         transformation = new VariableDecorrTransform( dataInfo);
      }
      else if (trName == "P" || trName == "PCA") {
         if (variables.Length() == 0) variables = "_V_";
         transformation = new VariablePCATransform   ( dataInfo);
      }
      else if (trName == "U" || trName == "Uniform") {
         if (variables.Length() == 0) variables = "_V_,_T_";
         transformation = new VariableGaussTransform ( dataInfo, "Uniform" );
      }
      else if (trName == "G" || trName == "Gauss") {
         if (variables.Length() == 0) variables = "_V_";
         transformation = new VariableGaussTransform ( dataInfo);
      }
      else if (trName == "N" || trName == "Norm" || trName == "Normalise" || trName == "Normalize") {
         if (variables.Length() == 0) variables = "_V_,_T_";
         transformation = new VariableNormalizeTransform( dataInfo);
      }
      else log << kFATAL << "<ProcessOptions> Variable transform '"
               << trName << "' unknown." << Endl;

      if (transformation) {
         ClassInfo* clsInfo = dataInfo.GetClassInfo(idxCls);
         if (clsInfo )
            log << kINFO << "Create Transformation \"" << trName << "\" with reference class "
                << clsInfo->GetName() << "=("<< idxCls <<")"<<Endl;
         else
            log << kINFO << "Create Transformation \"" << trName << "\" with events from all classes." << Endl;

         transformation->SelectInput( variables );
         transformationHandler.AddTransformation(transformation, idxCls);
      }
   }
   return;
}

//_______________________________________________________________________
void TMVA::MethodBase::DeclareCompatibilityOptions()
{
   // options that are used ONLY for the READER to ensure backward compatibility
   //   they are hence without any effect (the reader is only reading the training
   //   options that HAD been used at the training of the .xml weightfile at hand

   DeclareOptionRef( fNormalise=kFALSE, "Normalise", "Normalise input variables" ); // don't change the default !!!
   DeclareOptionRef( fUseDecorr=kFALSE, "D", "Use-decorrelated-variables flag" );
   DeclareOptionRef( fVariableTransformTypeString="Signal", "VarTransformType",
                     "Use signal or background events to derive for variable transformation (the transformation is applied on both types of, course)" );
   AddPreDefVal( TString("Signal") );
   AddPreDefVal( TString("Background") );
   DeclareOptionRef( fTxtWeightsOnly=kTRUE, "TxtWeightFilesOnly", "If True: write all training results (weights) as text files (False: some are written in ROOT format)" );
   // Why on earth ?? was this here? Was the verbosity level option  meant to 'disapear? Not a good idea i think..
   // DeclareOptionRef( fVerbosityLevelString="Default", "VerboseLevel", "Verbosity level" );
   // AddPreDefVal( TString("Default") ); // uses default defined in MsgLogger header
   // AddPreDefVal( TString("Debug")   );
   // AddPreDefVal( TString("Verbose") );
   // AddPreDefVal( TString("Info")    );
   // AddPreDefVal( TString("Warning") );
   // AddPreDefVal( TString("Error")   );
   // AddPreDefVal( TString("Fatal")   );
   DeclareOptionRef( fNbinsMVAPdf   = 60, "NbinsMVAPdf",   "Number of bins used for the PDFs of classifier outputs" );
   DeclareOptionRef( fNsmoothMVAPdf = 2,  "NsmoothMVAPdf", "Number of smoothing iterations for classifier PDFs" );
}


//_______________________________________________________________________
std::map<TString,Double_t>  TMVA::MethodBase::OptimizeTuningParameters(TString /* fomType */ , TString /* fitType */)
{
   // call the Optimzier with the set of paremeters and ranges that
   // are meant to be tuned.

   // this is just a dummy...  needs to be implemented for each method
   // individually (as long as we don't have it automatized via the
   // configuraion string

   Log() << kWARNING << "Parameter optimization is not yet implemented for method "
         << GetName() << Endl;
   Log() << kWARNING << "Currently we need to set hardcoded which parameter is tuned in which ranges"<<Endl;

   std::map<TString,Double_t> tunedParameters;
   tunedParameters.size(); // just to get rid of "unused" warning
   return tunedParameters;

}

//_______________________________________________________________________
void TMVA::MethodBase::SetTuneParameters(std::map<TString,Double_t> /* tuneParameters */)
{
   // set the tuning parameters accoding to the argument
   // This is just a dummy .. have a look at the MethodBDT how you could
   // perhaps implment the same thing for the other Classifiers..
}

//_______________________________________________________________________
void TMVA::MethodBase::TrainMethod()
{
   Data()->SetCurrentType(Types::kTraining);
   Event::SetIsTraining(kTRUE); // used to set negative event weights to zero if chosen to do so

   // train the MVA method
   if (Help()) PrintHelpMessage();

   // all histograms should be created in the method's subdirectory
   BaseDir()->cd();

   // once calculate all the transformation (e.g. the sequence of Decorr:Gauss:Decorr)
   //    needed for this classifier
   GetTransformationHandler().CalcTransformations(Data()->GetEventCollection());

   // call training of derived MVA
   Log() << kINFO << "Begin training" << Endl;
   Long64_t nEvents = Data()->GetNEvents();
   Timer traintimer( nEvents, GetName(), kTRUE );
   Train();
   Log() << kINFO << "End of training                                              " << Endl;
   SetTrainTime(traintimer.ElapsedSeconds());
   Log() << kINFO << "Elapsed time for training with " << nEvents <<  " events: "
         << traintimer.GetElapsedTime() << "         " << Endl;

   Log() << kINFO << "Create MVA output for ";

   // create PDFs for the signal and background MVA distributions (if required)
   if (DoMulticlass()) {
      Log() << "Multiclass classification on training sample" << Endl;
      AddMulticlassOutput(Types::kTraining);
   }
   else if (!DoRegression()) {

      Log() << "classification on training sample" << Endl;
      AddClassifierOutput(Types::kTraining);
      if (HasMVAPdfs()) {
         CreateMVAPdfs();
         AddClassifierOutputProb(Types::kTraining);
      }

   } else {

      Log() << "regression on training sample" << Endl;
      AddRegressionOutput( Types::kTraining );

      if (HasMVAPdfs() ) {
         Log() << "Create PDFs" << Endl;
         CreateMVAPdfs();
      }
   }

   // write the current MVA state into stream
   // produced are one text file and one ROOT file
   if (!fDisableWriting ) WriteStateToFile();

   // produce standalone make class (presently only supported for classification)
   if ((!DoRegression()) && (!fDisableWriting)) MakeClass();

   // write additional monitoring histograms to main target file (not the weight file)
   // again, make sure the histograms go into the method's subdirectory
   BaseDir()->cd();
   WriteMonitoringHistosToFile();
}

//_______________________________________________________________________
void TMVA::MethodBase::GetRegressionDeviation(UInt_t tgtNum, Types::ETreeType type, Double_t& stddev, Double_t& stddev90Percent ) const
{
   if (!DoRegression()) Log() << kFATAL << "Trying to use GetRegressionDeviation() with a classification job" << Endl;
   Log() << kINFO << "Create results for " << (type==Types::kTraining?"training":"testing") << Endl;
   ResultsRegression* regRes = (ResultsRegression*)Data()->GetResults(GetMethodName(), Types::kTesting, Types::kRegression);
   bool truncate = false;
   TH1F* h1 = regRes->QuadraticDeviation( tgtNum , truncate, 1.);
   stddev = sqrt(h1->GetMean());
   truncate = true;
   Double_t yq[1], xq[]={0.9};
   h1->GetQuantiles(1,yq,xq);
   TH1F* h2 = regRes->QuadraticDeviation( tgtNum , truncate, yq[0]);
   stddev90Percent = sqrt(h2->GetMean());
   delete h1;
   delete h2;
}

//_______________________________________________________________________
void TMVA::MethodBase::AddRegressionOutput(Types::ETreeType type)
{
   // prepare tree branch with the method's discriminating variable

   Data()->SetCurrentType(type);

   Log() << kINFO << "Create results for " << (type==Types::kTraining?"training":"testing") << Endl;

   ResultsRegression* regRes = (ResultsRegression*)Data()->GetResults(GetMethodName(), type, Types::kRegression);

   Long64_t nEvents = Data()->GetNEvents();

   // use timer
   Timer timer( nEvents, GetName(), kTRUE );

   Log() << kINFO << "Evaluation of " << GetMethodName() << " on "
         << (type==Types::kTraining?"training":"testing") << " sample" << Endl;

   regRes->Resize( nEvents );
   for (Int_t ievt=0; ievt<nEvents; ievt++) {
      Data()->SetCurrentEvent(ievt);
      std::vector< Float_t > vals = GetRegressionValues();
      regRes->SetValue( vals, ievt );
      timer.DrawProgressBar( ievt );
   }

   Log() << kINFO << "Elapsed time for evaluation of " << nEvents <<  " events: "
         << timer.GetElapsedTime() << "       " << Endl;

   // store time used for testing
   if (type==Types::kTesting)
      SetTestTime(timer.ElapsedSeconds());

   TString histNamePrefix(GetTestvarName());
   histNamePrefix += (type==Types::kTraining?"train":"test");
   regRes->CreateDeviationHistograms( histNamePrefix );
}

//_______________________________________________________________________
void TMVA::MethodBase::AddMulticlassOutput(Types::ETreeType type)
{
   // prepare tree branch with the method's discriminating variable

   Data()->SetCurrentType(type);

   Log() << kINFO << "Create results for " << (type==Types::kTraining?"training":"testing") << Endl;

   ResultsMulticlass* resMulticlass = dynamic_cast<ResultsMulticlass*>(Data()->GetResults(GetMethodName(), type, Types::kMulticlass));
   if (!resMulticlass) Log() << kFATAL<< "unable to create pointer in AddMulticlassOutput, exiting."<<Endl;

   Long64_t nEvents = Data()->GetNEvents();

   // use timer
   Timer timer( nEvents, GetName(), kTRUE );

   Log() << kINFO << "Multiclass evaluation of " << GetMethodName() << " on "
         << (type==Types::kTraining?"training":"testing") << " sample" << Endl;

   resMulticlass->Resize( nEvents );
   for (Int_t ievt=0; ievt<nEvents; ievt++) {
      Data()->SetCurrentEvent(ievt);
      std::vector< Float_t > vals = GetMulticlassValues();
      resMulticlass->SetValue( vals, ievt );
      timer.DrawProgressBar( ievt );
   }

   Log() << kINFO << "Elapsed time for evaluation of " << nEvents <<  " events: "
         << timer.GetElapsedTime() << "       " << Endl;

   // store time used for testing
   if (type==Types::kTesting)
      SetTestTime(timer.ElapsedSeconds());

   TString histNamePrefix(GetTestvarName());
   histNamePrefix += (type==Types::kTraining?"_Train":"_Test");
   resMulticlass->CreateMulticlassHistos( histNamePrefix, fNbinsMVAoutput, fNbinsH );
}



//_______________________________________________________________________
void TMVA::MethodBase::NoErrorCalc(Double_t* const err, Double_t* const errUpper) {
   if (err) *err=-1;
   if (errUpper) *errUpper=-1;
}

//_______________________________________________________________________
Double_t TMVA::MethodBase::GetMvaValue( const Event* const ev, Double_t* err, Double_t* errUpper ) {
   fTmpEvent = ev;
   Double_t val = GetMvaValue(err, errUpper);
   fTmpEvent = 0;
   return val;
}

//_______________________________________________________________________
Bool_t TMVA::MethodBase::IsSignalLike() {
   // uses a pre-set cut on the MVA output (SetSignalReferenceCut and SetSignalReferenceCutOrientation)
   // for a quick determination if an event would be selected as signal or background
   return GetMvaValue()*GetSignalReferenceCutOrientation() > GetSignalReferenceCut()*GetSignalReferenceCutOrientation() ? kTRUE : kFALSE;
}
//_______________________________________________________________________
Bool_t TMVA::MethodBase::IsSignalLike(Double_t mvaVal) {
   // uses a pre-set cut on the MVA output (SetSignalReferenceCut and SetSignalReferenceCutOrientation)
   // for a quick determination if an event with this mva output value would tbe selected as signal or background
   return mvaVal*GetSignalReferenceCutOrientation() > GetSignalReferenceCut()*GetSignalReferenceCutOrientation() ? kTRUE : kFALSE;
}

//_______________________________________________________________________
void TMVA::MethodBase::AddClassifierOutput( Types::ETreeType type )
{
   // prepare tree branch with the method's discriminating variable

   Data()->SetCurrentType(type);

   ResultsClassification* clRes =
      (ResultsClassification*)Data()->GetResults(GetMethodName(), type, Types::kClassification );

   Long64_t nEvents = Data()->GetNEvents();

   // use timer
   Timer timer( nEvents, GetName(), kTRUE );

   Log() << kINFO << "Evaluation of " << GetMethodName() << " on "
         << (type==Types::kTraining?"training":"testing") << " sample (" << nEvents << " events)" << Endl;

   clRes->Resize( nEvents );
   for (Int_t ievt=0; ievt<nEvents; ievt++) {
      Data()->SetCurrentEvent(ievt);
      clRes->SetValue( GetMvaValue(), ievt );

      // print progress
      Int_t modulo = Int_t(nEvents/100);
      if (modulo <= 0 ) modulo = 1;
      if (ievt%modulo == 0) timer.DrawProgressBar( ievt );
   }

   Log() << kINFO << "Elapsed time for evaluation of " << nEvents <<  " events: "
         << timer.GetElapsedTime() << "       " << Endl;

   // store time used for testing
   if (type==Types::kTesting)
      SetTestTime(timer.ElapsedSeconds());

}

//_______________________________________________________________________
void TMVA::MethodBase::AddClassifierOutputProb( Types::ETreeType type )
{
   // prepare tree branch with the method's discriminating variable

   Data()->SetCurrentType(type);

   ResultsClassification* mvaProb =
      (ResultsClassification*)Data()->GetResults(TString("prob_")+GetMethodName(), type, Types::kClassification );

   Long64_t nEvents = Data()->GetNEvents();

   // use timer
   Timer timer( nEvents, GetName(), kTRUE );

   Log() << kINFO << "Evaluation of " << GetMethodName() << " on "
         << (type==Types::kTraining?"training":"testing") << " sample" << Endl;

   mvaProb->Resize( nEvents );
   for (Int_t ievt=0; ievt<nEvents; ievt++) {

      Data()->SetCurrentEvent(ievt);
      Float_t proba = ((Float_t)GetProba( GetMvaValue(), 0.5 ));
      if (proba < 0) break;
      mvaProb->SetValue( proba, ievt );

      // print progress
      Int_t modulo = Int_t(nEvents/100);
      if (modulo <= 0 ) modulo = 1;
      if (ievt%modulo == 0) timer.DrawProgressBar( ievt );
   }

   Log() << kINFO << "Elapsed time for evaluation of " << nEvents <<  " events: "
         << timer.GetElapsedTime() << "       " << Endl;
}

//_______________________________________________________________________
void TMVA::MethodBase::TestRegression( Double_t& bias, Double_t& biasT,
                                       Double_t& dev,  Double_t& devT,
                                       Double_t& rms,  Double_t& rmsT,
                                       Double_t& mInf, Double_t& mInfT,
                                       Double_t& corr,
                                       Types::ETreeType type )
{
   // calculate <sum-of-deviation-squared> of regression output versus "true" value from test sample
   //
   //   bias = average deviation
   //   dev  = average absolute deviation
   //   rms  = rms of deviation
   //

   Types::ETreeType savedType = Data()->GetCurrentType();
   Data()->SetCurrentType(type);

   bias = 0; biasT = 0; dev = 0; devT = 0; rms = 0; rmsT = 0;
   Double_t sumw = 0;
   Double_t m1 = 0, m2 = 0, s1 = 0, s2 = 0, s12 = 0; // for correlation
   const Int_t nevt = GetNEvents();
   Float_t* rV = new Float_t[nevt];
   Float_t* tV = new Float_t[nevt];
   Float_t* wV = new Float_t[nevt];
   Float_t  xmin = 1e30, xmax = -1e30;
   for (Long64_t ievt=0; ievt<nevt; ievt++) {

      const Event* ev = Data()->GetEvent(ievt); // NOTE: need untransformed event here !
      Float_t t = ev->GetTarget(0);
      Float_t w = ev->GetWeight();
      Float_t r = GetRegressionValues()[0];
      Float_t d = (r-t);

      // find min/max
      xmin = TMath::Min(xmin, TMath::Min(t, r));
      xmax = TMath::Max(xmax, TMath::Max(t, r));

      // store for truncated RMS computation
      rV[ievt] = r;
      tV[ievt] = t;
      wV[ievt] = w;

      // compute deviation-squared
      sumw += w;
      bias += w * d;
      dev  += w * TMath::Abs(d);
      rms  += w * d * d;

      // compute correlation between target and regression estimate
      m1  += t*w; s1 += t*t*w;
      m2  += r*w; s2 += r*r*w;
      s12 += t*r;
   }

   // standard quantities
   bias /= sumw;
   dev  /= sumw;
   rms  /= sumw;
   rms  = TMath::Sqrt(rms - bias*bias);

   // correlation
   m1   /= sumw;
   m2   /= sumw;
   corr  = s12/sumw - m1*m2;
   corr /= TMath::Sqrt( (s1/sumw - m1*m1) * (s2/sumw - m2*m2) );

   // create histogram required for computeation of mutual information
   TH2F* hist  = new TH2F( "hist",  "hist",  150, xmin, xmax, 100, xmin, xmax );
   TH2F* histT = new TH2F( "histT", "histT", 150, xmin, xmax, 100, xmin, xmax );

   // compute truncated RMS and fill histogram
   Double_t devMax = bias + 2*rms;
   Double_t devMin = bias - 2*rms;
   sumw = 0;
   int ic=0;
   for (Long64_t ievt=0; ievt<nevt; ievt++) {
      Float_t d = (rV[ievt] - tV[ievt]);
      hist->Fill( rV[ievt], tV[ievt], wV[ievt] );
      if (d >= devMin && d <= devMax) {
         sumw  += wV[ievt];
         biasT += wV[ievt] * d;
         devT  += wV[ievt] * TMath::Abs(d);
         rmsT  += wV[ievt] * d * d;
         histT->Fill( rV[ievt], tV[ievt], wV[ievt] );
         ic++;
      }
   }
   biasT /= sumw;
   devT  /= sumw;
   rmsT  /= sumw;
   rmsT  = TMath::Sqrt(rmsT - biasT*biasT);
   mInf  = gTools().GetMutualInformation( *hist );
   mInfT = gTools().GetMutualInformation( *histT );

   delete hist;
   delete histT;

   delete [] rV;
   delete [] tV;
   delete [] wV;

   Data()->SetCurrentType(savedType);
}


//_______________________________________________________________________
void TMVA::MethodBase::TestMulticlass()
{
   // test multiclass classification

   ResultsMulticlass* resMulticlass = dynamic_cast<ResultsMulticlass*>(Data()->GetResults(GetMethodName(), Types::kTesting, Types::kMulticlass));
   if (!resMulticlass) Log() << kFATAL<< "unable to create pointer in TestMulticlass, exiting."<<Endl;
   Log() << kINFO << "Determine optimal multiclass cuts for test data..." << Endl;
   for (UInt_t icls = 0; icls<DataInfo().GetNClasses(); ++icls) {
      resMulticlass->GetBestMultiClassCuts(icls);
   }
}


//_______________________________________________________________________
void TMVA::MethodBase::TestClassification()
{
   // initialization
   Data()->SetCurrentType(Types::kTesting);

   ResultsClassification* mvaRes = dynamic_cast<ResultsClassification*>
      ( Data()->GetResults(GetMethodName(),Types::kTesting, Types::kClassification) );

   // sanity checks: tree must exist, and theVar must be in tree
   if (0==mvaRes && !(GetMethodTypeName().Contains("Cuts"))) {
      Log() << "mvaRes " << mvaRes << " GetMethodTypeName " << GetMethodTypeName()
            << " contains " << !(GetMethodTypeName().Contains("Cuts")) << Endl;
      Log() << kFATAL << "<TestInit> Test variable " << GetTestvarName()
            << " not found in tree" << Endl;
   }

   // basic statistics operations are made in base class
   gTools().ComputeStat( GetEventCollection(Types::kTesting), mvaRes->GetValueVector(),
                         fMeanS, fMeanB, fRmsS, fRmsB, fXmin, fXmax, fSignalClass );

   // choose reasonable histogram ranges, by removing outliers
   Double_t nrms = 10;
   fXmin = TMath::Max( TMath::Min( fMeanS - nrms*fRmsS, fMeanB - nrms*fRmsB ), fXmin );
   fXmax = TMath::Min( TMath::Max( fMeanS + nrms*fRmsS, fMeanB + nrms*fRmsB ), fXmax );

   // determine cut orientation
   fCutOrientation = (fMeanS > fMeanB) ? kPositive : kNegative;

   // fill 2 types of histograms for the various analyses
   // this one is for actual plotting

   Double_t sxmax = fXmax+0.00001;

   // classifier response distributions for training sample
   // MVA plots used for graphics representation (signal)
   TH1* mva_s = new TH1D( GetTestvarName() + "_S",GetTestvarName() + "_S", fNbinsMVAoutput, fXmin, sxmax );
   TH1* mva_b = new TH1D( GetTestvarName() + "_B",GetTestvarName() + "_B", fNbinsMVAoutput, fXmin, sxmax );
   mvaRes->Store(mva_s, "MVA_S");
   mvaRes->Store(mva_b, "MVA_B");
   mva_s->Sumw2();
   mva_b->Sumw2();

   TH1* proba_s = 0;
   TH1* proba_b = 0;
   TH1* rarity_s = 0;
   TH1* rarity_b = 0;
   if (HasMVAPdfs()) {
      // P(MVA) plots used for graphics representation
      proba_s = new TH1D( GetTestvarName() + "_Proba_S", GetTestvarName() + "_Proba_S", fNbinsMVAoutput, 0.0, 1.0 );
      proba_b = new TH1D( GetTestvarName() + "_Proba_B", GetTestvarName() + "_Proba_B", fNbinsMVAoutput, 0.0, 1.0 );
      mvaRes->Store(proba_s, "Prob_S");
      mvaRes->Store(proba_b, "Prob_B");
      proba_s->Sumw2();
      proba_b->Sumw2();

      // R(MVA) plots used for graphics representation
      rarity_s = new TH1D( GetTestvarName() + "_Rarity_S", GetTestvarName() + "_Rarity_S", fNbinsMVAoutput, 0.0, 1.0 );
      rarity_b = new TH1D( GetTestvarName() + "_Rarity_B", GetTestvarName() + "_Rarity_B", fNbinsMVAoutput, 0.0, 1.0 );
      mvaRes->Store(rarity_s, "Rar_S");
      mvaRes->Store(rarity_b, "Rar_B");
      rarity_s->Sumw2();
      rarity_b->Sumw2();
   }

   // MVA plots used for efficiency calculations (large number of bins)
   TH1* mva_eff_s = new TH1D( GetTestvarName() + "_S_high", GetTestvarName() + "_S_high", fNbinsH, fXmin, sxmax );
   TH1* mva_eff_b = new TH1D( GetTestvarName() + "_B_high", GetTestvarName() + "_B_high", fNbinsH, fXmin, sxmax );
   mvaRes->Store(mva_eff_s, "MVA_HIGHBIN_S");
   mvaRes->Store(mva_eff_b, "MVA_HIGHBIN_B");
   mva_eff_s->Sumw2();
   mva_eff_b->Sumw2();

   // fill the histograms
   ResultsClassification* mvaProb = dynamic_cast<ResultsClassification*>
      (Data()->GetResults( TString("prob_")+GetMethodName(), Types::kTesting, Types::kMaxAnalysisType ) );

   Log() << kINFO << "Loop over test events and fill histograms with classifier response..." << Endl;
   if (mvaProb) Log() << kINFO << "Also filling probability and rarity histograms (on request)..." << Endl;
   for (Long64_t ievt=0; ievt<GetNEvents(); ievt++) {

      const Event* ev = GetEvent(ievt);
      Float_t v = (*mvaRes)[ievt][0];
      Float_t w = ev->GetWeight();

      if (DataInfo().IsSignal(ev)) {
         mva_s ->Fill( v, w );
         if (mvaProb) {
            proba_s->Fill( (*mvaProb)[ievt][0], w );
            rarity_s->Fill( GetRarity( v ), w );
         }

         mva_eff_s ->Fill( v, w );
      }
      else {
         mva_b ->Fill( v, w );
         if (mvaProb) {
            proba_b->Fill( (*mvaProb)[ievt][0], w );
            rarity_b->Fill( GetRarity( v ), w );
         }
         mva_eff_b ->Fill( v, w );
      }
   }

   // uncomment those (and several others if you want unnormalized output
   gTools().NormHist( mva_s  );
   gTools().NormHist( mva_b  );
   gTools().NormHist( proba_s );
   gTools().NormHist( proba_b );
   gTools().NormHist( rarity_s );
   gTools().NormHist( rarity_b );
   gTools().NormHist( mva_eff_s  );
   gTools().NormHist( mva_eff_b  );

   // create PDFs from histograms, using default splines, and no additional smoothing
   if (fSplS) { delete fSplS; fSplS = 0; }
   if (fSplB) { delete fSplB; fSplB = 0; }
   fSplS = new PDF( TString(GetName()) + " PDF Sig", mva_s, PDF::kSpline2 );
   fSplB = new PDF( TString(GetName()) + " PDF Bkg", mva_b, PDF::kSpline2 );
}

//_______________________________________________________________________
void TMVA::MethodBase::WriteStateToStream( std::ostream& tf ) const
{
   // general method used in writing the header of the weight files where
   // the used variables, variable transformation type etc. is specified

   TString prefix = "";
   UserGroup_t * userInfo = gSystem->GetUserInfo();

   tf << prefix << "#GEN -*-*-*-*-*-*-*-*-*-*-*- general info -*-*-*-*-*-*-*-*-*-*-*-" << std::endl << prefix << std::endl;
   tf << prefix << "Method         : " << GetMethodTypeName() << "::" << GetMethodName() << std::endl;
   tf.setf(std::ios::left);
   tf << prefix << "TMVA Release   : " << std::setw(10) << GetTrainingTMVAVersionString() << "    ["
      << GetTrainingTMVAVersionCode() << "]" << std::endl;
   tf << prefix << "ROOT Release   : " << std::setw(10) << GetTrainingROOTVersionString() << "    ["
      << GetTrainingROOTVersionCode() << "]" << std::endl;
   tf << prefix << "Creator        : " << userInfo->fUser << std::endl;
   tf << prefix << "Date           : "; TDatime *d = new TDatime; tf << d->AsString() << std::endl; delete d;
   tf << prefix << "Host           : " << gSystem->GetBuildNode() << std::endl;
   tf << prefix << "Dir            : " << gSystem->WorkingDirectory() << std::endl;
   tf << prefix << "Training events: " << Data()->GetNTrainingEvents() << std::endl;

   TString analysisType(((const_cast<TMVA::MethodBase*>(this)->GetAnalysisType()==Types::kRegression) ? "Regression" : "Classification"));

   tf << prefix << "Analysis type  : " << "[" << ((GetAnalysisType()==Types::kRegression) ? "Regression" : "Classification") << "]" << std::endl;
   tf << prefix << std::endl;

   delete userInfo;

   // First write all options
   tf << prefix << std::endl << prefix << "#OPT -*-*-*-*-*-*-*-*-*-*-*-*- options -*-*-*-*-*-*-*-*-*-*-*-*-" << std::endl << prefix << std::endl;
   WriteOptionsToStream( tf, prefix );
   tf << prefix << std::endl;

   // Second write variable info
   tf << prefix << std::endl << prefix << "#VAR -*-*-*-*-*-*-*-*-*-*-*-* variables *-*-*-*-*-*-*-*-*-*-*-*-" << std::endl << prefix << std::endl;
   WriteVarsToStream( tf, prefix );
   tf << prefix << std::endl;
}

//_______________________________________________________________________
void TMVA::MethodBase::AddInfoItem( void* gi, const TString& name, const TString& value) const
{
   // xml writing
   void* it = gTools().AddChild(gi,"Info");
   gTools().AddAttr(it,"name", name);
   gTools().AddAttr(it,"value", value);
}

//_______________________________________________________________________
void TMVA::MethodBase::AddOutput( Types::ETreeType type, Types::EAnalysisType analysisType ) {
   if (analysisType == Types::kRegression) {
      AddRegressionOutput( type );
   } else if (analysisType == Types::kMulticlass) {
      AddMulticlassOutput( type );
   } else {
      AddClassifierOutput( type );
      if (HasMVAPdfs())
         AddClassifierOutputProb( type );
   }
}

//_______________________________________________________________________
void TMVA::MethodBase::WriteStateToXML( void* parent ) const
{
   // general method used in writing the header of the weight files where
   // the used variables, variable transformation type etc. is specified

   if (!parent) return;

   UserGroup_t* userInfo = gSystem->GetUserInfo();

   void* gi = gTools().AddChild(parent, "GeneralInfo");
   AddInfoItem( gi, "TMVA Release", GetTrainingTMVAVersionString() + " [" + gTools().StringFromInt(GetTrainingTMVAVersionCode()) + "]" );
   AddInfoItem( gi, "ROOT Release", GetTrainingROOTVersionString() + " [" + gTools().StringFromInt(GetTrainingROOTVersionCode()) + "]");
   AddInfoItem( gi, "Creator", userInfo->fUser);
   TDatime dt; AddInfoItem( gi, "Date", dt.AsString());
   AddInfoItem( gi, "Host", gSystem->GetBuildNode() );
   AddInfoItem( gi, "Dir", gSystem->WorkingDirectory());
   AddInfoItem( gi, "Training events", gTools().StringFromInt(Data()->GetNTrainingEvents()));
   AddInfoItem( gi, "TrainingTime", gTools().StringFromDouble(const_cast<TMVA::MethodBase*>(this)->GetTrainTime()));

   Types::EAnalysisType aType = const_cast<TMVA::MethodBase*>(this)->GetAnalysisType();
   TString analysisType((aType==Types::kRegression) ? "Regression" :
                        (aType==Types::kMulticlass ? "Multiclass" : "Classification"));
   AddInfoItem( gi, "AnalysisType", analysisType );
   delete userInfo;

   // write options
   AddOptionsXMLTo( parent );

   // write variable info
   AddVarsXMLTo( parent );

   // write spectator info
   if (!fDisableWriting)
      AddSpectatorsXMLTo( parent );

   // write class info if in multiclass mode
   AddClassesXMLTo(parent);

   // write target info if in regression mode
   if (DoRegression()) AddTargetsXMLTo(parent);

   // write transformations
   GetTransformationHandler(false).AddXMLTo( parent );

   // write MVA variable distributions
   void* pdfs = gTools().AddChild(parent, "MVAPdfs");
   if (fMVAPdfS) fMVAPdfS->AddXMLTo(pdfs);
   if (fMVAPdfB) fMVAPdfB->AddXMLTo(pdfs);

   // write weights
   AddWeightsXMLTo( parent );
}

//_______________________________________________________________________
void TMVA::MethodBase::ReadStateFromStream( TFile& rf )
{
   // write reference MVA distributions (and other information)
   // to a ROOT type weight file

   Bool_t addDirStatus = TH1::AddDirectoryStatus();
   TH1::AddDirectory( 0 ); // this avoids the binding of the hists in PDF to the current ROOT file
   fMVAPdfS = (TMVA::PDF*)rf.Get( "MVA_PDF_Signal" );
   fMVAPdfB = (TMVA::PDF*)rf.Get( "MVA_PDF_Background" );

   TH1::AddDirectory( addDirStatus );

   ReadWeightsFromStream( rf );

   SetTestvarName();
}

//_______________________________________________________________________
void TMVA::MethodBase::WriteStateToFile() const
{
   // write options and weights to file
   // note that each one text file for the main configuration information
   // and one ROOT file for ROOT objects are created

   // ---- create the text file
   TString tfname( GetWeightFileName() );

   // writing xml file
   TString xmlfname( tfname ); xmlfname.ReplaceAll( ".txt", ".xml" );
   Log() << kINFO << "Creating weight file in xml format: "
         << gTools().Color("lightblue") << xmlfname << gTools().Color("reset") << Endl;
   void* doc      = gTools().xmlengine().NewDoc();
   void* rootnode = gTools().AddChild(0,"MethodSetup", "", true);
   gTools().xmlengine().DocSetRootElement(doc,rootnode);
   gTools().AddAttr(rootnode,"Method", GetMethodTypeName() + "::" + GetMethodName());
   WriteStateToXML(rootnode);
   gTools().xmlengine().SaveDoc(doc,xmlfname);
   gTools().xmlengine().FreeDoc(doc);
}

//_______________________________________________________________________
void TMVA::MethodBase::ReadStateFromFile()
{
   // Function to write options and weights to file

   // get the filename

   TString tfname(GetWeightFileName());

   Log() << kINFO << "Reading weight file: "
         << gTools().Color("lightblue") << tfname << gTools().Color("reset") << Endl;

   if (tfname.EndsWith(".xml") ) {
#if ROOT_VERSION_CODE >= ROOT_VERSION(5,29,0)
      void* doc = gTools().xmlengine().ParseFile(tfname,gTools().xmlenginebuffersize()); // the default buffer size in TXMLEngine::ParseFile is 100k. Starting with ROOT 5.29 one can set the buffer size, see: http://savannah.cern.ch/bugs/?78864. This might be necessary for large XML files
#else
      void* doc = gTools().xmlengine().ParseFile(tfname);
#endif
      void* rootnode = gTools().xmlengine().DocGetRootElement(doc); // node "MethodSetup"
      ReadStateFromXML(rootnode);
      gTools().xmlengine().FreeDoc(doc);
   }
   else {
      std::filebuf fb;
      fb.open(tfname.Data(),std::ios::in);
      if (!fb.is_open()) { // file not found --> Error
         Log() << kFATAL << "<ReadStateFromFile> "
               << "Unable to open input weight file: " << tfname << Endl;
      }
      std::istream fin(&fb);
      ReadStateFromStream(fin);
      fb.close();
   }
   if (!fTxtWeightsOnly) {
      // ---- read the ROOT file
      TString rfname( tfname ); rfname.ReplaceAll( ".txt", ".root" );
      Log() << kINFO << "Reading root weight file: "
            << gTools().Color("lightblue") << rfname << gTools().Color("reset") << Endl;
      TFile* rfile = TFile::Open( rfname, "READ" );
      ReadStateFromStream( *rfile );
      rfile->Close();
   }
}
//_______________________________________________________________________
void TMVA::MethodBase::ReadStateFromXMLString( const char* xmlstr ) {
   // for reading from memory

#if ROOT_VERSION_CODE >= ROOT_VERSION(5,26,00)
   void* doc = gTools().xmlengine().ParseString(xmlstr);
   void* rootnode = gTools().xmlengine().DocGetRootElement(doc); // node "MethodSetup"
   ReadStateFromXML(rootnode);
   gTools().xmlengine().FreeDoc(doc);
#else
   Log() << kFATAL << "Method MethodBase::ReadStateFromXMLString( const char* xmlstr = "
         << xmlstr << " ) is not available for ROOT versions prior to 5.26/00." << Endl;
#endif

   return;
}

//_______________________________________________________________________
void TMVA::MethodBase::ReadStateFromXML( void* methodNode )
{
   TString fullMethodName;
   gTools().ReadAttr( methodNode, "Method", fullMethodName );
   fMethodName = fullMethodName(fullMethodName.Index("::")+2,fullMethodName.Length());

   // update logger
   Log().SetSource( GetName() );
   Log() << kINFO << "Read method \"" << GetMethodName() << "\" of type \"" << GetMethodTypeName() << "\"" << Endl;

   // after the method name is read, the testvar can be set
   SetTestvarName();

   TString nodeName("");
   void* ch = gTools().GetChild(methodNode);
   while (ch!=0) {
      nodeName = TString( gTools().GetName(ch) );

      if (nodeName=="GeneralInfo") {
         // read analysis type

         TString name(""),val("");
         void* antypeNode = gTools().GetChild(ch);
         while (antypeNode) {
            gTools().ReadAttr( antypeNode, "name",   name );

            if (name == "TrainingTime")
               gTools().ReadAttr( antypeNode, "value",  fTrainTime );

            if (name == "AnalysisType") {
               gTools().ReadAttr( antypeNode, "value",  val );
               val.ToLower();
               if      (val == "regression" )     SetAnalysisType( Types::kRegression );
               else if (val == "classification" ) SetAnalysisType( Types::kClassification );
               else if (val == "multiclass" )     SetAnalysisType( Types::kMulticlass );
               else Log() << kFATAL << "Analysis type " << val << " is not known." << Endl;
            }

            if (name == "TMVA Release" || name == "TMVA") {
               TString s;
               gTools().ReadAttr( antypeNode, "value", s);
               fTMVATrainingVersion = TString(s(s.Index("[")+1,s.Index("]")-s.Index("[")-1)).Atoi();
               Log() << kINFO << "MVA method was trained with TMVA Version: " << GetTrainingTMVAVersionString() << Endl;
            }

            if (name == "ROOT Release" || name == "ROOT") {
               TString s;
               gTools().ReadAttr( antypeNode, "value", s);
               fROOTTrainingVersion = TString(s(s.Index("[")+1,s.Index("]")-s.Index("[")-1)).Atoi();
               Log() << kINFO << "MVA method was trained with ROOT Version: " << GetTrainingROOTVersionString() << Endl;
            }
            antypeNode = gTools().GetNextChild(antypeNode);
         }
      }
      else if (nodeName=="Options") {
         ReadOptionsFromXML(ch);
         ParseOptions();

      }
      else if (nodeName=="Variables") {
         ReadVariablesFromXML(ch);
      }
      else if (nodeName=="Spectators") {
         ReadSpectatorsFromXML(ch);
      }
      else if (nodeName=="Classes") {
         if (DataInfo().GetNClasses()==0) ReadClassesFromXML(ch);
      }
      else if (nodeName=="Targets") {
         if (DataInfo().GetNTargets()==0 && DoRegression()) ReadTargetsFromXML(ch);
      }
      else if (nodeName=="Transformations") {
         GetTransformationHandler().ReadFromXML(ch);
      }
      else if (nodeName=="MVAPdfs") {
         TString pdfname;
         if (fMVAPdfS) { delete fMVAPdfS; fMVAPdfS=0; }
         if (fMVAPdfB) { delete fMVAPdfB; fMVAPdfB=0; }
         void* pdfnode = gTools().GetChild(ch);
         if (pdfnode) {
            gTools().ReadAttr(pdfnode, "Name", pdfname);
            fMVAPdfS = new PDF(pdfname);
            fMVAPdfS->ReadXML(pdfnode);
            pdfnode = gTools().GetNextChild(pdfnode);
            gTools().ReadAttr(pdfnode, "Name", pdfname);
            fMVAPdfB = new PDF(pdfname);
            fMVAPdfB->ReadXML(pdfnode);
         }
      }
      else if (nodeName=="Weights") {
         ReadWeightsFromXML(ch);
      }
      else {
         Log() << kWARNING << "Unparsed XML node: '" << nodeName << "'" << Endl;
      }
      ch = gTools().GetNextChild(ch);

   }

   // update transformation handler
   if (GetTransformationHandler().GetCallerName() == "") GetTransformationHandler().SetCallerName( GetName() );
}

//_______________________________________________________________________
void TMVA::MethodBase::ReadStateFromStream( std::istream& fin )
{
   // read the header from the weight files of the different MVA methods
   char buf[512];

   // when reading from stream, we assume the files are produced with TMVA<=397
   SetAnalysisType(Types::kClassification);


   // first read the method name
   GetLine(fin,buf);
   while (!TString(buf).BeginsWith("Method")) GetLine(fin,buf);
   TString namestr(buf);

   TString methodType = namestr(0,namestr.Index("::"));
   methodType = methodType(methodType.Last(' '),methodType.Length());
   methodType = methodType.Strip(TString::kLeading);

   TString methodName = namestr(namestr.Index("::")+2,namestr.Length());
   methodName = methodName.Strip(TString::kLeading);
   if (methodName == "") methodName = methodType;
   fMethodName  = methodName;

   Log() << kINFO << "Read method \"" << GetMethodName() << "\" of type \"" << GetMethodTypeName() << "\"" << Endl;

   // update logger
   Log().SetSource( GetName() );

   // now the question is whether to read the variables first or the options (well, of course the order
   // of writing them needs to agree)
   //
   // the option "Decorrelation" is needed to decide if the variables we
   // read are decorrelated or not
   //
   // the variables are needed by some methods (TMLP) to build the NN
   // which is done in ProcessOptions so for the time being we first Read and Parse the options then
   // we read the variables, and then we process the options

   // now read all options
   GetLine(fin,buf);
   while (!TString(buf).BeginsWith("#OPT")) GetLine(fin,buf);
   ReadOptionsFromStream(fin);
   ParseOptions();

   // Now read variable info
   fin.getline(buf,512);
   while (!TString(buf).BeginsWith("#VAR")) fin.getline(buf,512);
   ReadVarsFromStream(fin);

   // now we process the options (of the derived class)
   ProcessOptions();

   if (IsNormalised()) {
      VariableNormalizeTransform* norm = (VariableNormalizeTransform*)
         GetTransformationHandler().AddTransformation( new VariableNormalizeTransform(DataInfo()), -1 );
      norm->BuildTransformationFromVarInfo( DataInfo().GetVariableInfos() );
   }
   VariableTransformBase *varTrafo(0), *varTrafo2(0);
   if ( fVarTransformString == "None") {
      if (fUseDecorr)
         varTrafo = GetTransformationHandler().AddTransformation( new VariableDecorrTransform(DataInfo()), -1 );
   } else if ( fVarTransformString == "Decorrelate" ) {
      varTrafo = GetTransformationHandler().AddTransformation( new VariableDecorrTransform(DataInfo()), -1 );
   } else if ( fVarTransformString == "PCA"  ) {
      varTrafo = GetTransformationHandler().AddTransformation( new VariablePCATransform(DataInfo()), -1 );
   } else if ( fVarTransformString == "Uniform" ) {
      varTrafo  = GetTransformationHandler().AddTransformation( new VariableGaussTransform(DataInfo(),"Uniform"), -1 );
   } else if ( fVarTransformString == "Gauss" ) {
      varTrafo  = GetTransformationHandler().AddTransformation( new VariableGaussTransform(DataInfo()), -1 );
   } else if ( fVarTransformString == "GaussDecorr" ) {
      varTrafo  = GetTransformationHandler().AddTransformation( new VariableGaussTransform(DataInfo()), -1 );
      varTrafo2 = GetTransformationHandler().AddTransformation( new VariableDecorrTransform(DataInfo()), -1 );
   } else {
      Log() << kFATAL << "<ProcessOptions> Variable transform '"
            << fVarTransformString << "' unknown." << Endl;
   }
   // Now read decorrelation matrix if available
   if (GetTransformationHandler().GetTransformationList().GetSize() > 0) {
      fin.getline(buf,512);
      while (!TString(buf).BeginsWith("#MAT")) fin.getline(buf,512);
      if (varTrafo) {
         TString trafo(fVariableTransformTypeString); trafo.ToLower();
         varTrafo->ReadTransformationFromStream(fin, trafo );
      }
      if (varTrafo2) {
         TString trafo(fVariableTransformTypeString); trafo.ToLower();
         varTrafo2->ReadTransformationFromStream(fin, trafo );
      }
   }


   if (HasMVAPdfs()) {
      // Now read the MVA PDFs
      fin.getline(buf,512);
      while (!TString(buf).BeginsWith("#MVAPDFS")) fin.getline(buf,512);
      if (fMVAPdfS != 0) { delete fMVAPdfS; fMVAPdfS = 0; }
      if (fMVAPdfB != 0) { delete fMVAPdfB; fMVAPdfB = 0; }
      fMVAPdfS = new PDF(TString(GetName()) + " MVA PDF Sig");
      fMVAPdfB = new PDF(TString(GetName()) + " MVA PDF Bkg");
      fMVAPdfS->SetReadingVersion( GetTrainingTMVAVersionCode() );
      fMVAPdfB->SetReadingVersion( GetTrainingTMVAVersionCode() );

      fin >> *fMVAPdfS;
      fin >> *fMVAPdfB;
   }

   // Now read weights
   fin.getline(buf,512);
   while (!TString(buf).BeginsWith("#WGT")) fin.getline(buf,512);
   fin.getline(buf,512);
   ReadWeightsFromStream( fin );;

   // update transformation handler
   if (GetTransformationHandler().GetCallerName() == "") GetTransformationHandler().SetCallerName( GetName() );

}

//_______________________________________________________________________
void TMVA::MethodBase::WriteVarsToStream( std::ostream& o, const TString& prefix ) const
{
   // write the list of variables (name, min, max) for a given data
   // transformation method to the stream
   o << prefix << "NVar " << DataInfo().GetNVariables() << std::endl;
   std::vector<VariableInfo>::const_iterator varIt = DataInfo().GetVariableInfos().begin();
   for (; varIt!=DataInfo().GetVariableInfos().end(); varIt++) { o << prefix; varIt->WriteToStream(o); }
   o << prefix << "NSpec " << DataInfo().GetNSpectators() << std::endl;
   varIt = DataInfo().GetSpectatorInfos().begin();
   for (; varIt!=DataInfo().GetSpectatorInfos().end(); varIt++) { o << prefix; varIt->WriteToStream(o); }
}

//_______________________________________________________________________
void TMVA::MethodBase::ReadVarsFromStream( std::istream& istr )
{
   // Read the variables (name, min, max) for a given data
   // transformation method from the stream. In the stream we only
   // expect the limits which will be set
   TString dummy;
   UInt_t readNVar;
   istr >> dummy >> readNVar;

   if (readNVar!=DataInfo().GetNVariables()) {
      Log() << kFATAL << "You declared "<< DataInfo().GetNVariables() << " variables in the Reader"
            << " while there are " << readNVar << " variables declared in the file"
            << Endl;
   }

   // we want to make sure all variables are read in the order they are defined
   VariableInfo varInfo;
   std::vector<VariableInfo>::iterator varIt = DataInfo().GetVariableInfos().begin();
   int varIdx = 0;
   for (; varIt!=DataInfo().GetVariableInfos().end(); varIt++, varIdx++) {
      varInfo.ReadFromStream(istr);
      if (varIt->GetExpression() == varInfo.GetExpression()) {
         varInfo.SetExternalLink((*varIt).GetExternalLink());
         (*varIt) = varInfo;
      }
      else {
         Log() << kINFO << "ERROR in <ReadVarsFromStream>" << Endl;
         Log() << kINFO << "The definition (or the order) of the variables found in the input file is"  << Endl;
         Log() << kINFO << "is not the same as the one declared in the Reader (which is necessary for" << Endl;
         Log() << kINFO << "the correct working of the method):" << Endl;
         Log() << kINFO << "   var #" << varIdx <<" declared in Reader: " << varIt->GetExpression() << Endl;
         Log() << kINFO << "   var #" << varIdx <<" declared in file  : " << varInfo.GetExpression() << Endl;
         Log() << kFATAL << "The expression declared to the Reader needs to be checked (name or order are wrong)" << Endl;
      }
   }
}

//_______________________________________________________________________
void TMVA::MethodBase::AddVarsXMLTo( void* parent ) const
{
   // write variable info to XML
   void* vars = gTools().AddChild(parent, "Variables");
   gTools().AddAttr( vars, "NVar", gTools().StringFromInt(DataInfo().GetNVariables()) );

   for (UInt_t idx=0; idx<DataInfo().GetVariableInfos().size(); idx++) {
      VariableInfo& vi = DataInfo().GetVariableInfos()[idx];
      void* var = gTools().AddChild( vars, "Variable" );
      gTools().AddAttr( var, "VarIndex", idx );
      vi.AddToXML( var );
   }
}

//_______________________________________________________________________
void TMVA::MethodBase::AddSpectatorsXMLTo( void* parent ) const
{
   // write spectator info to XML
   void* specs = gTools().AddChild(parent, "Spectators");

   UInt_t writeIdx=0;
   for (UInt_t idx=0; idx<DataInfo().GetSpectatorInfos().size(); idx++) {

      VariableInfo& vi = DataInfo().GetSpectatorInfos()[idx];

      // we do not want to write spectators that are category-cuts,
      // except if the method is the category method and the spectators belong to it
      if (vi.GetVarType()=='C') continue;

      void* spec = gTools().AddChild( specs, "Spectator" );
      gTools().AddAttr( spec, "SpecIndex", writeIdx++ );
      vi.AddToXML( spec );
   }
   gTools().AddAttr( specs, "NSpec", gTools().StringFromInt(writeIdx) );
}

//_______________________________________________________________________
void TMVA::MethodBase::AddClassesXMLTo( void* parent ) const
{
   // write class info to XML
   UInt_t nClasses=DataInfo().GetNClasses();

   void* classes = gTools().AddChild(parent, "Classes");
   gTools().AddAttr( classes, "NClass", nClasses );

   for (UInt_t iCls=0; iCls<nClasses; ++iCls) {
      ClassInfo *classInfo=DataInfo().GetClassInfo (iCls);
      TString  className  =classInfo->GetName();
      UInt_t   classNumber=classInfo->GetNumber();

      void* classNode=gTools().AddChild(classes, "Class");
      gTools().AddAttr( classNode, "Name",  className   );
      gTools().AddAttr( classNode, "Index", classNumber );
   }
}
//_______________________________________________________________________
void TMVA::MethodBase::AddTargetsXMLTo( void* parent ) const
{
   // write target info to XML
   void* targets = gTools().AddChild(parent, "Targets");
   gTools().AddAttr( targets, "NTrgt", gTools().StringFromInt(DataInfo().GetNTargets()) );

   for (UInt_t idx=0; idx<DataInfo().GetTargetInfos().size(); idx++) {
      VariableInfo& vi = DataInfo().GetTargetInfos()[idx];
      void* tar = gTools().AddChild( targets, "Target" );
      gTools().AddAttr( tar, "TargetIndex", idx );
      vi.AddToXML( tar );
   }
}

//_______________________________________________________________________
void TMVA::MethodBase::ReadVariablesFromXML( void* varnode )
{
   // read variable info from XML
   UInt_t readNVar;
   gTools().ReadAttr( varnode, "NVar", readNVar);

   if (readNVar!=DataInfo().GetNVariables()) {
      Log() << kFATAL << "You declared "<< DataInfo().GetNVariables() << " variables in the Reader"
            << " while there are " << readNVar << " variables declared in the file"
            << Endl;
   }

   // we want to make sure all variables are read in the order they are defined
   VariableInfo readVarInfo, existingVarInfo;
   int varIdx = 0;
   void* ch = gTools().GetChild(varnode);
   while (ch) {
      gTools().ReadAttr( ch, "VarIndex", varIdx);
      existingVarInfo = DataInfo().GetVariableInfos()[varIdx];
      readVarInfo.ReadFromXML(ch);

      if (existingVarInfo.GetExpression() == readVarInfo.GetExpression()) {
         readVarInfo.SetExternalLink(existingVarInfo.GetExternalLink());
         existingVarInfo = readVarInfo;
      }
      else {
         Log() << kINFO << "ERROR in <ReadVariablesFromXML>" << Endl;
         Log() << kINFO << "The definition (or the order) of the variables found in the input file is"  << Endl;
         Log() << kINFO << "not the same as the one declared in the Reader (which is necessary for the" << Endl;
         Log() << kINFO << "correct working of the method):" << Endl;
         Log() << kINFO << "   var #" << varIdx <<" declared in Reader: " << existingVarInfo.GetExpression() << Endl;
         Log() << kINFO << "   var #" << varIdx <<" declared in file  : " << readVarInfo.GetExpression() << Endl;
         Log() << kFATAL << "The expression declared to the Reader needs to be checked (name or order are wrong)" << Endl;
      }
      ch = gTools().GetNextChild(ch);
   }
}

//_______________________________________________________________________
void TMVA::MethodBase::ReadSpectatorsFromXML( void* specnode )
{
   // read spectator info from XML
   UInt_t readNSpec;
   gTools().ReadAttr( specnode, "NSpec", readNSpec);

   if (readNSpec!=DataInfo().GetNSpectators(kFALSE)) {
      Log() << kFATAL << "You declared "<< DataInfo().GetNSpectators(kFALSE) << " spectators in the Reader"
            << " while there are " << readNSpec << " spectators declared in the file"
            << Endl;
   }

   // we want to make sure all variables are read in the order they are defined
   VariableInfo readSpecInfo, existingSpecInfo;
   int specIdx = 0;
   void* ch = gTools().GetChild(specnode);
   while (ch) {
      gTools().ReadAttr( ch, "SpecIndex", specIdx);
      existingSpecInfo = DataInfo().GetSpectatorInfos()[specIdx];
      readSpecInfo.ReadFromXML(ch);

      if (existingSpecInfo.GetExpression() == readSpecInfo.GetExpression()) {
         readSpecInfo.SetExternalLink(existingSpecInfo.GetExternalLink());
         existingSpecInfo = readSpecInfo;
      }
      else {
         Log() << kINFO << "ERROR in <ReadSpectatorsFromXML>" << Endl;
         Log() << kINFO << "The definition (or the order) of the spectators found in the input file is"  << Endl;
         Log() << kINFO << "not the same as the one declared in the Reader (which is necessary for the" << Endl;
         Log() << kINFO << "correct working of the method):" << Endl;
         Log() << kINFO << "  spec #" << specIdx <<" declared in Reader: " << existingSpecInfo.GetExpression() << Endl;
         Log() << kINFO << "  spec #" << specIdx <<" declared in file  : " << readSpecInfo.GetExpression() << Endl;
         Log() << kFATAL << "The expression declared to the Reader needs to be checked (name or order are wrong)" << Endl;
      }
      ch = gTools().GetNextChild(ch);
   }
}

//_______________________________________________________________________
void TMVA::MethodBase::ReadClassesFromXML( void* clsnode )
{
   // read number of classes from XML
   UInt_t readNCls;
   // coverity[tainted_data_argument]
   gTools().ReadAttr( clsnode, "NClass", readNCls);

   TString className="";
   UInt_t  classIndex=0;
   void* ch = gTools().GetChild(clsnode);
   if (!ch) {
      for (UInt_t icls = 0; icls<readNCls;++icls) {
         TString classname = Form("class%i",icls);
         DataInfo().AddClass(classname);

      }
   }
   else{
      while (ch) {
         gTools().ReadAttr( ch, "Index", classIndex);
         gTools().ReadAttr( ch, "Name",  className );
         DataInfo().AddClass(className);

         ch = gTools().GetNextChild(ch);
      }
   }

   // retrieve signal and background class index
   if (DataInfo().GetClassInfo("Signal") != 0) {
      fSignalClass = DataInfo().GetClassInfo("Signal")->GetNumber();
   }
   else
      fSignalClass=0;
   if (DataInfo().GetClassInfo("Background") != 0) {
      fBackgroundClass = DataInfo().GetClassInfo("Background")->GetNumber();
   }
   else
      fBackgroundClass=1;
}

//_______________________________________________________________________
void TMVA::MethodBase::ReadTargetsFromXML( void* tarnode )
{
   // read target info from XML
   UInt_t readNTar;
   gTools().ReadAttr( tarnode, "NTrgt", readNTar);

   int tarIdx = 0;
   TString expression;
   void* ch = gTools().GetChild(tarnode);
   while (ch) {
      gTools().ReadAttr( ch, "TargetIndex", tarIdx);
      gTools().ReadAttr( ch, "Expression", expression);
      DataInfo().AddTarget(expression,"","",0,0);

      ch = gTools().GetNextChild(ch);
   }
}

//_______________________________________________________________________
TDirectory* TMVA::MethodBase::BaseDir() const
{
   // returns the ROOT directory where info/histograms etc of the
   // corresponding MVA method instance are stored

   if (fBaseDir != 0) return fBaseDir;
   Log()<<kDEBUG<<" Base Directory for " << GetMethodTypeName() << " not set yet --> check if already there.." <<Endl;

   TDirectory* methodDir = MethodBaseDir();
   if (methodDir==0)
      Log() << kFATAL << "MethodBase::BaseDir() - MethodBaseDir() return a NULL pointer!" << Endl;

   TDirectory* dir = 0;

   TString defaultDir = GetMethodName();

   TObject* o = methodDir->FindObject(defaultDir);
   if (o!=0 && o->InheritsFrom(TDirectory::Class())) dir = (TDirectory*)o;

   if (dir != 0) {
      Log()<<kDEBUG<<" Base Directory for " << GetMethodName() << " existed, return it.." <<Endl;
      return dir;
   }

   Log()<<kDEBUG<<" Base Directory for " << GetMethodName() << " does not exist yet--> created it" <<Endl;
   TDirectory *sdir = methodDir->mkdir(defaultDir);

   // write weight file name into target file
   sdir->cd();
   TObjString wfilePath( gSystem->WorkingDirectory() );
   TObjString wfileName( GetWeightFileName() );
   wfilePath.Write( "TrainingPath" );
   wfileName.Write( "WeightFileName" );

   return sdir;
}

//_______________________________________________________________________
TDirectory* TMVA::MethodBase::MethodBaseDir() const
{
   // returns the ROOT directory where all instances of the
   // corresponding MVA method are stored

   if (fMethodBaseDir != 0) return fMethodBaseDir;

   Log()<<kDEBUG<<" Base Directory for " << GetMethodTypeName() << " not set yet --> check if already there.." <<Endl;

   const TString dirName(Form("Method_%s",GetMethodTypeName().Data()));

   TDirectory * dir = Factory::RootBaseDir()->GetDirectory(dirName);
   if (dir != 0) {
      Log()<<kDEBUG<<" Base Directory for " << GetMethodTypeName() << " existed, return it.." <<Endl;
      return dir;
   }

   Log()<<kDEBUG<<" Base Directory for " << GetMethodTypeName() << " does not exist yet--> created it" <<Endl;
   fMethodBaseDir = Factory::RootBaseDir()->mkdir(dirName,Form("Directory for all %s methods", GetMethodTypeName().Data()));

   Log()<<kDEBUG<<"Return from MethodBaseDir() after creating base directory "<<Endl;
   return fMethodBaseDir;
}

//_______________________________________________________________________
void TMVA::MethodBase::SetWeightFileDir( TString fileDir )
{
   // set directory of weight file

   fFileDir = fileDir;
   gSystem->MakeDirectory( fFileDir );
}

//_______________________________________________________________________
void TMVA::MethodBase::SetWeightFileName( TString theWeightFile)
{
   // set the weight file name (depreciated)
   fWeightFile = theWeightFile;
}

//_______________________________________________________________________
TString TMVA::MethodBase::GetWeightFileName() const
{
   // retrieve weight file name
   if (fWeightFile!="") return fWeightFile;

   // the default consists of
   // directory/jobname_methodname_suffix.extension.{root/txt}
   TString suffix = "";
   TString wFileDir(GetWeightFileDir());
   return ( wFileDir + (wFileDir[wFileDir.Length()-1]=='/' ? "" : "/")
            + GetJobName() + "_" + GetMethodName() +
            suffix + "." + gConfig().GetIONames().fWeightFileExtension + ".xml" );
}

//_______________________________________________________________________
void TMVA::MethodBase::WriteEvaluationHistosToFile(Types::ETreeType treetype)
{
   // writes all MVA evaluation histograms to file
   BaseDir()->cd();

   // write MVA PDFs to file - if exist
   if (0 != fMVAPdfS) {
      fMVAPdfS->GetOriginalHist()->Write();
      fMVAPdfS->GetSmoothedHist()->Write();
      fMVAPdfS->GetPDFHist()->Write();
   }
   if (0 != fMVAPdfB) {
      fMVAPdfB->GetOriginalHist()->Write();
      fMVAPdfB->GetSmoothedHist()->Write();
      fMVAPdfB->GetPDFHist()->Write();
   }

   // write result-histograms
   Results* results = Data()->GetResults( GetMethodName(), treetype, Types::kMaxAnalysisType );
   if (!results)
      Log() << kFATAL << "<WriteEvaluationHistosToFile> Unknown result: "
            << GetMethodName() << (treetype==Types::kTraining?"/kTraining":"/kTesting")
            << "/kMaxAnalysisType" << Endl;
   results->GetStorage()->Write();
   if (treetype==Types::kTesting) {
      GetTransformationHandler().PlotVariables (GetEventCollection( Types::kTesting ), BaseDir() );
   }
}

//_______________________________________________________________________
void  TMVA::MethodBase::WriteMonitoringHistosToFile( void ) const
{
   // write special monitoring histograms to file
   // dummy implementation here -----------------
}

//_______________________________________________________________________
Bool_t TMVA::MethodBase::GetLine(std::istream& fin, char* buf )
{
   // reads one line from the input stream
   // checks for certain keywords and interprets
   // the line if keywords are found
   fin.getline(buf,512);
   TString line(buf);
   if (line.BeginsWith("TMVA Release")) {
      Ssiz_t start  = line.First('[')+1;
      Ssiz_t length = line.Index("]",start)-start;
      TString code  = line(start,length);
      std::stringstream s(code.Data());
      s >> fTMVATrainingVersion;
      Log() << kINFO << "MVA method was trained with TMVA Version: " << GetTrainingTMVAVersionString() << Endl;
   }
   if (line.BeginsWith("ROOT Release")) {
      Ssiz_t start  = line.First('[')+1;
      Ssiz_t length = line.Index("]",start)-start;
      TString code  = line(start,length);
      std::stringstream s(code.Data());
      s >> fROOTTrainingVersion;
      Log() << kINFO << "MVA method was trained with ROOT Version: " << GetTrainingROOTVersionString() << Endl;
   }
   if (line.BeginsWith("Analysis type")) {
      Ssiz_t start  = line.First('[')+1;
      Ssiz_t length = line.Index("]",start)-start;
      TString code  = line(start,length);
      std::stringstream s(code.Data());
      std::string analysisType;
      s >> analysisType;
      if      (analysisType == "regression"     || analysisType == "Regression")     SetAnalysisType( Types::kRegression );
      else if (analysisType == "classification" || analysisType == "Classification") SetAnalysisType( Types::kClassification );
      else if (analysisType == "multiclass"     || analysisType == "Multiclass")     SetAnalysisType( Types::kMulticlass );
      else Log() << kFATAL << "Analysis type " << analysisType << " from weight-file not known!" << std::endl;

      Log() << kINFO << "Method was trained for "
            << (GetAnalysisType() == Types::kRegression ? "Regression" :
                (GetAnalysisType() == Types::kMulticlass ? "Multiclass" : "Classification")) << Endl;
   }

   return true;
}

//_______________________________________________________________________
void TMVA::MethodBase::CreateMVAPdfs()
{
   // Create PDFs of the MVA output variables

   Data()->SetCurrentType(Types::kTraining);

   // the PDF's are stored as results ONLY if the corresponding "results" are booked,
   // otherwise they will be only used 'online'
   ResultsClassification * mvaRes = dynamic_cast<ResultsClassification*>
      ( Data()->GetResults(GetMethodName(), Types::kTraining, Types::kClassification) );

   if (mvaRes==0 || mvaRes->GetSize()==0) {
      Log() << kERROR<< "<CreateMVAPdfs> No result of classifier testing available" << Endl;
   }

   Double_t minVal = *std::min_element(mvaRes->GetValueVector()->begin(),mvaRes->GetValueVector()->end());
   Double_t maxVal = *std::max_element(mvaRes->GetValueVector()->begin(),mvaRes->GetValueVector()->end());

   // create histograms that serve as basis to create the MVA Pdfs
   TH1* histMVAPdfS = new TH1D( GetMethodTypeName() + "_tr_S", GetMethodTypeName() + "_tr_S",
                                fMVAPdfS->GetHistNBins( mvaRes->GetSize() ), minVal, maxVal );
   TH1* histMVAPdfB = new TH1D( GetMethodTypeName() + "_tr_B", GetMethodTypeName() + "_tr_B",
                                fMVAPdfB->GetHistNBins( mvaRes->GetSize() ), minVal, maxVal );


   // compute sum of weights properly
   histMVAPdfS->Sumw2();
   histMVAPdfB->Sumw2();

   // fill histograms
   for (UInt_t ievt=0; ievt<mvaRes->GetSize(); ievt++) {
      Double_t theVal    = mvaRes->GetValueVector()->at(ievt);
      Double_t theWeight = Data()->GetEvent(ievt)->GetWeight();

      if (DataInfo().IsSignal(Data()->GetEvent(ievt))) histMVAPdfS->Fill( theVal, theWeight );
      else                                             histMVAPdfB->Fill( theVal, theWeight );
   }

   gTools().NormHist( histMVAPdfS );
   gTools().NormHist( histMVAPdfB );

   // momentary hack for ROOT problem
   histMVAPdfS->Write();
   histMVAPdfB->Write();

   // create PDFs
   fMVAPdfS->BuildPDF   ( histMVAPdfS );
   fMVAPdfB->BuildPDF   ( histMVAPdfB );
   fMVAPdfS->ValidatePDF( histMVAPdfS );
   fMVAPdfB->ValidatePDF( histMVAPdfB );

   if (DataInfo().GetNClasses() == 2) { // TODO: this is an ugly hack.. adapt this to new framework
      Log() << kINFO
            << Form( "<CreateMVAPdfs> Separation from histogram (PDF): %1.3f (%1.3f)",
                     GetSeparation( histMVAPdfS, histMVAPdfB ), GetSeparation( fMVAPdfS, fMVAPdfB ) )
            << Endl;
   }

   delete histMVAPdfS;
   delete histMVAPdfB;
}

Double_t TMVA::MethodBase::GetProba(const Event *ev){
   // the simple one, automatically calcualtes the mvaVal and uses the
   // SAME sig/bkg ratio as given in the training sample (typically 50/50
   // .. (NormMode=EqualNumEvents) but can be different)
   if (!fMVAPdfS || !fMVAPdfB) {
      Log() << kINFO << "<GetProba> MVA PDFs for Signal and Background don't exist yet, we'll create them on demand" << Endl;
      CreateMVAPdfs();
   }
   Double_t sigFraction = DataInfo().GetTrainingSumSignalWeights() / (DataInfo().GetTrainingSumSignalWeights() + DataInfo().GetTrainingSumBackgrWeights() );
   Double_t mvaVal = GetMvaValue(ev);

   return GetProba(mvaVal,sigFraction);

}
//_______________________________________________________________________
Double_t TMVA::MethodBase::GetProba( Double_t mvaVal, Double_t ap_sig )
{
   // compute likelihood ratio
   if (!fMVAPdfS || !fMVAPdfB) {
      Log() << kWARNING << "<GetProba> MVA PDFs for Signal and Background don't exist" << Endl;
      return -1.0;
   }
   Double_t p_s = fMVAPdfS->GetVal( mvaVal );
   Double_t p_b = fMVAPdfB->GetVal( mvaVal );

   Double_t denom = p_s*ap_sig + p_b*(1 - ap_sig);

   return (denom > 0) ? (p_s*ap_sig) / denom : -1;
}

//_______________________________________________________________________
Double_t TMVA::MethodBase::GetRarity( Double_t mvaVal, Types::ESBType reftype ) const
{
   // compute rarity:
   // R(x) = Integrate_[-oo..x] { PDF(x') dx' }
   // where PDF(x) is the PDF of the classifier's signal or background distribution

   if ((reftype == Types::kSignal && !fMVAPdfS) || (reftype == Types::kBackground && !fMVAPdfB)) {
      Log() << kWARNING << "<GetRarity> Required MVA PDF for Signal or Backgroud does not exist: "
            << "select option \"CreateMVAPdfs\"" << Endl;
      return 0.0;
   }

   PDF* thePdf = ((reftype == Types::kSignal) ? fMVAPdfS : fMVAPdfB);

   return thePdf->GetIntegral( thePdf->GetXmin(), mvaVal );
}

//_______________________________________________________________________
Double_t TMVA::MethodBase::GetEfficiency( const TString& theString, Types::ETreeType type,Double_t& effSerr )
{
   // fill background efficiency (resp. rejection) versus signal efficiency plots
   // returns signal efficiency at background efficiency indicated in theString

   Data()->SetCurrentType(type);
   Results* results = Data()->GetResults( GetMethodName(), type, Types::kClassification );
   std::vector<Float_t>* mvaRes = dynamic_cast<ResultsClassification*>(results)->GetValueVector();

   // parse input string for required background efficiency
   TList* list  = gTools().ParseFormatLine( theString );

   // sanity check
   Bool_t computeArea = kFALSE;
   if      (!list || list->GetSize() < 2) computeArea = kTRUE; // the area is computed
   else if (list->GetSize() > 2) {
      Log() << kFATAL << "<GetEfficiency> Wrong number of arguments"
            << " in string: " << theString
            << " | required format, e.g., Efficiency:0.05, or empty string" << Endl;
      delete list;
      return -1;
   }

   // sanity check
   if ( results->GetHist("MVA_S")->GetNbinsX() != results->GetHist("MVA_B")->GetNbinsX() ||
        results->GetHist("MVA_HIGHBIN_S")->GetNbinsX() != results->GetHist("MVA_HIGHBIN_B")->GetNbinsX() ) {
      Log() << kFATAL << "<GetEfficiency> Binning mismatch between signal and background histos" << Endl;
      delete list;
      return -1.0;
   }

   // create histograms

   // first, get efficiency histograms for signal and background
   TH1 * effhist = results->GetHist("MVA_HIGHBIN_S");
   Double_t xmin = effhist->GetXaxis()->GetXmin();
   Double_t xmax = effhist->GetXaxis()->GetXmax();

   TTHREAD_TLS(Double_t) nevtS;

   // first round ? --> create histograms
   if (results->DoesExist("MVA_EFF_S")==0) {

      // for efficiency plot
      TH1* eff_s = new TH1D( GetTestvarName() + "_effS", GetTestvarName() + " (signal)",     fNbinsH, xmin, xmax );
      TH1* eff_b = new TH1D( GetTestvarName() + "_effB", GetTestvarName() + " (background)", fNbinsH, xmin, xmax );
      results->Store(eff_s, "MVA_EFF_S");
      results->Store(eff_b, "MVA_EFF_B");

      // sign if cut
      Int_t sign = (fCutOrientation == kPositive) ? +1 : -1;

      // this method is unbinned
      nevtS = 0;
      for (UInt_t ievt=0; ievt<Data()->GetNEvents(); ievt++) {

         // read the tree
         Bool_t  isSignal  = DataInfo().IsSignal(GetEvent(ievt));
         Float_t theWeight = GetEvent(ievt)->GetWeight();
         Float_t theVal    = (*mvaRes)[ievt];

         // select histogram depending on if sig or bgd
         TH1* theHist = isSignal ? eff_s : eff_b;

         // count signal and background events in tree
         if (isSignal) nevtS+=theWeight;

         TAxis* axis   = theHist->GetXaxis();
         Int_t  maxbin = Int_t((theVal - axis->GetXmin())/(axis->GetXmax() - axis->GetXmin())*fNbinsH) + 1;
         if (sign > 0 && maxbin > fNbinsH) continue; // can happen... event doesn't count
         if (sign < 0 && maxbin < 1      ) continue; // can happen... event doesn't count
         if (sign > 0 && maxbin < 1      ) maxbin = 1;
         if (sign < 0 && maxbin > fNbinsH) maxbin = fNbinsH;

         if (sign > 0)
            for (Int_t ibin=1; ibin<=maxbin; ibin++) theHist->AddBinContent( ibin , theWeight);
         else if (sign < 0)
            for (Int_t ibin=maxbin+1; ibin<=fNbinsH; ibin++) theHist->AddBinContent( ibin , theWeight );
         else
            Log() << kFATAL << "<GetEfficiency> Mismatch in sign" << Endl;
      }

      // renormalise maximum to <=1
      // eff_s->Scale( 1.0/TMath::Max(1.,eff_s->GetMaximum()) );
      // eff_b->Scale( 1.0/TMath::Max(1.,eff_b->GetMaximum()) );

      eff_s->Scale( 1.0/TMath::Max(std::numeric_limits<double>::epsilon(),eff_s->GetMaximum()) );
      eff_b->Scale( 1.0/TMath::Max(std::numeric_limits<double>::epsilon(),eff_b->GetMaximum()) );

      // background efficiency versus signal efficiency
      TH1* eff_BvsS = new TH1D( GetTestvarName() + "_effBvsS", GetTestvarName() + "", fNbins, 0, 1 );
      results->Store(eff_BvsS, "MVA_EFF_BvsS");
      eff_BvsS->SetXTitle( "Signal eff" );
      eff_BvsS->SetYTitle( "Backgr eff" );

      // background rejection (=1-eff.) versus signal efficiency
      TH1* rej_BvsS = new TH1D( GetTestvarName() + "_rejBvsS", GetTestvarName() + "", fNbins, 0, 1 );
      results->Store(rej_BvsS);
      rej_BvsS->SetXTitle( "Signal eff" );
      rej_BvsS->SetYTitle( "Backgr rejection (1-eff)" );

      // inverse background eff (1/eff.) versus signal efficiency
      TH1* inveff_BvsS = new TH1D( GetTestvarName() + "_invBeffvsSeff",
                                   GetTestvarName(), fNbins, 0, 1 );
      results->Store(inveff_BvsS);
      inveff_BvsS->SetXTitle( "Signal eff" );
      inveff_BvsS->SetYTitle( "Inverse backgr. eff (1/eff)" );

      // use root finder
      // spline background efficiency plot
      // note that there is a bin shift when going from a TH1D object to a TGraph :-(
      if (Use_Splines_for_Eff_) {
         fSplRefS  = new TSpline1( "spline2_signal",     new TGraph( eff_s ) );
         fSplRefB  = new TSpline1( "spline2_background", new TGraph( eff_b ) );

         // verify spline sanity
         gTools().CheckSplines( eff_s, fSplRefS );
         gTools().CheckSplines( eff_b, fSplRefB );
      }

      // make the background-vs-signal efficiency plot

      // create root finder
      // reset static "this" pointer before calling external function
      ResetThisBase();
      RootFinder rootFinder( &IGetEffForRoot, fXmin, fXmax );

      Double_t effB = 0;
      fEffS = eff_s; // to be set for the root finder
      for (Int_t bini=1; bini<=fNbins; bini++) {

         // find cut value corresponding to a given signal efficiency
         Double_t effS = eff_BvsS->GetBinCenter( bini );
         Double_t cut  = rootFinder.Root( effS );

         // retrieve background efficiency for given cut
         if (Use_Splines_for_Eff_) effB = fSplRefB->Eval( cut );
         else                      effB = eff_b->GetBinContent( eff_b->FindBin( cut ) );

         // and fill histograms
         eff_BvsS->SetBinContent( bini, effB     );
         rej_BvsS->SetBinContent( bini, 1.0-effB );
         if (effB>std::numeric_limits<double>::epsilon())
            inveff_BvsS->SetBinContent( bini, 1.0/effB );
      }

      // create splines for histogram
      fSpleffBvsS = new TSpline1( "effBvsS", new TGraph( eff_BvsS ) );

      // search for overlap point where, when cutting on it,
      // one would obtain: eff_S = rej_B = 1 - eff_B
      Double_t effS, rejB, effS_ = 0, rejB_ = 0;
      Int_t    nbins_ = 5000;
      for (Int_t bini=1; bini<=nbins_; bini++) {

         // get corresponding signal and background efficiencies
         effS = (bini - 0.5)/Float_t(nbins_);
         rejB = 1.0 - fSpleffBvsS->Eval( effS );

         // find signal efficiency that corresponds to required background efficiency
         if ((effS - rejB)*(effS_ - rejB_) < 0) break;
         effS_ = effS;
         rejB_ = rejB;
      }

      // find cut that corresponds to signal efficiency and update signal-like criterion
      Double_t cut = rootFinder.Root( 0.5*(effS + effS_) );
      SetSignalReferenceCut( cut );
      fEffS = 0;
   }

   // must exist...
   if (0 == fSpleffBvsS) {
      delete list;
      return 0.0;
   }

   // now find signal efficiency that corresponds to required background efficiency
   Double_t effS = 0, effB = 0, effS_ = 0, effB_ = 0;
   Int_t    nbins_ = 1000;

   if (computeArea) {

      // compute area of rej-vs-eff plot
      Double_t integral = 0;
      for (Int_t bini=1; bini<=nbins_; bini++) {

         // get corresponding signal and background efficiencies
         effS = (bini - 0.5)/Float_t(nbins_);
         effB = fSpleffBvsS->Eval( effS );
         integral += (1.0 - effB);
      }
      integral /= nbins_;

      delete list;
      return integral;
   }
   else {

      // that will be the value of the efficiency retured (does not affect
      // the efficiency-vs-bkg plot which is done anyway.
      Float_t effBref  = atof( ((TObjString*)list->At(1))->GetString() );

      // find precise efficiency value
      for (Int_t bini=1; bini<=nbins_; bini++) {

         // get corresponding signal and background efficiencies
         effS = (bini - 0.5)/Float_t(nbins_);
         effB = fSpleffBvsS->Eval( effS );

         // find signal efficiency that corresponds to required background efficiency
         if ((effB - effBref)*(effB_ - effBref) <= 0) break;
         effS_ = effS;
         effB_ = effB;
      }

      // take mean between bin above and bin below
      effS = 0.5*(effS + effS_);

      effSerr = 0;
      if (nevtS > 0) effSerr = TMath::Sqrt( effS*(1.0 - effS)/nevtS );

      delete list;
      return effS;
   }

   return -1;
}

//_______________________________________________________________________
Double_t TMVA::MethodBase::GetTrainingEfficiency(const TString& theString)
{
   Data()->SetCurrentType(Types::kTraining);

   Results* results = Data()->GetResults(GetMethodName(), Types::kTesting, Types::kNoAnalysisType);

   // fill background efficiency (resp. rejection) versus signal efficiency plots
   // returns signal efficiency at background efficiency indicated in theString

   // parse input string for required background efficiency
   TList*  list  = gTools().ParseFormatLine( theString );
   // sanity check

   if (list->GetSize() != 2) {
      Log() << kFATAL << "<GetTrainingEfficiency> Wrong number of arguments"
            << " in string: " << theString
            << " | required format, e.g., Efficiency:0.05" << Endl;
      delete list;
      return -1;
   }
   // that will be the value of the efficiency retured (does not affect
   // the efficiency-vs-bkg plot which is done anyway.
   Float_t effBref  = atof( ((TObjString*)list->At(1))->GetString() );

   delete list;

   // sanity check
   if (results->GetHist("MVA_S")->GetNbinsX() != results->GetHist("MVA_B")->GetNbinsX() ||
       results->GetHist("MVA_HIGHBIN_S")->GetNbinsX() != results->GetHist("MVA_HIGHBIN_B")->GetNbinsX() ) {
      Log() << kFATAL << "<GetTrainingEfficiency> Binning mismatch between signal and background histos"
            << Endl;
      return -1.0;
   }

   // create histogram

   // first, get efficiency histograms for signal and background
   TH1 * effhist = results->GetHist("MVA_HIGHBIN_S");
   Double_t xmin = effhist->GetXaxis()->GetXmin();
   Double_t xmax = effhist->GetXaxis()->GetXmax();

   // first round ? --> create and fill histograms
   if (results->DoesExist("MVA_TRAIN_S")==0) {

      // classifier response distributions for test sample
      Double_t sxmax = fXmax+0.00001;

      // MVA plots on the training sample (check for overtraining)
      TH1* mva_s_tr = new TH1D( GetTestvarName() + "_Train_S",GetTestvarName() + "_Train_S", fNbinsMVAoutput, fXmin, sxmax );
      TH1* mva_b_tr = new TH1D( GetTestvarName() + "_Train_B",GetTestvarName() + "_Train_B", fNbinsMVAoutput, fXmin, sxmax );
      results->Store(mva_s_tr, "MVA_TRAIN_S");
      results->Store(mva_b_tr, "MVA_TRAIN_B");
      mva_s_tr->Sumw2();
      mva_b_tr->Sumw2();

      // Training efficiency plots
      TH1* mva_eff_tr_s = new TH1D( GetTestvarName() + "_trainingEffS", GetTestvarName() + " (signal)",
                                    fNbinsH, xmin, xmax );
      TH1* mva_eff_tr_b = new TH1D( GetTestvarName() + "_trainingEffB", GetTestvarName() + " (background)",
                                    fNbinsH, xmin, xmax );
      results->Store(mva_eff_tr_s, "MVA_TRAINEFF_S");
      results->Store(mva_eff_tr_b, "MVA_TRAINEFF_B");

      // sign if cut
      Int_t sign = (fCutOrientation == kPositive) ? +1 : -1;

      // this method is unbinned
      for (Int_t ievt=0; ievt<Data()->GetNEvents(); ievt++) {

         Data()->SetCurrentEvent(ievt);
         const Event* ev = GetEvent();

         Double_t theVal    = GetMvaValue();
         Double_t theWeight = ev->GetWeight();

         TH1* theEffHist = DataInfo().IsSignal(ev) ? mva_eff_tr_s : mva_eff_tr_b;
         TH1* theClsHist = DataInfo().IsSignal(ev) ? mva_s_tr : mva_b_tr;

         theClsHist->Fill( theVal, theWeight );

         TAxis* axis   = theEffHist->GetXaxis();
         Int_t  maxbin = Int_t((theVal - axis->GetXmin())/(axis->GetXmax() - axis->GetXmin())*fNbinsH) + 1;
         if (sign > 0 && maxbin > fNbinsH) continue; // can happen... event doesn't count
         if (sign < 0 && maxbin < 1      ) continue; // can happen... event doesn't count
         if (sign > 0 && maxbin < 1      ) maxbin = 1;
         if (sign < 0 && maxbin > fNbinsH) maxbin = fNbinsH;

         if (sign > 0) for (Int_t ibin=1;        ibin<=maxbin;  ibin++) theEffHist->AddBinContent( ibin , theWeight );
         else          for (Int_t ibin=maxbin+1; ibin<=fNbinsH; ibin++) theEffHist->AddBinContent( ibin , theWeight );
      }

      // normalise output distributions
      // uncomment those (and several others if you want unnormalized output
      gTools().NormHist( mva_s_tr  );
      gTools().NormHist( mva_b_tr  );

      // renormalise to maximum
      mva_eff_tr_s->Scale( 1.0/TMath::Max(std::numeric_limits<double>::epsilon(), mva_eff_tr_s->GetMaximum()) );
      mva_eff_tr_b->Scale( 1.0/TMath::Max(std::numeric_limits<double>::epsilon(), mva_eff_tr_b->GetMaximum()) );

      // Training background efficiency versus signal efficiency
      TH1* eff_bvss = new TH1D( GetTestvarName() + "_trainingEffBvsS", GetTestvarName() + "", fNbins, 0, 1 );
      // Training background rejection (=1-eff.) versus signal efficiency
      TH1* rej_bvss = new TH1D( GetTestvarName() + "_trainingRejBvsS", GetTestvarName() + "", fNbins, 0, 1 );
      results->Store(eff_bvss, "EFF_BVSS_TR");
      results->Store(rej_bvss, "REJ_BVSS_TR");

      // use root finder
      // spline background efficiency plot
      // note that there is a bin shift when going from a TH1D object to a TGraph :-(
      if (Use_Splines_for_Eff_) {
         if (fSplTrainRefS) delete fSplTrainRefS;
         if (fSplTrainRefB) delete fSplTrainRefB;
         fSplTrainRefS  = new TSpline1( "spline2_signal",     new TGraph( mva_eff_tr_s ) );
         fSplTrainRefB  = new TSpline1( "spline2_background", new TGraph( mva_eff_tr_b ) );

         // verify spline sanity
         gTools().CheckSplines( mva_eff_tr_s, fSplTrainRefS );
         gTools().CheckSplines( mva_eff_tr_b, fSplTrainRefB );
      }

      // make the background-vs-signal efficiency plot

      // create root finder
      // reset static "this" pointer before calling external function
      ResetThisBase();
      RootFinder rootFinder(&IGetEffForRoot, fXmin, fXmax );

      Double_t effB = 0;
      fEffS = results->GetHist("MVA_TRAINEFF_S");
      for (Int_t bini=1; bini<=fNbins; bini++) {

         // find cut value corresponding to a given signal efficiency
         Double_t effS = eff_bvss->GetBinCenter( bini );

         Double_t cut  = rootFinder.Root( effS );

         // retrieve background efficiency for given cut
         if (Use_Splines_for_Eff_) effB = fSplTrainRefB->Eval( cut );
         else                      effB = mva_eff_tr_b->GetBinContent( mva_eff_tr_b->FindBin( cut ) );

         // and fill histograms
         eff_bvss->SetBinContent( bini, effB     );
         rej_bvss->SetBinContent( bini, 1.0-effB );
      }
      fEffS = 0;

      // create splines for histogram
      fSplTrainEffBvsS = new TSpline1( "effBvsS", new TGraph( eff_bvss ) );
   }

   // must exist...
   if (0 == fSplTrainEffBvsS) return 0.0;

   // now find signal efficiency that corresponds to required background efficiency
   Double_t effS, effB, effS_ = 0, effB_ = 0;
   Int_t    nbins_ = 1000;
   for (Int_t bini=1; bini<=nbins_; bini++) {

      // get corresponding signal and background efficiencies
      effS = (bini - 0.5)/Float_t(nbins_);
      effB = fSplTrainEffBvsS->Eval( effS );

      // find signal efficiency that corresponds to required background efficiency
      if ((effB - effBref)*(effB_ - effBref) <= 0) break;
      effS_ = effS;
      effB_ = effB;
   }

   return 0.5*(effS + effS_); // the mean between bin above and bin below
}

//_______________________________________________________________________


std::vector<Float_t> TMVA::MethodBase::GetMulticlassEfficiency(std::vector<std::vector<Float_t> >& purity)
{
   Data()->SetCurrentType(Types::kTesting);
   ResultsMulticlass* resMulticlass = dynamic_cast<ResultsMulticlass*>(Data()->GetResults(GetMethodName(), Types::kTesting, Types::kMulticlass));
   if (!resMulticlass) Log() << kFATAL<< "unable to create pointer in GetMulticlassEfficiency, exiting."<<Endl;

   purity.push_back(resMulticlass->GetAchievablePur());
   return resMulticlass->GetAchievableEff();
}

//_______________________________________________________________________

std::vector<Float_t> TMVA::MethodBase::GetMulticlassTrainingEfficiency(std::vector<std::vector<Float_t> >& purity)
{
   Data()->SetCurrentType(Types::kTraining);
   ResultsMulticlass* resMulticlass = dynamic_cast<ResultsMulticlass*>(Data()->GetResults(GetMethodName(), Types::kTraining, Types::kMulticlass));
   if (!resMulticlass) Log() << kFATAL<< "unable to create pointer in GetMulticlassTrainingEfficiency, exiting."<<Endl;

   Log() << kINFO << "Determine optimal multiclass cuts for training data..." << Endl;
   for (UInt_t icls = 0; icls<DataInfo().GetNClasses(); ++icls) {
      resMulticlass->GetBestMultiClassCuts(icls);
   }

   purity.push_back(resMulticlass->GetAchievablePur());
   return resMulticlass->GetAchievableEff();
}


//_______________________________________________________________________
Double_t TMVA::MethodBase::GetSignificance( void ) const
{
   // compute significance of mean difference
   // significance = |<S> - <B>|/Sqrt(RMS_S2 + RMS_B2)
   Double_t rms = sqrt( fRmsS*fRmsS + fRmsB*fRmsB );

   return (rms > 0) ? TMath::Abs(fMeanS - fMeanB)/rms : 0;
}

//_______________________________________________________________________
Double_t TMVA::MethodBase::GetSeparation( TH1* histoS, TH1* histoB ) const
{
   // compute "separation" defined as
   // <s2> = (1/2) Int_-oo..+oo { (S(x) - B(x))^2/(S(x) + B(x)) dx }
   return gTools().GetSeparation( histoS, histoB );
}

//_______________________________________________________________________
Double_t TMVA::MethodBase::GetSeparation( PDF* pdfS, PDF* pdfB ) const
{
   // compute "separation" defined as
   // <s2> = (1/2) Int_-oo..+oo { (S(x) - B(x))^2/(S(x) + B(x)) dx }

   // note, if zero pointers given, use internal pdf
   // sanity check first
   if ((!pdfS && pdfB) || (pdfS && !pdfB))
      Log() << kFATAL << "<GetSeparation> Mismatch in pdfs" << Endl;
   if (!pdfS) pdfS = fSplS;
   if (!pdfB) pdfB = fSplB;

   if (!fSplS || !fSplB) {
      Log()<<kWARNING<< "could not calculate the separation, distributions"
           << " fSplS or fSplB are not yet filled" << Endl;
      return 0;
   }else{
      return gTools().GetSeparation( *pdfS, *pdfB );
   }
}

//_______________________________________________________________________
Double_t TMVA::MethodBase::GetROCIntegral(TH1D *histS, TH1D *histB) const
{
   // calculate the area (integral) under the ROC curve as a
   // overall quality measure of the classification

   // note, if zero pointers given, use internal pdf
   // sanity check first
   if ((!histS && histB) || (histS && !histB))
      Log() << kFATAL << "<GetROCIntegral(TH1D*, TH1D*)> Mismatch in hists" << Endl;

   if (histS==0 || histB==0) return 0.;

   TMVA::PDF *pdfS = new TMVA::PDF( " PDF Sig", histS, TMVA::PDF::kSpline3 );
   TMVA::PDF *pdfB = new TMVA::PDF( " PDF Bkg", histB, TMVA::PDF::kSpline3 );


   Double_t xmin = TMath::Min(pdfS->GetXmin(), pdfB->GetXmin());
   Double_t xmax = TMath::Max(pdfS->GetXmax(), pdfB->GetXmax());

   Double_t integral = 0;
   UInt_t   nsteps = 1000;
   Double_t step = (xmax-xmin)/Double_t(nsteps);
   Double_t cut = xmin;
   for (UInt_t i=0; i<nsteps; i++) {
      integral += (1-pdfB->GetIntegral(cut,xmax)) * pdfS->GetVal(cut);
      cut+=step;
   }
   return integral*step;
}


//_______________________________________________________________________
Double_t TMVA::MethodBase::GetROCIntegral(PDF *pdfS, PDF *pdfB) const
{
   // calculate the area (integral) under the ROC curve as a
   // overall quality measure of the classification

   // note, if zero pointers given, use internal pdf
   // sanity check first
   if ((!pdfS && pdfB) || (pdfS && !pdfB))
      Log() << kFATAL << "<GetSeparation> Mismatch in pdfs" << Endl;
   if (!pdfS) pdfS = fSplS;
   if (!pdfB) pdfB = fSplB;

   if (pdfS==0 || pdfB==0) return 0.;

   Double_t xmin = TMath::Min(pdfS->GetXmin(), pdfB->GetXmin());
   Double_t xmax = TMath::Max(pdfS->GetXmax(), pdfB->GetXmax());

   Double_t integral = 0;
   UInt_t   nsteps = 1000;
   Double_t step = (xmax-xmin)/Double_t(nsteps);
   Double_t cut = xmin;
   for (UInt_t i=0; i<nsteps; i++) {
      integral += (1-pdfB->GetIntegral(cut,xmax)) * pdfS->GetVal(cut);
      cut+=step;
   }
   return integral*step;
}

//_______________________________________________________________________
Double_t TMVA::MethodBase::GetMaximumSignificance( Double_t SignalEvents,
                                                   Double_t BackgroundEvents,
                                                   Double_t& max_significance_value ) const
{
   // plot significance, S/Sqrt(S^2 + B^2), curve for given number
   // of signal and background events; returns cut for maximum significance
   // also returned via reference is the maximum significance

   Results* results = Data()->GetResults( GetMethodName(), Types::kTesting, Types::kMaxAnalysisType );

   Double_t max_significance(0);
   Double_t effS(0),effB(0),significance(0);
   TH1D *temp_histogram = new TH1D("temp", "temp", fNbinsH, fXmin, fXmax );

   if (SignalEvents <= 0 || BackgroundEvents <= 0) {
      Log() << kFATAL << "<GetMaximumSignificance> "
            << "Number of signal or background events is <= 0 ==> abort"
            << Endl;
   }

   Log() << kINFO << "Using ratio SignalEvents/BackgroundEvents = "
         << SignalEvents/BackgroundEvents << Endl;

   TH1* eff_s = results->GetHist("MVA_EFF_S");
   TH1* eff_b = results->GetHist("MVA_EFF_B");

   if ( (eff_s==0) || (eff_b==0) ) {
      Log() << kWARNING << "Efficiency histograms empty !" << Endl;
      Log() << kWARNING << "no maximum cut found, return 0" << Endl;
      return 0;
   }

   for (Int_t bin=1; bin<=fNbinsH; bin++) {
      effS = eff_s->GetBinContent( bin );
      effB = eff_b->GetBinContent( bin );

      // put significance into a histogram
      significance = sqrt(SignalEvents)*( effS )/sqrt( effS + ( BackgroundEvents / SignalEvents) * effB  );

      temp_histogram->SetBinContent(bin,significance);
   }

   // find maximum in histogram
   max_significance = temp_histogram->GetBinCenter( temp_histogram->GetMaximumBin() );
   max_significance_value = temp_histogram->GetBinContent( temp_histogram->GetMaximumBin() );

   // delete
   delete temp_histogram;

   Log() << kINFO << "Optimal cut at      : " << max_significance << Endl;
   Log() << kINFO << "Maximum significance: " << max_significance_value << Endl;

   return max_significance;
}

//_______________________________________________________________________
void TMVA::MethodBase::Statistics( Types::ETreeType treeType, const TString& theVarName,
                                   Double_t& meanS, Double_t& meanB,
                                   Double_t& rmsS,  Double_t& rmsB,
                                   Double_t& xmin,  Double_t& xmax )
{
   // calculates rms,mean, xmin, xmax of the event variable
   // this can be either done for the variables as they are or for
   // normalised variables (in the range of 0-1) if "norm" is set to kTRUE

   Types::ETreeType previousTreeType = Data()->GetCurrentType();
   Data()->SetCurrentType(treeType);

   Long64_t entries = Data()->GetNEvents();

   // sanity check
   if (entries <=0)
      Log() << kFATAL << "<CalculateEstimator> Wrong tree type: " << treeType << Endl;

   // index of the wanted variable
   UInt_t varIndex = DataInfo().FindVarIndex( theVarName );

   // first fill signal and background in arrays before analysis
   xmin               = +DBL_MAX;
   xmax               = -DBL_MAX;
   Long64_t nEventsS  = -1;
   Long64_t nEventsB  = -1;

   // take into account event weights
   meanS = 0;
   meanB = 0;
   rmsS  = 0;
   rmsB  = 0;
   Double_t sumwS = 0, sumwB = 0;

   // loop over all training events
   for (Int_t ievt = 0; ievt < entries; ievt++) {

      const Event* ev = GetEvent(ievt);

      Double_t theVar = ev->GetValue(varIndex);
      Double_t weight = ev->GetWeight();

      if (DataInfo().IsSignal(ev)) {
         sumwS               += weight;
         meanS               += weight*theVar;
         rmsS                += weight*theVar*theVar;
      }
      else {
         sumwB               += weight;
         meanB               += weight*theVar;
         rmsB                += weight*theVar*theVar;
      }
      xmin = TMath::Min( xmin, theVar );
      xmax = TMath::Max( xmax, theVar );
   }
   ++nEventsS;
   ++nEventsB;

   meanS = meanS/sumwS;
   meanB = meanB/sumwB;
   rmsS  = TMath::Sqrt( rmsS/sumwS - meanS*meanS );
   rmsB  = TMath::Sqrt( rmsB/sumwB - meanB*meanB );

   Data()->SetCurrentType(previousTreeType);
}

//_______________________________________________________________________
void TMVA::MethodBase::MakeClass( const TString& theClassFileName ) const
{
   // create reader class for method (classification only at present)

   // the default consists of
   TString classFileName = "";
   if (theClassFileName == "")
      classFileName = GetWeightFileDir() + "/" + GetJobName() + "_" + GetMethodName() + ".class.C";
   else
      classFileName = theClassFileName;

   TString className = TString("Read") + GetMethodName();

   TString tfname( classFileName );
   Log() << kINFO << "Creating standalone response class: "
         << gTools().Color("lightblue") << classFileName << gTools().Color("reset") << Endl;

   std::ofstream fout( classFileName );
   if (!fout.good()) { // file could not be opened --> Error
      Log() << kFATAL << "<MakeClass> Unable to open file: " << classFileName << Endl;
   }

   // now create the class
   // preamble
   fout << "// Class: " << className << std::endl;
   fout << "// Automatically generated by MethodBase::MakeClass" << std::endl << "//" << std::endl;

   // print general information and configuration state
   fout << std::endl;
   fout << "/* configuration options =====================================================" << std::endl << std::endl;
   WriteStateToStream( fout );
   fout << std::endl;
   fout << "============================================================================ */" << std::endl;

   // generate the class
   fout << "" << std::endl;
   fout << "#include <vector>" << std::endl;
   fout << "#include <cmath>" << std::endl;
   fout << "#include <string>" << std::endl;
   fout << "#include <iostream>" << std::endl;
   fout << "" << std::endl;
   // now if the classifier needs to write some addicional classes for its response implementation
   // this code goes here: (at least the header declarations need to come before the main class
   this->MakeClassSpecificHeader( fout, className );

   fout << "#ifndef IClassifierReader__def" << std::endl;
   fout << "#define IClassifierReader__def" << std::endl;
   fout << std::endl;
   fout << "class IClassifierReader {" << std::endl;
   fout << std::endl;
   fout << " public:" << std::endl;
   fout << std::endl;
   fout << "   // constructor" << std::endl;
   fout << "   IClassifierReader() : fStatusIsClean( true ) {}" << std::endl;
   fout << "   virtual ~IClassifierReader() {}" << std::endl;
   fout << std::endl;
   fout << "   // return classifier response" << std::endl;
   fout << "   virtual double GetMvaValue( const std::vector<double>& inputValues ) const = 0;" << std::endl;
   fout << std::endl;
   fout << "   // returns classifier status" << std::endl;
   fout << "   bool IsStatusClean() const { return fStatusIsClean; }" << std::endl;
   fout << std::endl;
   fout << " protected:" << std::endl;
   fout << std::endl;
   fout << "   bool fStatusIsClean;" << std::endl;
   fout << "};" << std::endl;
   fout << std::endl;
   fout << "#endif" << std::endl;
   fout << std::endl;
   fout << "class " << className << " : public IClassifierReader {" << std::endl;
   fout << std::endl;
   fout << " public:" << std::endl;
   fout << std::endl;
   fout << "   // constructor" << std::endl;
   fout << "   " << className << "( std::vector<std::string>& theInputVars ) " << std::endl;
   fout << "      : IClassifierReader()," << std::endl;
   fout << "        fClassName( \"" << className << "\" )," << std::endl;
   fout << "        fNvars( " << GetNvar() << " )," << std::endl;
   fout << "        fIsNormalised( " << (IsNormalised() ? "true" : "false") << " )" << std::endl;
   fout << "   {      " << std::endl;
   fout << "      // the training input variables" << std::endl;
   fout << "      const char* inputVars[] = { ";
   for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
      fout << "\"" << GetOriginalVarName(ivar) << "\"";
      if (ivar<GetNvar()-1) fout << ", ";
   }
   fout << " };" << std::endl;
   fout << std::endl;
   fout << "      // sanity checks" << std::endl;
   fout << "      if (theInputVars.size() <= 0) {" << std::endl;
   fout << "         std::cout << \"Problem in class \\\"\" << fClassName << \"\\\": empty input vector\" << std::endl;" << std::endl;
   fout << "         fStatusIsClean = false;" << std::endl;
   fout << "      }" << std::endl;
   fout << std::endl;
   fout << "      if (theInputVars.size() != fNvars) {" << std::endl;
   fout << "         std::cout << \"Problem in class \\\"\" << fClassName << \"\\\": mismatch in number of input values: \"" << std::endl;
   fout << "                   << theInputVars.size() << \" != \" << fNvars << std::endl;" << std::endl;
   fout << "         fStatusIsClean = false;" << std::endl;
   fout << "      }" << std::endl;
   fout << std::endl;
   fout << "      // validate input variables" << std::endl;
   fout << "      for (size_t ivar = 0; ivar < theInputVars.size(); ivar++) {" << std::endl;
   fout << "         if (theInputVars[ivar] != inputVars[ivar]) {" << std::endl;
   fout << "            std::cout << \"Problem in class \\\"\" << fClassName << \"\\\": mismatch in input variable names\" << std::endl" << std::endl;
   fout << "                      << \" for variable [\" << ivar << \"]: \" << theInputVars[ivar].c_str() << \" != \" << inputVars[ivar] << std::endl;" << std::endl;
   fout << "            fStatusIsClean = false;" << std::endl;
   fout << "         }" << std::endl;
   fout << "      }" << std::endl;
   fout << std::endl;
   fout << "      // initialize min and max vectors (for normalisation)" << std::endl;
   for (UInt_t ivar = 0; ivar < GetNvar(); ivar++) {
      fout << "      fVmin[" << ivar << "] = " << std::setprecision(15) << GetXmin( ivar ) << ";" << std::endl;
      fout << "      fVmax[" << ivar << "] = " << std::setprecision(15) << GetXmax( ivar ) << ";" << std::endl;
   }
   fout << std::endl;
   fout << "      // initialize input variable types" << std::endl;
   for (UInt_t ivar=0; ivar<GetNvar(); ivar++) {
      fout << "      fType[" << ivar << "] = \'" << DataInfo().GetVariableInfo(ivar).GetVarType() << "\';" << std::endl;
   }
   fout << std::endl;
   fout << "      // initialize constants" << std::endl;
   fout << "      Initialize();" << std::endl;
   fout << std::endl;
   if (GetTransformationHandler().GetTransformationList().GetSize() != 0) {
      fout << "      // initialize transformation" << std::endl;
      fout << "      InitTransform();" << std::endl;
   }
   fout << "   }" << std::endl;
   fout << std::endl;
   fout << "   // destructor" << std::endl;
   fout << "   virtual ~" << className << "() {" << std::endl;
   fout << "      Clear(); // method-specific" << std::endl;
   fout << "   }" << std::endl;
   fout << std::endl;
   fout << "   // the classifier response" << std::endl;
   fout << "   // \"inputValues\" is a vector of input values in the same order as the " << std::endl;
   fout << "   // variables given to the constructor" << std::endl;
   fout << "   double GetMvaValue( const std::vector<double>& inputValues ) const;" << std::endl;
   fout << std::endl;
   fout << " private:" << std::endl;
   fout << std::endl;
   fout << "   // method-specific destructor" << std::endl;
   fout << "   void Clear();" << std::endl;
   fout << std::endl;
   if (GetTransformationHandler().GetTransformationList().GetSize()!=0) {
      fout << "   // input variable transformation" << std::endl;
      GetTransformationHandler().MakeFunction(fout, className,1);
      fout << "   void InitTransform();" << std::endl;
      fout << "   void Transform( std::vector<double> & iv, int sigOrBgd ) const;" << std::endl;
      fout << std::endl;
   }
   fout << "   // common member variables" << std::endl;
   fout << "   const char* fClassName;" << std::endl;
   fout << std::endl;
   fout << "   const size_t fNvars;" << std::endl;
   fout << "   size_t GetNvar()           const { return fNvars; }" << std::endl;
   fout << "   char   GetType( int ivar ) const { return fType[ivar]; }" << std::endl;
   fout << std::endl;
   fout << "   // normalisation of input variables" << std::endl;
   fout << "   const bool fIsNormalised;" << std::endl;
   fout << "   bool IsNormalised() const { return fIsNormalised; }" << std::endl;
   fout << "   double fVmin[" << GetNvar() << "];" << std::endl;
   fout << "   double fVmax[" << GetNvar() << "];" << std::endl;
   fout << "   double NormVariable( double x, double xmin, double xmax ) const {" << std::endl;
   fout << "      // normalise to output range: [-1, 1]" << std::endl;
   fout << "      return 2*(x - xmin)/(xmax - xmin) - 1.0;" << std::endl;
   fout << "   }" << std::endl;
   fout << std::endl;
   fout << "   // type of input variable: 'F' or 'I'" << std::endl;
   fout << "   char   fType[" << GetNvar() << "];" << std::endl;
   fout << std::endl;
   fout << "   // initialize internal variables" << std::endl;
   fout << "   void Initialize();" << std::endl;
   fout << "   double GetMvaValue__( const std::vector<double>& inputValues ) const;" << std::endl;
   fout << "" << std::endl;
   fout << "   // private members (method specific)" << std::endl;

   // call the classifier specific output (the classifier must close the class !)
   MakeClassSpecific( fout, className );

   fout << "   inline double " << className << "::GetMvaValue( const std::vector<double>& inputValues ) const" << std::endl;
   fout << "   {" << std::endl;
   fout << "      // classifier response value" << std::endl;
   fout << "      double retval = 0;" << std::endl;
   fout << std::endl;
   fout << "      // classifier response, sanity check first" << std::endl;
   fout << "      if (!IsStatusClean()) {" << std::endl;
   fout << "         std::cout << \"Problem in class \\\"\" << fClassName << \"\\\": cannot return classifier response\"" << std::endl;
   fout << "                   << \" because status is dirty\" << std::endl;" << std::endl;
   fout << "         retval = 0;" << std::endl;
   fout << "      }" << std::endl;
   fout << "      else {" << std::endl;
   fout << "         if (IsNormalised()) {" << std::endl;
   fout << "            // normalise variables" << std::endl;
   fout << "            std::vector<double> iV;" << std::endl;
   fout << "            iV.reserve(inputValues.size());" << std::endl;
   fout << "            int ivar = 0;" << std::endl;
   fout << "            for (std::vector<double>::const_iterator varIt = inputValues.begin();" << std::endl;
   fout << "                 varIt != inputValues.end(); varIt++, ivar++) {" << std::endl;
   fout << "               iV.push_back(NormVariable( *varIt, fVmin[ivar], fVmax[ivar] ));" << std::endl;
   fout << "            }" << std::endl;
   if (GetTransformationHandler().GetTransformationList().GetSize()!=0 &&
       GetMethodType() != Types::kLikelihood &&
       GetMethodType() != Types::kHMatrix) {
      fout << "            Transform( iV, -1 );" << std::endl;
   }
   fout << "            retval = GetMvaValue__( iV );" << std::endl;
   fout << "         }" << std::endl;
   fout << "         else {" << std::endl;
   if (GetTransformationHandler().GetTransformationList().GetSize()!=0 &&
       GetMethodType() != Types::kLikelihood &&
       GetMethodType() != Types::kHMatrix) {
      fout << "            std::vector<double> iV;" << std::endl;
      fout << "            int ivar = 0;" << std::endl;
      fout << "            for (std::vector<double>::const_iterator varIt = inputValues.begin();" << std::endl;
      fout << "                 varIt != inputValues.end(); varIt++, ivar++) {" << std::endl;
      fout << "               iV.push_back(*varIt);" << std::endl;
      fout << "            }" << std::endl;
      fout << "            Transform( iV, -1 );" << std::endl;
      fout << "            retval = GetMvaValue__( iV );" << std::endl;
   }
   else {
      fout << "            retval = GetMvaValue__( inputValues );" << std::endl;
   }
   fout << "         }" << std::endl;
   fout << "      }" << std::endl;
   fout << std::endl;
   fout << "      return retval;" << std::endl;
   fout << "   }" << std::endl;

   // create output for transformation - if any
   if (GetTransformationHandler().GetTransformationList().GetSize()!=0)
      GetTransformationHandler().MakeFunction(fout, className,2);

   // close the file
   fout.close();
}

//_______________________________________________________________________
void TMVA::MethodBase::PrintHelpMessage() const
{
   // prints out method-specific help method

   // if options are written to reference file, also append help info
   std::streambuf* cout_sbuf = std::cout.rdbuf(); // save original sbuf
   std::ofstream* o = 0;
   if (gConfig().WriteOptionsReference()) {
      Log() << kINFO << "Print Help message for class " << GetName() << " into file: " << GetReferenceFile() << Endl;
      o = new std::ofstream( GetReferenceFile(), std::ios::app );
      if (!o->good()) { // file could not be opened --> Error
         Log() << kFATAL << "<PrintHelpMessage> Unable to append to output file: " << GetReferenceFile() << Endl;
      }
      std::cout.rdbuf( o->rdbuf() ); // redirect 'std::cout' to file
   }

   //         "|--------------------------------------------------------------|"
   if (!o) {
      Log() << kINFO << Endl;
      Log() << gTools().Color("bold")
            << "================================================================"
            << gTools().Color( "reset" )
            << Endl;
      Log() << gTools().Color("bold")
            << "H e l p   f o r   M V A   m e t h o d   [ " << GetName() << " ] :"
            << gTools().Color( "reset" )
            << Endl;
   }
   else {
      Log() << "Help for MVA method [ " << GetName() << " ] :" << Endl;
   }

   // print method-specific help message
   GetHelpMessage();

   if (!o) {
      Log() << Endl;
      Log() << "<Suppress this message by specifying \"!H\" in the booking option>" << Endl;
      Log() << gTools().Color("bold")
            << "================================================================"
            << gTools().Color( "reset" )
            << Endl;
      Log() << Endl;
   }
   else {
      // indicate END
      Log() << "# End of Message___" << Endl;
   }

   std::cout.rdbuf( cout_sbuf ); // restore the original stream buffer
   if (o) o->close();
}

// ----------------------- r o o t   f i n d i n g ----------------------------

//_______________________________________________________________________
Double_t TMVA::MethodBase::IGetEffForRoot( Double_t theCut )
{
   // interface for RootFinder
   return MethodBase::GetThisBase()->GetEffForRoot( theCut );
}

//_______________________________________________________________________
Double_t TMVA::MethodBase::GetEffForRoot( Double_t theCut )
{
   // returns efficiency as function of cut
   Double_t retval=0;

   // retrieve the class object
   if (Use_Splines_for_Eff_) {
      retval = fSplRefS->Eval( theCut );
   }
   else retval = fEffS->GetBinContent( fEffS->FindBin( theCut ) );

   // caution: here we take some "forbidden" action to hide a problem:
   // in some cases, in particular for likelihood, the binned efficiency distributions
   // do not equal 1, at xmin, and 0 at xmax; of course, in principle we have the
   // unbinned information available in the trees, but the unbinned minimization is
   // too slow, and we don't need to do a precision measurement here. Hence, we force
   // this property.
   Double_t eps = 1.0e-5;
   if      (theCut-fXmin < eps) retval = (GetCutOrientation() == kPositive) ? 1.0 : 0.0;
   else if (fXmax-theCut < eps) retval = (GetCutOrientation() == kPositive) ? 0.0 : 1.0;

   return retval;
}

//_______________________________________________________________________
const std::vector<TMVA::Event*>& TMVA::MethodBase::GetEventCollection( Types::ETreeType type)
{
   // returns the event collection (i.e. the dataset) TRANSFORMED using the
   //   classifiers specific Variable Transformation (e.g. Decorr or Decorr:Gauss:Decorr)

   // if there's no variable transformation for this classifier, just hand back the
   //  event collection of the data set
   if (GetTransformationHandler().GetTransformationList().GetEntries() <= 0) {
      return (Data()->GetEventCollection(type));
   }

   // otherwise, transform ALL the events and hand back the vector of the pointers to the
   // transformed events. If the pointer is already != 0, i.e. the whole thing has been
   // done before, I don't need to do it again, but just "hand over" the pointer to those events.
   Int_t idx = Data()->TreeIndex(type);  //index indicating Training,Testing,...  events/datasets
   if (fEventCollections.at(idx) == 0) {
      fEventCollections.at(idx) = &(Data()->GetEventCollection(type));
      fEventCollections.at(idx) = GetTransformationHandler().CalcTransformations(*(fEventCollections.at(idx)),kTRUE);
   }
   return *(fEventCollections.at(idx));
}

//_______________________________________________________________________
TString TMVA::MethodBase::GetTrainingTMVAVersionString() const
{
   // calculates the TMVA version string from the training version code on the fly
   UInt_t a = GetTrainingTMVAVersionCode() & 0xff0000; a>>=16;
   UInt_t b = GetTrainingTMVAVersionCode() & 0x00ff00; b>>=8;
   UInt_t c = GetTrainingTMVAVersionCode() & 0x0000ff;

   return TString(Form("%i.%i.%i",a,b,c));
}

//_______________________________________________________________________
TString TMVA::MethodBase::GetTrainingROOTVersionString() const
{
   // calculates the ROOT version string from the training version code on the fly
   UInt_t a = GetTrainingROOTVersionCode() & 0xff0000; a>>=16;
   UInt_t b = GetTrainingROOTVersionCode() & 0x00ff00; b>>=8;
   UInt_t c = GetTrainingROOTVersionCode() & 0x0000ff;

   return TString(Form("%i.%02i/%02i",a,b,c));
}

//_______________________________________________________________________
TMVA::MethodBase* TMVA::MethodBase::GetThisBase()
{
   // return a pointer the base class of this method
   return GetThisBaseThreadLocal();
}

//_______________________________________________________________________
void TMVA::MethodBase::ResetThisBase()
{
   // reset required for RootFinder
   GetThisBaseThreadLocal() = this;
}
//_______________________________________________________________________
Double_t TMVA::MethodBase::GetKSTrainingVsTest(Char_t SorB, TString opt){

   ResultsClassification* mvaRes = dynamic_cast<ResultsClassification*>
      ( Data()->GetResults(GetMethodName(),Types::kTesting, Types::kClassification) );

   if (mvaRes != NULL) {
     TH1D *mva_s = dynamic_cast<TH1D*> (mvaRes->GetHist("MVA_S"));
     TH1D *mva_b = dynamic_cast<TH1D*> (mvaRes->GetHist("MVA_B"));
     TH1D *mva_s_tr = dynamic_cast<TH1D*> (mvaRes->GetHist("MVA_TRAIN_S"));
     TH1D *mva_b_tr = dynamic_cast<TH1D*> (mvaRes->GetHist("MVA_TRAIN_B"));

     if ( !mva_s || !mva_b || !mva_s_tr || !mva_b_tr) return -1;

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