//
// File generated by ../bin/rootcint_tmp at Wed Apr 26 15:03:27 2017

// Do NOT change. Changes will be lost next time file is generated
//

#define R__DICTIONARY_FILENAME G__TMVA3
#include "RConfig.h" //rootcint 4834
#if !defined(R__ACCESS_IN_SYMBOL)
//Break the privacy of classes -- Disabled for the moment
#define private public
#define protected public
#endif

// Since CINT ignores the std namespace, we need to do so in this file.
namespace std {} using namespace std;
#include "G__TMVA3.h"

#include "TCollectionProxyInfo.h"
#include "TClass.h"
#include "TBuffer.h"
#include "TMemberInspector.h"
#include "TInterpreter.h"
#include "TVirtualMutex.h"
#include "TError.h"

#ifndef G__ROOT
#define G__ROOT
#endif

#include "RtypesImp.h"
#include "TIsAProxy.h"
#include "TFileMergeInfo.h"

// Direct notice to TROOT of the dictionary's loading.
namespace {
   static struct DictInit {
      DictInit() {
         ROOT::RegisterModule();
      }
   } __TheDictionaryInitializer;
}

// START OF SHADOWS

namespace ROOTShadow {
   namespace Shadow {
      namespace TMVA {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMVA::Config Config;
      #else
      class Config  {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TMVA::Config::VariablePlotting VariablePlotting;
         #else
         class VariablePlotting  {
            public:
            //friend XX;
            float fTimesRMS; //
            int fNbins1D; //
            int fNbins2D; //
            int fMaxNumOfAllowedVariablesForScatterPlots; //
            int fNbinsMVAoutput; //
            int fNbinsXOfROCCurve; //
         };
         #endif

         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TMVA::Config::IONames IONames;
         #else
         class IONames  {
            public:
            //friend XX;
            ::TString fWeightFileDir; //
            ::TString fWeightFileExtension; //
            ::TString fOptionsReferenceFileDir; //
         };
         #endif

         // To force the creation of a virtual table, throw just in case.
         virtual ~Config() throw() {};
      };
      #endif
      } 
      namespace TMVA {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMVA::BDTEventWrapper BDTEventWrapper;
      #else
      class BDTEventWrapper  {
         public:
         //friend XX;
         :: TMVA::Event* fEvent; //pointer to the event
         double fBkgWeight; //cumulative background weight for splitting
         double fSigWeight; //same for the signal weights
      };
      #endif
      } 
      namespace TMVA {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMVA::CCTreeWrapper CCTreeWrapper;
      #else
      class CCTreeWrapper  {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TMVA::CCTreeWrapper::CCTreeNode CCTreeNode;
         #else
         class CCTreeNode  :  virtual public ::TMVA::Node {
            public:
            //friend XX;
            // To force the creation of a virtual table, throw just in case.
            virtual ~CCTreeNode() throw() {};
            int fNLeafDaughters; //! number of terminal descendants
            double fNodeResubstitutionEstimate; //! R(t) = misclassification rate for node t
            double fResubstitutionEstimate; //! R(T_t) = sum[t' in ~T_t]{ R(t) }
            double fAlphaC; //! critical point, g(t) = alpha_c(t)
            double fMinAlphaC; //! G(t), minimum critical point of t and its descendants
            ::TMVA::DecisionTreeNode* fDTNode; //! pointer to wrapped node in the decision tree
         };
         #endif

         typedef ::std::vector< ::TMVA::Event*, ::allocator< ::TMVA::Event*> > EventList;
         ::TMVA::SeparationBase* fQualityIndex; //! pointer to the used quality index calculator
         ::TMVA::DecisionTree* fDTParent; //! pointer to underlying DecisionTree
         CCTreeNode* fRoot; //! the root node of the (wrapped) decision Tree
      };
      #endif
      } 
      namespace TMVA {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMVA::CCPruner CCPruner;
      #else
      class CCPruner  {
         public:
         //friend XX;
         typedef ::std::vector< ::TMVA::Event*, ::allocator< ::TMVA::Event*> > EventList;
         float fAlpha; //! regularization parameter in CC pruning
         :: TMVA::CCPruner::EventList* fValidationSample; //! the event sample to select the optimally-pruned tree
         :: TMVA::DataSet* fValidationDataSet; //! the event sample to select the optimally-pruned tree
         ::TMVA::SeparationBase* fQualityIndex; //! the quality index used to calculate R(t), R(T) = sum[t in ~T]{ R(t) }
         bool fOwnQIndex; //! flag indicates if fQualityIndex is owned by this
         ::TMVA::DecisionTree* fTree; //! (pruned) decision tree
         vector< ::TMVA::DecisionTreeNode* > fPruneSequence; //! map of weakest links (i.e., branches to prune) -> pruning index
         vector< Float_t > fPruneStrengthList; //! map of alpha -> pruning index
         vector< Float_t > fQualityIndexList; //! map of R(T) -> pruning index
         int fOptimalK; //! index of the optimal tree in the pruned tree sequence
         bool fDebug; //! debug flag
      };
      #endif
      } 
      namespace TMVA {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMVA::CostComplexityPruneTool CostComplexityPruneTool;
      #else
      class CostComplexityPruneTool  :  public ::TMVA::IPruneTool {
         public:
         //friend XX;
         // To force the creation of a virtual table, throw just in case.
         virtual ~CostComplexityPruneTool() throw() {};
         ::TMVA::SeparationBase* fQualityIndexTool; //! the quality index used to calculate R(t), R(T) = sum[t in ~T]{ R(t) }
         vector< ::TMVA::DecisionTreeNode*, allocator< ::TMVA::DecisionTreeNode* >  > fPruneSequence; //! map of weakest links (i.e., branches to prune) -> pruning index
         vector< Double_t > fPruneStrengthList; //! map of alpha -> pruning index
         vector< Double_t > fQualityIndexList; //! map of R(T) -> pruning index
         int fOptimalK; //! the optimal index of the prune sequence
         ::TMVA::MsgLogger* fLogger; //! output stream to save logging information
      };
      #endif
      } 
   } // of namespace Shadow
} // of namespace ROOTShadow
// END OF SHADOWS

namespace TMVA {
   namespace ROOTDict {
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
      static void TMVA_Dictionary();

      // Function generating the singleton type initializer
      inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
      {
         static ::ROOT::TGenericClassInfo 
            instance("TMVA", 0 /*version*/, "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/OptimizeConfigParameters.h", 59,
                     ::ROOT::DefineBehavior((void*)0,(void*)0),
                     &TMVA_Dictionary, 0);
         return &instance;
      }
      // Insure that the inline function is _not_ optimized away by the compiler
      ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;  
      // Static variable to force the class initialization
      static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));

      // Dictionary for non-ClassDef classes
      static void TMVA_Dictionary() {
         GenerateInitInstance()->GetClass();
      }

   }
}

namespace ROOTDict {
   void TMVAcLcLConfig_ShowMembers(void *obj, TMemberInspector &R__insp);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::Config*)
   {
      ::TMVA::Config *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::Config >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::Config", ::TMVA::Config::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/Config.h", 51,
                  typeid(::TMVA::Config), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::Config::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::Config) );
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::Config*)
   {
      return GenerateInitInstanceLocal((::TMVA::Config*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::Config*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLConfigcLcLVariablePlotting_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMVAcLcLConfigcLcLVariablePlotting_Dictionary();
   static void *new_TMVAcLcLConfigcLcLVariablePlotting(void *p = 0);
   static void *newArray_TMVAcLcLConfigcLcLVariablePlotting(Long_t size, void *p);
   static void delete_TMVAcLcLConfigcLcLVariablePlotting(void *p);
   static void deleteArray_TMVAcLcLConfigcLcLVariablePlotting(void *p);
   static void destruct_TMVAcLcLConfigcLcLVariablePlotting(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::Config::VariablePlotting*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMVA::Config::VariablePlotting) == sizeof( ::ROOTShadow::Shadow::TMVA::Config::VariablePlotting));
      ::TMVA::Config::VariablePlotting *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TMVA::Config::VariablePlotting),0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::Config::VariablePlotting", "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/Config.h", 79,
                  typeid(::TMVA::Config::VariablePlotting), ::ROOT::DefineBehavior(ptr, ptr),
                  &TMVAcLcLConfigcLcLVariablePlotting_ShowMembers, &TMVAcLcLConfigcLcLVariablePlotting_Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::Config::VariablePlotting) );
      instance.SetNew(&new_TMVAcLcLConfigcLcLVariablePlotting);
      instance.SetNewArray(&newArray_TMVAcLcLConfigcLcLVariablePlotting);
      instance.SetDelete(&delete_TMVAcLcLConfigcLcLVariablePlotting);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLConfigcLcLVariablePlotting);
      instance.SetDestructor(&destruct_TMVAcLcLConfigcLcLVariablePlotting);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::Config::VariablePlotting*)
   {
      return GenerateInitInstanceLocal((::TMVA::Config::VariablePlotting*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::Config::VariablePlotting*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMVAcLcLConfigcLcLVariablePlotting_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::Config::VariablePlotting*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLConfigcLcLIONames_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMVAcLcLConfigcLcLIONames_Dictionary();
   static void *new_TMVAcLcLConfigcLcLIONames(void *p = 0);
   static void *newArray_TMVAcLcLConfigcLcLIONames(Long_t size, void *p);
   static void delete_TMVAcLcLConfigcLcLIONames(void *p);
   static void deleteArray_TMVAcLcLConfigcLcLIONames(void *p);
   static void destruct_TMVAcLcLConfigcLcLIONames(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::Config::IONames*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMVA::Config::IONames) == sizeof( ::ROOTShadow::Shadow::TMVA::Config::IONames));
      ::TMVA::Config::IONames *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TMVA::Config::IONames),0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::Config::IONames", "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/Config.h", 92,
                  typeid(::TMVA::Config::IONames), ::ROOT::DefineBehavior(ptr, ptr),
                  &TMVAcLcLConfigcLcLIONames_ShowMembers, &TMVAcLcLConfigcLcLIONames_Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::Config::IONames) );
      instance.SetNew(&new_TMVAcLcLConfigcLcLIONames);
      instance.SetNewArray(&newArray_TMVAcLcLConfigcLcLIONames);
      instance.SetDelete(&delete_TMVAcLcLConfigcLcLIONames);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLConfigcLcLIONames);
      instance.SetDestructor(&destruct_TMVAcLcLConfigcLcLIONames);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::Config::IONames*)
   {
      return GenerateInitInstanceLocal((::TMVA::Config::IONames*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::Config::IONames*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMVAcLcLConfigcLcLIONames_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::Config::IONames*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLKDEKernel_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLKDEKernel(void *p = 0);
   static void *newArray_TMVAcLcLKDEKernel(Long_t size, void *p);
   static void delete_TMVAcLcLKDEKernel(void *p);
   static void deleteArray_TMVAcLcLKDEKernel(void *p);
   static void destruct_TMVAcLcLKDEKernel(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::KDEKernel*)
   {
      ::TMVA::KDEKernel *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::KDEKernel >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::KDEKernel", ::TMVA::KDEKernel::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/KDEKernel.h", 52,
                  typeid(::TMVA::KDEKernel), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::KDEKernel::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::KDEKernel) );
      instance.SetNew(&new_TMVAcLcLKDEKernel);
      instance.SetNewArray(&newArray_TMVAcLcLKDEKernel);
      instance.SetDelete(&delete_TMVAcLcLKDEKernel);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLKDEKernel);
      instance.SetDestructor(&destruct_TMVAcLcLKDEKernel);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::KDEKernel*)
   {
      return GenerateInitInstanceLocal((::TMVA::KDEKernel*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::KDEKernel*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLInterval_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLInterval(void *p);
   static void deleteArray_TMVAcLcLInterval(void *p);
   static void destruct_TMVAcLcLInterval(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::Interval*)
   {
      ::TMVA::Interval *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::Interval >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::Interval", ::TMVA::Interval::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/Interval.h", 63,
                  typeid(::TMVA::Interval), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::Interval::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::Interval) );
      instance.SetDelete(&delete_TMVAcLcLInterval);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLInterval);
      instance.SetDestructor(&destruct_TMVAcLcLInterval);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::Interval*)
   {
      return GenerateInitInstanceLocal((::TMVA::Interval*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::Interval*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLLogInterval_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLLogInterval(void *p);
   static void deleteArray_TMVAcLcLLogInterval(void *p);
   static void destruct_TMVAcLcLLogInterval(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::LogInterval*)
   {
      ::TMVA::LogInterval *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::LogInterval >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::LogInterval", ::TMVA::LogInterval::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/LogInterval.h", 87,
                  typeid(::TMVA::LogInterval), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::LogInterval::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::LogInterval) );
      instance.SetDelete(&delete_TMVAcLcLLogInterval);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLLogInterval);
      instance.SetDestructor(&destruct_TMVAcLcLLogInterval);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::LogInterval*)
   {
      return GenerateInitInstanceLocal((::TMVA::LogInterval*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::LogInterval*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLIFitterTarget_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLIFitterTarget(void *p);
   static void deleteArray_TMVAcLcLIFitterTarget(void *p);
   static void destruct_TMVAcLcLIFitterTarget(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::IFitterTarget*)
   {
      ::TMVA::IFitterTarget *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::IFitterTarget >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::IFitterTarget", ::TMVA::IFitterTarget::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/IFitterTarget.h", 46,
                  typeid(::TMVA::IFitterTarget), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::IFitterTarget::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::IFitterTarget) );
      instance.SetDelete(&delete_TMVAcLcLIFitterTarget);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLIFitterTarget);
      instance.SetDestructor(&destruct_TMVAcLcLIFitterTarget);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::IFitterTarget*)
   {
      return GenerateInitInstanceLocal((::TMVA::IFitterTarget*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::IFitterTarget*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLFitterBase_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLFitterBase(void *p);
   static void deleteArray_TMVAcLcLFitterBase(void *p);
   static void destruct_TMVAcLcLFitterBase(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::FitterBase*)
   {
      ::TMVA::FitterBase *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::FitterBase >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::FitterBase", ::TMVA::FitterBase::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/FitterBase.h", 57,
                  typeid(::TMVA::FitterBase), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::FitterBase::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::FitterBase) );
      instance.SetDelete(&delete_TMVAcLcLFitterBase);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLFitterBase);
      instance.SetDestructor(&destruct_TMVAcLcLFitterBase);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::FitterBase*)
   {
      return GenerateInitInstanceLocal((::TMVA::FitterBase*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::FitterBase*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLMCFitter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMCFitter(void *p);
   static void deleteArray_TMVAcLcLMCFitter(void *p);
   static void destruct_TMVAcLcLMCFitter(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::MCFitter*)
   {
      ::TMVA::MCFitter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::MCFitter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::MCFitter", ::TMVA::MCFitter::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/MCFitter.h", 45,
                  typeid(::TMVA::MCFitter), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::MCFitter::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::MCFitter) );
      instance.SetDelete(&delete_TMVAcLcLMCFitter);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLMCFitter);
      instance.SetDestructor(&destruct_TMVAcLcLMCFitter);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::MCFitter*)
   {
      return GenerateInitInstanceLocal((::TMVA::MCFitter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::MCFitter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLGeneticFitter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLGeneticFitter(void *p);
   static void deleteArray_TMVAcLcLGeneticFitter(void *p);
   static void destruct_TMVAcLcLGeneticFitter(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::GeneticFitter*)
   {
      ::TMVA::GeneticFitter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::GeneticFitter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::GeneticFitter", ::TMVA::GeneticFitter::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/GeneticFitter.h", 45,
                  typeid(::TMVA::GeneticFitter), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::GeneticFitter::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::GeneticFitter) );
      instance.SetDelete(&delete_TMVAcLcLGeneticFitter);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLGeneticFitter);
      instance.SetDestructor(&destruct_TMVAcLcLGeneticFitter);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::GeneticFitter*)
   {
      return GenerateInitInstanceLocal((::TMVA::GeneticFitter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::GeneticFitter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLSimulatedAnnealingFitter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLSimulatedAnnealingFitter(void *p);
   static void deleteArray_TMVAcLcLSimulatedAnnealingFitter(void *p);
   static void destruct_TMVAcLcLSimulatedAnnealingFitter(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::SimulatedAnnealingFitter*)
   {
      ::TMVA::SimulatedAnnealingFitter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::SimulatedAnnealingFitter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::SimulatedAnnealingFitter", ::TMVA::SimulatedAnnealingFitter::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/SimulatedAnnealingFitter.h", 49,
                  typeid(::TMVA::SimulatedAnnealingFitter), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::SimulatedAnnealingFitter::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::SimulatedAnnealingFitter) );
      instance.SetDelete(&delete_TMVAcLcLSimulatedAnnealingFitter);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLSimulatedAnnealingFitter);
      instance.SetDestructor(&destruct_TMVAcLcLSimulatedAnnealingFitter);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::SimulatedAnnealingFitter*)
   {
      return GenerateInitInstanceLocal((::TMVA::SimulatedAnnealingFitter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::SimulatedAnnealingFitter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLMinuitWrapper_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMinuitWrapper(void *p);
   static void deleteArray_TMVAcLcLMinuitWrapper(void *p);
   static void destruct_TMVAcLcLMinuitWrapper(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::MinuitWrapper*)
   {
      ::TMVA::MinuitWrapper *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::MinuitWrapper >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::MinuitWrapper", ::TMVA::MinuitWrapper::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/MinuitWrapper.h", 49,
                  typeid(::TMVA::MinuitWrapper), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::MinuitWrapper::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::MinuitWrapper) );
      instance.SetDelete(&delete_TMVAcLcLMinuitWrapper);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLMinuitWrapper);
      instance.SetDestructor(&destruct_TMVAcLcLMinuitWrapper);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::MinuitWrapper*)
   {
      return GenerateInitInstanceLocal((::TMVA::MinuitWrapper*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::MinuitWrapper*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLMinuitFitter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMinuitFitter(void *p);
   static void deleteArray_TMVAcLcLMinuitFitter(void *p);
   static void destruct_TMVAcLcLMinuitFitter(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::MinuitFitter*)
   {
      ::TMVA::MinuitFitter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::MinuitFitter >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::MinuitFitter", ::TMVA::MinuitFitter::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/MinuitFitter.h", 51,
                  typeid(::TMVA::MinuitFitter), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::MinuitFitter::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::MinuitFitter) );
      instance.SetDelete(&delete_TMVAcLcLMinuitFitter);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLMinuitFitter);
      instance.SetDestructor(&destruct_TMVAcLcLMinuitFitter);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::MinuitFitter*)
   {
      return GenerateInitInstanceLocal((::TMVA::MinuitFitter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::MinuitFitter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLPDEFoamCell_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLPDEFoamCell(void *p = 0);
   static void *newArray_TMVAcLcLPDEFoamCell(Long_t size, void *p);
   static void delete_TMVAcLcLPDEFoamCell(void *p);
   static void deleteArray_TMVAcLcLPDEFoamCell(void *p);
   static void destruct_TMVAcLcLPDEFoamCell(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoamCell*)
   {
      ::TMVA::PDEFoamCell *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoamCell >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::PDEFoamCell", ::TMVA::PDEFoamCell::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/PDEFoamCell.h", 47,
                  typeid(::TMVA::PDEFoamCell), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::PDEFoamCell::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::PDEFoamCell) );
      instance.SetNew(&new_TMVAcLcLPDEFoamCell);
      instance.SetNewArray(&newArray_TMVAcLcLPDEFoamCell);
      instance.SetDelete(&delete_TMVAcLcLPDEFoamCell);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoamCell);
      instance.SetDestructor(&destruct_TMVAcLcLPDEFoamCell);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoamCell*)
   {
      return GenerateInitInstanceLocal((::TMVA::PDEFoamCell*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoamCell*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLPDEFoamVect_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLPDEFoamVect(void *p = 0);
   static void *newArray_TMVAcLcLPDEFoamVect(Long_t size, void *p);
   static void delete_TMVAcLcLPDEFoamVect(void *p);
   static void deleteArray_TMVAcLcLPDEFoamVect(void *p);
   static void destruct_TMVAcLcLPDEFoamVect(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoamVect*)
   {
      ::TMVA::PDEFoamVect *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoamVect >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::PDEFoamVect", ::TMVA::PDEFoamVect::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/PDEFoamVect.h", 38,
                  typeid(::TMVA::PDEFoamVect), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::PDEFoamVect::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::PDEFoamVect) );
      instance.SetNew(&new_TMVAcLcLPDEFoamVect);
      instance.SetNewArray(&newArray_TMVAcLcLPDEFoamVect);
      instance.SetDelete(&delete_TMVAcLcLPDEFoamVect);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoamVect);
      instance.SetDestructor(&destruct_TMVAcLcLPDEFoamVect);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoamVect*)
   {
      return GenerateInitInstanceLocal((::TMVA::PDEFoamVect*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoamVect*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLPDEFoamDensityBase_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLPDEFoamDensityBase(void *p);
   static void deleteArray_TMVAcLcLPDEFoamDensityBase(void *p);
   static void destruct_TMVAcLcLPDEFoamDensityBase(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoamDensityBase*)
   {
      ::TMVA::PDEFoamDensityBase *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoamDensityBase >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::PDEFoamDensityBase", ::TMVA::PDEFoamDensityBase::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/PDEFoamDensityBase.h", 54,
                  typeid(::TMVA::PDEFoamDensityBase), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::PDEFoamDensityBase::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::PDEFoamDensityBase) );
      instance.SetDelete(&delete_TMVAcLcLPDEFoamDensityBase);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoamDensityBase);
      instance.SetDestructor(&destruct_TMVAcLcLPDEFoamDensityBase);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoamDensityBase*)
   {
      return GenerateInitInstanceLocal((::TMVA::PDEFoamDensityBase*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoamDensityBase*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLPDEFoamKernelBase_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLPDEFoamKernelBase(void *p);
   static void deleteArray_TMVAcLcLPDEFoamKernelBase(void *p);
   static void destruct_TMVAcLcLPDEFoamKernelBase(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoamKernelBase*)
   {
      ::TMVA::PDEFoamKernelBase *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoamKernelBase >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::PDEFoamKernelBase", ::TMVA::PDEFoamKernelBase::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/PDEFoamKernelBase.h", 43,
                  typeid(::TMVA::PDEFoamKernelBase), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::PDEFoamKernelBase::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::PDEFoamKernelBase) );
      instance.SetDelete(&delete_TMVAcLcLPDEFoamKernelBase);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoamKernelBase);
      instance.SetDestructor(&destruct_TMVAcLcLPDEFoamKernelBase);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoamKernelBase*)
   {
      return GenerateInitInstanceLocal((::TMVA::PDEFoamKernelBase*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoamKernelBase*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLPDEFoam_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLPDEFoam(void *p = 0);
   static void *newArray_TMVAcLcLPDEFoam(Long_t size, void *p);
   static void delete_TMVAcLcLPDEFoam(void *p);
   static void deleteArray_TMVAcLcLPDEFoam(void *p);
   static void destruct_TMVAcLcLPDEFoam(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoam*)
   {
      ::TMVA::PDEFoam *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoam >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::PDEFoam", ::TMVA::PDEFoam::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/PDEFoam.h", 104,
                  typeid(::TMVA::PDEFoam), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::PDEFoam::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::PDEFoam) );
      instance.SetNew(&new_TMVAcLcLPDEFoam);
      instance.SetNewArray(&newArray_TMVAcLcLPDEFoam);
      instance.SetDelete(&delete_TMVAcLcLPDEFoam);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoam);
      instance.SetDestructor(&destruct_TMVAcLcLPDEFoam);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoam*)
   {
      return GenerateInitInstanceLocal((::TMVA::PDEFoam*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoam*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLPDEFoamDiscriminant_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLPDEFoamDiscriminant(void *p = 0);
   static void *newArray_TMVAcLcLPDEFoamDiscriminant(Long_t size, void *p);
   static void delete_TMVAcLcLPDEFoamDiscriminant(void *p);
   static void deleteArray_TMVAcLcLPDEFoamDiscriminant(void *p);
   static void destruct_TMVAcLcLPDEFoamDiscriminant(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoamDiscriminant*)
   {
      ::TMVA::PDEFoamDiscriminant *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoamDiscriminant >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::PDEFoamDiscriminant", ::TMVA::PDEFoamDiscriminant::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/PDEFoamDiscriminant.h", 41,
                  typeid(::TMVA::PDEFoamDiscriminant), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::PDEFoamDiscriminant::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::PDEFoamDiscriminant) );
      instance.SetNew(&new_TMVAcLcLPDEFoamDiscriminant);
      instance.SetNewArray(&newArray_TMVAcLcLPDEFoamDiscriminant);
      instance.SetDelete(&delete_TMVAcLcLPDEFoamDiscriminant);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoamDiscriminant);
      instance.SetDestructor(&destruct_TMVAcLcLPDEFoamDiscriminant);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoamDiscriminant*)
   {
      return GenerateInitInstanceLocal((::TMVA::PDEFoamDiscriminant*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoamDiscriminant*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLPDEFoamDecisionTree_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLPDEFoamDecisionTree(void *p = 0);
   static void *newArray_TMVAcLcLPDEFoamDecisionTree(Long_t size, void *p);
   static void delete_TMVAcLcLPDEFoamDecisionTree(void *p);
   static void deleteArray_TMVAcLcLPDEFoamDecisionTree(void *p);
   static void destruct_TMVAcLcLPDEFoamDecisionTree(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoamDecisionTree*)
   {
      ::TMVA::PDEFoamDecisionTree *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoamDecisionTree >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::PDEFoamDecisionTree", ::TMVA::PDEFoamDecisionTree::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/PDEFoamDecisionTree.h", 44,
                  typeid(::TMVA::PDEFoamDecisionTree), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::PDEFoamDecisionTree::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::PDEFoamDecisionTree) );
      instance.SetNew(&new_TMVAcLcLPDEFoamDecisionTree);
      instance.SetNewArray(&newArray_TMVAcLcLPDEFoamDecisionTree);
      instance.SetDelete(&delete_TMVAcLcLPDEFoamDecisionTree);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoamDecisionTree);
      instance.SetDestructor(&destruct_TMVAcLcLPDEFoamDecisionTree);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoamDecisionTree*)
   {
      return GenerateInitInstanceLocal((::TMVA::PDEFoamDecisionTree*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoamDecisionTree*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLPDEFoamDiscriminantDensity_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLPDEFoamDiscriminantDensity(void *p = 0);
   static void *newArray_TMVAcLcLPDEFoamDiscriminantDensity(Long_t size, void *p);
   static void delete_TMVAcLcLPDEFoamDiscriminantDensity(void *p);
   static void deleteArray_TMVAcLcLPDEFoamDiscriminantDensity(void *p);
   static void destruct_TMVAcLcLPDEFoamDiscriminantDensity(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoamDiscriminantDensity*)
   {
      ::TMVA::PDEFoamDiscriminantDensity *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoamDiscriminantDensity >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::PDEFoamDiscriminantDensity", ::TMVA::PDEFoamDiscriminantDensity::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/PDEFoamDiscriminantDensity.h", 44,
                  typeid(::TMVA::PDEFoamDiscriminantDensity), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::PDEFoamDiscriminantDensity::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::PDEFoamDiscriminantDensity) );
      instance.SetNew(&new_TMVAcLcLPDEFoamDiscriminantDensity);
      instance.SetNewArray(&newArray_TMVAcLcLPDEFoamDiscriminantDensity);
      instance.SetDelete(&delete_TMVAcLcLPDEFoamDiscriminantDensity);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoamDiscriminantDensity);
      instance.SetDestructor(&destruct_TMVAcLcLPDEFoamDiscriminantDensity);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoamDiscriminantDensity*)
   {
      return GenerateInitInstanceLocal((::TMVA::PDEFoamDiscriminantDensity*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoamDiscriminantDensity*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLPDEFoamEventDensity_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLPDEFoamEventDensity(void *p = 0);
   static void *newArray_TMVAcLcLPDEFoamEventDensity(Long_t size, void *p);
   static void delete_TMVAcLcLPDEFoamEventDensity(void *p);
   static void deleteArray_TMVAcLcLPDEFoamEventDensity(void *p);
   static void destruct_TMVAcLcLPDEFoamEventDensity(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoamEventDensity*)
   {
      ::TMVA::PDEFoamEventDensity *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoamEventDensity >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::PDEFoamEventDensity", ::TMVA::PDEFoamEventDensity::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/PDEFoamEventDensity.h", 44,
                  typeid(::TMVA::PDEFoamEventDensity), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::PDEFoamEventDensity::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::PDEFoamEventDensity) );
      instance.SetNew(&new_TMVAcLcLPDEFoamEventDensity);
      instance.SetNewArray(&newArray_TMVAcLcLPDEFoamEventDensity);
      instance.SetDelete(&delete_TMVAcLcLPDEFoamEventDensity);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoamEventDensity);
      instance.SetDestructor(&destruct_TMVAcLcLPDEFoamEventDensity);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoamEventDensity*)
   {
      return GenerateInitInstanceLocal((::TMVA::PDEFoamEventDensity*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoamEventDensity*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLPDEFoamTargetDensity_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLPDEFoamTargetDensity(void *p = 0);
   static void *newArray_TMVAcLcLPDEFoamTargetDensity(Long_t size, void *p);
   static void delete_TMVAcLcLPDEFoamTargetDensity(void *p);
   static void deleteArray_TMVAcLcLPDEFoamTargetDensity(void *p);
   static void destruct_TMVAcLcLPDEFoamTargetDensity(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoamTargetDensity*)
   {
      ::TMVA::PDEFoamTargetDensity *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoamTargetDensity >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::PDEFoamTargetDensity", ::TMVA::PDEFoamTargetDensity::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/PDEFoamTargetDensity.h", 44,
                  typeid(::TMVA::PDEFoamTargetDensity), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::PDEFoamTargetDensity::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::PDEFoamTargetDensity) );
      instance.SetNew(&new_TMVAcLcLPDEFoamTargetDensity);
      instance.SetNewArray(&newArray_TMVAcLcLPDEFoamTargetDensity);
      instance.SetDelete(&delete_TMVAcLcLPDEFoamTargetDensity);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoamTargetDensity);
      instance.SetDestructor(&destruct_TMVAcLcLPDEFoamTargetDensity);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoamTargetDensity*)
   {
      return GenerateInitInstanceLocal((::TMVA::PDEFoamTargetDensity*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoamTargetDensity*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLPDEFoamDecisionTreeDensity_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLPDEFoamDecisionTreeDensity(void *p = 0);
   static void *newArray_TMVAcLcLPDEFoamDecisionTreeDensity(Long_t size, void *p);
   static void delete_TMVAcLcLPDEFoamDecisionTreeDensity(void *p);
   static void deleteArray_TMVAcLcLPDEFoamDecisionTreeDensity(void *p);
   static void destruct_TMVAcLcLPDEFoamDecisionTreeDensity(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoamDecisionTreeDensity*)
   {
      ::TMVA::PDEFoamDecisionTreeDensity *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoamDecisionTreeDensity >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::PDEFoamDecisionTreeDensity", ::TMVA::PDEFoamDecisionTreeDensity::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/PDEFoamDecisionTreeDensity.h", 53,
                  typeid(::TMVA::PDEFoamDecisionTreeDensity), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::PDEFoamDecisionTreeDensity::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::PDEFoamDecisionTreeDensity) );
      instance.SetNew(&new_TMVAcLcLPDEFoamDecisionTreeDensity);
      instance.SetNewArray(&newArray_TMVAcLcLPDEFoamDecisionTreeDensity);
      instance.SetDelete(&delete_TMVAcLcLPDEFoamDecisionTreeDensity);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoamDecisionTreeDensity);
      instance.SetDestructor(&destruct_TMVAcLcLPDEFoamDecisionTreeDensity);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoamDecisionTreeDensity*)
   {
      return GenerateInitInstanceLocal((::TMVA::PDEFoamDecisionTreeDensity*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoamDecisionTreeDensity*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLPDEFoamEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLPDEFoamEvent(void *p = 0);
   static void *newArray_TMVAcLcLPDEFoamEvent(Long_t size, void *p);
   static void delete_TMVAcLcLPDEFoamEvent(void *p);
   static void deleteArray_TMVAcLcLPDEFoamEvent(void *p);
   static void destruct_TMVAcLcLPDEFoamEvent(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoamEvent*)
   {
      ::TMVA::PDEFoamEvent *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoamEvent >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::PDEFoamEvent", ::TMVA::PDEFoamEvent::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/PDEFoamEvent.h", 41,
                  typeid(::TMVA::PDEFoamEvent), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::PDEFoamEvent::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::PDEFoamEvent) );
      instance.SetNew(&new_TMVAcLcLPDEFoamEvent);
      instance.SetNewArray(&newArray_TMVAcLcLPDEFoamEvent);
      instance.SetDelete(&delete_TMVAcLcLPDEFoamEvent);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoamEvent);
      instance.SetDestructor(&destruct_TMVAcLcLPDEFoamEvent);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoamEvent*)
   {
      return GenerateInitInstanceLocal((::TMVA::PDEFoamEvent*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoamEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLPDEFoamMultiTarget_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLPDEFoamMultiTarget(void *p = 0);
   static void *newArray_TMVAcLcLPDEFoamMultiTarget(Long_t size, void *p);
   static void delete_TMVAcLcLPDEFoamMultiTarget(void *p);
   static void deleteArray_TMVAcLcLPDEFoamMultiTarget(void *p);
   static void destruct_TMVAcLcLPDEFoamMultiTarget(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoamMultiTarget*)
   {
      ::TMVA::PDEFoamMultiTarget *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoamMultiTarget >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::PDEFoamMultiTarget", ::TMVA::PDEFoamMultiTarget::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/PDEFoamMultiTarget.h", 46,
                  typeid(::TMVA::PDEFoamMultiTarget), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::PDEFoamMultiTarget::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::PDEFoamMultiTarget) );
      instance.SetNew(&new_TMVAcLcLPDEFoamMultiTarget);
      instance.SetNewArray(&newArray_TMVAcLcLPDEFoamMultiTarget);
      instance.SetDelete(&delete_TMVAcLcLPDEFoamMultiTarget);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoamMultiTarget);
      instance.SetDestructor(&destruct_TMVAcLcLPDEFoamMultiTarget);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoamMultiTarget*)
   {
      return GenerateInitInstanceLocal((::TMVA::PDEFoamMultiTarget*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoamMultiTarget*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLPDEFoamTarget_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLPDEFoamTarget(void *p = 0);
   static void *newArray_TMVAcLcLPDEFoamTarget(Long_t size, void *p);
   static void delete_TMVAcLcLPDEFoamTarget(void *p);
   static void deleteArray_TMVAcLcLPDEFoamTarget(void *p);
   static void destruct_TMVAcLcLPDEFoamTarget(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoamTarget*)
   {
      ::TMVA::PDEFoamTarget *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoamTarget >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::PDEFoamTarget", ::TMVA::PDEFoamTarget::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/PDEFoamTarget.h", 41,
                  typeid(::TMVA::PDEFoamTarget), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::PDEFoamTarget::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::PDEFoamTarget) );
      instance.SetNew(&new_TMVAcLcLPDEFoamTarget);
      instance.SetNewArray(&newArray_TMVAcLcLPDEFoamTarget);
      instance.SetDelete(&delete_TMVAcLcLPDEFoamTarget);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoamTarget);
      instance.SetDestructor(&destruct_TMVAcLcLPDEFoamTarget);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoamTarget*)
   {
      return GenerateInitInstanceLocal((::TMVA::PDEFoamTarget*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoamTarget*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLPDEFoamKernelTrivial_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLPDEFoamKernelTrivial(void *p = 0);
   static void *newArray_TMVAcLcLPDEFoamKernelTrivial(Long_t size, void *p);
   static void delete_TMVAcLcLPDEFoamKernelTrivial(void *p);
   static void deleteArray_TMVAcLcLPDEFoamKernelTrivial(void *p);
   static void destruct_TMVAcLcLPDEFoamKernelTrivial(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoamKernelTrivial*)
   {
      ::TMVA::PDEFoamKernelTrivial *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoamKernelTrivial >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::PDEFoamKernelTrivial", ::TMVA::PDEFoamKernelTrivial::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/PDEFoamKernelTrivial.h", 42,
                  typeid(::TMVA::PDEFoamKernelTrivial), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::PDEFoamKernelTrivial::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::PDEFoamKernelTrivial) );
      instance.SetNew(&new_TMVAcLcLPDEFoamKernelTrivial);
      instance.SetNewArray(&newArray_TMVAcLcLPDEFoamKernelTrivial);
      instance.SetDelete(&delete_TMVAcLcLPDEFoamKernelTrivial);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoamKernelTrivial);
      instance.SetDestructor(&destruct_TMVAcLcLPDEFoamKernelTrivial);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoamKernelTrivial*)
   {
      return GenerateInitInstanceLocal((::TMVA::PDEFoamKernelTrivial*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoamKernelTrivial*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLPDEFoamKernelLinN_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLPDEFoamKernelLinN(void *p = 0);
   static void *newArray_TMVAcLcLPDEFoamKernelLinN(Long_t size, void *p);
   static void delete_TMVAcLcLPDEFoamKernelLinN(void *p);
   static void deleteArray_TMVAcLcLPDEFoamKernelLinN(void *p);
   static void destruct_TMVAcLcLPDEFoamKernelLinN(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoamKernelLinN*)
   {
      ::TMVA::PDEFoamKernelLinN *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoamKernelLinN >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::PDEFoamKernelLinN", ::TMVA::PDEFoamKernelLinN::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/PDEFoamKernelLinN.h", 42,
                  typeid(::TMVA::PDEFoamKernelLinN), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::PDEFoamKernelLinN::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::PDEFoamKernelLinN) );
      instance.SetNew(&new_TMVAcLcLPDEFoamKernelLinN);
      instance.SetNewArray(&newArray_TMVAcLcLPDEFoamKernelLinN);
      instance.SetDelete(&delete_TMVAcLcLPDEFoamKernelLinN);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoamKernelLinN);
      instance.SetDestructor(&destruct_TMVAcLcLPDEFoamKernelLinN);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoamKernelLinN*)
   {
      return GenerateInitInstanceLocal((::TMVA::PDEFoamKernelLinN*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoamKernelLinN*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLPDEFoamKernelGauss_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLPDEFoamKernelGauss(void *p);
   static void deleteArray_TMVAcLcLPDEFoamKernelGauss(void *p);
   static void destruct_TMVAcLcLPDEFoamKernelGauss(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoamKernelGauss*)
   {
      ::TMVA::PDEFoamKernelGauss *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoamKernelGauss >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::PDEFoamKernelGauss", ::TMVA::PDEFoamKernelGauss::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/PDEFoamKernelGauss.h", 42,
                  typeid(::TMVA::PDEFoamKernelGauss), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::PDEFoamKernelGauss::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::PDEFoamKernelGauss) );
      instance.SetDelete(&delete_TMVAcLcLPDEFoamKernelGauss);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoamKernelGauss);
      instance.SetDestructor(&destruct_TMVAcLcLPDEFoamKernelGauss);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoamKernelGauss*)
   {
      return GenerateInitInstanceLocal((::TMVA::PDEFoamKernelGauss*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoamKernelGauss*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLBDTEventWrapper_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMVAcLcLBDTEventWrapper_Dictionary();
   static void delete_TMVAcLcLBDTEventWrapper(void *p);
   static void deleteArray_TMVAcLcLBDTEventWrapper(void *p);
   static void destruct_TMVAcLcLBDTEventWrapper(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::BDTEventWrapper*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMVA::BDTEventWrapper) == sizeof( ::ROOTShadow::Shadow::TMVA::BDTEventWrapper));
      ::TMVA::BDTEventWrapper *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TMVA::BDTEventWrapper),0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::BDTEventWrapper", "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/BDTEventWrapper.h", 31,
                  typeid(::TMVA::BDTEventWrapper), ::ROOT::DefineBehavior(ptr, ptr),
                  &TMVAcLcLBDTEventWrapper_ShowMembers, &TMVAcLcLBDTEventWrapper_Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::BDTEventWrapper) );
      instance.SetDelete(&delete_TMVAcLcLBDTEventWrapper);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLBDTEventWrapper);
      instance.SetDestructor(&destruct_TMVAcLcLBDTEventWrapper);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::BDTEventWrapper*)
   {
      return GenerateInitInstanceLocal((::TMVA::BDTEventWrapper*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::BDTEventWrapper*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMVAcLcLBDTEventWrapper_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::BDTEventWrapper*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLCCTreeWrapper_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMVAcLcLCCTreeWrapper_Dictionary();
   static void delete_TMVAcLcLCCTreeWrapper(void *p);
   static void deleteArray_TMVAcLcLCCTreeWrapper(void *p);
   static void destruct_TMVAcLcLCCTreeWrapper(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::CCTreeWrapper*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMVA::CCTreeWrapper) == sizeof( ::ROOTShadow::Shadow::TMVA::CCTreeWrapper));
      ::TMVA::CCTreeWrapper *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TMVA::CCTreeWrapper),0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::CCTreeWrapper", "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/CCTreeWrapper.h", 46,
                  typeid(::TMVA::CCTreeWrapper), ::ROOT::DefineBehavior(ptr, ptr),
                  &TMVAcLcLCCTreeWrapper_ShowMembers, &TMVAcLcLCCTreeWrapper_Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::CCTreeWrapper) );
      instance.SetDelete(&delete_TMVAcLcLCCTreeWrapper);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLCCTreeWrapper);
      instance.SetDestructor(&destruct_TMVAcLcLCCTreeWrapper);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::CCTreeWrapper*)
   {
      return GenerateInitInstanceLocal((::TMVA::CCTreeWrapper*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::CCTreeWrapper*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMVAcLcLCCTreeWrapper_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::CCTreeWrapper*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLCCPruner_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMVAcLcLCCPruner_Dictionary();
   static void delete_TMVAcLcLCCPruner(void *p);
   static void deleteArray_TMVAcLcLCCPruner(void *p);
   static void destruct_TMVAcLcLCCPruner(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::CCPruner*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMVA::CCPruner) == sizeof( ::ROOTShadow::Shadow::TMVA::CCPruner));
      ::TMVA::CCPruner *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TMVA::CCPruner),0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::CCPruner", "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/CCPruner.h", 65,
                  typeid(::TMVA::CCPruner), ::ROOT::DefineBehavior(ptr, ptr),
                  &TMVAcLcLCCPruner_ShowMembers, &TMVAcLcLCCPruner_Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::CCPruner) );
      instance.SetDelete(&delete_TMVAcLcLCCPruner);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLCCPruner);
      instance.SetDestructor(&destruct_TMVAcLcLCCPruner);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::CCPruner*)
   {
      return GenerateInitInstanceLocal((::TMVA::CCPruner*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::CCPruner*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMVAcLcLCCPruner_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::CCPruner*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLCostComplexityPruneTool_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMVAcLcLCostComplexityPruneTool_Dictionary();
   static void *new_TMVAcLcLCostComplexityPruneTool(void *p = 0);
   static void *newArray_TMVAcLcLCostComplexityPruneTool(Long_t size, void *p);
   static void delete_TMVAcLcLCostComplexityPruneTool(void *p);
   static void deleteArray_TMVAcLcLCostComplexityPruneTool(void *p);
   static void destruct_TMVAcLcLCostComplexityPruneTool(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::CostComplexityPruneTool*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMVA::CostComplexityPruneTool) == sizeof( ::ROOTShadow::Shadow::TMVA::CostComplexityPruneTool));
      ::TMVA::CostComplexityPruneTool *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TMVA::CostComplexityPruneTool),0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::CostComplexityPruneTool", "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/CostComplexityPruneTool.h", 71,
                  typeid(::TMVA::CostComplexityPruneTool), ::ROOT::DefineBehavior(ptr, ptr),
                  &TMVAcLcLCostComplexityPruneTool_ShowMembers, &TMVAcLcLCostComplexityPruneTool_Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::CostComplexityPruneTool) );
      instance.SetNew(&new_TMVAcLcLCostComplexityPruneTool);
      instance.SetNewArray(&newArray_TMVAcLcLCostComplexityPruneTool);
      instance.SetDelete(&delete_TMVAcLcLCostComplexityPruneTool);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLCostComplexityPruneTool);
      instance.SetDestructor(&destruct_TMVAcLcLCostComplexityPruneTool);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::CostComplexityPruneTool*)
   {
      return GenerateInitInstanceLocal((::TMVA::CostComplexityPruneTool*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::CostComplexityPruneTool*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void TMVAcLcLCostComplexityPruneTool_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::CostComplexityPruneTool*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLSVEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLSVEvent(void *p = 0);
   static void *newArray_TMVAcLcLSVEvent(Long_t size, void *p);
   static void delete_TMVAcLcLSVEvent(void *p);
   static void deleteArray_TMVAcLcLSVEvent(void *p);
   static void destruct_TMVAcLcLSVEvent(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::SVEvent*)
   {
      ::TMVA::SVEvent *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::SVEvent >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::SVEvent", ::TMVA::SVEvent::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/SVEvent.h", 42,
                  typeid(::TMVA::SVEvent), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::SVEvent::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::SVEvent) );
      instance.SetNew(&new_TMVAcLcLSVEvent);
      instance.SetNewArray(&newArray_TMVAcLcLSVEvent);
      instance.SetDelete(&delete_TMVAcLcLSVEvent);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLSVEvent);
      instance.SetDestructor(&destruct_TMVAcLcLSVEvent);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::SVEvent*)
   {
      return GenerateInitInstanceLocal((::TMVA::SVEvent*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::SVEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLOptimizeConfigParameters_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLOptimizeConfigParameters(void *p);
   static void deleteArray_TMVAcLcLOptimizeConfigParameters(void *p);
   static void destruct_TMVAcLcLOptimizeConfigParameters(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::OptimizeConfigParameters*)
   {
      ::TMVA::OptimizeConfigParameters *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::OptimizeConfigParameters >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::OptimizeConfigParameters", ::TMVA::OptimizeConfigParameters::Class_Version(), "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/tmva/inc/TMVA/OptimizeConfigParameters.h", 63,
                  typeid(::TMVA::OptimizeConfigParameters), ::ROOT::DefineBehavior(ptr, ptr),
                  &::TMVA::OptimizeConfigParameters::Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::OptimizeConfigParameters) );
      instance.SetDelete(&delete_TMVAcLcLOptimizeConfigParameters);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLOptimizeConfigParameters);
      instance.SetDestructor(&destruct_TMVAcLcLOptimizeConfigParameters);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::OptimizeConfigParameters*)
   {
      return GenerateInitInstanceLocal((::TMVA::OptimizeConfigParameters*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::OptimizeConfigParameters*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOTDict

      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr Config::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *Config::Class_Name()
{
   return "TMVA::Config";
}

//______________________________________________________________________________
const char *Config::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::Config*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int Config::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::Config*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void Config::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::Config*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *Config::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::Config*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr KDEKernel::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *KDEKernel::Class_Name()
{
   return "TMVA::KDEKernel";
}

//______________________________________________________________________________
const char *KDEKernel::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::KDEKernel*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int KDEKernel::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::KDEKernel*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void KDEKernel::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::KDEKernel*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *KDEKernel::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::KDEKernel*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr Interval::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *Interval::Class_Name()
{
   return "TMVA::Interval";
}

//______________________________________________________________________________
const char *Interval::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::Interval*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int Interval::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::Interval*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void Interval::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::Interval*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *Interval::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::Interval*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr LogInterval::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *LogInterval::Class_Name()
{
   return "TMVA::LogInterval";
}

//______________________________________________________________________________
const char *LogInterval::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::LogInterval*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int LogInterval::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::LogInterval*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void LogInterval::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::LogInterval*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *LogInterval::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::LogInterval*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr IFitterTarget::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *IFitterTarget::Class_Name()
{
   return "TMVA::IFitterTarget";
}

//______________________________________________________________________________
const char *IFitterTarget::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::IFitterTarget*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int IFitterTarget::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::IFitterTarget*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void IFitterTarget::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::IFitterTarget*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *IFitterTarget::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::IFitterTarget*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr FitterBase::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *FitterBase::Class_Name()
{
   return "TMVA::FitterBase";
}

//______________________________________________________________________________
const char *FitterBase::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::FitterBase*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int FitterBase::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::FitterBase*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void FitterBase::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::FitterBase*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *FitterBase::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::FitterBase*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr MCFitter::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *MCFitter::Class_Name()
{
   return "TMVA::MCFitter";
}

//______________________________________________________________________________
const char *MCFitter::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::MCFitter*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int MCFitter::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::MCFitter*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void MCFitter::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::MCFitter*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *MCFitter::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::MCFitter*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr GeneticFitter::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *GeneticFitter::Class_Name()
{
   return "TMVA::GeneticFitter";
}

//______________________________________________________________________________
const char *GeneticFitter::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::GeneticFitter*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int GeneticFitter::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::GeneticFitter*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void GeneticFitter::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::GeneticFitter*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *GeneticFitter::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::GeneticFitter*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr SimulatedAnnealingFitter::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *SimulatedAnnealingFitter::Class_Name()
{
   return "TMVA::SimulatedAnnealingFitter";
}

//______________________________________________________________________________
const char *SimulatedAnnealingFitter::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::SimulatedAnnealingFitter*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int SimulatedAnnealingFitter::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::SimulatedAnnealingFitter*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void SimulatedAnnealingFitter::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::SimulatedAnnealingFitter*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *SimulatedAnnealingFitter::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::SimulatedAnnealingFitter*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr MinuitWrapper::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *MinuitWrapper::Class_Name()
{
   return "TMVA::MinuitWrapper";
}

//______________________________________________________________________________
const char *MinuitWrapper::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::MinuitWrapper*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int MinuitWrapper::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::MinuitWrapper*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void MinuitWrapper::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::MinuitWrapper*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *MinuitWrapper::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::MinuitWrapper*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr MinuitFitter::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *MinuitFitter::Class_Name()
{
   return "TMVA::MinuitFitter";
}

//______________________________________________________________________________
const char *MinuitFitter::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::MinuitFitter*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int MinuitFitter::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::MinuitFitter*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void MinuitFitter::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::MinuitFitter*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *MinuitFitter::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::MinuitFitter*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr PDEFoamCell::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PDEFoamCell::Class_Name()
{
   return "TMVA::PDEFoamCell";
}

//______________________________________________________________________________
const char *PDEFoamCell::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamCell*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PDEFoamCell::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamCell*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PDEFoamCell::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamCell*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PDEFoamCell::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamCell*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr PDEFoamVect::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PDEFoamVect::Class_Name()
{
   return "TMVA::PDEFoamVect";
}

//______________________________________________________________________________
const char *PDEFoamVect::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamVect*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PDEFoamVect::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamVect*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PDEFoamVect::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamVect*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PDEFoamVect::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamVect*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr PDEFoamDensityBase::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PDEFoamDensityBase::Class_Name()
{
   return "TMVA::PDEFoamDensityBase";
}

//______________________________________________________________________________
const char *PDEFoamDensityBase::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDensityBase*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PDEFoamDensityBase::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDensityBase*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PDEFoamDensityBase::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDensityBase*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PDEFoamDensityBase::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDensityBase*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr PDEFoamKernelBase::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PDEFoamKernelBase::Class_Name()
{
   return "TMVA::PDEFoamKernelBase";
}

//______________________________________________________________________________
const char *PDEFoamKernelBase::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamKernelBase*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PDEFoamKernelBase::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamKernelBase*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PDEFoamKernelBase::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamKernelBase*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PDEFoamKernelBase::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamKernelBase*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr PDEFoam::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PDEFoam::Class_Name()
{
   return "TMVA::PDEFoam";
}

//______________________________________________________________________________
const char *PDEFoam::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoam*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PDEFoam::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoam*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PDEFoam::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoam*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PDEFoam::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoam*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr PDEFoamDiscriminant::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PDEFoamDiscriminant::Class_Name()
{
   return "TMVA::PDEFoamDiscriminant";
}

//______________________________________________________________________________
const char *PDEFoamDiscriminant::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDiscriminant*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PDEFoamDiscriminant::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDiscriminant*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PDEFoamDiscriminant::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDiscriminant*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PDEFoamDiscriminant::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDiscriminant*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr PDEFoamDecisionTree::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PDEFoamDecisionTree::Class_Name()
{
   return "TMVA::PDEFoamDecisionTree";
}

//______________________________________________________________________________
const char *PDEFoamDecisionTree::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDecisionTree*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PDEFoamDecisionTree::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDecisionTree*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PDEFoamDecisionTree::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDecisionTree*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PDEFoamDecisionTree::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDecisionTree*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr PDEFoamDiscriminantDensity::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PDEFoamDiscriminantDensity::Class_Name()
{
   return "TMVA::PDEFoamDiscriminantDensity";
}

//______________________________________________________________________________
const char *PDEFoamDiscriminantDensity::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDiscriminantDensity*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PDEFoamDiscriminantDensity::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDiscriminantDensity*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PDEFoamDiscriminantDensity::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDiscriminantDensity*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PDEFoamDiscriminantDensity::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDiscriminantDensity*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr PDEFoamEventDensity::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PDEFoamEventDensity::Class_Name()
{
   return "TMVA::PDEFoamEventDensity";
}

//______________________________________________________________________________
const char *PDEFoamEventDensity::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamEventDensity*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PDEFoamEventDensity::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamEventDensity*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PDEFoamEventDensity::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamEventDensity*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PDEFoamEventDensity::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamEventDensity*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr PDEFoamTargetDensity::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PDEFoamTargetDensity::Class_Name()
{
   return "TMVA::PDEFoamTargetDensity";
}

//______________________________________________________________________________
const char *PDEFoamTargetDensity::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamTargetDensity*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PDEFoamTargetDensity::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamTargetDensity*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PDEFoamTargetDensity::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamTargetDensity*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PDEFoamTargetDensity::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamTargetDensity*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr PDEFoamDecisionTreeDensity::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PDEFoamDecisionTreeDensity::Class_Name()
{
   return "TMVA::PDEFoamDecisionTreeDensity";
}

//______________________________________________________________________________
const char *PDEFoamDecisionTreeDensity::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDecisionTreeDensity*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PDEFoamDecisionTreeDensity::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDecisionTreeDensity*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PDEFoamDecisionTreeDensity::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDecisionTreeDensity*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PDEFoamDecisionTreeDensity::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDecisionTreeDensity*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr PDEFoamEvent::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PDEFoamEvent::Class_Name()
{
   return "TMVA::PDEFoamEvent";
}

//______________________________________________________________________________
const char *PDEFoamEvent::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamEvent*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PDEFoamEvent::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamEvent*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PDEFoamEvent::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamEvent*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PDEFoamEvent::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamEvent*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr PDEFoamMultiTarget::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PDEFoamMultiTarget::Class_Name()
{
   return "TMVA::PDEFoamMultiTarget";
}

//______________________________________________________________________________
const char *PDEFoamMultiTarget::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamMultiTarget*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PDEFoamMultiTarget::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamMultiTarget*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PDEFoamMultiTarget::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamMultiTarget*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PDEFoamMultiTarget::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamMultiTarget*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr PDEFoamTarget::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PDEFoamTarget::Class_Name()
{
   return "TMVA::PDEFoamTarget";
}

//______________________________________________________________________________
const char *PDEFoamTarget::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamTarget*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PDEFoamTarget::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamTarget*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PDEFoamTarget::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamTarget*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PDEFoamTarget::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamTarget*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr PDEFoamKernelTrivial::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PDEFoamKernelTrivial::Class_Name()
{
   return "TMVA::PDEFoamKernelTrivial";
}

//______________________________________________________________________________
const char *PDEFoamKernelTrivial::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamKernelTrivial*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PDEFoamKernelTrivial::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamKernelTrivial*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PDEFoamKernelTrivial::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamKernelTrivial*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PDEFoamKernelTrivial::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamKernelTrivial*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr PDEFoamKernelLinN::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PDEFoamKernelLinN::Class_Name()
{
   return "TMVA::PDEFoamKernelLinN";
}

//______________________________________________________________________________
const char *PDEFoamKernelLinN::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamKernelLinN*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PDEFoamKernelLinN::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamKernelLinN*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PDEFoamKernelLinN::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamKernelLinN*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PDEFoamKernelLinN::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamKernelLinN*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr PDEFoamKernelGauss::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *PDEFoamKernelGauss::Class_Name()
{
   return "TMVA::PDEFoamKernelGauss";
}

//______________________________________________________________________________
const char *PDEFoamKernelGauss::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamKernelGauss*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int PDEFoamKernelGauss::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamKernelGauss*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void PDEFoamKernelGauss::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamKernelGauss*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *PDEFoamKernelGauss::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::PDEFoamKernelGauss*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr SVEvent::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *SVEvent::Class_Name()
{
   return "TMVA::SVEvent";
}

//______________________________________________________________________________
const char *SVEvent::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::SVEvent*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int SVEvent::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::SVEvent*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void SVEvent::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::SVEvent*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *SVEvent::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::SVEvent*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
atomic_TClass_ptr OptimizeConfigParameters::fgIsA(0);  // static to hold class pointer

//______________________________________________________________________________
const char *OptimizeConfigParameters::Class_Name()
{
   return "TMVA::OptimizeConfigParameters";
}

//______________________________________________________________________________
const char *OptimizeConfigParameters::ImplFileName()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::OptimizeConfigParameters*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int OptimizeConfigParameters::ImplFileLine()
{
   return ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::OptimizeConfigParameters*)0x0)->GetImplFileLine();
}

//______________________________________________________________________________
void OptimizeConfigParameters::Dictionary()
{
   fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::OptimizeConfigParameters*)0x0)->GetClass();
}

//______________________________________________________________________________
TClass *OptimizeConfigParameters::Class()
{
   if (!fgIsA) { R__LOCKGUARD2(gCINTMutex); if(!fgIsA) {fgIsA = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::OptimizeConfigParameters*)0x0)->GetClass();} }
   return fgIsA;
}

} // namespace TMVA
      namespace TMVA {
//______________________________________________________________________________
void Config::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMVA::Config.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::Config::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::Config::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void Config::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::Config.
      TClass *R__cl = ::TMVA::Config::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVariablePlotting", (void*)&fVariablePlotting);
      R__insp.InspectMember("TMVA::Config::VariablePlotting", (void*)&fVariablePlotting, "fVariablePlotting.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIONames", (void*)&fIONames);
      R__insp.InspectMember("TMVA::Config::IONames", (void*)&fIONames, "fIONames.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseColoredConsole", &fUseColoredConsole);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSilent", &fSilent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWriteOptionsReference", &fWriteOptionsReference);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawProgressBar", &fDrawProgressBar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
}

} // namespace TMVA
namespace ROOTDict {
} // end of namespace ROOTDict for class ::TMVA::Config

//______________________________________________________________________________
namespace ROOTDict {
   void TMVAcLcLConfigcLcLVariablePlotting_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMVA::Config::VariablePlotting.
      typedef ::ROOTShadow::Shadow::TMVA::Config::VariablePlotting ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::Config::VariablePlotting*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimesRMS", &sobj->fTimesRMS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbins1D", &sobj->fNbins1D);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbins2D", &sobj->fNbins2D);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxNumOfAllowedVariablesForScatterPlots", &sobj->fMaxNumOfAllowedVariablesForScatterPlots);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbinsMVAoutput", &sobj->fNbinsMVAoutput);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbinsXOfROCCurve", &sobj->fNbinsXOfROCCurve);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLConfigcLcLVariablePlotting(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::Config::VariablePlotting : new ::TMVA::Config::VariablePlotting;
   }
   static void *newArray_TMVAcLcLConfigcLcLVariablePlotting(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::Config::VariablePlotting[nElements] : new ::TMVA::Config::VariablePlotting[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLConfigcLcLVariablePlotting(void *p) {
      delete ((::TMVA::Config::VariablePlotting*)p);
   }
   static void deleteArray_TMVAcLcLConfigcLcLVariablePlotting(void *p) {
      delete [] ((::TMVA::Config::VariablePlotting*)p);
   }
   static void destruct_TMVAcLcLConfigcLcLVariablePlotting(void *p) {
      typedef ::TMVA::Config::VariablePlotting current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::Config::VariablePlotting

//______________________________________________________________________________
namespace ROOTDict {
   void TMVAcLcLConfigcLcLIONames_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMVA::Config::IONames.
      typedef ::ROOTShadow::Shadow::TMVA::Config::IONames ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::Config::IONames*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWeightFileDir", &sobj->fWeightFileDir);
      R__insp.InspectMember(sobj->fWeightFileDir, "fWeightFileDir.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWeightFileExtension", &sobj->fWeightFileExtension);
      R__insp.InspectMember(sobj->fWeightFileExtension, "fWeightFileExtension.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptionsReferenceFileDir", &sobj->fOptionsReferenceFileDir);
      R__insp.InspectMember(sobj->fOptionsReferenceFileDir, "fOptionsReferenceFileDir.");
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLConfigcLcLIONames(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::Config::IONames : new ::TMVA::Config::IONames;
   }
   static void *newArray_TMVAcLcLConfigcLcLIONames(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::Config::IONames[nElements] : new ::TMVA::Config::IONames[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLConfigcLcLIONames(void *p) {
      delete ((::TMVA::Config::IONames*)p);
   }
   static void deleteArray_TMVAcLcLConfigcLcLIONames(void *p) {
      delete [] ((::TMVA::Config::IONames*)p);
   }
   static void destruct_TMVAcLcLConfigcLcLIONames(void *p) {
      typedef ::TMVA::Config::IONames current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::Config::IONames

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::KDEKernel::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::KDEKernel::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void KDEKernel::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::KDEKernel.
      TClass *R__cl = ::TMVA::KDEKernel::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigma", &fSigma);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIter", &fIter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLowerEdge", &fLowerEdge);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpperEdge", &fUpperEdge);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFineFactor", &fFineFactor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fKernel_integ", &fKernel_integ);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKDEborder", &fKDEborder);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHist", &fHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFirstIterHist", &fFirstIterHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSigmaHist", &fSigmaHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHiddenIteration", &fHiddenIteration);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLKDEKernel(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::KDEKernel : new ::TMVA::KDEKernel;
   }
   static void *newArray_TMVAcLcLKDEKernel(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::KDEKernel[nElements] : new ::TMVA::KDEKernel[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLKDEKernel(void *p) {
      delete ((::TMVA::KDEKernel*)p);
   }
   static void deleteArray_TMVAcLcLKDEKernel(void *p) {
      delete [] ((::TMVA::KDEKernel*)p);
   }
   static void destruct_TMVAcLcLKDEKernel(void *p) {
      typedef ::TMVA::KDEKernel current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::KDEKernel

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::Interval::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::Interval::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void Interval::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::Interval.
      TClass *R__cl = ::TMVA::Interval::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMin", &fMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMax", &fMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbins", &fNbins);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLInterval(void *p) {
      delete ((::TMVA::Interval*)p);
   }
   static void deleteArray_TMVAcLcLInterval(void *p) {
      delete [] ((::TMVA::Interval*)p);
   }
   static void destruct_TMVAcLcLInterval(void *p) {
      typedef ::TMVA::Interval current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::Interval

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::LogInterval::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::LogInterval::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void LogInterval::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::LogInterval.
      TClass *R__cl = ::TMVA::LogInterval::IsA();
      if (R__cl || R__insp.IsA()) { }
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::Interval baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLLogInterval(void *p) {
      delete ((::TMVA::LogInterval*)p);
   }
   static void deleteArray_TMVAcLcLLogInterval(void *p) {
      delete [] ((::TMVA::LogInterval*)p);
   }
   static void destruct_TMVAcLcLLogInterval(void *p) {
      typedef ::TMVA::LogInterval current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::LogInterval

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::FitterBase::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::FitterBase::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void FitterBase::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::FitterBase.
      TClass *R__cl = ::TMVA::FitterBase::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRanges", (void*)&fRanges);
      R__insp.InspectMember("const vector<TMVA::Interval*>", (void*)&fRanges, "fRanges.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpars", &fNpars);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClassName", &fClassName);
      R__insp.InspectMember(fClassName, "fClassName.");
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::Configurable baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLFitterBase(void *p) {
      delete ((::TMVA::FitterBase*)p);
   }
   static void deleteArray_TMVAcLcLFitterBase(void *p) {
      delete [] ((::TMVA::FitterBase*)p);
   }
   static void destruct_TMVAcLcLFitterBase(void *p) {
      typedef ::TMVA::FitterBase current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::FitterBase

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::MCFitter::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::MCFitter::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MCFitter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MCFitter.
      TClass *R__cl = ::TMVA::MCFitter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSamples", &fSamples);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigma", &fSigma);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSeed", &fSeed);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::FitterBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMCFitter(void *p) {
      delete ((::TMVA::MCFitter*)p);
   }
   static void deleteArray_TMVAcLcLMCFitter(void *p) {
      delete [] ((::TMVA::MCFitter*)p);
   }
   static void destruct_TMVAcLcLMCFitter(void *p) {
      typedef ::TMVA::MCFitter current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MCFitter

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::GeneticFitter::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::GeneticFitter::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void GeneticFitter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::GeneticFitter.
      TClass *R__cl = ::TMVA::GeneticFitter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCycles", &fCycles);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNsteps", &fNsteps);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPopSize", &fPopSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSC_steps", &fSC_steps);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSC_rate", &fSC_rate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSC_factor", &fSC_factor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConvCrit", &fConvCrit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSaveBestFromGeneration", &fSaveBestFromGeneration);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSaveBestFromCycle", &fSaveBestFromCycle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrim", &fTrim);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSeed", &fSeed);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::FitterBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLGeneticFitter(void *p) {
      delete ((::TMVA::GeneticFitter*)p);
   }
   static void deleteArray_TMVAcLcLGeneticFitter(void *p) {
      delete [] ((::TMVA::GeneticFitter*)p);
   }
   static void destruct_TMVAcLcLGeneticFitter(void *p) {
      typedef ::TMVA::GeneticFitter current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::GeneticFitter

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::SimulatedAnnealingFitter::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::SimulatedAnnealingFitter::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void SimulatedAnnealingFitter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::SimulatedAnnealingFitter.
      TClass *R__cl = ::TMVA::SimulatedAnnealingFitter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxCalls", &fMaxCalls);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInitialTemperature", &fInitialTemperature);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinTemperature", &fMinTemperature);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEps", &fEps);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKernelTemperatureS", &fKernelTemperatureS);
      R__insp.InspectMember(fKernelTemperatureS, "fKernelTemperatureS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTemperatureScale", &fTemperatureScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAdaptiveSpeed", &fAdaptiveSpeed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTemperatureAdaptiveStep", &fTemperatureAdaptiveStep);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseDefaultScale", &fUseDefaultScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseDefaultTemperature", &fUseDefaultTemperature);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::FitterBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLSimulatedAnnealingFitter(void *p) {
      delete ((::TMVA::SimulatedAnnealingFitter*)p);
   }
   static void deleteArray_TMVAcLcLSimulatedAnnealingFitter(void *p) {
      delete [] ((::TMVA::SimulatedAnnealingFitter*)p);
   }
   static void destruct_TMVAcLcLSimulatedAnnealingFitter(void *p) {
      typedef ::TMVA::SimulatedAnnealingFitter current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::SimulatedAnnealingFitter

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::MinuitFitter::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::MinuitFitter::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MinuitFitter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MinuitFitter.
      TClass *R__cl = ::TMVA::MinuitFitter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMinWrap", &fMinWrap);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorLevel", &fErrorLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPrintLevel", &fPrintLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFitStrategy", &fFitStrategy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPrintWarnings", &fPrintWarnings);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseImprove", &fUseImprove);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseMinos", &fUseMinos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBatch", &fBatch);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxCalls", &fMaxCalls);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTolerance", &fTolerance);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::FitterBase baseClass1;
      baseClass1::ShowMembers(R__insp);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::IFitterTarget baseClass2;
      baseClass2::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMinuitFitter(void *p) {
      delete ((::TMVA::MinuitFitter*)p);
   }
   static void deleteArray_TMVAcLcLMinuitFitter(void *p) {
      delete [] ((::TMVA::MinuitFitter*)p);
   }
   static void destruct_TMVAcLcLMinuitFitter(void *p) {
      typedef ::TMVA::MinuitFitter current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MinuitFitter

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::MinuitWrapper::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::MinuitWrapper::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MinuitWrapper::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MinuitWrapper.
      TClass *R__cl = ::TMVA::MinuitWrapper::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParameters", (void*)&fParameters);
      R__insp.InspectMember("vector<Double_t>", (void*)&fParameters, "fParameters.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumPar", &fNumPar);
      TMinuit::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMinuitWrapper(void *p) {
      delete ((::TMVA::MinuitWrapper*)p);
   }
   static void deleteArray_TMVAcLcLMinuitWrapper(void *p) {
      delete [] ((::TMVA::MinuitWrapper*)p);
   }
   static void destruct_TMVAcLcLMinuitWrapper(void *p) {
      typedef ::TMVA::MinuitWrapper current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MinuitWrapper

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::IFitterTarget::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::IFitterTarget::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void IFitterTarget::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::IFitterTarget.
      TClass *R__cl = ::TMVA::IFitterTarget::IsA();
      if (R__cl || R__insp.IsA()) { }
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLIFitterTarget(void *p) {
      delete ((::TMVA::IFitterTarget*)p);
   }
   static void deleteArray_TMVAcLcLIFitterTarget(void *p) {
      delete [] ((::TMVA::IFitterTarget*)p);
   }
   static void destruct_TMVAcLcLIFitterTarget(void *p) {
      typedef ::TMVA::IFitterTarget current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::IFitterTarget

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::PDEFoam::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::PDEFoam::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void PDEFoam::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::PDEFoam.
      TClass *R__cl = ::TMVA::PDEFoam::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", &fName);
      R__insp.InspectMember(fName, "fName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDim", &fDim);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNCells", &fNCells);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNBin", &fNBin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNSampl", &fNSampl);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvPerBin", &fEvPerBin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaskDiv", &fMaskDiv);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInhiDiv", &fInhiDiv);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNoAct", &fNoAct);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastCe", &fLastCe);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCells", &fCells);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistEdg", &fHistEdg);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRvec", &fRvec);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPseRan", &fPseRan);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAlpha", &fAlpha);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFoamType", &fFoamType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXmin", &fXmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXmax", &fXmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNElements", &fNElements);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNmin", &fNmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxDepth", &fMaxDepth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVolFrac", &fVolFrac);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFillFoamWithOrigWeights", &fFillFoamWithOrigWeights);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDTSeparation", &fDTSeparation);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPeekMax", &fPeekMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDistr", &fDistr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTimer", &fTimer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVariableNames", &fVariableNames);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
      TObject::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLPDEFoam(void *p) {
      return  p ? new(p) ::TMVA::PDEFoam : new ::TMVA::PDEFoam;
   }
   static void *newArray_TMVAcLcLPDEFoam(Long_t nElements, void *p) {
      return p ? new(p) ::TMVA::PDEFoam[nElements] : new ::TMVA::PDEFoam[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLPDEFoam(void *p) {
      delete ((::TMVA::PDEFoam*)p);
   }
   static void deleteArray_TMVAcLcLPDEFoam(void *p) {
      delete [] ((::TMVA::PDEFoam*)p);
   }
   static void destruct_TMVAcLcLPDEFoam(void *p) {
      typedef ::TMVA::PDEFoam current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::PDEFoam

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::PDEFoamEvent::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::PDEFoamEvent::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void PDEFoamEvent::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::PDEFoamEvent.
      TClass *R__cl = ::TMVA::PDEFoamEvent::IsA();
      if (R__cl || R__insp.IsA()) { }
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::PDEFoam baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLPDEFoamEvent(void *p) {
      return  p ? new(p) ::TMVA::PDEFoamEvent : new ::TMVA::PDEFoamEvent;
   }
   static void *newArray_TMVAcLcLPDEFoamEvent(Long_t nElements, void *p) {
      return p ? new(p) ::TMVA::PDEFoamEvent[nElements] : new ::TMVA::PDEFoamEvent[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLPDEFoamEvent(void *p) {
      delete ((::TMVA::PDEFoamEvent*)p);
   }
   static void deleteArray_TMVAcLcLPDEFoamEvent(void *p) {
      delete [] ((::TMVA::PDEFoamEvent*)p);
   }
   static void destruct_TMVAcLcLPDEFoamEvent(void *p) {
      typedef ::TMVA::PDEFoamEvent current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::PDEFoamEvent

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::PDEFoamDiscriminant::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::PDEFoamDiscriminant::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void PDEFoamDiscriminant::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::PDEFoamDiscriminant.
      TClass *R__cl = ::TMVA::PDEFoamDiscriminant::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClass", &fClass);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::PDEFoam baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLPDEFoamDiscriminant(void *p) {
      return  p ? new(p) ::TMVA::PDEFoamDiscriminant : new ::TMVA::PDEFoamDiscriminant;
   }
   static void *newArray_TMVAcLcLPDEFoamDiscriminant(Long_t nElements, void *p) {
      return p ? new(p) ::TMVA::PDEFoamDiscriminant[nElements] : new ::TMVA::PDEFoamDiscriminant[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLPDEFoamDiscriminant(void *p) {
      delete ((::TMVA::PDEFoamDiscriminant*)p);
   }
   static void deleteArray_TMVAcLcLPDEFoamDiscriminant(void *p) {
      delete [] ((::TMVA::PDEFoamDiscriminant*)p);
   }
   static void destruct_TMVAcLcLPDEFoamDiscriminant(void *p) {
      typedef ::TMVA::PDEFoamDiscriminant current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::PDEFoamDiscriminant

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::PDEFoamTarget::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::PDEFoamTarget::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void PDEFoamTarget::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::PDEFoamTarget.
      TClass *R__cl = ::TMVA::PDEFoamTarget::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTarget", &fTarget);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::PDEFoam baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLPDEFoamTarget(void *p) {
      return  p ? new(p) ::TMVA::PDEFoamTarget : new ::TMVA::PDEFoamTarget;
   }
   static void *newArray_TMVAcLcLPDEFoamTarget(Long_t nElements, void *p) {
      return p ? new(p) ::TMVA::PDEFoamTarget[nElements] : new ::TMVA::PDEFoamTarget[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLPDEFoamTarget(void *p) {
      delete ((::TMVA::PDEFoamTarget*)p);
   }
   static void deleteArray_TMVAcLcLPDEFoamTarget(void *p) {
      delete [] ((::TMVA::PDEFoamTarget*)p);
   }
   static void destruct_TMVAcLcLPDEFoamTarget(void *p) {
      typedef ::TMVA::PDEFoamTarget current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::PDEFoamTarget

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::PDEFoamMultiTarget::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::PDEFoamMultiTarget::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void PDEFoamMultiTarget::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::PDEFoamMultiTarget.
      TClass *R__cl = ::TMVA::PDEFoamMultiTarget::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTargetSelection", &fTargetSelection);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::PDEFoamEvent baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLPDEFoamMultiTarget(void *p) {
      return  p ? new(p) ::TMVA::PDEFoamMultiTarget : new ::TMVA::PDEFoamMultiTarget;
   }
   static void *newArray_TMVAcLcLPDEFoamMultiTarget(Long_t nElements, void *p) {
      return p ? new(p) ::TMVA::PDEFoamMultiTarget[nElements] : new ::TMVA::PDEFoamMultiTarget[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLPDEFoamMultiTarget(void *p) {
      delete ((::TMVA::PDEFoamMultiTarget*)p);
   }
   static void deleteArray_TMVAcLcLPDEFoamMultiTarget(void *p) {
      delete [] ((::TMVA::PDEFoamMultiTarget*)p);
   }
   static void destruct_TMVAcLcLPDEFoamMultiTarget(void *p) {
      typedef ::TMVA::PDEFoamMultiTarget current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::PDEFoamMultiTarget

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::PDEFoamDecisionTree::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::PDEFoamDecisionTree::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void PDEFoamDecisionTree::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::PDEFoamDecisionTree.
      TClass *R__cl = ::TMVA::PDEFoamDecisionTree::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSepType", &fSepType);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::PDEFoamDiscriminant baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLPDEFoamDecisionTree(void *p) {
      return  p ? new(p) ::TMVA::PDEFoamDecisionTree : new ::TMVA::PDEFoamDecisionTree;
   }
   static void *newArray_TMVAcLcLPDEFoamDecisionTree(Long_t nElements, void *p) {
      return p ? new(p) ::TMVA::PDEFoamDecisionTree[nElements] : new ::TMVA::PDEFoamDecisionTree[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLPDEFoamDecisionTree(void *p) {
      delete ((::TMVA::PDEFoamDecisionTree*)p);
   }
   static void deleteArray_TMVAcLcLPDEFoamDecisionTree(void *p) {
      delete [] ((::TMVA::PDEFoamDecisionTree*)p);
   }
   static void destruct_TMVAcLcLPDEFoamDecisionTree(void *p) {
      typedef ::TMVA::PDEFoamDecisionTree current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::PDEFoamDecisionTree

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::PDEFoamDensityBase::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::PDEFoamDensityBase::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void PDEFoamDensityBase::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::PDEFoamDensityBase.
      TClass *R__cl = ::TMVA::PDEFoamDensityBase::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBox", (void*)&fBox);
      R__insp.InspectMember("vector<Double_t>", (void*)&fBox, "fBox.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoxVolume", &fBoxVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoxHasChanged", &fBoxHasChanged);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBst", &fBst);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
      TObject::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLPDEFoamDensityBase(void *p) {
      delete ((::TMVA::PDEFoamDensityBase*)p);
   }
   static void deleteArray_TMVAcLcLPDEFoamDensityBase(void *p) {
      delete [] ((::TMVA::PDEFoamDensityBase*)p);
   }
   static void destruct_TMVAcLcLPDEFoamDensityBase(void *p) {
      typedef ::TMVA::PDEFoamDensityBase current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::PDEFoamDensityBase

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::PDEFoamDiscriminantDensity::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::PDEFoamDiscriminantDensity::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void PDEFoamDiscriminantDensity::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::PDEFoamDiscriminantDensity.
      TClass *R__cl = ::TMVA::PDEFoamDiscriminantDensity::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClass", &fClass);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::PDEFoamDensityBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLPDEFoamDiscriminantDensity(void *p) {
      return  p ? new(p) ::TMVA::PDEFoamDiscriminantDensity : new ::TMVA::PDEFoamDiscriminantDensity;
   }
   static void *newArray_TMVAcLcLPDEFoamDiscriminantDensity(Long_t nElements, void *p) {
      return p ? new(p) ::TMVA::PDEFoamDiscriminantDensity[nElements] : new ::TMVA::PDEFoamDiscriminantDensity[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLPDEFoamDiscriminantDensity(void *p) {
      delete ((::TMVA::PDEFoamDiscriminantDensity*)p);
   }
   static void deleteArray_TMVAcLcLPDEFoamDiscriminantDensity(void *p) {
      delete [] ((::TMVA::PDEFoamDiscriminantDensity*)p);
   }
   static void destruct_TMVAcLcLPDEFoamDiscriminantDensity(void *p) {
      typedef ::TMVA::PDEFoamDiscriminantDensity current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::PDEFoamDiscriminantDensity

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::PDEFoamEventDensity::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::PDEFoamEventDensity::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void PDEFoamEventDensity::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::PDEFoamEventDensity.
      TClass *R__cl = ::TMVA::PDEFoamEventDensity::IsA();
      if (R__cl || R__insp.IsA()) { }
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::PDEFoamDensityBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLPDEFoamEventDensity(void *p) {
      return  p ? new(p) ::TMVA::PDEFoamEventDensity : new ::TMVA::PDEFoamEventDensity;
   }
   static void *newArray_TMVAcLcLPDEFoamEventDensity(Long_t nElements, void *p) {
      return p ? new(p) ::TMVA::PDEFoamEventDensity[nElements] : new ::TMVA::PDEFoamEventDensity[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLPDEFoamEventDensity(void *p) {
      delete ((::TMVA::PDEFoamEventDensity*)p);
   }
   static void deleteArray_TMVAcLcLPDEFoamEventDensity(void *p) {
      delete [] ((::TMVA::PDEFoamEventDensity*)p);
   }
   static void destruct_TMVAcLcLPDEFoamEventDensity(void *p) {
      typedef ::TMVA::PDEFoamEventDensity current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::PDEFoamEventDensity

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::PDEFoamTargetDensity::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::PDEFoamTargetDensity::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void PDEFoamTargetDensity::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::PDEFoamTargetDensity.
      TClass *R__cl = ::TMVA::PDEFoamTargetDensity::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTarget", &fTarget);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::PDEFoamDensityBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLPDEFoamTargetDensity(void *p) {
      return  p ? new(p) ::TMVA::PDEFoamTargetDensity : new ::TMVA::PDEFoamTargetDensity;
   }
   static void *newArray_TMVAcLcLPDEFoamTargetDensity(Long_t nElements, void *p) {
      return p ? new(p) ::TMVA::PDEFoamTargetDensity[nElements] : new ::TMVA::PDEFoamTargetDensity[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLPDEFoamTargetDensity(void *p) {
      delete ((::TMVA::PDEFoamTargetDensity*)p);
   }
   static void deleteArray_TMVAcLcLPDEFoamTargetDensity(void *p) {
      delete [] ((::TMVA::PDEFoamTargetDensity*)p);
   }
   static void destruct_TMVAcLcLPDEFoamTargetDensity(void *p) {
      typedef ::TMVA::PDEFoamTargetDensity current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::PDEFoamTargetDensity

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::PDEFoamDecisionTreeDensity::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::PDEFoamDecisionTreeDensity::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void PDEFoamDecisionTreeDensity::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::PDEFoamDecisionTreeDensity.
      TClass *R__cl = ::TMVA::PDEFoamDecisionTreeDensity::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClass", &fClass);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::PDEFoamDensityBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLPDEFoamDecisionTreeDensity(void *p) {
      return  p ? new(p) ::TMVA::PDEFoamDecisionTreeDensity : new ::TMVA::PDEFoamDecisionTreeDensity;
   }
   static void *newArray_TMVAcLcLPDEFoamDecisionTreeDensity(Long_t nElements, void *p) {
      return p ? new(p) ::TMVA::PDEFoamDecisionTreeDensity[nElements] : new ::TMVA::PDEFoamDecisionTreeDensity[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLPDEFoamDecisionTreeDensity(void *p) {
      delete ((::TMVA::PDEFoamDecisionTreeDensity*)p);
   }
   static void deleteArray_TMVAcLcLPDEFoamDecisionTreeDensity(void *p) {
      delete [] ((::TMVA::PDEFoamDecisionTreeDensity*)p);
   }
   static void destruct_TMVAcLcLPDEFoamDecisionTreeDensity(void *p) {
      typedef ::TMVA::PDEFoamDecisionTreeDensity current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::PDEFoamDecisionTreeDensity

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::PDEFoamVect::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::PDEFoamVect::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void PDEFoamVect::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::PDEFoamVect.
      TClass *R__cl = ::TMVA::PDEFoamVect::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDim", &fDim);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCoords", &fCoords);
      TObject::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLPDEFoamVect(void *p) {
      return  p ? new(p) ::TMVA::PDEFoamVect : new ::TMVA::PDEFoamVect;
   }
   static void *newArray_TMVAcLcLPDEFoamVect(Long_t nElements, void *p) {
      return p ? new(p) ::TMVA::PDEFoamVect[nElements] : new ::TMVA::PDEFoamVect[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLPDEFoamVect(void *p) {
      delete ((::TMVA::PDEFoamVect*)p);
   }
   static void deleteArray_TMVAcLcLPDEFoamVect(void *p) {
      delete [] ((::TMVA::PDEFoamVect*)p);
   }
   static void destruct_TMVAcLcLPDEFoamVect(void *p) {
      typedef ::TMVA::PDEFoamVect current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::PDEFoamVect

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::PDEFoamCell::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::PDEFoamCell::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void PDEFoamCell::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::PDEFoamCell.
      TClass *R__cl = ::TMVA::PDEFoamCell::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDim", &fDim);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSerial", &fSerial);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &fStatus);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParent", &fParent);
      R__insp.InspectMember(fParent, "fParent.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDaught0", &fDaught0);
      R__insp.InspectMember(fDaught0, "fDaught0.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDaught1", &fDaught1);
      R__insp.InspectMember(fDaught1, "fDaught1.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXdiv", &fXdiv);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBest", &fBest);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVolume", &fVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIntegral", &fIntegral);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrive", &fDrive);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElement", &fElement);
      TObject::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLPDEFoamCell(void *p) {
      return  p ? new(p) ::TMVA::PDEFoamCell : new ::TMVA::PDEFoamCell;
   }
   static void *newArray_TMVAcLcLPDEFoamCell(Long_t nElements, void *p) {
      return p ? new(p) ::TMVA::PDEFoamCell[nElements] : new ::TMVA::PDEFoamCell[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLPDEFoamCell(void *p) {
      delete ((::TMVA::PDEFoamCell*)p);
   }
   static void deleteArray_TMVAcLcLPDEFoamCell(void *p) {
      delete [] ((::TMVA::PDEFoamCell*)p);
   }
   static void destruct_TMVAcLcLPDEFoamCell(void *p) {
      typedef ::TMVA::PDEFoamCell current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::PDEFoamCell

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::PDEFoamKernelBase::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::PDEFoamKernelBase::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void PDEFoamKernelBase::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::PDEFoamKernelBase.
      TClass *R__cl = ::TMVA::PDEFoamKernelBase::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
      TObject::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLPDEFoamKernelBase(void *p) {
      delete ((::TMVA::PDEFoamKernelBase*)p);
   }
   static void deleteArray_TMVAcLcLPDEFoamKernelBase(void *p) {
      delete [] ((::TMVA::PDEFoamKernelBase*)p);
   }
   static void destruct_TMVAcLcLPDEFoamKernelBase(void *p) {
      typedef ::TMVA::PDEFoamKernelBase current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::PDEFoamKernelBase

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::PDEFoamKernelTrivial::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::PDEFoamKernelTrivial::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void PDEFoamKernelTrivial::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::PDEFoamKernelTrivial.
      TClass *R__cl = ::TMVA::PDEFoamKernelTrivial::IsA();
      if (R__cl || R__insp.IsA()) { }
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::PDEFoamKernelBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLPDEFoamKernelTrivial(void *p) {
      return  p ? new(p) ::TMVA::PDEFoamKernelTrivial : new ::TMVA::PDEFoamKernelTrivial;
   }
   static void *newArray_TMVAcLcLPDEFoamKernelTrivial(Long_t nElements, void *p) {
      return p ? new(p) ::TMVA::PDEFoamKernelTrivial[nElements] : new ::TMVA::PDEFoamKernelTrivial[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLPDEFoamKernelTrivial(void *p) {
      delete ((::TMVA::PDEFoamKernelTrivial*)p);
   }
   static void deleteArray_TMVAcLcLPDEFoamKernelTrivial(void *p) {
      delete [] ((::TMVA::PDEFoamKernelTrivial*)p);
   }
   static void destruct_TMVAcLcLPDEFoamKernelTrivial(void *p) {
      typedef ::TMVA::PDEFoamKernelTrivial current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::PDEFoamKernelTrivial

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::PDEFoamKernelLinN::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::PDEFoamKernelLinN::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void PDEFoamKernelLinN::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::PDEFoamKernelLinN.
      TClass *R__cl = ::TMVA::PDEFoamKernelLinN::IsA();
      if (R__cl || R__insp.IsA()) { }
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::PDEFoamKernelBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLPDEFoamKernelLinN(void *p) {
      return  p ? new(p) ::TMVA::PDEFoamKernelLinN : new ::TMVA::PDEFoamKernelLinN;
   }
   static void *newArray_TMVAcLcLPDEFoamKernelLinN(Long_t nElements, void *p) {
      return p ? new(p) ::TMVA::PDEFoamKernelLinN[nElements] : new ::TMVA::PDEFoamKernelLinN[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLPDEFoamKernelLinN(void *p) {
      delete ((::TMVA::PDEFoamKernelLinN*)p);
   }
   static void deleteArray_TMVAcLcLPDEFoamKernelLinN(void *p) {
      delete [] ((::TMVA::PDEFoamKernelLinN*)p);
   }
   static void destruct_TMVAcLcLPDEFoamKernelLinN(void *p) {
      typedef ::TMVA::PDEFoamKernelLinN current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::PDEFoamKernelLinN

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::PDEFoamKernelGauss::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::PDEFoamKernelGauss::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void PDEFoamKernelGauss::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::PDEFoamKernelGauss.
      TClass *R__cl = ::TMVA::PDEFoamKernelGauss::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigma", &fSigma);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::PDEFoamKernelBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLPDEFoamKernelGauss(void *p) {
      delete ((::TMVA::PDEFoamKernelGauss*)p);
   }
   static void deleteArray_TMVAcLcLPDEFoamKernelGauss(void *p) {
      delete [] ((::TMVA::PDEFoamKernelGauss*)p);
   }
   static void destruct_TMVAcLcLPDEFoamKernelGauss(void *p) {
      typedef ::TMVA::PDEFoamKernelGauss current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::PDEFoamKernelGauss

//______________________________________________________________________________
namespace ROOTDict {
   void TMVAcLcLBDTEventWrapper_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMVA::BDTEventWrapper.
      typedef ::ROOTShadow::Shadow::TMVA::BDTEventWrapper ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::BDTEventWrapper*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEvent", &sobj->fEvent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBkgWeight", &sobj->fBkgWeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigWeight", &sobj->fSigWeight);
   }

}

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLBDTEventWrapper(void *p) {
      delete ((::TMVA::BDTEventWrapper*)p);
   }
   static void deleteArray_TMVAcLcLBDTEventWrapper(void *p) {
      delete [] ((::TMVA::BDTEventWrapper*)p);
   }
   static void destruct_TMVAcLcLBDTEventWrapper(void *p) {
      typedef ::TMVA::BDTEventWrapper current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::BDTEventWrapper

//______________________________________________________________________________
namespace ROOTDict {
   void TMVAcLcLCCTreeWrapper_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMVA::CCTreeWrapper.
      typedef ::ROOTShadow::Shadow::TMVA::CCTreeWrapper ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::CCTreeWrapper*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fQualityIndex", &sobj->fQualityIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDTParent", &sobj->fDTParent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRoot", &sobj->fRoot);
   }

}

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLCCTreeWrapper(void *p) {
      delete ((::TMVA::CCTreeWrapper*)p);
   }
   static void deleteArray_TMVAcLcLCCTreeWrapper(void *p) {
      delete [] ((::TMVA::CCTreeWrapper*)p);
   }
   static void destruct_TMVAcLcLCCTreeWrapper(void *p) {
      typedef ::TMVA::CCTreeWrapper current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::CCTreeWrapper

//______________________________________________________________________________
namespace ROOTDict {
   void TMVAcLcLCCPruner_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMVA::CCPruner.
      typedef ::ROOTShadow::Shadow::TMVA::CCPruner ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::CCPruner*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlpha", &sobj->fAlpha);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fValidationSample", &sobj->fValidationSample);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fValidationDataSet", &sobj->fValidationDataSet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fQualityIndex", &sobj->fQualityIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOwnQIndex", &sobj->fOwnQIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTree", &sobj->fTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPruneSequence", (void*)&sobj->fPruneSequence);
      R__insp.InspectMember("vector<TMVA::DecisionTreeNode*>", (void*)&sobj->fPruneSequence, "fPruneSequence.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPruneStrengthList", (void*)&sobj->fPruneStrengthList);
      R__insp.InspectMember("vector<Float_t>", (void*)&sobj->fPruneStrengthList, "fPruneStrengthList.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fQualityIndexList", (void*)&sobj->fQualityIndexList);
      R__insp.InspectMember("vector<Float_t>", (void*)&sobj->fQualityIndexList, "fQualityIndexList.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptimalK", &sobj->fOptimalK);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDebug", &sobj->fDebug);
   }

}

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLCCPruner(void *p) {
      delete ((::TMVA::CCPruner*)p);
   }
   static void deleteArray_TMVAcLcLCCPruner(void *p) {
      delete [] ((::TMVA::CCPruner*)p);
   }
   static void destruct_TMVAcLcLCCPruner(void *p) {
      typedef ::TMVA::CCPruner current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::CCPruner

//______________________________________________________________________________
namespace ROOTDict {
   void TMVAcLcLCostComplexityPruneTool_ShowMembers(void *obj, TMemberInspector &R__insp)
   {
      // Inspect the data members of an object of class TMVA::CostComplexityPruneTool.
      typedef ::ROOTShadow::Shadow::TMVA::CostComplexityPruneTool ShadowClass;
      ShadowClass *sobj = (ShadowClass*)obj;
      if (sobj) { } // Dummy usage just in case there is no datamember.

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::CostComplexityPruneTool*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fQualityIndexTool", &sobj->fQualityIndexTool);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPruneSequence", (void*)&sobj->fPruneSequence);
      R__insp.InspectMember("vector<TMVA::DecisionTreeNode*,allocator<TMVA::DecisionTreeNode*> >", (void*)&sobj->fPruneSequence, "fPruneSequence.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPruneStrengthList", (void*)&sobj->fPruneStrengthList);
      R__insp.InspectMember("vector<Double_t>", (void*)&sobj->fPruneStrengthList, "fPruneStrengthList.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fQualityIndexList", (void*)&sobj->fQualityIndexList);
      R__insp.InspectMember("vector<Double_t>", (void*)&sobj->fQualityIndexList, "fQualityIndexList.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptimalK", &sobj->fOptimalK);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &sobj->fLogger);
      R__insp.GenericShowMembers("TMVA::IPruneTool", ( ::TMVA::IPruneTool * )( (::TMVA::CostComplexityPruneTool*) obj ), false);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLCostComplexityPruneTool(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::CostComplexityPruneTool : new ::TMVA::CostComplexityPruneTool;
   }
   static void *newArray_TMVAcLcLCostComplexityPruneTool(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::CostComplexityPruneTool[nElements] : new ::TMVA::CostComplexityPruneTool[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLCostComplexityPruneTool(void *p) {
      delete ((::TMVA::CostComplexityPruneTool*)p);
   }
   static void deleteArray_TMVAcLcLCostComplexityPruneTool(void *p) {
      delete [] ((::TMVA::CostComplexityPruneTool*)p);
   }
   static void destruct_TMVAcLcLCostComplexityPruneTool(void *p) {
      typedef ::TMVA::CostComplexityPruneTool current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::CostComplexityPruneTool

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::SVEvent::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::SVEvent::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void SVEvent::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::SVEvent.
      TClass *R__cl = ::TMVA::SVEvent::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataVector", (void*)&fDataVector);
      R__insp.InspectMember("vector<Float_t>", (void*)&fDataVector, "fDataVector.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCweight", &fCweight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlpha", &fAlpha);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlpha_p", &fAlpha_p);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorCache", &fErrorCache);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNVar", &fNVar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTypeFlag", &fTypeFlag);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIdx", &fIdx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNs", &fNs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShrinked", &fIsShrinked);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLine", &fLine);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTarget", &fTarget);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLSVEvent(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::SVEvent : new ::TMVA::SVEvent;
   }
   static void *newArray_TMVAcLcLSVEvent(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::SVEvent[nElements] : new ::TMVA::SVEvent[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLSVEvent(void *p) {
      delete ((::TMVA::SVEvent*)p);
   }
   static void deleteArray_TMVAcLcLSVEvent(void *p) {
      delete [] ((::TMVA::SVEvent*)p);
   }
   static void destruct_TMVAcLcLSVEvent(void *p) {
      typedef ::TMVA::SVEvent current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::SVEvent

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

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TMVA::OptimizeConfigParameters::Class(),this);
   } else {
      R__b.WriteClassBuffer(TMVA::OptimizeConfigParameters::Class(),this);
   }
}

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void OptimizeConfigParameters::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::OptimizeConfigParameters.
      TClass *R__cl = ::TMVA::OptimizeConfigParameters::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMethod", &fMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFOMvsIter", (void*)&fFOMvsIter);
      R__insp.InspectMember("vector<Float_t>", (void*)&fFOMvsIter, "fFOMvsIter.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTuneParameters", (void*)&fTuneParameters);
      R__insp.InspectMember("map<TString,TMVA::Interval*>", (void*)&fTuneParameters, "fTuneParameters.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTunedParameters", (void*)&fTunedParameters);
      R__insp.InspectMember("map<TString,Double_t>", (void*)&fTunedParameters, "fTunedParameters.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlreadyTrainedParCombination", (void*)&fAlreadyTrainedParCombination);
      R__insp.InspectMember("map<std::vector<Double_t>,Double_t>", (void*)&fAlreadyTrainedParCombination, "fAlreadyTrainedParCombination.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFOMType", &fFOMType);
      R__insp.InspectMember(fFOMType, "fFOMType.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptimizationFitType", &fOptimizationFitType);
      R__insp.InspectMember(fOptimizationFitType, "fOptimizationFitType.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMvaSig", &fMvaSig);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMvaBkg", &fMvaBkg);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMvaSigFineBin", &fMvaSigFineBin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMvaBkgFineBin", &fMvaBkgFineBin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNotDoneYet", &fNotDoneYet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::IFitterTarget baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLOptimizeConfigParameters(void *p) {
      delete ((::TMVA::OptimizeConfigParameters*)p);
   }
   static void deleteArray_TMVAcLcLOptimizeConfigParameters(void *p) {
      delete [] ((::TMVA::OptimizeConfigParameters*)p);
   }
   static void destruct_TMVAcLcLOptimizeConfigParameters(void *p) {
      typedef ::TMVA::OptimizeConfigParameters current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::OptimizeConfigParameters

namespace ROOTDict {
   void vectorlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEdoublegR_Dictionary();
   static void *new_vectorlEdoublegR(void *p = 0);
   static void *newArray_vectorlEdoublegR(Long_t size, void *p);
   static void delete_vectorlEdoublegR(void *p);
   static void deleteArray_vectorlEdoublegR(void *p);
   static void destruct_vectorlEdoublegR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<double>*)
   {
      vector<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<double>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<double>", -2, "/home/mice/Grid/MAUS-v2.8.5/third_party/source/root_v5.34.36/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<double>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(vector<double>) );
      instance.SetNew(&new_vectorlEdoublegR);
      instance.SetNewArray(&newArray_vectorlEdoublegR);
      instance.SetDelete(&delete_vectorlEdoublegR);
      instance.SetDeleteArray(&deleteArray_vectorlEdoublegR);
      instance.SetDestructor(&destruct_vectorlEdoublegR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<double> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEdoublegR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const vector<double>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double> : new vector<double>;
   }
   static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double>[nElements] : new vector<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEdoublegR(void *p) {
      delete ((vector<double>*)p);
   }
   static void deleteArray_vectorlEdoublegR(void *p) {
      delete [] ((vector<double>*)p);
   }
   static void destruct_vectorlEdoublegR(void *p) {
      typedef vector<double> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<double>

/********************************************************
* G__TMVA3.cxx
* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED
*          FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().
*          CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.
********************************************************/

#ifdef G__MEMTEST
#undef malloc
#undef free
#endif

#if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif

extern "C" void G__cpp_reset_tagtableG__TMVA3();

extern "C" void G__set_cpp_environmentG__TMVA3() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TMVA/Config.h");
  G__add_compiledheader("TMVA/KDEKernel.h");
  G__add_compiledheader("TMVA/Interval.h");
  G__add_compiledheader("TMVA/LogInterval.h");
  G__add_compiledheader("TMVA/FitterBase.h");
  G__add_compiledheader("TMVA/MCFitter.h");
  G__add_compiledheader("TMVA/GeneticFitter.h");
  G__add_compiledheader("TMVA/SimulatedAnnealingFitter.h");
  G__add_compiledheader("TMVA/MinuitFitter.h");
  G__add_compiledheader("TMVA/MinuitWrapper.h");
  G__add_compiledheader("TMVA/IFitterTarget.h");
  G__add_compiledheader("TMVA/PDEFoam.h");
  G__add_compiledheader("TMVA/PDEFoamDecisionTree.h");
  G__add_compiledheader("TMVA/PDEFoamDensityBase.h");
  G__add_compiledheader("TMVA/PDEFoamDiscriminantDensity.h");
  G__add_compiledheader("TMVA/PDEFoamEventDensity.h");
  G__add_compiledheader("TMVA/PDEFoamTargetDensity.h");
  G__add_compiledheader("TMVA/PDEFoamDecisionTreeDensity.h");
  G__add_compiledheader("TMVA/PDEFoamMultiTarget.h");
  G__add_compiledheader("TMVA/PDEFoamVect.h");
  G__add_compiledheader("TMVA/PDEFoamCell.h");
  G__add_compiledheader("TMVA/PDEFoamDiscriminant.h");
  G__add_compiledheader("TMVA/PDEFoamEvent.h");
  G__add_compiledheader("TMVA/PDEFoamTarget.h");
  G__add_compiledheader("TMVA/PDEFoamKernelBase.h");
  G__add_compiledheader("TMVA/PDEFoamKernelTrivial.h");
  G__add_compiledheader("TMVA/PDEFoamKernelLinN.h");
  G__add_compiledheader("TMVA/PDEFoamKernelGauss.h");
  G__add_compiledheader("TMVA/BDTEventWrapper.h");
  G__add_compiledheader("TMVA/CCTreeWrapper.h");
  G__add_compiledheader("TMVA/CCPruner.h");
  G__add_compiledheader("TMVA/CostComplexityPruneTool.h");
  G__add_compiledheader("TMVA/SVEvent.h");
  G__add_compiledheader("TMVA/OptimizeConfigParameters.h");
  G__cpp_reset_tagtableG__TMVA3();
}
#include <new>
extern "C" int G__cpp_dllrevG__TMVA3() { return(30051515); }

/*********************************************************
* Member function Interface Method
*********************************************************/

/* TMVA */
static int G__G__TMVA3_127_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::Config& obj = TMVA::gConfig();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_127_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::MsgLogger& obj = TMVA::Endl(*(TMVA::MsgLogger*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_127_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ostream& obj = TMVA::operator<<(*(ostream*) libp->para[0].ref, *(TMVA::Node*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_127_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ostream& obj = TMVA::operator<<(*(ostream*) libp->para[0].ref, (TMVA::Node*) G__int(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_127_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ostream& obj = TMVA::operator<<(*(ostream*) libp->para[0].ref, *(TMVA::BinaryTree*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_127_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const istream& obj = TMVA::operator>>(*(istream*) libp->para[0].ref, *(TMVA::BinaryTree*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_127_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ostream& obj = TMVA::operator<<(*(ostream*) libp->para[0].ref, *(TMVA::Event*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::Config */
static int G__G__TMVA3_129_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::Config& obj = TMVA::Config::Instance();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::Config::DestroyInstance();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMVA::Config*) G__getstructoffset())->UseColor());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Config*) G__getstructoffset())->SetUseColor((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMVA::Config*) G__getstructoffset())->IsSilent());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Config*) G__getstructoffset())->SetSilent((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMVA::Config*) G__getstructoffset())->WriteOptionsReference());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Config*) G__getstructoffset())->SetWriteOptionsReference((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMVA::Config*) G__getstructoffset())->DrawProgressBar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Config*) G__getstructoffset())->SetDrawProgressBar((Bool_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::Config::VariablePlotting& obj = ((TMVA::Config*) G__getstructoffset())->GetVariablePlotting();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::Config::IONames& obj = ((TMVA::Config*) G__getstructoffset())->GetIONames();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::Config::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::Config::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::Config::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::Config::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMVA::Config*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Config*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Config*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Config*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::Config::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::Config::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::Config::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_129_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::Config::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__TMVA3_129_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMVA::Config* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMVA::Config(*(TMVA::Config*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfig));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_129_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::Config* dest = (TMVA::Config*) G__getstructoffset();
   *dest = *(TMVA::Config*) libp->para[0].ref;
   const TMVA::Config& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::Config::VariablePlotting */
// automatic default constructor
static int G__G__TMVA3_130_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::Config::VariablePlotting *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Config::VariablePlotting[n];
     } else {
       p = new((void*) gvp) TMVA::Config::VariablePlotting[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Config::VariablePlotting;
     } else {
       p = new((void*) gvp) TMVA::Config::VariablePlotting;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__TMVA3_130_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMVA::Config::VariablePlotting* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMVA::Config::VariablePlotting(*(TMVA::Config::VariablePlotting*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::Config::VariablePlotting G__TTMVAcLcLConfigcLcLVariablePlotting;
static int G__G__TMVA3_130_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::Config::VariablePlotting*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::Config::VariablePlotting*) (soff+(sizeof(TMVA::Config::VariablePlotting)*i)))->~G__TTMVAcLcLConfigcLcLVariablePlotting();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::Config::VariablePlotting*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::Config::VariablePlotting*) (soff))->~G__TTMVAcLcLConfigcLcLVariablePlotting();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_130_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::Config::VariablePlotting* dest = (TMVA::Config::VariablePlotting*) G__getstructoffset();
   *dest = *(TMVA::Config::VariablePlotting*) libp->para[0].ref;
   const TMVA::Config::VariablePlotting& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::Config::IONames */
// automatic default constructor
static int G__G__TMVA3_131_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::Config::IONames *p;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Config::IONames[n];
     } else {
       p = new((void*) gvp) TMVA::Config::IONames[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Config::IONames;
     } else {
       p = new((void*) gvp) TMVA::Config::IONames;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__TMVA3_131_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMVA::Config::IONames* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMVA::Config::IONames(*(TMVA::Config::IONames*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::Config::IONames G__TTMVAcLcLConfigcLcLIONames;
static int G__G__TMVA3_131_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::Config::IONames*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::Config::IONames*) (soff+(sizeof(TMVA::Config::IONames)*i)))->~G__TTMVAcLcLConfigcLcLIONames();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::Config::IONames*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::Config::IONames*) (soff))->~G__TTMVAcLcLConfigcLcLIONames();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_131_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::Config::IONames* dest = (TMVA::Config::IONames*) G__getstructoffset();
   *dest = *(TMVA::Config::IONames*) libp->para[0].ref;
   const TMVA::Config::IONames& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::KDEKernel */
static int G__G__TMVA3_135_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::KDEKernel* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::KDEKernel(
(TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (TMVA::KDEKernel::EKernelBorder) G__int(libp->para[4]), (Float_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TMVA::KDEKernel(
(TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (TMVA::KDEKernel::EKernelBorder) G__int(libp->para[4]), (Float_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::KDEKernel(
(TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (TMVA::KDEKernel::EKernelBorder) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TMVA::KDEKernel(
(TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
, (TMVA::KDEKernel::EKernelBorder) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::KDEKernel(
(TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TMVA::KDEKernel(
(TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::KDEKernel(
(TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::KDEKernel(
(TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
, (Float_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::KDEKernel((TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMVA::KDEKernel((TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::KDEKernel((TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TMVA::KDEKernel((TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TMVA::KDEKernel[n];
       } else {
         p = new((void*) gvp) TMVA::KDEKernel[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TMVA::KDEKernel;
       } else {
         p = new((void*) gvp) TMVA::KDEKernel;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernel));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_135_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TMVA::KDEKernel*) G__getstructoffset())->GetBinKernelIntegral((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_135_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TMVA::KDEKernel*) G__getstructoffset())->SetKernelType((TMVA::KDEKernel::EKernelType) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TMVA::KDEKernel*) G__getstructoffset())->SetKernelType();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_135_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const TMVA::KDEKernel*) G__getstructoffset())->GetName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_135_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::KDEKernel::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_135_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::KDEKernel::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_135_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::KDEKernel::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_135_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::KDEKernel::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_135_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMVA::KDEKernel*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_135_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::KDEKernel*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_135_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::KDEKernel*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_135_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::KDEKernel*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_135_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::KDEKernel::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_135_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::KDEKernel::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_135_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::KDEKernel::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_135_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::KDEKernel::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__TMVA3_135_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMVA::KDEKernel* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMVA::KDEKernel(*(TMVA::KDEKernel*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernel));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::KDEKernel G__TTMVAcLcLKDEKernel;
static int G__G__TMVA3_135_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::KDEKernel*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::KDEKernel*) (soff+(sizeof(TMVA::KDEKernel)*i)))->~G__TTMVAcLcLKDEKernel();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::KDEKernel*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::KDEKernel*) (soff))->~G__TTMVAcLcLKDEKernel();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_135_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::KDEKernel* dest = (TMVA::KDEKernel*) G__getstructoffset();
   *dest = *(TMVA::KDEKernel*) libp->para[0].ref;
   const TMVA::KDEKernel& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::Interval */
static int G__G__TMVA3_140_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::Interval* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Interval(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::Interval(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Interval((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) TMVA::Interval((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLInterval));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::Interval* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::Interval(*(TMVA::Interval*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMVA::Interval(*(TMVA::Interval*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLInterval));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMVA::Interval*) G__getstructoffset())->GetMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMVA::Interval*) G__getstructoffset())->GetMax());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMVA::Interval*) G__getstructoffset())->GetWidth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMVA::Interval*) G__getstructoffset())->GetNbins());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMVA::Interval*) G__getstructoffset())->GetMean());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMVA::Interval*) G__getstructoffset())->GetRndm(*(TRandom3*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMVA::Interval*) G__getstructoffset())->GetElement((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letdouble(result7, 100, (double) ((const TMVA::Interval*) G__getstructoffset())->GetStepSize((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TMVA::Interval*) G__getstructoffset())->GetStepSize());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Interval*) G__getstructoffset())->SetMax((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Interval*) G__getstructoffset())->SetMin((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TMVA::Interval*) G__getstructoffset())->Print(*(ostream*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::Interval::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::Interval::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::Interval::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::Interval::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMVA::Interval*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Interval*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Interval*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Interval*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::Interval::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::Interval::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::Interval::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_140_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::Interval::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::Interval G__TTMVAcLcLInterval;
static int G__G__TMVA3_140_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::Interval*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::Interval*) (soff+(sizeof(TMVA::Interval)*i)))->~G__TTMVAcLcLInterval();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::Interval*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::Interval*) (soff))->~G__TTMVAcLcLInterval();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_140_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::Interval* dest = (TMVA::Interval*) G__getstructoffset();
   *dest = *(TMVA::Interval*) libp->para[0].ref;
   const TMVA::Interval& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::LogInterval */
static int G__G__TMVA3_141_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::LogInterval* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::LogInterval(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::LogInterval(
(Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::LogInterval((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) TMVA::LogInterval((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLLogInterval));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_141_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::LogInterval* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::LogInterval(*(TMVA::LogInterval*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMVA::LogInterval(*(TMVA::LogInterval*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLLogInterval));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_141_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::LogInterval*) G__getstructoffset())->SetMax((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_141_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::LogInterval*) G__getstructoffset())->SetMin((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_141_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::MsgLogger& obj = ((const TMVA::LogInterval*) G__getstructoffset())->Log();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_141_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::LogInterval::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_141_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::LogInterval::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_141_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::LogInterval::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_141_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::LogInterval::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_141_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::LogInterval*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_141_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::LogInterval::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_141_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::LogInterval::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_141_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::LogInterval::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_141_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::LogInterval::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::LogInterval G__TTMVAcLcLLogInterval;
static int G__G__TMVA3_141_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::LogInterval*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::LogInterval*) (soff+(sizeof(TMVA::LogInterval)*i)))->~G__TTMVAcLcLLogInterval();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::LogInterval*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::LogInterval*) (soff))->~G__TTMVAcLcLLogInterval();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_141_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::LogInterval* dest = (TMVA::LogInterval*) G__getstructoffset();
   *dest = *(TMVA::LogInterval*) libp->para[0].ref;
   const TMVA::LogInterval& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::IFitterTarget */
static int G__G__TMVA3_197_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::IFitterTarget*) G__getstructoffset())->EstimatorFunction(*(vector<Double_t>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_197_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::IFitterTarget*) G__getstructoffset())->ProgressNotifier(*((TString*) G__int(libp->para[0])), *((TString*) G__int(libp->para[1])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_197_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::IFitterTarget::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_197_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::IFitterTarget::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_197_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::IFitterTarget::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_197_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::IFitterTarget::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_197_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMVA::IFitterTarget*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_197_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::IFitterTarget*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_197_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::IFitterTarget*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_197_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::IFitterTarget*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_197_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::IFitterTarget::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_197_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::IFitterTarget::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_197_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::IFitterTarget::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_197_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::IFitterTarget::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::IFitterTarget G__TTMVAcLcLIFitterTarget;
static int G__G__TMVA3_197_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::IFitterTarget*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::IFitterTarget*) (soff+(sizeof(TMVA::IFitterTarget)*i)))->~G__TTMVAcLcLIFitterTarget();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::IFitterTarget*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::IFitterTarget*) (soff))->~G__TTMVAcLcLIFitterTarget();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_197_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::IFitterTarget* dest = (TMVA::IFitterTarget*) G__getstructoffset();
   *dest = *(TMVA::IFitterTarget*) libp->para[0].ref;
   const TMVA::IFitterTarget& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::FitterBase */
static int G__G__TMVA3_198_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::FitterBase*) G__getstructoffset())->Run());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_198_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::FitterBase*) G__getstructoffset())->Run(*(vector<Double_t>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_198_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::FitterBase*) G__getstructoffset())->EstimatorFunction(*(vector<Double_t>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_198_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::IFitterTarget& obj = ((const TMVA::FitterBase*) G__getstructoffset())->GetFitterTarget();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_198_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMVA::FitterBase*) G__getstructoffset())->GetNpars());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_198_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::FitterBase::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_198_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::FitterBase::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_198_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::FitterBase::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_198_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::FitterBase::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_198_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::FitterBase*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_198_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::FitterBase::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_198_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::FitterBase::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_198_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::FitterBase::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_198_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::FitterBase::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::FitterBase G__TTMVAcLcLFitterBase;
static int G__G__TMVA3_198_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::FitterBase*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::FitterBase*) (soff+(sizeof(TMVA::FitterBase)*i)))->~G__TTMVAcLcLFitterBase();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::FitterBase*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::FitterBase*) (soff))->~G__TTMVAcLcLFitterBase();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::MCFitter */
static int G__G__TMVA3_207_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MCFitter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::MCFitter(
*(TMVA::IFitterTarget*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(vector<TMVA::Interval*>*) libp->para[2].ref, *(TString*) libp->para[3].ref);
   } else {
     p = new((void*) gvp) TMVA::MCFitter(
*(TMVA::IFitterTarget*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(vector<TMVA::Interval*>*) libp->para[2].ref, *(TString*) libp->para[3].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMCFitter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_207_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::MCFitter*) G__getstructoffset())->SetParameters((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_207_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::MCFitter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_207_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::MCFitter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_207_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::MCFitter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_207_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::MCFitter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_207_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::MCFitter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_207_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::MCFitter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_207_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::MCFitter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_207_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::MCFitter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_207_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::MCFitter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::MCFitter G__TTMVAcLcLMCFitter;
static int G__G__TMVA3_207_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::MCFitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::MCFitter*) (soff+(sizeof(TMVA::MCFitter)*i)))->~G__TTMVAcLcLMCFitter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::MCFitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::MCFitter*) (soff))->~G__TTMVAcLcLMCFitter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::GeneticFitter */
static int G__G__TMVA3_208_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::GeneticFitter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::GeneticFitter(
*(TMVA::IFitterTarget*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(vector<TMVA::Interval*>*) libp->para[2].ref, *(TString*) libp->para[3].ref);
   } else {
     p = new((void*) gvp) TMVA::GeneticFitter(
*(TMVA::IFitterTarget*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(vector<TMVA::Interval*>*) libp->para[2].ref, *(TString*) libp->para[3].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLGeneticFitter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_208_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::GeneticFitter*) G__getstructoffset())->SetParameters(
(Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_208_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::GeneticFitter*) G__getstructoffset())->NewFitness((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_208_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::GeneticFitter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_208_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::GeneticFitter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_208_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::GeneticFitter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_208_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::GeneticFitter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_208_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::GeneticFitter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_208_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::GeneticFitter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_208_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::GeneticFitter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_208_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::GeneticFitter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_208_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::GeneticFitter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::GeneticFitter G__TTMVAcLcLGeneticFitter;
static int G__G__TMVA3_208_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::GeneticFitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::GeneticFitter*) (soff+(sizeof(TMVA::GeneticFitter)*i)))->~G__TTMVAcLcLGeneticFitter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::GeneticFitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::GeneticFitter*) (soff))->~G__TTMVAcLcLGeneticFitter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::SimulatedAnnealingFitter */
static int G__G__TMVA3_209_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::SimulatedAnnealingFitter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::SimulatedAnnealingFitter(
*(TMVA::IFitterTarget*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(vector<TMVA::Interval*>*) libp->para[2].ref, *(TString*) libp->para[3].ref);
   } else {
     p = new((void*) gvp) TMVA::SimulatedAnnealingFitter(
*(TMVA::IFitterTarget*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(vector<TMVA::Interval*>*) libp->para[2].ref, *(TString*) libp->para[3].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_209_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::SimulatedAnnealingFitter*) G__getstructoffset())->SetParameters(
(Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, *((TString*) G__int(libp->para[4])), (Double_t) G__double(libp->para[5])
, (Double_t) G__double(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (Bool_t) G__int(libp->para[8]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_209_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::SimulatedAnnealingFitter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_209_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::SimulatedAnnealingFitter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_209_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::SimulatedAnnealingFitter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_209_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::SimulatedAnnealingFitter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_209_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::SimulatedAnnealingFitter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_209_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::SimulatedAnnealingFitter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_209_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::SimulatedAnnealingFitter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_209_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::SimulatedAnnealingFitter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_209_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::SimulatedAnnealingFitter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::SimulatedAnnealingFitter G__TTMVAcLcLSimulatedAnnealingFitter;
static int G__G__TMVA3_209_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::SimulatedAnnealingFitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::SimulatedAnnealingFitter*) (soff+(sizeof(TMVA::SimulatedAnnealingFitter)*i)))->~G__TTMVAcLcLSimulatedAnnealingFitter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::SimulatedAnnealingFitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::SimulatedAnnealingFitter*) (soff))->~G__TTMVAcLcLSimulatedAnnealingFitter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::MinuitWrapper */
static int G__G__TMVA3_211_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MinuitWrapper* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::MinuitWrapper(*(TMVA::IFitterTarget*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMVA::MinuitWrapper(*(TMVA::IFitterTarget*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitWrapper));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_211_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::MinuitWrapper*) G__getstructoffset())->SetFitterTarget(*(TMVA::IFitterTarget*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_211_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TMVA::MinuitWrapper*) G__getstructoffset())->ExecuteCommand((const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_211_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TMVA::MinuitWrapper*) G__getstructoffset())->GetStats(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
, *(Int_t*) G__Intref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_211_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TMVA::MinuitWrapper*) G__getstructoffset())->GetErrors((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_211_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TMVA::MinuitWrapper*) G__getstructoffset())->SetParameter((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_211_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::MinuitWrapper::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_211_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::MinuitWrapper::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_211_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::MinuitWrapper::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_211_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::MinuitWrapper::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_211_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::MinuitWrapper*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_211_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::MinuitWrapper::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_211_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::MinuitWrapper::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_211_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::MinuitWrapper::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_211_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::MinuitWrapper::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::MinuitWrapper G__TTMVAcLcLMinuitWrapper;
static int G__G__TMVA3_211_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::MinuitWrapper*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::MinuitWrapper*) (soff+(sizeof(TMVA::MinuitWrapper)*i)))->~G__TTMVAcLcLMinuitWrapper();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::MinuitWrapper*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::MinuitWrapper*) (soff))->~G__TTMVAcLcLMinuitWrapper();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::MinuitFitter */
static int G__G__TMVA3_212_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::MinuitFitter*) G__getstructoffset())->Init();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_212_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::MinuitFitter*) G__getstructoffset())->EstimatorFunction(*(vector<Double_t>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_212_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::MinuitFitter::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_212_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::MinuitFitter::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_212_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::MinuitFitter::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_212_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::MinuitFitter::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_212_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::MinuitFitter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_212_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::MinuitFitter::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_212_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::MinuitFitter::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_212_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::MinuitFitter::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_212_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::MinuitFitter::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::MinuitFitter G__TTMVAcLcLMinuitFitter;
static int G__G__TMVA3_212_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::MinuitFitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::MinuitFitter*) (soff+(sizeof(TMVA::MinuitFitter)*i)))->~G__TTMVAcLcLMinuitFitter();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::MinuitFitter*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::MinuitFitter*) (soff))->~G__TTMVAcLcLMinuitFitter();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::PDEFoamCell */
static int G__G__TMVA3_320_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamCell* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamCell[n];
     } else {
       p = new((void*) gvp) TMVA::PDEFoamCell[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamCell;
     } else {
       p = new((void*) gvp) TMVA::PDEFoamCell;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamCell* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamCell((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TMVA::PDEFoamCell((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamCell* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamCell(*(TMVA::PDEFoamCell*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMVA::PDEFoamCell(*(TMVA::PDEFoamCell*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamCell*) G__getstructoffset())->Fill((Int_t) G__int(libp->para[0]), (TMVA::PDEFoamCell*) G__int(libp->para[1])
, (TMVA::PDEFoamCell*) G__int(libp->para[2]), (TMVA::PDEFoamCell*) G__int(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetXdiv());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetBest());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamCell*) G__getstructoffset())->SetBest((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamCell*) G__getstructoffset())->SetXdiv((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetHcub(*(TMVA::PDEFoamVect*) libp->para[0].ref, *(TMVA::PDEFoamVect*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetHSize(*(TMVA::PDEFoamVect*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamCell*) G__getstructoffset())->CalcVolume();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetVolume());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetIntg());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetDriv());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamCell*) G__getstructoffset())->SetIntg((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamCell*) G__getstructoffset())->SetDriv((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetStat());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamCell*) G__getstructoffset())->SetStat((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetPare());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetDau0());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetDau1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamCell*) G__getstructoffset())->SetDau0((TMVA::PDEFoamCell*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamCell*) G__getstructoffset())->SetDau1((TMVA::PDEFoamCell*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamCell*) G__getstructoffset())->SetPare((TMVA::PDEFoamCell*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamCell*) G__getstructoffset())->SetSerial((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetSerial());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TMVA::PDEFoamCell*) G__getstructoffset())->GetDepth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 104, (long) ((TMVA::PDEFoamCell*) G__getstructoffset())->GetTreeDepth((UInt_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 104, (long) ((TMVA::PDEFoamCell*) G__getstructoffset())->GetTreeDepth());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamCell*) G__getstructoffset())->SetElement((TObject*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetElement());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::PDEFoamCell::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamCell::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::PDEFoamCell::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::PDEFoamCell::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamCell*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamCell::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamCell::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamCell::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_320_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamCell::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::PDEFoamCell G__TTMVAcLcLPDEFoamCell;
static int G__G__TMVA3_320_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::PDEFoamCell*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::PDEFoamCell*) (soff+(sizeof(TMVA::PDEFoamCell)*i)))->~G__TTMVAcLcLPDEFoamCell();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::PDEFoamCell*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::PDEFoamCell*) (soff))->~G__TTMVAcLcLPDEFoamCell();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_320_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamCell* dest = (TMVA::PDEFoamCell*) G__getstructoffset();
   *dest = *(TMVA::PDEFoamCell*) libp->para[0].ref;
   const TMVA::PDEFoamCell& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::PDEFoamVect */
static int G__G__TMVA3_321_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamVect* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamVect[n];
     } else {
       p = new((void*) gvp) TMVA::PDEFoamVect[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamVect;
     } else {
       p = new((void*) gvp) TMVA::PDEFoamVect;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamVect* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamVect((Int_t) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TMVA::PDEFoamVect((Int_t) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamVect* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamVect(*(TMVA::PDEFoamVect*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMVA::PDEFoamVect(*(TMVA::PDEFoamVect*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::PDEFoamVect& obj = ((TMVA::PDEFoamVect*) G__getstructoffset())->operator=(*(TMVA::PDEFoamVect*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const Double_t& obj = ((TMVA::PDEFoamVect*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.d = (double) (obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::PDEFoamVect& obj = ((TMVA::PDEFoamVect*) G__getstructoffset())->operator=((Double_t*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::PDEFoamVect& obj = ((TMVA::PDEFoamVect*) G__getstructoffset())->operator=((Double_t) G__double(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::PDEFoamVect& obj = ((TMVA::PDEFoamVect*) G__getstructoffset())->operator+=(*(TMVA::PDEFoamVect*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::PDEFoamVect& obj = ((TMVA::PDEFoamVect*) G__getstructoffset())->operator-=(*(TMVA::PDEFoamVect*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::PDEFoamVect& obj = ((TMVA::PDEFoamVect*) G__getstructoffset())->operator*=(*(Double_t*) G__Doubleref(&libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMVA::PDEFoamVect* pobj;
         TMVA::PDEFoamVect xobj = ((TMVA::PDEFoamVect*) G__getstructoffset())->operator+(*(TMVA::PDEFoamVect*) libp->para[0].ref);
         pobj = new TMVA::PDEFoamVect(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TMVA::PDEFoamVect* pobj;
         TMVA::PDEFoamVect xobj = ((TMVA::PDEFoamVect*) G__getstructoffset())->operator-(*(TMVA::PDEFoamVect*) libp->para[0].ref);
         pobj = new TMVA::PDEFoamVect(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMVA::PDEFoamVect*) G__getstructoffset())->GetDim());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMVA::PDEFoamVect*) G__getstructoffset())->GetCoord((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::PDEFoamVect::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamVect::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::PDEFoamVect::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::PDEFoamVect::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamVect*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamVect::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamVect::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamVect::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_321_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamVect::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::PDEFoamVect G__TTMVAcLcLPDEFoamVect;
static int G__G__TMVA3_321_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::PDEFoamVect*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::PDEFoamVect*) (soff+(sizeof(TMVA::PDEFoamVect)*i)))->~G__TTMVAcLcLPDEFoamVect();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::PDEFoamVect*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::PDEFoamVect*) (soff))->~G__TTMVAcLcLPDEFoamVect();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::PDEFoamDensityBase */
static int G__G__TMVA3_322_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamDensityBase*) G__getstructoffset())->FillBinarySearchTree((TMVA::Event*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_322_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamDensityBase*) G__getstructoffset())->SetBox(*((vector<Double_t>*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_322_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Double_t>& obj = ((const TMVA::PDEFoamDensityBase*) G__getstructoffset())->GetBox();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_322_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::PDEFoamDensityBase*) G__getstructoffset())->Density(*(vector<Double_t>*) libp->para[0].ref, *(Double_t*) G__Doubleref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_322_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::PDEFoamDensityBase::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_322_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamDensityBase::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_322_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::PDEFoamDensityBase::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_322_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::PDEFoamDensityBase::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_322_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamDensityBase*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_322_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamDensityBase::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_322_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamDensityBase::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_322_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamDensityBase::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_322_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamDensityBase::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::PDEFoamDensityBase G__TTMVAcLcLPDEFoamDensityBase;
static int G__G__TMVA3_322_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::PDEFoamDensityBase*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::PDEFoamDensityBase*) (soff+(sizeof(TMVA::PDEFoamDensityBase)*i)))->~G__TTMVAcLcLPDEFoamDensityBase();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::PDEFoamDensityBase*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::PDEFoamDensityBase*) (soff))->~G__TTMVAcLcLPDEFoamDensityBase();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_322_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamDensityBase* dest = (TMVA::PDEFoamDensityBase*) G__getstructoffset();
   *dest = *(TMVA::PDEFoamDensityBase*) libp->para[0].ref;
   const TMVA::PDEFoamDensityBase& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::PDEFoamKernelBase */
static int G__G__TMVA3_323_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TMVA::PDEFoamKernelBase*) G__getstructoffset())->Estimate((TMVA::PDEFoam*) G__int(libp->para[0]), *(vector<Float_t>*) libp->para[1].ref
, (TMVA::ECellValue) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_323_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::MsgLogger& obj = ((const TMVA::PDEFoamKernelBase*) G__getstructoffset())->Log();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_323_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::PDEFoamKernelBase::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_323_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamKernelBase::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_323_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::PDEFoamKernelBase::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_323_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::PDEFoamKernelBase::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_323_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamKernelBase*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_323_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamKernelBase::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_323_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamKernelBase::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_323_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamKernelBase::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_323_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamKernelBase::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::PDEFoamKernelBase G__TTMVAcLcLPDEFoamKernelBase;
static int G__G__TMVA3_323_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::PDEFoamKernelBase*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::PDEFoamKernelBase*) (soff+(sizeof(TMVA::PDEFoamKernelBase)*i)))->~G__TTMVAcLcLPDEFoamKernelBase();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::PDEFoamKernelBase*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::PDEFoamKernelBase*) (soff))->~G__TTMVAcLcLPDEFoamKernelBase();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_323_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamKernelBase* dest = (TMVA::PDEFoamKernelBase*) G__getstructoffset();
   *dest = *(TMVA::PDEFoamKernelBase*) libp->para[0].ref;
   const TMVA::PDEFoamKernelBase& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::PDEFoam */
static int G__G__TMVA3_324_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoam* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoam[n];
     } else {
       p = new((void*) gvp) TMVA::PDEFoam[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoam;
     } else {
       p = new((void*) gvp) TMVA::PDEFoam;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoam* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoam(*(TString*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMVA::PDEFoam(*(TString*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->Initialize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->FillBinarySearchTree((TMVA::Event*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->Create();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->FillFoamCells((TMVA::Event*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->ResetCellElements();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->Finalize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->SetDim((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->SetnCells((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->SetnSampl((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->SetnBin((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->SetEvPerBin((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->SetInhiDiv((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->SetDensity((TMVA::PDEFoamDensityBase*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMVA::PDEFoam*) G__getstructoffset())->GetTotDim());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TMVA::PDEFoam*) G__getstructoffset())->GetFoamName();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TMVA::PDEFoam*) G__getstructoffset())->GetNActiveCells());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TMVA::PDEFoam*) G__getstructoffset())->GetNInActiveCells());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TMVA::PDEFoam*) G__getstructoffset())->GetNCells());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMVA::PDEFoam*) G__getstructoffset())->GetRootCell());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->SetNmin((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((TMVA::PDEFoam*) G__getstructoffset())->GetNmin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->SetMaxDepth((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TMVA::PDEFoam*) G__getstructoffset())->GetMaxDepth());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->SetXmin((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->SetXmax((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMVA::PDEFoam*) G__getstructoffset())->GetXmin((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMVA::PDEFoam*) G__getstructoffset())->GetXmax((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->AddVariableName((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->AddVariableName((TObjString*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TMVA::PDEFoam*) G__getstructoffset())->GetVariableName((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->DeleteBinarySearchTree();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::PDEFoam*) G__getstructoffset())->VarTransform((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Float_t>* pobj;
         const vector<Float_t> xobj = ((const TMVA::PDEFoam*) G__getstructoffset())->VarTransform(*(vector<Float_t>*) libp->para[0].ref);
         pobj = new vector<Float_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::PDEFoam*) G__getstructoffset())->VarTransformInvers((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Float_t>* pobj;
         const vector<Float_t> xobj = ((const TMVA::PDEFoam*) G__getstructoffset())->VarTransformInvers(*(vector<Float_t>*) libp->para[0].ref);
         pobj = new vector<Float_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->CheckAll((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TMVA::PDEFoam*) G__getstructoffset())->PrintCell((Long_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TMVA::PDEFoam*) G__getstructoffset())->PrintCell();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->PrintCells();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::MsgLogger& obj = ((const TMVA::PDEFoam*) G__getstructoffset())->Log();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      G__letint(result7, 85, (long) ((TMVA::PDEFoam*) G__getstructoffset())->Project2((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TMVA::ECellValue) G__int(libp->para[2]), (TMVA::PDEFoamKernelBase*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4])));
      break;
   case 4:
      G__letint(result7, 85, (long) ((TMVA::PDEFoam*) G__getstructoffset())->Project2((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TMVA::ECellValue) G__int(libp->para[2]), (TMVA::PDEFoamKernelBase*) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 85, (long) ((TMVA::PDEFoam*) G__getstructoffset())->Project2((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TMVA::ECellValue) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TMVA::PDEFoam*) G__getstructoffset())->Project2((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TMVA::PDEFoam*) G__getstructoffset())->Draw1Dim((TMVA::ECellValue) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (TMVA::PDEFoamKernelBase*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TMVA::PDEFoam*) G__getstructoffset())->Draw1Dim((TMVA::ECellValue) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TMVA::PDEFoam*) G__getstructoffset())->RootPlot2dim(*(TString*) libp->para[0].ref, *((TString*) G__int(libp->para[1]))
, (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TMVA::PDEFoam*) G__getstructoffset())->RootPlot2dim(*(TString*) libp->para[0].ref, *((TString*) G__int(libp->para[1]))
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TMVA::PDEFoam*) G__getstructoffset())->RootPlot2dim(*(TString*) libp->para[0].ref, *((TString*) G__int(libp->para[1])));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TMVA::PDEFoam*) G__getstructoffset())->GetCellValue(*(vector<Float_t>*) libp->para[0].ref, (TMVA::ECellValue) G__int(libp->para[1])
, (TMVA::PDEFoamKernelBase*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<Float_t>* pobj;
         vector<Float_t> xobj = ((TMVA::PDEFoam*) G__getstructoffset())->GetCellValue(*(map<Int_t,Float_t>*) libp->para[0].ref, (TMVA::ECellValue) G__int(libp->para[1]));
         pobj = new vector<Float_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TMVA::PDEFoam*) G__getstructoffset())->GetCellValue((TMVA::PDEFoamCell*) G__int(libp->para[0]), (TMVA::ECellValue) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::PDEFoam::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoam::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::PDEFoam::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::PDEFoam::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoam*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoam::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoam::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoam::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_324_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoam::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::PDEFoam G__TTMVAcLcLPDEFoam;
static int G__G__TMVA3_324_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::PDEFoam*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::PDEFoam*) (soff+(sizeof(TMVA::PDEFoam)*i)))->~G__TTMVAcLcLPDEFoam();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::PDEFoam*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::PDEFoam*) (soff))->~G__TTMVAcLcLPDEFoam();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_324_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoam* dest = (TMVA::PDEFoam*) G__getstructoffset();
   *dest = *(TMVA::PDEFoam*) libp->para[0].ref;
   const TMVA::PDEFoam& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::PDEFoamDiscriminant */
static int G__G__TMVA3_402_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamDiscriminant* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamDiscriminant[n];
     } else {
       p = new((void*) gvp) TMVA::PDEFoamDiscriminant[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamDiscriminant;
     } else {
       p = new((void*) gvp) TMVA::PDEFoamDiscriminant;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminant));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_402_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamDiscriminant* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamDiscriminant(*(TString*) libp->para[0].ref, (UInt_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMVA::PDEFoamDiscriminant(*(TString*) libp->para[0].ref, (UInt_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminant));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_402_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::PDEFoamDiscriminant::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_402_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamDiscriminant::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_402_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::PDEFoamDiscriminant::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_402_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::PDEFoamDiscriminant::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_402_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamDiscriminant*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_402_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamDiscriminant::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_402_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamDiscriminant::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_402_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamDiscriminant::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_402_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamDiscriminant::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::PDEFoamDiscriminant G__TTMVAcLcLPDEFoamDiscriminant;
static int G__G__TMVA3_402_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::PDEFoamDiscriminant*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::PDEFoamDiscriminant*) (soff+(sizeof(TMVA::PDEFoamDiscriminant)*i)))->~G__TTMVAcLcLPDEFoamDiscriminant();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::PDEFoamDiscriminant*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::PDEFoamDiscriminant*) (soff))->~G__TTMVAcLcLPDEFoamDiscriminant();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_402_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamDiscriminant* dest = (TMVA::PDEFoamDiscriminant*) G__getstructoffset();
   *dest = *(TMVA::PDEFoamDiscriminant*) libp->para[0].ref;
   const TMVA::PDEFoamDiscriminant& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::PDEFoamDecisionTree */
static int G__G__TMVA3_404_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamDecisionTree* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamDecisionTree[n];
     } else {
       p = new((void*) gvp) TMVA::PDEFoamDecisionTree[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamDecisionTree;
     } else {
       p = new((void*) gvp) TMVA::PDEFoamDecisionTree;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTree));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_404_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamDecisionTree* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamDecisionTree(
*(TString*) libp->para[0].ref, (TMVA::SeparationBase*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) TMVA::PDEFoamDecisionTree(
*(TString*) libp->para[0].ref, (TMVA::SeparationBase*) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTree));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_404_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::PDEFoamDecisionTree::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_404_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamDecisionTree::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_404_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::PDEFoamDecisionTree::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_404_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::PDEFoamDecisionTree::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_404_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamDecisionTree*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_404_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamDecisionTree::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_404_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamDecisionTree::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_404_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamDecisionTree::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_404_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamDecisionTree::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::PDEFoamDecisionTree G__TTMVAcLcLPDEFoamDecisionTree;
static int G__G__TMVA3_404_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::PDEFoamDecisionTree*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::PDEFoamDecisionTree*) (soff+(sizeof(TMVA::PDEFoamDecisionTree)*i)))->~G__TTMVAcLcLPDEFoamDecisionTree();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::PDEFoamDecisionTree*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::PDEFoamDecisionTree*) (soff))->~G__TTMVAcLcLPDEFoamDecisionTree();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_404_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamDecisionTree* dest = (TMVA::PDEFoamDecisionTree*) G__getstructoffset();
   *dest = *(TMVA::PDEFoamDecisionTree*) libp->para[0].ref;
   const TMVA::PDEFoamDecisionTree& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::PDEFoamDiscriminantDensity */
static int G__G__TMVA3_405_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamDiscriminantDensity* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamDiscriminantDensity[n];
     } else {
       p = new((void*) gvp) TMVA::PDEFoamDiscriminantDensity[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamDiscriminantDensity;
     } else {
       p = new((void*) gvp) TMVA::PDEFoamDiscriminantDensity;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminantDensity));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_405_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamDiscriminantDensity* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamDiscriminantDensity(*((vector<Double_t>*) G__int(libp->para[0])), (UInt_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMVA::PDEFoamDiscriminantDensity(*((vector<Double_t>*) G__int(libp->para[0])), (UInt_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminantDensity));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_405_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamDiscriminantDensity* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamDiscriminantDensity(*(TMVA::PDEFoamDiscriminantDensity*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMVA::PDEFoamDiscriminantDensity(*(TMVA::PDEFoamDiscriminantDensity*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminantDensity));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_405_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::PDEFoamDiscriminantDensity::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_405_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamDiscriminantDensity::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_405_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::PDEFoamDiscriminantDensity::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_405_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::PDEFoamDiscriminantDensity::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_405_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamDiscriminantDensity*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_405_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamDiscriminantDensity::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_405_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamDiscriminantDensity::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_405_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamDiscriminantDensity::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_405_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamDiscriminantDensity::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::PDEFoamDiscriminantDensity G__TTMVAcLcLPDEFoamDiscriminantDensity;
static int G__G__TMVA3_405_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::PDEFoamDiscriminantDensity*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::PDEFoamDiscriminantDensity*) (soff+(sizeof(TMVA::PDEFoamDiscriminantDensity)*i)))->~G__TTMVAcLcLPDEFoamDiscriminantDensity();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::PDEFoamDiscriminantDensity*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::PDEFoamDiscriminantDensity*) (soff))->~G__TTMVAcLcLPDEFoamDiscriminantDensity();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_405_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamDiscriminantDensity* dest = (TMVA::PDEFoamDiscriminantDensity*) G__getstructoffset();
   *dest = *(TMVA::PDEFoamDiscriminantDensity*) libp->para[0].ref;
   const TMVA::PDEFoamDiscriminantDensity& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::PDEFoamEventDensity */
static int G__G__TMVA3_406_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamEventDensity* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamEventDensity[n];
     } else {
       p = new((void*) gvp) TMVA::PDEFoamEventDensity[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamEventDensity;
     } else {
       p = new((void*) gvp) TMVA::PDEFoamEventDensity;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEventDensity));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_406_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamEventDensity* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamEventDensity(*((vector<Double_t>*) G__int(libp->para[0])));
   } else {
     p = new((void*) gvp) TMVA::PDEFoamEventDensity(*((vector<Double_t>*) G__int(libp->para[0])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEventDensity));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_406_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamEventDensity* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamEventDensity(*(TMVA::PDEFoamEventDensity*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMVA::PDEFoamEventDensity(*(TMVA::PDEFoamEventDensity*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEventDensity));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_406_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::PDEFoamEventDensity::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_406_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamEventDensity::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_406_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::PDEFoamEventDensity::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_406_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::PDEFoamEventDensity::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_406_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamEventDensity*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_406_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamEventDensity::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_406_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamEventDensity::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_406_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamEventDensity::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_406_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamEventDensity::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::PDEFoamEventDensity G__TTMVAcLcLPDEFoamEventDensity;
static int G__G__TMVA3_406_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::PDEFoamEventDensity*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::PDEFoamEventDensity*) (soff+(sizeof(TMVA::PDEFoamEventDensity)*i)))->~G__TTMVAcLcLPDEFoamEventDensity();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::PDEFoamEventDensity*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::PDEFoamEventDensity*) (soff))->~G__TTMVAcLcLPDEFoamEventDensity();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_406_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamEventDensity* dest = (TMVA::PDEFoamEventDensity*) G__getstructoffset();
   *dest = *(TMVA::PDEFoamEventDensity*) libp->para[0].ref;
   const TMVA::PDEFoamEventDensity& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::PDEFoamTargetDensity */
static int G__G__TMVA3_407_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamTargetDensity* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamTargetDensity[n];
     } else {
       p = new((void*) gvp) TMVA::PDEFoamTargetDensity[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamTargetDensity;
     } else {
       p = new((void*) gvp) TMVA::PDEFoamTargetDensity;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTargetDensity));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_407_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamTargetDensity* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamTargetDensity(*((vector<Double_t>*) G__int(libp->para[0])), (UInt_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMVA::PDEFoamTargetDensity(*((vector<Double_t>*) G__int(libp->para[0])), (UInt_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTargetDensity));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_407_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamTargetDensity* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamTargetDensity(*(TMVA::PDEFoamTargetDensity*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMVA::PDEFoamTargetDensity(*(TMVA::PDEFoamTargetDensity*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTargetDensity));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_407_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::PDEFoamTargetDensity::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_407_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamTargetDensity::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_407_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::PDEFoamTargetDensity::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_407_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::PDEFoamTargetDensity::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_407_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamTargetDensity*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_407_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamTargetDensity::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_407_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamTargetDensity::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_407_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamTargetDensity::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_407_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamTargetDensity::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::PDEFoamTargetDensity G__TTMVAcLcLPDEFoamTargetDensity;
static int G__G__TMVA3_407_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::PDEFoamTargetDensity*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::PDEFoamTargetDensity*) (soff+(sizeof(TMVA::PDEFoamTargetDensity)*i)))->~G__TTMVAcLcLPDEFoamTargetDensity();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::PDEFoamTargetDensity*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::PDEFoamTargetDensity*) (soff))->~G__TTMVAcLcLPDEFoamTargetDensity();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_407_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamTargetDensity* dest = (TMVA::PDEFoamTargetDensity*) G__getstructoffset();
   *dest = *(TMVA::PDEFoamTargetDensity*) libp->para[0].ref;
   const TMVA::PDEFoamTargetDensity& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::PDEFoamDecisionTreeDensity */
static int G__G__TMVA3_408_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamDecisionTreeDensity* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamDecisionTreeDensity[n];
     } else {
       p = new((void*) gvp) TMVA::PDEFoamDecisionTreeDensity[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamDecisionTreeDensity;
     } else {
       p = new((void*) gvp) TMVA::PDEFoamDecisionTreeDensity;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTreeDensity));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_408_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamDecisionTreeDensity* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamDecisionTreeDensity(*((vector<Double_t>*) G__int(libp->para[0])), (UInt_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMVA::PDEFoamDecisionTreeDensity(*((vector<Double_t>*) G__int(libp->para[0])), (UInt_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTreeDensity));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_408_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamDecisionTreeDensity* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamDecisionTreeDensity(*(TMVA::PDEFoamDecisionTreeDensity*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMVA::PDEFoamDecisionTreeDensity(*(TMVA::PDEFoamDecisionTreeDensity*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTreeDensity));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_408_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamDecisionTreeDensity*) G__getstructoffset())->FillHistograms(*(TMVA::Volume*) libp->para[0].ref, *(vector<TH1D*>*) libp->para[1].ref
, *(vector<TH1D*>*) libp->para[2].ref, *(vector<TH1D*>*) libp->para[3].ref
, *(vector<TH1D*>*) libp->para[4].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_408_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::PDEFoamDecisionTreeDensity::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_408_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamDecisionTreeDensity::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_408_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::PDEFoamDecisionTreeDensity::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_408_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::PDEFoamDecisionTreeDensity::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_408_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamDecisionTreeDensity*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_408_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamDecisionTreeDensity::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_408_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamDecisionTreeDensity::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_408_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamDecisionTreeDensity::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_408_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamDecisionTreeDensity::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::PDEFoamDecisionTreeDensity G__TTMVAcLcLPDEFoamDecisionTreeDensity;
static int G__G__TMVA3_408_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::PDEFoamDecisionTreeDensity*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::PDEFoamDecisionTreeDensity*) (soff+(sizeof(TMVA::PDEFoamDecisionTreeDensity)*i)))->~G__TTMVAcLcLPDEFoamDecisionTreeDensity();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::PDEFoamDecisionTreeDensity*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::PDEFoamDecisionTreeDensity*) (soff))->~G__TTMVAcLcLPDEFoamDecisionTreeDensity();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_408_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamDecisionTreeDensity* dest = (TMVA::PDEFoamDecisionTreeDensity*) G__getstructoffset();
   *dest = *(TMVA::PDEFoamDecisionTreeDensity*) libp->para[0].ref;
   const TMVA::PDEFoamDecisionTreeDensity& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::PDEFoamEvent */
static int G__G__TMVA3_413_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamEvent* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamEvent[n];
     } else {
       p = new((void*) gvp) TMVA::PDEFoamEvent[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamEvent;
     } else {
       p = new((void*) gvp) TMVA::PDEFoamEvent;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_413_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamEvent* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamEvent(*(TString*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMVA::PDEFoamEvent(*(TString*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_413_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::PDEFoamEvent::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_413_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamEvent::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_413_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::PDEFoamEvent::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_413_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::PDEFoamEvent::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_413_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_413_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamEvent::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_413_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamEvent::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_413_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamEvent::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_413_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamEvent::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::PDEFoamEvent G__TTMVAcLcLPDEFoamEvent;
static int G__G__TMVA3_413_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::PDEFoamEvent*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::PDEFoamEvent*) (soff+(sizeof(TMVA::PDEFoamEvent)*i)))->~G__TTMVAcLcLPDEFoamEvent();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::PDEFoamEvent*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::PDEFoamEvent*) (soff))->~G__TTMVAcLcLPDEFoamEvent();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_413_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamEvent* dest = (TMVA::PDEFoamEvent*) G__getstructoffset();
   *dest = *(TMVA::PDEFoamEvent*) libp->para[0].ref;
   const TMVA::PDEFoamEvent& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::PDEFoamMultiTarget */
static int G__G__TMVA3_415_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamMultiTarget* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamMultiTarget[n];
     } else {
       p = new((void*) gvp) TMVA::PDEFoamMultiTarget[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamMultiTarget;
     } else {
       p = new((void*) gvp) TMVA::PDEFoamMultiTarget;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamMultiTarget));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_415_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamMultiTarget* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamMultiTarget(*(TString*) libp->para[0].ref, (TMVA::ETargetSelection) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMVA::PDEFoamMultiTarget(*(TString*) libp->para[0].ref, (TMVA::ETargetSelection) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamMultiTarget));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_415_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::PDEFoamMultiTarget::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_415_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamMultiTarget::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_415_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::PDEFoamMultiTarget::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_415_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::PDEFoamMultiTarget::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_415_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamMultiTarget*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_415_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamMultiTarget::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_415_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamMultiTarget::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_415_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamMultiTarget::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_415_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamMultiTarget::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::PDEFoamMultiTarget G__TTMVAcLcLPDEFoamMultiTarget;
static int G__G__TMVA3_415_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::PDEFoamMultiTarget*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::PDEFoamMultiTarget*) (soff+(sizeof(TMVA::PDEFoamMultiTarget)*i)))->~G__TTMVAcLcLPDEFoamMultiTarget();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::PDEFoamMultiTarget*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::PDEFoamMultiTarget*) (soff))->~G__TTMVAcLcLPDEFoamMultiTarget();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_415_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamMultiTarget* dest = (TMVA::PDEFoamMultiTarget*) G__getstructoffset();
   *dest = *(TMVA::PDEFoamMultiTarget*) libp->para[0].ref;
   const TMVA::PDEFoamMultiTarget& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::PDEFoamTarget */
static int G__G__TMVA3_416_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamTarget* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamTarget[n];
     } else {
       p = new((void*) gvp) TMVA::PDEFoamTarget[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamTarget;
     } else {
       p = new((void*) gvp) TMVA::PDEFoamTarget;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTarget));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_416_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamTarget* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamTarget(*(TString*) libp->para[0].ref, (UInt_t) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMVA::PDEFoamTarget(*(TString*) libp->para[0].ref, (UInt_t) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTarget));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_416_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::PDEFoamTarget::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_416_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamTarget::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_416_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::PDEFoamTarget::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_416_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::PDEFoamTarget::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_416_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamTarget*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_416_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamTarget::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_416_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamTarget::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_416_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamTarget::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_416_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamTarget::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::PDEFoamTarget G__TTMVAcLcLPDEFoamTarget;
static int G__G__TMVA3_416_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::PDEFoamTarget*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::PDEFoamTarget*) (soff+(sizeof(TMVA::PDEFoamTarget)*i)))->~G__TTMVAcLcLPDEFoamTarget();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::PDEFoamTarget*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::PDEFoamTarget*) (soff))->~G__TTMVAcLcLPDEFoamTarget();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_416_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamTarget* dest = (TMVA::PDEFoamTarget*) G__getstructoffset();
   *dest = *(TMVA::PDEFoamTarget*) libp->para[0].ref;
   const TMVA::PDEFoamTarget& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::PDEFoamKernelTrivial */
static int G__G__TMVA3_417_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamKernelTrivial* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamKernelTrivial[n];
     } else {
       p = new((void*) gvp) TMVA::PDEFoamKernelTrivial[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamKernelTrivial;
     } else {
       p = new((void*) gvp) TMVA::PDEFoamKernelTrivial;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelTrivial));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_417_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamKernelTrivial* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamKernelTrivial(*(TMVA::PDEFoamKernelTrivial*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMVA::PDEFoamKernelTrivial(*(TMVA::PDEFoamKernelTrivial*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelTrivial));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_417_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::PDEFoamKernelTrivial::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_417_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamKernelTrivial::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_417_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::PDEFoamKernelTrivial::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_417_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::PDEFoamKernelTrivial::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_417_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamKernelTrivial*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_417_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamKernelTrivial::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_417_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamKernelTrivial::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_417_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamKernelTrivial::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_417_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamKernelTrivial::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::PDEFoamKernelTrivial G__TTMVAcLcLPDEFoamKernelTrivial;
static int G__G__TMVA3_417_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::PDEFoamKernelTrivial*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::PDEFoamKernelTrivial*) (soff+(sizeof(TMVA::PDEFoamKernelTrivial)*i)))->~G__TTMVAcLcLPDEFoamKernelTrivial();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::PDEFoamKernelTrivial*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::PDEFoamKernelTrivial*) (soff))->~G__TTMVAcLcLPDEFoamKernelTrivial();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_417_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamKernelTrivial* dest = (TMVA::PDEFoamKernelTrivial*) G__getstructoffset();
   *dest = *(TMVA::PDEFoamKernelTrivial*) libp->para[0].ref;
   const TMVA::PDEFoamKernelTrivial& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::PDEFoamKernelLinN */
static int G__G__TMVA3_418_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamKernelLinN* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamKernelLinN[n];
     } else {
       p = new((void*) gvp) TMVA::PDEFoamKernelLinN[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDEFoamKernelLinN;
     } else {
       p = new((void*) gvp) TMVA::PDEFoamKernelLinN;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelLinN));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_418_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamKernelLinN* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamKernelLinN(*(TMVA::PDEFoamKernelLinN*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMVA::PDEFoamKernelLinN(*(TMVA::PDEFoamKernelLinN*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelLinN));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_418_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::PDEFoamKernelLinN::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_418_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamKernelLinN::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_418_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::PDEFoamKernelLinN::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_418_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::PDEFoamKernelLinN::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_418_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamKernelLinN*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_418_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamKernelLinN::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_418_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamKernelLinN::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_418_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamKernelLinN::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_418_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamKernelLinN::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::PDEFoamKernelLinN G__TTMVAcLcLPDEFoamKernelLinN;
static int G__G__TMVA3_418_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::PDEFoamKernelLinN*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::PDEFoamKernelLinN*) (soff+(sizeof(TMVA::PDEFoamKernelLinN)*i)))->~G__TTMVAcLcLPDEFoamKernelLinN();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::PDEFoamKernelLinN*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::PDEFoamKernelLinN*) (soff))->~G__TTMVAcLcLPDEFoamKernelLinN();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_418_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamKernelLinN* dest = (TMVA::PDEFoamKernelLinN*) G__getstructoffset();
   *dest = *(TMVA::PDEFoamKernelLinN*) libp->para[0].ref;
   const TMVA::PDEFoamKernelLinN& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::PDEFoamKernelGauss */
static int G__G__TMVA3_419_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamKernelGauss* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamKernelGauss((Float_t) G__double(libp->para[0]));
   } else {
     p = new((void*) gvp) TMVA::PDEFoamKernelGauss((Float_t) G__double(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelGauss));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_419_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamKernelGauss* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::PDEFoamKernelGauss(*(TMVA::PDEFoamKernelGauss*) libp->para[0].ref);
   } else {
     p = new((void*) gvp) TMVA::PDEFoamKernelGauss(*(TMVA::PDEFoamKernelGauss*) libp->para[0].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelGauss));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_419_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::PDEFoamKernelGauss::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_419_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamKernelGauss::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_419_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::PDEFoamKernelGauss::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_419_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::PDEFoamKernelGauss::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_419_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::PDEFoamKernelGauss*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_419_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamKernelGauss::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_419_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamKernelGauss::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_419_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::PDEFoamKernelGauss::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_419_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::PDEFoamKernelGauss::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::PDEFoamKernelGauss G__TTMVAcLcLPDEFoamKernelGauss;
static int G__G__TMVA3_419_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::PDEFoamKernelGauss*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::PDEFoamKernelGauss*) (soff+(sizeof(TMVA::PDEFoamKernelGauss)*i)))->~G__TTMVAcLcLPDEFoamKernelGauss();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::PDEFoamKernelGauss*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::PDEFoamKernelGauss*) (soff))->~G__TTMVAcLcLPDEFoamKernelGauss();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_419_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDEFoamKernelGauss* dest = (TMVA::PDEFoamKernelGauss*) G__getstructoffset();
   *dest = *(TMVA::PDEFoamKernelGauss*) libp->para[0].ref;
   const TMVA::PDEFoamKernelGauss& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::BDTEventWrapper */
static int G__G__TMVA3_420_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::BDTEventWrapper* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 1
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::BDTEventWrapper((TMVA::Event*) G__int(libp->para[0]));
   } else {
     p = new((void*) gvp) TMVA::BDTEventWrapper((TMVA::Event*) G__int(libp->para[0]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLBDTEventWrapper));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_420_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMVA::BDTEventWrapper*) G__getstructoffset())->operator<(*(TMVA::BDTEventWrapper*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_420_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::BDTEventWrapper*) G__getstructoffset())->SetCumulativeWeight((Bool_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_420_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMVA::BDTEventWrapper*) G__getstructoffset())->GetCumulativeWeight((Bool_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_420_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::BDTEventWrapper::SetVarIndex((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_420_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMVA::BDTEventWrapper*) G__getstructoffset())->GetVal());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_420_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMVA::BDTEventWrapper*) G__getstructoffset())->operator*());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__TMVA3_420_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMVA::BDTEventWrapper* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMVA::BDTEventWrapper(*(TMVA::BDTEventWrapper*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLBDTEventWrapper));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::BDTEventWrapper G__TTMVAcLcLBDTEventWrapper;
static int G__G__TMVA3_420_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::BDTEventWrapper*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::BDTEventWrapper*) (soff+(sizeof(TMVA::BDTEventWrapper)*i)))->~G__TTMVAcLcLBDTEventWrapper();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::BDTEventWrapper*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::BDTEventWrapper*) (soff))->~G__TTMVAcLcLBDTEventWrapper();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::CCTreeWrapper */
static int G__G__TMVA3_531_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::CCTreeWrapper* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::CCTreeWrapper((TMVA::DecisionTree*) G__int(libp->para[0]), (TMVA::SeparationBase*) G__int(libp->para[1]));
   } else {
     p = new((void*) gvp) TMVA::CCTreeWrapper((TMVA::DecisionTree*) G__int(libp->para[0]), (TMVA::SeparationBase*) G__int(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrapper));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_531_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((TMVA::CCTreeWrapper*) G__getstructoffset())->CheckEvent(*(TMVA::Event*) libp->para[0].ref, (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((TMVA::CCTreeWrapper*) G__getstructoffset())->CheckEvent(*(TMVA::Event*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_531_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::CCTreeWrapper*) G__getstructoffset())->TestTreeQuality((TMVA::CCTreeWrapper::EventList*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_531_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::CCTreeWrapper*) G__getstructoffset())->TestTreeQuality((TMVA::DataSet*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_531_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::CCTreeWrapper*) G__getstructoffset())->PruneNode((TMVA::CCTreeWrapper::CCTreeNode*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_531_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::CCTreeWrapper*) G__getstructoffset())->InitTree((TMVA::CCTreeWrapper::CCTreeNode*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_531_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TMVA::CCTreeWrapper*) G__getstructoffset())->GetRoot());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__TMVA3_531_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMVA::CCTreeWrapper* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMVA::CCTreeWrapper(*(TMVA::CCTreeWrapper*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrapper));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::CCTreeWrapper G__TTMVAcLcLCCTreeWrapper;
static int G__G__TMVA3_531_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::CCTreeWrapper*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::CCTreeWrapper*) (soff+(sizeof(TMVA::CCTreeWrapper)*i)))->~G__TTMVAcLcLCCTreeWrapper();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::CCTreeWrapper*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::CCTreeWrapper*) (soff))->~G__TTMVAcLcLCCTreeWrapper();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_531_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::CCTreeWrapper* dest = (TMVA::CCTreeWrapper*) G__getstructoffset();
   *dest = *(TMVA::CCTreeWrapper*) libp->para[0].ref;
   const TMVA::CCTreeWrapper& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::CCPruner */
static int G__G__TMVA3_533_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::CCPruner* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::CCPruner(
(TMVA::DecisionTree*) G__int(libp->para[0]), (TMVA::CCPruner::EventList*) G__int(libp->para[1])
, (TMVA::SeparationBase*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::CCPruner(
(TMVA::DecisionTree*) G__int(libp->para[0]), (TMVA::CCPruner::EventList*) G__int(libp->para[1])
, (TMVA::SeparationBase*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::CCPruner((TMVA::DecisionTree*) G__int(libp->para[0]), (TMVA::CCPruner::EventList*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMVA::CCPruner((TMVA::DecisionTree*) G__int(libp->para[0]), (TMVA::CCPruner::EventList*) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCPruner));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_533_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::CCPruner* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::CCPruner(
(TMVA::DecisionTree*) G__int(libp->para[0]), (TMVA::DataSet*) G__int(libp->para[1])
, (TMVA::SeparationBase*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::CCPruner(
(TMVA::DecisionTree*) G__int(libp->para[0]), (TMVA::DataSet*) G__int(libp->para[1])
, (TMVA::SeparationBase*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::CCPruner((TMVA::DecisionTree*) G__int(libp->para[0]), (TMVA::DataSet*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMVA::CCPruner((TMVA::DecisionTree*) G__int(libp->para[0]), (TMVA::DataSet*) G__int(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCPruner));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_533_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TMVA::CCPruner*) G__getstructoffset())->SetPruneStrength((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TMVA::CCPruner*) G__getstructoffset())->SetPruneStrength();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_533_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::CCPruner*) G__getstructoffset())->Optimize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_533_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TMVA::DecisionTreeNode*>* pobj;
         const vector<TMVA::DecisionTreeNode*> xobj = ((const TMVA::CCPruner*) G__getstructoffset())->GetOptimalPruneSequence();
         pobj = new vector<TMVA::DecisionTreeNode*>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_533_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::CCPruner*) G__getstructoffset())->GetOptimalQualityIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_533_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::CCPruner*) G__getstructoffset())->GetOptimalPruneStrength());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__TMVA3_533_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMVA::CCPruner* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMVA::CCPruner(*(TMVA::CCPruner*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCPruner));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::CCPruner G__TTMVAcLcLCCPruner;
static int G__G__TMVA3_533_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::CCPruner*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::CCPruner*) (soff+(sizeof(TMVA::CCPruner)*i)))->~G__TTMVAcLcLCCPruner();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::CCPruner*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::CCPruner*) (soff))->~G__TTMVAcLcLCCPruner();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::CostComplexityPruneTool */
static int G__G__TMVA3_541_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::CostComplexityPruneTool* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::CostComplexityPruneTool((TMVA::SeparationBase*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TMVA::CostComplexityPruneTool((TMVA::SeparationBase*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TMVA::CostComplexityPruneTool[n];
       } else {
         p = new((void*) gvp) TMVA::CostComplexityPruneTool[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TMVA::CostComplexityPruneTool;
       } else {
         p = new((void*) gvp) TMVA::CostComplexityPruneTool;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__TMVA3_541_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMVA::CostComplexityPruneTool* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMVA::CostComplexityPruneTool(*(TMVA::CostComplexityPruneTool*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::CostComplexityPruneTool G__TTMVAcLcLCostComplexityPruneTool;
static int G__G__TMVA3_541_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::CostComplexityPruneTool*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::CostComplexityPruneTool*) (soff+(sizeof(TMVA::CostComplexityPruneTool)*i)))->~G__TTMVAcLcLCostComplexityPruneTool();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::CostComplexityPruneTool*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::CostComplexityPruneTool*) (soff))->~G__TTMVAcLcLCostComplexityPruneTool();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic assignment operator
static int G__G__TMVA3_541_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::CostComplexityPruneTool* dest = (TMVA::CostComplexityPruneTool*) G__getstructoffset();
   *dest = *(TMVA::CostComplexityPruneTool*) libp->para[0].ref;
   const TMVA::CostComplexityPruneTool& obj = *dest;
   result7->ref = (long) (&obj);
   result7->obj.i = (long) (&obj);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::SVEvent */
static int G__G__TMVA3_542_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::SVEvent* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::SVEvent[n];
     } else {
       p = new((void*) gvp) TMVA::SVEvent[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::SVEvent;
     } else {
       p = new((void*) gvp) TMVA::SVEvent;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::SVEvent* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::SVEvent(
(TMVA::Event*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::SVEvent(
(TMVA::Event*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::SVEvent((TMVA::Event*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1]));
     } else {
       p = new((void*) gvp) TMVA::SVEvent((TMVA::Event*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::SVEvent* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::SVEvent(
(vector<Float_t>*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TMVA::SVEvent(
(vector<Float_t>*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::SVEvent* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::SVEvent(
(vector<Float_t>*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3]));
   } else {
     p = new((void*) gvp) TMVA::SVEvent(
(vector<Float_t>*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Float_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::SVEvent*) G__getstructoffset())->SetAlpha((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::SVEvent*) G__getstructoffset())->SetAlpha_p((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::SVEvent*) G__getstructoffset())->SetErrorCache((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::SVEvent*) G__getstructoffset())->SetIsShrinked((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::SVEvent*) G__getstructoffset())->SetLine((Float_t*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::SVEvent*) G__getstructoffset())->SetIdx((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::SVEvent*) G__getstructoffset())->SetNs((UInt_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::SVEvent*) G__getstructoffset())->UpdateErrorCache((Float_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TMVA::SVEvent*) G__getstructoffset())->GetDataVector());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::SVEvent*) G__getstructoffset())->GetAlpha());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::SVEvent*) G__getstructoffset())->GetAlpha_p());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::SVEvent*) G__getstructoffset())->GetDeltaAlpha());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::SVEvent*) G__getstructoffset())->GetErrorCache());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMVA::SVEvent*) G__getstructoffset())->GetTypeFlag());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMVA::SVEvent*) G__getstructoffset())->GetNVar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMVA::SVEvent*) G__getstructoffset())->GetIdx());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 70, (long) ((const TMVA::SVEvent*) G__getstructoffset())->GetLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TMVA::SVEvent*) G__getstructoffset())->GetNs());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::SVEvent*) G__getstructoffset())->GetCweight());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::SVEvent*) G__getstructoffset())->GetTarget());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMVA::SVEvent*) G__getstructoffset())->IsInI0a());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMVA::SVEvent*) G__getstructoffset())->IsInI0b());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMVA::SVEvent*) G__getstructoffset())->IsInI0());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMVA::SVEvent*) G__getstructoffset())->IsInI1());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMVA::SVEvent*) G__getstructoffset())->IsInI2());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMVA::SVEvent*) G__getstructoffset())->IsInI3());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TMVA::SVEvent*) G__getstructoffset())->Print(*(ostream*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::SVEvent*) G__getstructoffset())->PrintData();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::SVEvent::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::SVEvent::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::SVEvent::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::SVEvent::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMVA::SVEvent*) G__getstructoffset())->IsA());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::SVEvent*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::SVEvent*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::SVEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::SVEvent::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::SVEvent::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::SVEvent::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_542_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::SVEvent::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__TMVA3_542_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMVA::SVEvent* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMVA::SVEvent(*(TMVA::SVEvent*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::SVEvent G__TTMVAcLcLSVEvent;
static int G__G__TMVA3_542_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::SVEvent*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::SVEvent*) (soff+(sizeof(TMVA::SVEvent)*i)))->~G__TTMVAcLcLSVEvent();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::SVEvent*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::SVEvent*) (soff))->~G__TTMVAcLcLSVEvent();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::OptimizeConfigParameters */
static int G__G__TMVA3_586_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::OptimizeConfigParameters* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::OptimizeConfigParameters(
(TMVA::MethodBase*) G__int(libp->para[0]), *((map<TString,TMVA::Interval*>*) G__int(libp->para[1]))
, *((TString*) G__int(libp->para[2])), *((TString*) G__int(libp->para[3])));
     } else {
       p = new((void*) gvp) TMVA::OptimizeConfigParameters(
(TMVA::MethodBase*) G__int(libp->para[0]), *((map<TString,TMVA::Interval*>*) G__int(libp->para[1]))
, *((TString*) G__int(libp->para[2])), *((TString*) G__int(libp->para[3])));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::OptimizeConfigParameters(
(TMVA::MethodBase*) G__int(libp->para[0]), *((map<TString,TMVA::Interval*>*) G__int(libp->para[1]))
, *((TString*) G__int(libp->para[2])));
     } else {
       p = new((void*) gvp) TMVA::OptimizeConfigParameters(
(TMVA::MethodBase*) G__int(libp->para[0]), *((map<TString,TMVA::Interval*>*) G__int(libp->para[1]))
, *((TString*) G__int(libp->para[2])));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::OptimizeConfigParameters((TMVA::MethodBase*) G__int(libp->para[0]), *((map<TString,TMVA::Interval*>*) G__int(libp->para[1])));
     } else {
       p = new((void*) gvp) TMVA::OptimizeConfigParameters((TMVA::MethodBase*) G__int(libp->para[0]), *((map<TString,TMVA::Interval*>*) G__int(libp->para[1])));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_586_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         map<TString,Double_t>* pobj;
         map<TString,Double_t> xobj = ((TMVA::OptimizeConfigParameters*) G__getstructoffset())->optimize();
         pobj = new map<TString,Double_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_586_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::OptimizeConfigParameters::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_586_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::OptimizeConfigParameters::Class_Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_586_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) TMVA::OptimizeConfigParameters::Class_Version());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_586_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      TMVA::OptimizeConfigParameters::Dictionary();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_586_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::OptimizeConfigParameters*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_586_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::OptimizeConfigParameters::DeclFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_586_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::OptimizeConfigParameters::ImplFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_586_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) TMVA::OptimizeConfigParameters::ImplFileName());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA3_586_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) TMVA::OptimizeConfigParameters::DeclFileLine());
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic copy constructor
static int G__G__TMVA3_586_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)

{
   TMVA::OptimizeConfigParameters* p;
   void* tmp = (void*) G__int(libp->para[0]);
   p = new TMVA::OptimizeConfigParameters(*(TMVA::OptimizeConfigParameters*) tmp);
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters));
   return(1 || funcname || hash || result7 || libp) ;
}

// automatic destructor
typedef TMVA::OptimizeConfigParameters G__TTMVAcLcLOptimizeConfigParameters;
static int G__G__TMVA3_586_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   char* gvp = (char*) G__getgvp();
   long soff = G__getstructoffset();
   int n = G__getaryconstruct();
   //
   //has_a_delete: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::OptimizeConfigParameters*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::OptimizeConfigParameters*) (soff+(sizeof(TMVA::OptimizeConfigParameters)*i)))->~G__TTMVAcLcLOptimizeConfigParameters();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::OptimizeConfigParameters*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::OptimizeConfigParameters*) (soff))->~G__TTMVAcLcLOptimizeConfigParameters();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* TMVA */

/* TMVA::Config */

/* TMVA::Config::VariablePlotting */

/* TMVA::Config::IONames */

/* TMVA::KDEKernel */

/* TMVA::Interval */

/* TMVA::LogInterval */

/* TMVA::IFitterTarget */

/* TMVA::FitterBase */

/* TMVA::MCFitter */

/* TMVA::GeneticFitter */

/* TMVA::SimulatedAnnealingFitter */

/* TMVA::MinuitWrapper */

/* TMVA::MinuitFitter */

/* TMVA::PDEFoamCell */

/* TMVA::PDEFoamVect */

/* TMVA::PDEFoamDensityBase */

/* TMVA::PDEFoamKernelBase */

/* TMVA::PDEFoam */

/* TMVA::PDEFoamDiscriminant */

/* TMVA::PDEFoamDecisionTree */

/* TMVA::PDEFoamDiscriminantDensity */

/* TMVA::PDEFoamEventDensity */

/* TMVA::PDEFoamTargetDensity */

/* TMVA::PDEFoamDecisionTreeDensity */

/* TMVA::PDEFoamEvent */

/* TMVA::PDEFoamMultiTarget */

/* TMVA::PDEFoamTarget */

/* TMVA::PDEFoamKernelTrivial */

/* TMVA::PDEFoamKernelLinN */

/* TMVA::PDEFoamKernelGauss */

/* TMVA::BDTEventWrapper */

/* TMVA::CCTreeWrapper */

/* TMVA::CCPruner */

/* TMVA::CostComplexityPruneTool */

/* TMVA::SVEvent */

/* TMVA::OptimizeConfigParameters */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__TMVA3 {
 public:
  G__Sizep2memfuncG__TMVA3(): p(&G__Sizep2memfuncG__TMVA3::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__TMVA3::*p)();
};

size_t G__get_sizep2memfuncG__TMVA3()
{
  G__Sizep2memfuncG__TMVA3 a;
  G__setsizep2memfunc((int)a.sizep2memfunc());
  return((size_t)a.sizep2memfunc());
}


/*********************************************************
* virtual base class offset calculation interface
*********************************************************/

   /* Setting up class inheritance */

/*********************************************************
* Inheritance information setup/
*********************************************************/
extern "C" void G__cpp_setup_inheritanceG__TMVA3() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLLogInterval))) {
     TMVA::LogInterval *G__Lderived;
     G__Lderived=(TMVA::LogInterval*)0x1000;
     {
       TMVA::Interval *G__Lpbase=(TMVA::Interval*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLLogInterval),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLInterval),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLFitterBase))) {
     TMVA::FitterBase *G__Lderived;
     G__Lderived=(TMVA::FitterBase*)0x1000;
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLFitterBase),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLFitterBase),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMCFitter))) {
     TMVA::MCFitter *G__Lderived;
     G__Lderived=(TMVA::MCFitter*)0x1000;
     {
       TMVA::FitterBase *G__Lpbase=(TMVA::FitterBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMCFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLFitterBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMCFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMCFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLGeneticFitter))) {
     TMVA::GeneticFitter *G__Lderived;
     G__Lderived=(TMVA::GeneticFitter*)0x1000;
     {
       TMVA::FitterBase *G__Lpbase=(TMVA::FitterBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLGeneticFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLFitterBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLGeneticFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLGeneticFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter))) {
     TMVA::SimulatedAnnealingFitter *G__Lderived;
     G__Lderived=(TMVA::SimulatedAnnealingFitter*)0x1000;
     {
       TMVA::FitterBase *G__Lpbase=(TMVA::FitterBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLFitterBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitWrapper))) {
     TMVA::MinuitWrapper *G__Lderived;
     G__Lderived=(TMVA::MinuitWrapper*)0x1000;
     {
       TMinuit *G__Lpbase=(TMinuit*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitWrapper),G__get_linked_tagnum(&G__G__TMVA3LN_TMinuit),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitWrapper),G__get_linked_tagnum(&G__G__TMVA3LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitWrapper),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitFitter))) {
     TMVA::MinuitFitter *G__Lderived;
     G__Lderived=(TMVA::MinuitFitter*)0x1000;
     {
       TMVA::FitterBase *G__Lpbase=(TMVA::FitterBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLFitterBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TMVA::IFitterTarget *G__Lpbase=(TMVA::IFitterTarget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLIFitterTarget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMinuit))) {
     TMinuit *G__Lderived;
     G__Lderived=(TMinuit*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMinuit),G__get_linked_tagnum(&G__G__TMVA3LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMinuit),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell))) {
     TMVA::PDEFoamCell *G__Lderived;
     G__Lderived=(TMVA::PDEFoamCell*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect))) {
     TMVA::PDEFoamVect *G__Lderived;
     G__Lderived=(TMVA::PDEFoamVect*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDensityBase))) {
     TMVA::PDEFoamDensityBase *G__Lderived;
     G__Lderived=(TMVA::PDEFoamDensityBase*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDensityBase),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelBase))) {
     TMVA::PDEFoamKernelBase *G__Lderived;
     G__Lderived=(TMVA::PDEFoamKernelBase*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelBase),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam))) {
     TMVA::PDEFoam *G__Lderived;
     G__Lderived=(TMVA::PDEFoam*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminant))) {
     TMVA::PDEFoamDiscriminant *G__Lderived;
     G__Lderived=(TMVA::PDEFoamDiscriminant*)0x1000;
     {
       TMVA::PDEFoam *G__Lpbase=(TMVA::PDEFoam*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminant),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminant),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTree))) {
     TMVA::PDEFoamDecisionTree *G__Lderived;
     G__Lderived=(TMVA::PDEFoamDecisionTree*)0x1000;
     {
       TMVA::PDEFoamDiscriminant *G__Lpbase=(TMVA::PDEFoamDiscriminant*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTree),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminant),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TMVA::PDEFoam *G__Lpbase=(TMVA::PDEFoam*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTree),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTree),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminantDensity))) {
     TMVA::PDEFoamDiscriminantDensity *G__Lderived;
     G__Lderived=(TMVA::PDEFoamDiscriminantDensity*)0x1000;
     {
       TMVA::PDEFoamDensityBase *G__Lpbase=(TMVA::PDEFoamDensityBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminantDensity),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDensityBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminantDensity),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEventDensity))) {
     TMVA::PDEFoamEventDensity *G__Lderived;
     G__Lderived=(TMVA::PDEFoamEventDensity*)0x1000;
     {
       TMVA::PDEFoamDensityBase *G__Lpbase=(TMVA::PDEFoamDensityBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEventDensity),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDensityBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEventDensity),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTargetDensity))) {
     TMVA::PDEFoamTargetDensity *G__Lderived;
     G__Lderived=(TMVA::PDEFoamTargetDensity*)0x1000;
     {
       TMVA::PDEFoamDensityBase *G__Lpbase=(TMVA::PDEFoamDensityBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTargetDensity),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDensityBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTargetDensity),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTreeDensity))) {
     TMVA::PDEFoamDecisionTreeDensity *G__Lderived;
     G__Lderived=(TMVA::PDEFoamDecisionTreeDensity*)0x1000;
     {
       TMVA::PDEFoamDensityBase *G__Lpbase=(TMVA::PDEFoamDensityBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTreeDensity),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDensityBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTreeDensity),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEvent))) {
     TMVA::PDEFoamEvent *G__Lderived;
     G__Lderived=(TMVA::PDEFoamEvent*)0x1000;
     {
       TMVA::PDEFoam *G__Lpbase=(TMVA::PDEFoam*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEvent),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEvent),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamMultiTarget))) {
     TMVA::PDEFoamMultiTarget *G__Lderived;
     G__Lderived=(TMVA::PDEFoamMultiTarget*)0x1000;
     {
       TMVA::PDEFoamEvent *G__Lpbase=(TMVA::PDEFoamEvent*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamMultiTarget),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEvent),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TMVA::PDEFoam *G__Lpbase=(TMVA::PDEFoam*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamMultiTarget),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamMultiTarget),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTarget))) {
     TMVA::PDEFoamTarget *G__Lderived;
     G__Lderived=(TMVA::PDEFoamTarget*)0x1000;
     {
       TMVA::PDEFoam *G__Lpbase=(TMVA::PDEFoam*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTarget),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTarget),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelTrivial))) {
     TMVA::PDEFoamKernelTrivial *G__Lderived;
     G__Lderived=(TMVA::PDEFoamKernelTrivial*)0x1000;
     {
       TMVA::PDEFoamKernelBase *G__Lpbase=(TMVA::PDEFoamKernelBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelTrivial),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelTrivial),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelLinN))) {
     TMVA::PDEFoamKernelLinN *G__Lderived;
     G__Lderived=(TMVA::PDEFoamKernelLinN*)0x1000;
     {
       TMVA::PDEFoamKernelBase *G__Lpbase=(TMVA::PDEFoamKernelBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelLinN),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelLinN),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelGauss))) {
     TMVA::PDEFoamKernelGauss *G__Lderived;
     G__Lderived=(TMVA::PDEFoamKernelGauss*)0x1000;
     {
       TMVA::PDEFoamKernelBase *G__Lpbase=(TMVA::PDEFoamKernelBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelGauss),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelGauss),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool))) {
     TMVA::CostComplexityPruneTool *G__Lderived;
     G__Lderived=(TMVA::CostComplexityPruneTool*)0x1000;
     {
       TMVA::IPruneTool *G__Lpbase=(TMVA::IPruneTool*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLIPruneTool),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters))) {
     TMVA::OptimizeConfigParameters *G__Lderived;
     G__Lderived=(TMVA::OptimizeConfigParameters*)0x1000;
     {
       TMVA::IFitterTarget *G__Lpbase=(TMVA::IFitterTarget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLIFitterTarget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__TMVA3() {

   /* Setting up typedef entry */
   G__search_typename2("Int_t",105,-1,0,-1);
   G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
   G__search_typename2("UInt_t",104,-1,0,-1);
   G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
   G__search_typename2("Long_t",108,-1,0,-1);
   G__setnewtype(-1,"Signed long integer 8 bytes (long)",0);
   G__search_typename2("Float_t",102,-1,0,-1);
   G__setnewtype(-1,"Float 4 bytes (float)",0);
   G__search_typename2("Double_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes",0);
   G__search_typename2("Bool_t",103,-1,0,-1);
   G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__TMVA3LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__TMVA3LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__G__TMVA3LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__G__TMVA3LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMVAVersion_t",104,-1,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVA));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,TMVA::Types::EMVA>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,TMVA::Types::EMVA,less<TString> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<EMsgType,std::string>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TMVA::EMsgType,string>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TMVA::EMsgType,string,less<TMVA::EMsgType> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Option<Bool_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptionlEboolgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVA));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<bool>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEboolcOallocatorlEboolgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Option<Bool_t*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptionlEboolmUgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVA));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Option<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptionlEfloatgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVA));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<float>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::Interval*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<double>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTBaselEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTBaselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const TMVA::BinarySearchTreeNode*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::Event*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Int_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Double_t,const TMVA::Event*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::pair<Double_t,const TMVA::Event*> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<Double_t,const TMVA::Event*> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<double,const TMVA::Event*> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Float_t*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<float*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::PDEFoamCell*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<Int_t,Float_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplEintcOfloatcOlesslEintgRcOallocatorlEpairlEconstsPintcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,float>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplEintcOfloatcOlesslEintgRcOallocatorlEpairlEconstsPintcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,float,less<int> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplEintcOfloatcOlesslEintgRcOallocatorlEpairlEconstsPintcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<PDEFoamCell*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TH1D*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETH1DmUcOallocatorlETH1DmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETH1DmUcOallocatorlETH1DmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETH1DmUcOallocatorlETH1DmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETH1DmUcOallocatorlETH1DmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETH1DmUcOallocatorlETH1DmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,TObjArray*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*,less<string> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<VariableInfo>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::VariableInfo>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<ClassInfo*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::ClassInfo*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const TMVA::Event*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<Event*>*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<Event*>*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<TMVA::Event*,allocator<TMVA::Event*> >*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,Results*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,TMVA::Results*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,TMVA::Results*,less<TString> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::map<TString,Results*> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<map<TString,Results*> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<map<TString,TMVA::Results*,less<TString>,allocator<pair<const TString,TMVA::Results*> > > >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Char_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEcharcOallocatorlEchargRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEcharcOallocatorlEchargRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEcharcOallocatorlEchargRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<char>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEcharcOallocatorlEchargRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Float_t,Long64_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_pairlEfloatcOlongsPlonggR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::pair<Float_t,Long64_t>*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<Float_t,Long64_t>*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<float,long long>*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<std::pair<Float_t,Long64_t>*> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<pair<Float_t,Long64_t>*> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<pair<float,long long>*,allocator<pair<float,long long>*> > >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Long64_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<long long>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<Long64_t> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<Long64_t> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<long long,allocator<long long> > >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Event*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrapper));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("EventList",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrapper));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Event*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCPruner));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("EventList",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCPruner));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::DecisionTreeNode*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const Event*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLIPruneTool));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<DecisionTreeNode*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::TransformationHandler::VariableStat>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<TMVA::TransformationHandler::VariableStat> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<TMVA::TransformationHandler::VariableStat> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> > >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Ranking*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::Ranking*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,double>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,double,less<TString> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<Float_t> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<Float_t> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<float,allocator<float> > >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const std::vector<TMVA::Event*>*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const vector<TMVA::Event*,allocator<TMVA::Event*> >*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,TMVA::Interval*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOTMVAcLcLIntervalmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIntervalmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,TMVA::Interval*,less<TString> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOTMVAcLcLIntervalmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIntervalmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::vector<Double_t>,Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<vector<Double_t>,Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<vector<double,allocator<double> >,double>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<vector<double,allocator<double> >,double,less<vector<double,allocator<double> > > >",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TMVA */
static void G__setup_memvarTMVA(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVA));
   {
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kDEBUG=%lldLL",(long long)TMVA::kDEBUG).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kVERBOSE=%lldLL",(long long)TMVA::kVERBOSE).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kINFO=%lldLL",(long long)TMVA::kINFO).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kWARNING=%lldLL",(long long)TMVA::kWARNING).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kERROR=%lldLL",(long long)TMVA::kERROR).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kFATAL=%lldLL",(long long)TMVA::kFATAL).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kSILENT=%lldLL",(long long)TMVA::kSILENT).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEDTSeparation),-1,-2,1,G__FastAllocString(2048).Format("kFoam=%lldLL",(long long)TMVA::kFoam).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEDTSeparation),-1,-2,1,G__FastAllocString(2048).Format("kGiniIndex=%lldLL",(long long)TMVA::kGiniIndex).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEDTSeparation),-1,-2,1,G__FastAllocString(2048).Format("kMisClassificationError=%lldLL",(long long)TMVA::kMisClassificationError).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEDTSeparation),-1,-2,1,G__FastAllocString(2048).Format("kCrossEntropy=%lldLL",(long long)TMVA::kCrossEntropy).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEDTSeparation),-1,-2,1,G__FastAllocString(2048).Format("kGiniIndexWithLaplace=%lldLL",(long long)TMVA::kGiniIndexWithLaplace).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEDTSeparation),-1,-2,1,G__FastAllocString(2048).Format("kSdivSqrtSplusB=%lldLL",(long long)TMVA::kSdivSqrtSplusB).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEFoamType),-1,-2,1,G__FastAllocString(2048).Format("kSeparate=%lldLL",(long long)TMVA::kSeparate).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEFoamType),-1,-2,1,G__FastAllocString(2048).Format("kDiscr=%lldLL",(long long)TMVA::kDiscr).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEFoamType),-1,-2,1,G__FastAllocString(2048).Format("kMonoTarget=%lldLL",(long long)TMVA::kMonoTarget).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEFoamType),-1,-2,1,G__FastAllocString(2048).Format("kMultiTarget=%lldLL",(long long)TMVA::kMultiTarget).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEFoamType),-1,-2,1,G__FastAllocString(2048).Format("kMultiClass=%lldLL",(long long)TMVA::kMultiClass).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kValue=%lldLL",(long long)TMVA::kValue).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kValueError=%lldLL",(long long)TMVA::kValueError).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kValueDensity=%lldLL",(long long)TMVA::kValueDensity).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kMeanValue=%lldLL",(long long)TMVA::kMeanValue).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kRms=%lldLL",(long long)TMVA::kRms).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kRmsOvMean=%lldLL",(long long)TMVA::kRmsOvMean).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kCellVolume=%lldLL",(long long)TMVA::kCellVolume).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLETargetSelection),-1,-2,1,G__FastAllocString(2048).Format("kMean=%lldLL",(long long)TMVA::kMean).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLETargetSelection),-1,-2,1,G__FastAllocString(2048).Format("kMpv=%lldLL",(long long)TMVA::kMpv).data(),0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::Config */
static void G__setup_memvarTMVAcLcLConfig(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfig));
   { TMVA::Config *p; p=(TMVA::Config*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fVariablePlotting)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting),-1,-1,1,"fVariablePlotting=",0,"Customisable plotting properties");
   G__memvar_setup((void*)((long)(&p->fIONames)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames),-1,-1,1,"fIONames=",0,"Customisable weight file properties");
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfig),-1,-2,4,"fgConfigPtr=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseColoredConsole=",0,"coloured standard output");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSilent=",0,"no output at all");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fWriteOptionsReference=",0,"if set true: Configurable objects write file with option reference");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDrawProgressBar=",0,"draw progress bar to indicate training evolution");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"message logger");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::Config::VariablePlotting */
static void G__setup_memvarTMVAcLcLConfigcLcLVariablePlotting(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting));
   { TMVA::Config::VariablePlotting *p; p=(TMVA::Config::VariablePlotting*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fTimesRMS)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fTimesRMS=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fNbins1D)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fNbins1D=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fNbins2D)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fNbins2D=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fMaxNumOfAllowedVariablesForScatterPlots)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fMaxNumOfAllowedVariablesForScatterPlots=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fNbinsMVAoutput)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fNbinsMVAoutput=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fNbinsXOfROCCurve)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fNbinsXOfROCCurve=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::Config::IONames */
static void G__setup_memvarTMVAcLcLConfigcLcLIONames(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames));
   { TMVA::Config::IONames *p; p=(TMVA::Config::IONames*)0x1000; if (p) { }
   G__memvar_setup((void*)((long)(&p->fWeightFileDir)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TString),-1,-1,1,"fWeightFileDir=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fWeightFileExtension)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TString),-1,-1,1,"fWeightFileExtension=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fOptionsReferenceFileDir)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TString),-1,-1,1,"fOptionsReferenceFileDir=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::KDEKernel */
static void G__setup_memvarTMVAcLcLKDEKernel(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernel));
   { TMVA::KDEKernel *p; p=(TMVA::KDEKernel*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelType),-1,-2,1,G__FastAllocString(2048).Format("kNone=%lldLL",(long long)TMVA::KDEKernel::kNone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelType),-1,-2,1,G__FastAllocString(2048).Format("kGauss=%lldLL",(long long)TMVA::KDEKernel::kGauss).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelIter),-1,-2,1,G__FastAllocString(2048).Format("kNonadaptiveKDE=%lldLL",(long long)TMVA::KDEKernel::kNonadaptiveKDE).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelIter),-1,-2,1,G__FastAllocString(2048).Format("kAdaptiveKDE=%lldLL",(long long)TMVA::KDEKernel::kAdaptiveKDE).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelBorder),-1,-2,1,G__FastAllocString(2048).Format("kNoTreatment=%lldLL",(long long)TMVA::KDEKernel::kNoTreatment).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelBorder),-1,-2,1,G__FastAllocString(2048).Format("kKernelRenorm=%lldLL",(long long)TMVA::KDEKernel::kKernelRenorm).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelBorder),-1,-2,1,G__FastAllocString(2048).Format("kSampleMirror=%lldLL",(long long)TMVA::KDEKernel::kSampleMirror).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fSigma=",0,"Width of the Kernel function");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelIter),-1,-1,4,"fIter=",0,"iteration number");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fLowerEdge=",0,"the lower edge of the PDF");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fUpperEdge=",0,"the upper edge of the PDF");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fFineFactor=",0,"fine tuning factor for Adaptive KDE: factor to multiply the \"width\" of the Kernel function");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TF1),-1,-1,4,"fKernel_integ=",0,"the integral of the Kernel function");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelBorder),-1,-1,4,"fKDEborder=",0,"The method to take care about \"border\" effects");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TH1F),-1,-1,4,"fHist=",0,"copy of input histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TH1F),-1,-1,4,"fFirstIterHist=",0,"histogram to be filled in the hidden iteration");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TH1F),-1,-1,4,"fSigmaHist=",0,"contains the Sigmas Widths for adaptive KDE ");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fHiddenIteration=",0,"Defines if whats currently running is the ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"message logger");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::Interval */
static void G__setup_memvarTMVAcLcLInterval(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLInterval));
   { TMVA::Interval *p; p=(TMVA::Interval*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMin=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fMax=",0,"the constraints of the Interval");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNbins=",0,"when >0 : number of bins (discrete interval); when ==0 continuous interval");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger),-1,-2,4,"fgLogger=",0,"message logger");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::LogInterval */
static void G__setup_memvarTMVAcLcLLogInterval(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLLogInterval));
   { TMVA::LogInterval *p; p=(TMVA::LogInterval*)0x1000; if (p) { }
   G__memvar_setup((void*)(&TMVA::LogInterval::fgLogger),85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger),-1,-2,1,"fgLogger=",0,"message logger");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::IFitterTarget */
static void G__setup_memvarTMVAcLcLIFitterTarget(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLIFitterTarget));
   { TMVA::IFitterTarget *p; p=(TMVA::IFitterTarget*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::FitterBase */
static void G__setup_memvarTMVAcLcLFitterBase(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLFitterBase));
   { TMVA::FitterBase *p; p=(TMVA::FitterBase*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,1,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLIFitterTarget),-1,-1,2,"fFitterTarget=",0,"pointer to target of fitting procedure");
   G__memvar_setup((void*)0,117,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR),G__defined_typename("vector<TMVA::Interval*>"),-1,2,"fRanges=",0,"allowed intervals");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNpars=",0,"number of parameters");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger),-1,-1,2,"fLogger=",0,"message logger");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TString),-1,-1,2,"fClassName=",0,"remove TMVA:: from TObject name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MCFitter */
static void G__setup_memvarTMVAcLcLMCFitter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMCFitter));
   { TMVA::MCFitter *p; p=(TMVA::MCFitter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSamples=",0,"number of MC samples");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSigma=",0,"new samples are generated randomly with a gaussian probability with fSigma around the current best value");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fSeed=",0,"Seed for the random generator (0 takes random seeds)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::GeneticFitter */
static void G__setup_memvarTMVAcLcLGeneticFitter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLGeneticFitter));
   { TMVA::GeneticFitter *p; p=(TMVA::GeneticFitter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCycles=",0,"number of (nearly) independent calculation cycles");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNsteps=",0,"convergence criteria: if no improvements > fConvCrit was achieved within the last fNsteps: cycle has \"converged\"");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPopSize=",0,"number of individuals to start with");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSC_steps=",0,"regulates how strong the mutations for the coordinates are: if within fSC_steps there were more than...");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSC_rate=",0,"... fSC_rate improvements, than multiply the sigma of the gaussion which defines how the random numbers are generated ...");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSC_factor=",0,"... with fSC_factor; if there were less improvements: divide by that factor; if there were exactly fSC_rate improvements, dont change anything");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fConvCrit=",0,"improvements bigger than fConvCrit are counted as \"improvement\"");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSaveBestFromGeneration=",0,"store the best individuals from one generation (these are included as \"hints\" in the last cycle of GA calculation)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSaveBestFromCycle=",0,"store the best individuals from one cycle (these are included as \"hints\" in the last cycle of GA calculation)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTrim=",0,"take care, that the number of individuals is less fPopSize (trimming is done after the fitness of the individuals is assessed)");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fSeed=",0,"Seed for the random generator (0 takes random seeds)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::SimulatedAnnealingFitter */
static void G__setup_memvarTMVAcLcLSimulatedAnnealingFitter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter));
   { TMVA::SimulatedAnnealingFitter *p; p=(TMVA::SimulatedAnnealingFitter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMaxCalls=",0,"max number of FCN calls");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fInitialTemperature=",0,"initial temperature (depends on FCN)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMinTemperature=",0,"minimum temperature before SA quit");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEps=",0,"relative required FCN accuracy at minimum");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TString),-1,-1,4,"fKernelTemperatureS=",0,"string just to set fKernelTemperature");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTemperatureScale=",0,"how fast temperature change");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAdaptiveSpeed=",0,"how fast temperature change in adaptive (in adaptive two variables describe");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTemperatureAdaptiveStep=",0,"used to calculate InitialTemperature if fUseDefaultTemperature");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseDefaultScale=",0,"if TRUE, SA calculates its own TemperatureScale");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseDefaultTemperature=",0,"if TRUE, SA calculates its own InitialTemperature (MinTemperautre)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MinuitWrapper */
static void G__setup_memvarTMVAcLcLMinuitWrapper(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitWrapper));
   { TMVA::MinuitWrapper *p; p=(TMVA::MinuitWrapper*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,1,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLIFitterTarget),-1,-1,4,"fFitterTarget=",0,"fitter Target");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fParameters=",0,"vector holding the current parameters ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNumPar=",0,"number of parameters");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MinuitFitter */
static void G__setup_memvarTMVAcLcLMinuitFitter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitFitter));
   { TMVA::MinuitFitter *p; p=(TMVA::MinuitFitter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitWrapper),-1,-1,2,"fMinWrap=",0,"holds a wrapper around TMinuit");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fErrorLevel=",0,"minuit error level");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPrintLevel=",0,"minuit printout level");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fFitStrategy=",0,"minuit strategy level");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fPrintWarnings=",0,"minuit warnings level");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseImprove=",0,"flag for 'IMPROVE' use");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseMinos=",0,"flag for 'MINOS' use");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fBatch=",0,"batch mode");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMaxCalls=",0,"(approximate) maximum number of function calls");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTolerance=",0,"tolerance to the function value at the minimum");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::PDEFoamCell */
static void G__setup_memvarTMVAcLcLPDEFoamCell(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell));
   { TMVA::PDEFoamCell *p; p=(TMVA::PDEFoamCell*)0x1000; if (p) { }
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,4,"fDim=",0,"Dimension of the vector space");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSerial=",0,"Serial number");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fStatus=",0,"Status (active, inactive)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TRef),-1,-1,4,"fParent=",0,"Pointer to parent cell");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TRef),-1,-1,4,"fDaught0=",0,"Pointer to daughter 1");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TRef),-1,-1,4,"fDaught1=",0,"Pointer to daughter 2");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fXdiv=",0,"Factor for division");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fBest=",0,"Best Edge for division");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fVolume=",0,"Cartesian Volume of cell");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fIntegral=",0,"Integral over cell (estimate from exploration)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDrive=",0,"Driver  integral, only for cell build-up");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TObject),-1,-1,4,"fElement=",0,"may set by the user to save some data in this cell");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::PDEFoamVect */
static void G__setup_memvarTMVAcLcLPDEFoamVect(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect));
   { TMVA::PDEFoamVect *p; p=(TMVA::PDEFoamVect*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDim=",0,"Dimension");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCoords=",0,"[fDim] Coordinates");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::PDEFoamDensityBase */
static void G__setup_memvarTMVAcLcLPDEFoamDensityBase(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDensityBase));
   { TMVA::PDEFoamDensityBase *p; p=(TMVA::PDEFoamDensityBase*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fBox=",0,"range-searching box");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fBoxVolume=",0,"volume of range searching box");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fBoxHasChanged=",0,"range searching box has changed");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLBinarySearchTree),-1,-1,2,"fBst=",0,"Binary tree to find events within a volume");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger),-1,-1,2,"fLogger=",0,"! message logger");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::PDEFoamKernelBase */
static void G__setup_memvarTMVAcLcLPDEFoamKernelBase(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelBase));
   { TMVA::PDEFoamKernelBase *p; p=(TMVA::PDEFoamKernelBase*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger),-1,-1,2,"fLogger=",0,"! message logger");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::PDEFoam */
static void G__setup_memvarTMVAcLcLPDEFoam(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam));
   { TMVA::PDEFoam *p; p=(TMVA::PDEFoam*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TString),-1,-1,2,"fName=",0,"Name of a given instance of the FOAM class");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDim=",0,"Dimension of the integration/simulation space");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNCells=",0,"Maximum number of cells");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNBin=",0,"No. of bins in the edge histogram for cell MC exploration");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNSampl=",0,"No. of MC events, when dividing (exploring) cell");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fEvPerBin=",0,"Maximum number of effective (wt=1) events per bin");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaskDiv=",0,"! [fDim] Dynamic Mask for cell division");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fInhiDiv=",0,"! [fDim] Flags for inhibiting cell division");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNoAct=",0,"Number of active cells");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLastCe=",0,"Index of the last cell");
   G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell),-1,-1,2,"fCells=",0,"[fNCells] Array of ALL cells");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TObjArray),-1,-1,2,"fHistEdg=",0,"Histograms of wt, one for each cell edge");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRvec=",0,"[fDim] random number vector from r.n. generator fDim+1 maximum elements");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TRandom3),-1,-1,2,"fPseRan=",0,"Pointer to user-defined generator of pseudorandom numbers");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAlpha=",0,"[fDim] Internal parameters of the hyperrectangle");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEFoamType),-1,-1,2,"fFoamType=",0,"BACKWARDS COMPATIBILITY: type of foam");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXmin=",0,"[fDim] minimum for variable transform");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXmax=",0,"[fDim] maximum for variable transform");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fNElements=",0,"BACKWARDS COMPATIBILITY: number of variables in every cell");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fNmin=",0,"minimal number of events in cell to split cell");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fMaxDepth=",0,"maximum depth of cell tree");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fVolFrac=",0,"BACKWARDS COMPATIBILITY: volume fraction (with respect to total phase space");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fFillFoamWithOrigWeights=",0,"BACKWARDS COMPATIBILITY: fill the foam with boost or orig. weights");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEDTSeparation),-1,-1,2,"fDTSeparation=",0,"BACKWARDS COMPATIBILITY: split cells according to decision tree logic");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fPeekMax=",0,"BACKWARDS COMPATIBILITY: peek up cell with max. driver integral for split");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDensityBase),-1,-1,2,"fDistr=",0,"! distribution of training events");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLTimer),-1,-1,2,"fTimer=",0,"! timer for graphical output");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TObjArray),-1,-1,2,"fVariableNames=",0,"collection of all variable names");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger),-1,-1,2,"fLogger=",0,"! message logger");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::PDEFoamDiscriminant */
static void G__setup_memvarTMVAcLcLPDEFoamDiscriminant(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminant));
   { TMVA::PDEFoamDiscriminant *p; p=(TMVA::PDEFoamDiscriminant*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fClass=",0,"signal class");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::PDEFoamDecisionTree */
static void G__setup_memvarTMVAcLcLPDEFoamDecisionTree(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTree));
   { TMVA::PDEFoamDecisionTree *p; p=(TMVA::PDEFoamDecisionTree*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSeparationBase),-1,-1,4,"fSepType=",0,"separation type");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::PDEFoamDiscriminantDensity */
static void G__setup_memvarTMVAcLcLPDEFoamDiscriminantDensity(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminantDensity));
   { TMVA::PDEFoamDiscriminantDensity *p; p=(TMVA::PDEFoamDiscriminantDensity*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fClass=",0,"signal class");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::PDEFoamEventDensity */
static void G__setup_memvarTMVAcLcLPDEFoamEventDensity(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEventDensity));
   { TMVA::PDEFoamEventDensity *p; p=(TMVA::PDEFoamEventDensity*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::PDEFoamTargetDensity */
static void G__setup_memvarTMVAcLcLPDEFoamTargetDensity(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTargetDensity));
   { TMVA::PDEFoamTargetDensity *p; p=(TMVA::PDEFoamTargetDensity*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTarget=",0,"the target to calculate the density for");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::PDEFoamDecisionTreeDensity */
static void G__setup_memvarTMVAcLcLPDEFoamDecisionTreeDensity(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTreeDensity));
   { TMVA::PDEFoamDecisionTreeDensity *p; p=(TMVA::PDEFoamDecisionTreeDensity*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fClass=",0,"signal class");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::PDEFoamEvent */
static void G__setup_memvarTMVAcLcLPDEFoamEvent(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEvent));
   { TMVA::PDEFoamEvent *p; p=(TMVA::PDEFoamEvent*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::PDEFoamMultiTarget */
static void G__setup_memvarTMVAcLcLPDEFoamMultiTarget(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamMultiTarget));
   { TMVA::PDEFoamMultiTarget *p; p=(TMVA::PDEFoamMultiTarget*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLETargetSelection),-1,-1,2,"fTargetSelection=",0,"the target selection method");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::PDEFoamTarget */
static void G__setup_memvarTMVAcLcLPDEFoamTarget(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTarget));
   { TMVA::PDEFoamTarget *p; p=(TMVA::PDEFoamTarget*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fTarget=",0,"the target to fill the cells with");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::PDEFoamKernelTrivial */
static void G__setup_memvarTMVAcLcLPDEFoamKernelTrivial(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelTrivial));
   { TMVA::PDEFoamKernelTrivial *p; p=(TMVA::PDEFoamKernelTrivial*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::PDEFoamKernelLinN */
static void G__setup_memvarTMVAcLcLPDEFoamKernelLinN(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelLinN));
   { TMVA::PDEFoamKernelLinN *p; p=(TMVA::PDEFoamKernelLinN*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::PDEFoamKernelGauss */
static void G__setup_memvarTMVAcLcLPDEFoamKernelGauss(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelGauss));
   { TMVA::PDEFoamKernelGauss *p; p=(TMVA::PDEFoamKernelGauss*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fSigma=",0,"width of gauss curve");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::BDTEventWrapper */
static void G__setup_memvarTMVAcLcLBDTEventWrapper(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLBDTEventWrapper));
   { TMVA::BDTEventWrapper *p; p=(TMVA::BDTEventWrapper*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fVarIndex=",0,"index of the variable to sort on");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEvent),-1,-1,4,"fEvent=",0,"pointer to the event");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fBkgWeight=",0,"cumulative background weight for splitting");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSigWeight=",0,"same for the signal weights");
   }
   G__tag_memvar_reset();
}


   /* TMVA::CCTreeWrapper */
static void G__setup_memvarTMVAcLcLCCTreeWrapper(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrapper));
   { TMVA::CCTreeWrapper *p; p=(TMVA::CCTreeWrapper*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSeparationBase),-1,-1,4,"fQualityIndex=",0,"! pointer to the used quality index calculator");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLDecisionTree),-1,-1,4,"fDTParent=",0,"! pointer to underlying DecisionTree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrappercLcLCCTreeNode),-1,-1,4,"fRoot=",0,"! the root node of the (wrapped) decision Tree");
   }
   G__tag_memvar_reset();
}


   /* TMVA::CCPruner */
static void G__setup_memvarTMVAcLcLCCPruner(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCPruner));
   { TMVA::CCPruner *p; p=(TMVA::CCPruner*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fAlpha=",0,"! regularization parameter in CC pruning");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),G__defined_typename("EventList"),-1,4,"fValidationSample=",0,"! the event sample to select the optimally-pruned tree");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLDataSet),-1,-1,4,"fValidationDataSet=",0,"! the event sample to select the optimally-pruned tree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSeparationBase),-1,-1,4,"fQualityIndex=",0,"! the quality index used to calculate R(t), R(T) = sum[t in ~T]{ R(t) }");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fOwnQIndex=",0,"! flag indicates if fQualityIndex is owned by this");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLDecisionTree),-1,-1,4,"fTree=",0,"! (pruned) decision tree");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgR),G__defined_typename("vector<TMVA::DecisionTreeNode*>"),-1,4,"fPruneSequence=",0,"! map of weakest links (i.e., branches to prune) -> pruning index");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fPruneStrengthList=",0,"! map of alpha -> pruning index");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fQualityIndexList=",0,"! map of R(T) -> pruning index");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOptimalK=",0,"! index of the optimal tree in the pruned tree sequence");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDebug=",0,"! debug flag");
   }
   G__tag_memvar_reset();
}


   /* TMVA::CostComplexityPruneTool */
static void G__setup_memvarTMVAcLcLCostComplexityPruneTool(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool));
   { TMVA::CostComplexityPruneTool *p; p=(TMVA::CostComplexityPruneTool*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSeparationBase),-1,-1,4,"fQualityIndexTool=",0,"! the quality index used to calculate R(t), R(T) = sum[t in ~T]{ R(t) }");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgR),-1,-1,4,"fPruneSequence=",0,"! map of weakest links (i.e., branches to prune) -> pruning index");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fPruneStrengthList=",0,"! map of alpha -> pruning index");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fQualityIndexList=",0,"! map of R(T) -> pruning index");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOptimalK=",0,"! the optimal index of the prune sequence");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"! output stream to save logging information");
   }
   G__tag_memvar_reset();
}


   /* TMVA::SVEvent */
static void G__setup_memvarTMVAcLcLSVEvent(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent));
   { TMVA::SVEvent *p; p=(TMVA::SVEvent*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fDataVector=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,1,-1,G__defined_typename("Float_t"),-1,4,"fCweight=",0,"svm cost weight");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fAlpha=",0,"lagrange multiplier");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fAlpha_p=",0,"lagrange multiplier");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fErrorCache=",0,"optimization parameter");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNVar=",0,"number of variables");
   G__memvar_setup((void*)0,105,0,1,-1,G__defined_typename("Int_t"),-1,4,"fTypeFlag=",0,"is sig or bkg - svm requieres 1 for sig and -1 for bkg");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIdx=",0,"index flag");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNs=",0,"documentation");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIsShrinked=",0,"shrinking flag, see documentation");
   G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,4,"fLine=",0,"pointer to column of kerenl matrix ");
   G__memvar_setup((void*)0,102,0,1,-1,G__defined_typename("Float_t"),-1,4,"fTarget=",0,"regression target");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::OptimizeConfigParameters */
static void G__setup_memvarTMVAcLcLOptimizeConfigParameters(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters));
   { TMVA::OptimizeConfigParameters *p; p=(TMVA::OptimizeConfigParameters*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,4,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMethodBase),-1,-1,4,"fMethod=",0,"The MVA method to be evaluated");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fFOMvsIter=",0,"graph showing the develompment of the Figure Of Merit values during the fit");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOTMVAcLcLIntervalmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIntervalmUgRsPgRsPgR),G__defined_typename("map<TString,TMVA::Interval*>"),-1,4,"fTuneParameters=",0,"parameters included in the tuning");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR),G__defined_typename("map<TString,Double_t>"),-1,4,"fTunedParameters=",0,"parameters included in the tuning");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR),G__defined_typename("map<std::vector<Double_t>,Double_t>"),-1,4,"fAlreadyTrainedParCombination=",0,"save parameters for which the FOM is already known (GA seems to evaluate the same parameters several times)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TString),-1,-1,4,"fFOMType=",0,"the FOM type (Separation, ROC integra.. whaeter you implemented..");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TString),-1,-1,4,"fOptimizationFitType=",0,"which type of optimisation procedure to be used ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TH1D),-1,-1,4,"fMvaSig=",0,"MVA distrituion for signal events, used for spline fit");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TH1D),-1,-1,4,"fMvaBkg=",0,"MVA distrituion for bakgr. events, used for spline fit");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TH1D),-1,-1,4,"fMvaSigFineBin=",0,"MVA distrituion for signal events");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TH1D),-1,-1,4,"fMvaBkgFineBin=",0,"MVA distrituion for bakgr. events");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNotDoneYet=",0,"flat to indicate of Method Transformations have been optained yet or not (normally done in MethodBase::TrainMethod)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"message logger");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__TMVA3() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTMVA(void) {
   /* TMVA */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVA));
   G__memfunc_setup("gConfig",701,G__G__TMVA3_127_0_1, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfig), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) G__func2void( (TMVA::Config& (*)())(&TMVA::gConfig) ), 0);
   G__memfunc_setup("Endl",387,G__G__TMVA3_127_0_2, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger), -1, 1, 1, 1, 1, 0, "u 'TMVA::MsgLogger' - 1 - ml", (char*)NULL, (void*) G__func2void( (TMVA::MsgLogger& (*)(TMVA::MsgLogger&))(&TMVA::Endl) ), 0);
   G__memfunc_setup("operator<<",996,G__G__TMVA3_127_0_3, 117, G__get_linked_tagnum(&G__G__TMVA3LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os u 'TMVA::Node' - 11 - node", (char*)NULL, (void*) G__func2void( (ostream& (*)(ostream&, const TMVA::Node&))(&TMVA::operator<<) ), 0);
   G__memfunc_setup("operator<<",996,G__G__TMVA3_127_0_4, 117, G__get_linked_tagnum(&G__G__TMVA3LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os U 'TMVA::Node' - 10 - node", (char*)NULL, (void*) G__func2void( (ostream& (*)(ostream&, const TMVA::Node*))(&TMVA::operator<<) ), 0);
   G__memfunc_setup("operator<<",996,G__G__TMVA3_127_0_5, 117, G__get_linked_tagnum(&G__G__TMVA3LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os u 'TMVA::BinaryTree' - 11 - tree", (char*)NULL, (void*) G__func2void( (ostream& (*)(ostream&, const TMVA::BinaryTree&))(&TMVA::operator<<) ), 0);
   G__memfunc_setup("operator>>",1000,G__G__TMVA3_127_0_6, 117, G__get_linked_tagnum(&G__G__TMVA3LN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr u 'TMVA::BinaryTree' - 1 - tree", (char*)NULL, (void*) G__func2void( (istream& (*)(istream&, TMVA::BinaryTree&))(&TMVA::operator>>) ), 0);
   G__memfunc_setup("operator<<",996,G__G__TMVA3_127_0_7, 117, G__get_linked_tagnum(&G__G__TMVA3LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os u 'TMVA::Event' - 11 - event", (char*)NULL, (void*) G__func2void( (ostream& (*)(ostream&, const TMVA::Event&))(&TMVA::operator<<) ), 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLConfig(void) {
   /* TMVA::Config */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfig));
   G__memfunc_setup("Instance",821,G__G__TMVA3_129_0_1, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfig), -1, 1, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TMVA::Config& (*)())(&TMVA::Config::Instance) ), 0);
   G__memfunc_setup("DestroyInstance",1567,G__G__TMVA3_129_0_2, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::Config::DestroyInstance) ), 0);
   G__memfunc_setup("UseColor",812,G__G__TMVA3_129_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUseColor",1112,G__G__TMVA3_129_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - uc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSilent",811,G__G__TMVA3_129_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSilent",923,G__G__TMVA3_129_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteOptionsReference",2182,G__G__TMVA3_129_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWriteOptionsReference",2482,G__G__TMVA3_129_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawProgressBar",1528,G__G__TMVA3_129_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDrawProgressBar",1828,G__G__TMVA3_129_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVariablePlotting",1943,G__G__TMVA3_129_0_11, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIONames",940,G__G__TMVA3_129_0_12, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Config",598,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfig), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA3_129_0_15, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::Config::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_129_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Config::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_129_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::Config::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_129_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::Config::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA3_129_0_19, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA3_129_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__TMVA3_129_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_129_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_129_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Config::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_129_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Config::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_129_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Config::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_129_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Config::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("Config", 598, G__G__TMVA3_129_0_27, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfig), -1, 0, 1, 1, 1, 0, "u 'TMVA::Config' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_129_0_28, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfig), -1, 1, 1, 1, 1, 0, "u 'TMVA::Config' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLConfigcLcLVariablePlotting(void) {
   /* TMVA::Config::VariablePlotting */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting));
   // automatic default constructor
   G__memfunc_setup("VariablePlotting", 1655, G__G__TMVA3_130_0_1, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("VariablePlotting", 1655, G__G__TMVA3_130_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting), -1, 0, 1, 1, 1, 0, "u 'TMVA::Config::VariablePlotting' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~VariablePlotting", 1781, G__G__TMVA3_130_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_130_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting), -1, 1, 1, 1, 1, 0, "u 'TMVA::Config::VariablePlotting' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLConfigcLcLIONames(void) {
   /* TMVA::Config::IONames */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames));
   // automatic default constructor
   G__memfunc_setup("IONames", 652, G__G__TMVA3_131_0_1, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("IONames", 652, G__G__TMVA3_131_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames), -1, 0, 1, 1, 1, 0, "u 'TMVA::Config::IONames' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~IONames", 778, G__G__TMVA3_131_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_131_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames), -1, 1, 1, 1, 1, 0, "u 'TMVA::Config::IONames' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLKDEKernel(void) {
   /* TMVA::KDEKernel */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernel));
   G__memfunc_setup("KDEKernel",821,G__G__TMVA3_135_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernel), -1, 0, 6, 1, 1, 0, 
"i 'TMVA::KDEKernel::EKernelIter' - 0 'kNonadaptiveKDE' kiter U 'TH1' - 10 '0' hist "
"f - 'Float_t' 0 '0.' lower_edge f - 'Float_t' 0 '1.' upper_edge "
"i 'TMVA::KDEKernel::EKernelBorder' - 0 'kNoTreatment' kborder f - 'Float_t' 0 '1.' FineFactor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBinKernelIntegral",2000,G__G__TMVA3_135_0_2, 102, -1, G__defined_typename("Float_t"), 0, 4, 1, 1, 0, 
"f - 'Float_t' 0 - lowr f - 'Float_t' 0 - highr "
"f - 'Float_t' 0 - mean i - 'Int_t' 0 - binnum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetKernelType",1327,G__G__TMVA3_135_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TMVA::KDEKernel::EKernelType' - 0 'kGauss' ktype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,G__G__TMVA3_135_0_4, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA3_135_0_6, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::KDEKernel::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_135_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::KDEKernel::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_135_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::KDEKernel::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_135_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::KDEKernel::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA3_135_0_10, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA3_135_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__TMVA3_135_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_135_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_135_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::KDEKernel::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_135_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::KDEKernel::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_135_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::KDEKernel::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_135_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::KDEKernel::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("KDEKernel", 821, G__G__TMVA3_135_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernel), -1, 0, 1, 1, 1, 0, "u 'TMVA::KDEKernel' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~KDEKernel", 947, G__G__TMVA3_135_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_135_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernel), -1, 1, 1, 1, 1, 0, "u 'TMVA::KDEKernel' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLInterval(void) {
   /* TMVA::Interval */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLInterval));
   G__memfunc_setup("Interval",837,G__G__TMVA3_140_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLInterval), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - min d - 'Double_t' 0 - max "
"i - 'Int_t' 0 '0' nbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Interval",837,G__G__TMVA3_140_0_2, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLInterval), -1, 0, 1, 1, 1, 0, "u 'TMVA::Interval' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMin",580,G__G__TMVA3_140_0_3, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMax",582,G__G__TMVA3_140_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetWidth",800,G__G__TMVA3_140_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNbins",794,G__G__TMVA3_140_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMean",673,G__G__TMVA3_140_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRndm",689,G__G__TMVA3_140_0_8, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "u 'TRandom3' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetElement",1002,G__G__TMVA3_140_0_9, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - position", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStepSize",1111,G__G__TMVA3_140_0_10, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' iBin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMax",594,G__G__TMVA3_140_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMin",592,G__G__TMVA3_140_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,G__G__TMVA3_140_0_13, 121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA3_140_0_15, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::Interval::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_140_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Interval::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_140_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::Interval::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_140_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::Interval::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA3_140_0_19, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA3_140_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__TMVA3_140_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_140_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_140_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Interval::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_140_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Interval::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_140_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Interval::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_140_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Interval::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~Interval", 963, G__G__TMVA3_140_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_140_0_28, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLInterval), -1, 1, 1, 1, 1, 0, "u 'TMVA::Interval' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLLogInterval(void) {
   /* TMVA::LogInterval */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLLogInterval));
   G__memfunc_setup("LogInterval",1127,G__G__TMVA3_141_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLLogInterval), -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - min d - 'Double_t' 0 - max "
"i - 'Int_t' 0 '0' nbins", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LogInterval",1127,G__G__TMVA3_141_0_2, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLLogInterval), -1, 0, 1, 1, 1, 0, "u 'TMVA::LogInterval' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMin",580,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMax",582,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetWidth",800,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNbins",794,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMean",673,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRndm",689,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "u 'TRandom3' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetElement",1002,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - position", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStepSize",1111,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 '0' iBin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMax",594,G__G__TMVA3_141_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMin",592,G__G__TMVA3_141_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,G__G__TMVA3_141_0_13, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA3_141_0_14, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::LogInterval::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_141_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::LogInterval::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_141_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::LogInterval::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_141_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::LogInterval::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_141_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_141_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::LogInterval::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_141_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::LogInterval::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_141_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::LogInterval::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_141_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::LogInterval::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~LogInterval", 1253, G__G__TMVA3_141_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_141_0_27, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLLogInterval), -1, 1, 1, 1, 1, 0, "u 'TMVA::LogInterval' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLIFitterTarget(void) {
   /* TMVA::IFitterTarget */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLIFitterTarget));
   G__memfunc_setup("EstimatorFunction",1790,G__G__TMVA3_197_0_2, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - parameters", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ProgressNotifier",1685,G__G__TMVA3_197_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TString' - 0 - - u 'TString' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA3_197_0_4, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::IFitterTarget::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_197_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::IFitterTarget::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_197_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::IFitterTarget::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_197_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::IFitterTarget::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA3_197_0_8, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA3_197_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__TMVA3_197_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_197_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_197_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::IFitterTarget::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_197_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::IFitterTarget::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_197_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::IFitterTarget::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_197_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::IFitterTarget::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~IFitterTarget", 1436, G__G__TMVA3_197_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_197_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLIFitterTarget), -1, 1, 1, 1, 1, 0, "u 'TMVA::IFitterTarget' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLFitterBase(void) {
   /* TMVA::FitterBase */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLFitterBase));
   G__memfunc_setup("Run",309,G__G__TMVA3_198_0_2, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Run",309,G__G__TMVA3_198_0_3, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - pars", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("EstimatorFunction",1790,G__G__TMVA3_198_0_4, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - parameters", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitterTarget",1525,G__G__TMVA3_198_0_5, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLIFitterTarget), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNpars",804,G__G__TMVA3_198_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA3_198_0_10, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::FitterBase::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_198_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::FitterBase::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_198_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::FitterBase::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_198_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::FitterBase::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_198_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_198_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::FitterBase::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_198_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::FitterBase::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_198_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::FitterBase::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_198_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::FitterBase::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~FitterBase", 1127, G__G__TMVA3_198_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMCFitter(void) {
   /* TMVA::MCFitter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMCFitter));
   G__memfunc_setup("MCFitter",766,G__G__TMVA3_207_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMCFitter), -1, 0, 4, 1, 1, 0, 
"u 'TMVA::IFitterTarget' - 1 - target u 'TString' - 11 - name "
"u 'vector<TMVA::Interval*,allocator<TMVA::Interval*> >' 'vector<TMVA::Interval*>' 11 - ranges u 'TString' - 11 - theOption", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParameters",1344,G__G__TMVA3_207_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - cycles", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Run",309,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - pars", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA3_207_0_5, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MCFitter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_207_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MCFitter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_207_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MCFitter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_207_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MCFitter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_207_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_207_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MCFitter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_207_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MCFitter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_207_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MCFitter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_207_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MCFitter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MCFitter", 892, G__G__TMVA3_207_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLGeneticFitter(void) {
   /* TMVA::GeneticFitter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLGeneticFitter));
   G__memfunc_setup("GeneticFitter",1325,G__G__TMVA3_208_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLGeneticFitter), -1, 0, 4, 1, 1, 0, 
"u 'TMVA::IFitterTarget' - 1 - target u 'TString' - 11 - name "
"u 'vector<TMVA::Interval*,allocator<TMVA::Interval*> >' 'vector<TMVA::Interval*>' 11 - ranges u 'TString' - 11 - theOption", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParameters",1344,G__G__TMVA3_208_0_2, 121, -1, -1, 0, 7, 1, 1, 0, 
"i - 'Int_t' 0 - cycles i - 'Int_t' 0 - nsteps "
"i - 'Int_t' 0 - popSize i - 'Int_t' 0 - SC_steps "
"i - 'Int_t' 0 - SC_rate d - 'Double_t' 0 - SC_factor "
"d - 'Double_t' 0 - convCrit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Run",309,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - pars", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NewFitness",1030,G__G__TMVA3_208_0_4, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - oldF d - 'Double_t' 0 - newF", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA3_208_0_6, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::GeneticFitter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_208_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GeneticFitter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_208_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::GeneticFitter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_208_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::GeneticFitter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_208_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_208_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GeneticFitter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_208_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::GeneticFitter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_208_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GeneticFitter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_208_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::GeneticFitter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~GeneticFitter", 1451, G__G__TMVA3_208_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLSimulatedAnnealingFitter(void) {
   /* TMVA::SimulatedAnnealingFitter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter));
   G__memfunc_setup("SimulatedAnnealingFitter",2467,G__G__TMVA3_209_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter), -1, 0, 4, 1, 1, 0, 
"u 'TMVA::IFitterTarget' - 1 - target u 'TString' - 11 - name "
"u 'vector<TMVA::Interval*,allocator<TMVA::Interval*> >' 'vector<TMVA::Interval*>' 11 - ranges u 'TString' - 11 - theOption", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParameters",1344,G__G__TMVA3_209_0_2, 121, -1, -1, 0, 9, 1, 1, 0, 
"i - 'Int_t' 0 - fMaxCalls d - 'Double_t' 0 - fInitialTemperature "
"d - 'Double_t' 0 - fMinTemperature d - 'Double_t' 0 - fEps "
"u 'TString' - 0 - fKernelTemperatureS d - 'Double_t' 0 - fTemperatureScale "
"d - 'Double_t' 0 - fTemperatureAdaptiveStep g - 'Bool_t' 0 - fUseDefaultScale "
"g - 'Bool_t' 0 - fUseDefaultTemperature", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Run",309,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - pars", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA3_209_0_5, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::SimulatedAnnealingFitter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_209_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SimulatedAnnealingFitter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_209_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::SimulatedAnnealingFitter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_209_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::SimulatedAnnealingFitter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_209_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_209_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SimulatedAnnealingFitter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_209_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::SimulatedAnnealingFitter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_209_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SimulatedAnnealingFitter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_209_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::SimulatedAnnealingFitter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~SimulatedAnnealingFitter", 2593, G__G__TMVA3_209_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMinuitWrapper(void) {
   /* TMVA::MinuitWrapper */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitWrapper));
   G__memfunc_setup("MinuitWrapper",1367,G__G__TMVA3_211_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitWrapper), -1, 0, 2, 1, 1, 0, 
"u 'TMVA::IFitterTarget' - 1 - target i - 'Int_t' 0 - maxpar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - - D - 'Double_t' 0 - - "
"d - 'Double_t' 1 - - D - 'Double_t' 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFitterTarget",1537,G__G__TMVA3_211_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMVA::IFitterTarget' - 1 - target", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExecuteCommand",1426,G__G__TMVA3_211_0_4, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - command D - 'Double_t' 0 - args "
"i - 'Int_t' 0 - nargs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStats",815,G__G__TMVA3_211_0_6, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"d - 'Double_t' 1 - amin d - 'Double_t' 1 - edm "
"d - 'Double_t' 1 - errdef i - 'Int_t' 1 - nvpar "
"i - 'Int_t' 1 - nparx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetErrors",925,G__G__TMVA3_211_0_7, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - ipar d - 'Double_t' 1 - eplus "
"d - 'Double_t' 1 - eminus d - 'Double_t' 1 - eparab "
"d - 'Double_t' 1 - globcc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParameter",1229,G__G__TMVA3_211_0_8, 105, -1, G__defined_typename("Int_t"), 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - ipar C - - 10 - parname "
"d - 'Double_t' 0 - value d - 'Double_t' 0 - verr "
"d - 'Double_t' 0 - vlow d - 'Double_t' 0 - vhigh", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA3_211_0_10, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MinuitWrapper::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_211_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MinuitWrapper::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_211_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MinuitWrapper::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_211_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MinuitWrapper::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_211_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_211_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MinuitWrapper::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_211_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MinuitWrapper::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_211_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MinuitWrapper::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_211_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MinuitWrapper::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MinuitWrapper", 1493, G__G__TMVA3_211_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMinuitFitter(void) {
   /* TMVA::MinuitFitter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitFitter));
   G__memfunc_setup("Init",404,G__G__TMVA3_212_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Run",309,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - pars", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EstimatorFunction",1790,G__G__TMVA3_212_0_4, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - pars", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA3_212_0_6, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MinuitFitter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_212_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MinuitFitter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_212_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MinuitFitter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_212_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MinuitFitter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_212_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_212_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MinuitFitter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_212_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MinuitFitter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_212_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MinuitFitter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_212_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MinuitFitter::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MinuitFitter", 1378, G__G__TMVA3_212_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLPDEFoamCell(void) {
   /* TMVA::PDEFoamCell */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell));
   G__memfunc_setup("PDEFoamCell",988,G__G__TMVA3_320_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell), -1, 0, 0, 1, 1, 0, "", "Default Constructor for ROOT streamers", (void*) NULL, 0);
   G__memfunc_setup("PDEFoamCell",988,G__G__TMVA3_320_0_2, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", "User Constructor", (void*) NULL, 0);
   G__memfunc_setup("PDEFoamCell",988,G__G__TMVA3_320_0_3, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell), -1, 0, 1, 1, 1, 0, "u 'TMVA::PDEFoamCell' - 11 - -", "Copy constructor", (void*) NULL, 0);
   G__memfunc_setup("Fill",391,G__G__TMVA3_320_0_4, 121, -1, -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - - U 'TMVA::PDEFoamCell' - 0 - - "
"U 'TMVA::PDEFoamCell' - 0 - - U 'TMVA::PDEFoamCell' - 0 - -", "Assigns values of attributes", (void*) NULL, 0);
   G__memfunc_setup("GetXdiv",699,G__G__TMVA3_320_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "Pointer to Xdiv", (void*) NULL, 0);
   G__memfunc_setup("GetBest",686,G__G__TMVA3_320_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "Pointer to Best", (void*) NULL, 0);
   G__memfunc_setup("SetBest",698,G__G__TMVA3_320_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - Best", "Set Best edge candidate", (void*) NULL, 0);
   G__memfunc_setup("SetXdiv",711,G__G__TMVA3_320_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - Xdiv", "Set x-division for best edge cand.", (void*) NULL, 0);
   G__memfunc_setup("GetHcub",674,G__G__TMVA3_320_0_9, 121, -1, -1, 0, 2, 1, 1, 8, 
"u 'TMVA::PDEFoamVect' - 1 - - u 'TMVA::PDEFoamVect' - 1 - -", "Get position and size vectors (h-cubical subspace)", (void*) NULL, 0);
   G__memfunc_setup("GetHSize",771,G__G__TMVA3_320_0_10, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TMVA::PDEFoamVect' - 1 - -", "Get size only of cell vector  (h-cubical subspace)", (void*) NULL, 0);
   G__memfunc_setup("CalcVolume",1003,G__G__TMVA3_320_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", "Calculates volume of cell", (void*) NULL, 0);
   G__memfunc_setup("GetVolume",920,G__G__TMVA3_320_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "Volume of cell", (void*) NULL, 0);
   G__memfunc_setup("GetIntg",690,G__G__TMVA3_320_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "Get Integral", (void*) NULL, 0);
   G__memfunc_setup("GetDriv",693,G__G__TMVA3_320_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "Get Drive", (void*) NULL, 0);
   G__memfunc_setup("SetIntg",702,G__G__TMVA3_320_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - Intg", "Set true integral", (void*) NULL, 0);
   G__memfunc_setup("SetDriv",705,G__G__TMVA3_320_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - Driv", "Set driver integral", (void*) NULL, 0);
   G__memfunc_setup("GetStat",700,G__G__TMVA3_320_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "Get Status", (void*) NULL, 0);
   G__memfunc_setup("SetStat",712,G__G__TMVA3_320_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - Stat", "Set Status", (void*) NULL, 0);
   G__memfunc_setup("GetPare",680,G__G__TMVA3_320_0_19, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell), -1, 0, 0, 1, 1, 8, "", "Get Pointer to parent cell", (void*) NULL, 0);
   G__memfunc_setup("GetDau0",618,G__G__TMVA3_320_0_20, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell), -1, 0, 0, 1, 1, 8, "", "Get Pointer to 1-st daughter vertex", (void*) NULL, 0);
   G__memfunc_setup("GetDau1",619,G__G__TMVA3_320_0_21, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell), -1, 0, 0, 1, 1, 8, "", "Get Pointer to 2-nd daughter vertex", (void*) NULL, 0);
   G__memfunc_setup("SetDau0",630,G__G__TMVA3_320_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::PDEFoamCell' - 0 - Daug", "Set pointer to 1-st daughter", (void*) NULL, 0);
   G__memfunc_setup("SetDau1",631,G__G__TMVA3_320_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::PDEFoamCell' - 0 - Daug", "Set pointer to 2-nd daughter", (void*) NULL, 0);
   G__memfunc_setup("SetPare",692,G__G__TMVA3_320_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::PDEFoamCell' - 0 - Pare", "Set pointer to parent", (void*) NULL, 0);
   G__memfunc_setup("SetSerial",908,G__G__TMVA3_320_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - Serial", "Set serial number", (void*) NULL, 0);
   G__memfunc_setup("GetSerial",896,G__G__TMVA3_320_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "Get serial number", (void*) NULL, 0);
   G__memfunc_setup("GetDepth",789,G__G__TMVA3_320_0_27, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", "Get depth in binary tree", (void*) NULL, 0);
   G__memfunc_setup("GetTreeDepth",1189,G__G__TMVA3_320_0_28, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 0, "h - 'UInt_t' 0 '0' depth", "Get depth of binary tree", (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 - option", "Prints cell content", (void*) NULL, 1);
   G__memfunc_setup("SetElement",1014,G__G__TMVA3_320_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - fobj", "Set user variable", (void*) NULL, 0);
   G__memfunc_setup("GetElement",1002,G__G__TMVA3_320_0_31, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TObject), -1, 0, 0, 1, 1, 8, "", "Get pointer to user varibale", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA3_320_0_32, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoamCell::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_320_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamCell::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_320_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoamCell::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_320_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoamCell::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_320_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_320_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamCell::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_320_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamCell::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_320_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamCell::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_320_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamCell::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PDEFoamCell", 1114, G__G__TMVA3_320_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_320_0_45, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamCell' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLPDEFoamVect(void) {
   /* TMVA::PDEFoamVect */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect));
   G__memfunc_setup("PDEFoamVect",1006,G__G__TMVA3_321_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 0, 0, 1, 1, 0, "", "Constructor", (void*) NULL, 0);
   G__memfunc_setup("PDEFoamVect",1006,G__G__TMVA3_321_0_2, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", "USER Constructor", (void*) NULL, 0);
   G__memfunc_setup("PDEFoamVect",1006,G__G__TMVA3_321_0_3, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 0, 1, 1, 1, 0, "u 'TMVA::PDEFoamVect' - 11 - -", "Copy constructor", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__TMVA3_321_0_4, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamVect' - 11 - -", "= operator; Substitution", (void*) NULL, 0);
   G__memfunc_setup("operator[]",1060,G__G__TMVA3_321_0_5, 100, -1, G__defined_typename("Double_t"), 1, 1, 1, 1, 0, "i - 'Int_t' 0 - -", "[] provides POINTER to coordinate", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__TMVA3_321_0_6, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 1, 1, 1, 1, 0, "D - 'Double_t' 0 - -", "LOAD IN entire double vector", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__TMVA3_321_0_7, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 1, 1, 1, 1, 0, "d - 'Double_t' 0 - -", "LOAD IN double number", (void*) NULL, 0);
   G__memfunc_setup("operator+=",980,G__G__TMVA3_321_0_8, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamVect' - 11 - -", "+=; add vector u+=v  (FAST)", (void*) NULL, 0);
   G__memfunc_setup("operator-=",982,G__G__TMVA3_321_0_9, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamVect' - 11 - -", "+=; add vector u+=v  (FAST)", (void*) NULL, 0);
   G__memfunc_setup("operator*=",979,G__G__TMVA3_321_0_10, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 1, 1, 1, 1, 0, "d - 'Double_t' 11 - -", "*=; mult. by scalar v*=x (FAST)", (void*) NULL, 0);
   G__memfunc_setup("operator+",919,G__G__TMVA3_321_0_11, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 0, 1, 1, 1, 0, "u 'TMVA::PDEFoamVect' - 11 - -", "+;  u=v+s, NEVER USE IT, SLOW!!!", (void*) NULL, 0);
   G__memfunc_setup("operator-",921,G__G__TMVA3_321_0_12, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 0, 1, 1, 1, 0, "u 'TMVA::PDEFoamVect' - 11 - -", "-;  u=v-s, NEVER USE IT, SLOW!!!", (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 - option", "Prints vector", (void*) NULL, 1);
   G__memfunc_setup("GetDim",570,G__G__TMVA3_321_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "Returns dimension", (void*) NULL, 0);
   G__memfunc_setup("GetCoord",791,G__G__TMVA3_321_0_15, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", "Returns coordinate", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA3_321_0_16, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoamVect::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_321_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamVect::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_321_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoamVect::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_321_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoamVect::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_321_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_321_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamVect::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_321_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamVect::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_321_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamVect::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_321_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamVect::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PDEFoamVect", 1132, G__G__TMVA3_321_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLPDEFoamDensityBase(void) {
   /* TMVA::PDEFoamDensityBase */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDensityBase));
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBoxVolume",1217,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillBinarySearchTree",2002,G__G__TMVA3_322_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::Event' - 10 - ev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBox",597,G__G__TMVA3_322_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 0 - box", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBox",585,G__G__TMVA3_322_0_8, 117, G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<Double_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Density",736,G__G__TMVA3_322_0_9, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - Xarg d - 'Double_t' 1 - event_density", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__TMVA3_322_0_10, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoamDensityBase::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_322_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamDensityBase::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_322_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoamDensityBase::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_322_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoamDensityBase::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_322_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_322_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamDensityBase::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_322_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamDensityBase::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_322_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamDensityBase::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_322_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamDensityBase::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PDEFoamDensityBase", 1845, G__G__TMVA3_322_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_322_0_23, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDensityBase), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamDensityBase' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLPDEFoamKernelBase(void) {
   /* TMVA::PDEFoamKernelBase */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelBase));
   G__memfunc_setup("Estimate",828,G__G__TMVA3_323_0_3, 102, -1, G__defined_typename("Float_t"), 0, 3, 1, 1, 0, 
"U 'TMVA::PDEFoam' - 0 - - u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - - "
"i 'TMVA::ECellValue' - 0 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Log",290,G__G__TMVA3_323_0_4, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA3_323_0_5, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoamKernelBase::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_323_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamKernelBase::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_323_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoamKernelBase::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_323_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoamKernelBase::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_323_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_323_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamKernelBase::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_323_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamKernelBase::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_323_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamKernelBase::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_323_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamKernelBase::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PDEFoamKernelBase", 1718, G__G__TMVA3_323_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_323_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelBase), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamKernelBase' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLPDEFoam(void) {
   /* TMVA::PDEFoam */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam));
   G__memfunc_setup("OutputGrow",1072,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'false' finished", "nice TMVA console output", (void*) NULL, 0);
   G__memfunc_setup("InitCells",903,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Initialisation of all foam cells", (void*) NULL, 0);
   G__memfunc_setup("CellFill",775,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - - U 'TMVA::PDEFoamCell' - 0 - -", "Allocates new empty cell and return its index", (void*) NULL, 0);
   G__memfunc_setup("Explore",735,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TMVA::PDEFoamCell' - 0 - Cell", "Exploration of the new cell, determine <wt>, wtMax etc.", (void*) NULL, 1);
   G__memfunc_setup("Varedu",615,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"D - 'Double_t' 0 - - i - 'Int_t' 1 - - "
"d - 'Double_t' 1 - - d - 'Double_t' 1 - -", "Determines the best edge, variace reduction", (void*) NULL, 0);
   G__memfunc_setup("MakeAlpha",868,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Provides random point inside hyperrectangle", (void*) NULL, 0);
   G__memfunc_setup("Grow",415,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "build up foam", (void*) NULL, 0);
   G__memfunc_setup("PeekMax",683,(G__InterfaceMethod) NULL, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 2, 0, "", "peek cell with max. driver integral", (void*) NULL, 0);
   G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "U 'TMVA::PDEFoamCell' - 0 - -", "Divide iCell into two daughters; iCell retained, taged as inactive", (void*) NULL, 0);
   G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 2, 0, 
"D - 'Double_t' 0 - xRand d - 'Double_t' 1 - event_density", "evaluate distribution on point 'xRand'", (void*) NULL, 0);
   G__memfunc_setup("GetCellElement",1386,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 2, 8, 
"U 'TMVA::PDEFoamCell' - 10 - cell h - 'UInt_t' 0 - i", "get Element 'i' in cell 'cell'", (void*) NULL, 0);
   G__memfunc_setup("SetCellElement",1398,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"U 'TMVA::PDEFoamCell' - 0 - cell h - 'UInt_t' 0 - i "
"d - 'Double_t' 0 - value", "set Element 'i' in cell 'cell' to value 'value'", (void*) NULL, 0);
   G__memfunc_setup("CellValueIsUndefined",1995,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'TMVA::PDEFoamCell' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindCell",769,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell), -1, 0, 1, 1, 2, 8, "u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindCells",884,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR), G__defined_typename("vector<TMVA::PDEFoamCell*>"), 0, 1, 1, 2, 8, "u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindCells",884,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR), G__defined_typename("vector<TMVA::PDEFoamCell*>"), 0, 1, 1, 2, 8, "u 'map<int,float,less<int>,allocator<pair<const int,float> > >' 'map<Int_t,Float_t>' 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindCells",884,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 8, 
"u 'map<int,float,less<int>,allocator<pair<const int,float> > >' 'map<Int_t,Float_t>' 11 - - U 'TMVA::PDEFoamCell' - 0 - - "
"u 'vector<TMVA::PDEFoamCell*,allocator<TMVA::PDEFoamCell*> >' - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDistr",806,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDensityBase), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PDEFoam",604,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam), -1, 0, 1, 1, 2, 0, "u 'TMVA::PDEFoam' - 11 - -", "Copy Constructor  NOT USED", (void*) NULL, 0);
   G__memfunc_setup("PDEFoam",604,G__G__TMVA3_324_0_20, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam), -1, 0, 0, 1, 1, 0, "", "Default constructor (used only by ROOT streamer)", (void*) NULL, 0);
   G__memfunc_setup("PDEFoam",604,G__G__TMVA3_324_0_21, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam), -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - -", "Principal user-defined constructor", (void*) NULL, 0);
   G__memfunc_setup("Initialize",1042,G__G__TMVA3_324_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", "initialize the PDEFoam", (void*) NULL, 0);
   G__memfunc_setup("FillBinarySearchTree",2002,G__G__TMVA3_324_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::Event' - 10 - ev", "fill event into BST", (void*) NULL, 0);
   G__memfunc_setup("Create",596,G__G__TMVA3_324_0_24, 121, -1, -1, 0, 0, 1, 1, 0, "", "build-up foam", (void*) NULL, 0);
   G__memfunc_setup("FillFoamCells",1277,G__G__TMVA3_324_0_25, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TMVA::Event' - 10 - ev f - 'Float_t' 0 - wt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ResetCellElements",1728,G__G__TMVA3_324_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Finalize",818,G__G__TMVA3_324_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetDim",582,G__G__TMVA3_324_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - kDim", "Sets dimension of cubical space", (void*) NULL, 0);
   G__memfunc_setup("SetnCells",909,G__G__TMVA3_324_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - nCells", "Sets maximum number of cells", (void*) NULL, 0);
   G__memfunc_setup("SetnSampl",919,G__G__TMVA3_324_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - nSampl", "Sets no of MC events in cell exploration", (void*) NULL, 0);
   G__memfunc_setup("SetnBin",691,G__G__TMVA3_324_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nBin", "Sets no of bins in histogs in cell exploration", (void*) NULL, 0);
   G__memfunc_setup("SetEvPerBin",1063,G__G__TMVA3_324_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - EvPerBin", "Sets max. no. of effective events per bin", (void*) NULL, 0);
   G__memfunc_setup("SetInhiDiv",983,G__G__TMVA3_324_0_33, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - -", "Set inhibition of cell division along certain edge", (void*) NULL, 0);
   G__memfunc_setup("SetDensity",1036,G__G__TMVA3_324_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::PDEFoamDensityBase' - 0 - dens", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTotDim",881,G__G__TMVA3_324_0_35, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "Get total dimension", (void*) NULL, 0);
   G__memfunc_setup("GetFoamName",1060,G__G__TMVA3_324_0_36, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TString), -1, 0, 0, 1, 1, 8, "", "Get name of foam", (void*) NULL, 0);
   G__memfunc_setup("GetNActiveCells",1469,G__G__TMVA3_324_0_37, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", "returns number of active cells", (void*) NULL, 0);
   G__memfunc_setup("GetNInActiveCells",1652,G__G__TMVA3_324_0_38, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", "returns number of not active cells", (void*) NULL, 0);
   G__memfunc_setup("GetNCells",865,G__G__TMVA3_324_0_39, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", "returns number of cells", (void*) NULL, 0);
   G__memfunc_setup("GetRootCell",1092,G__G__TMVA3_324_0_40, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell), -1, 0, 0, 1, 1, 8, "", "get pointer to root cell", (void*) NULL, 0);
   G__memfunc_setup("SetNmin",702,G__G__TMVA3_324_0_41, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNmin",690,G__G__TMVA3_324_0_42, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMaxDepth",1095,G__G__TMVA3_324_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - maxdepth", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxDepth",1083,G__G__TMVA3_324_0_44, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetXmin",712,G__G__TMVA3_324_0_45, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - idim d - 'Double_t' 0 - wmin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetXmax",714,G__G__TMVA3_324_0_46, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - idim d - 'Double_t' 0 - wmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXmin",700,G__G__TMVA3_324_0_47, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idim", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXmax",702,G__G__TMVA3_324_0_48, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idim", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddVariableName",1456,G__G__TMVA3_324_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddVariableName",1456,G__G__TMVA3_324_0_50, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObjString' - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVariableName",1479,G__G__TMVA3_324_0_51, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TObjString), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteBinarySearchTree",2206,G__G__TMVA3_324_0_52, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("VarTransform",1253,G__G__TMVA3_324_0_53, 102, -1, G__defined_typename("Float_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - idim f - 'Float_t' 0 - x", "transform [xmin, xmax] --> [0, 1]", (void*) NULL, 0);
   G__memfunc_setup("VarTransform",1253,G__G__TMVA3_324_0_54, 117, G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 0, 1, 1, 1, 8, "u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - invec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("VarTransformInvers",1884,G__G__TMVA3_324_0_55, 102, -1, G__defined_typename("Float_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - idim f - 'Float_t' 0 - x", "transform [0, 1] --> [xmin, xmax]", (void*) NULL, 0);
   G__memfunc_setup("VarTransformInvers",1884,G__G__TMVA3_324_0_56, 117, G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 0, 1, 1, 1, 8, "u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - invec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckAll",759,G__G__TMVA3_324_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", "Checks correctness of the entire data structure in the FOAM object", (void*) NULL, 0);
   G__memfunc_setup("PrintCell",909,G__G__TMVA3_324_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 '0' iCell", "Print content of cell", (void*) NULL, 0);
   G__memfunc_setup("PrintCells",1024,G__G__TMVA3_324_0_59, 121, -1, -1, 0, 0, 1, 1, 0, "", "Prints content of all cells", (void*) NULL, 0);
   G__memfunc_setup("Log",290,G__G__TMVA3_324_0_60, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Project2",777,G__G__TMVA3_324_0_61, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TH2D), -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - idim1 i - 'Int_t' 0 - idim2 "
"i 'TMVA::ECellValue' - 0 'kValue' cell_value U 'TMVA::PDEFoamKernelBase' - 0 'NULL' kernel "
"h - 'UInt_t' 0 '50' nbin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Draw1Dim",729,G__G__TMVA3_324_0_62, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TH1D), -1, 0, 3, 1, 1, 0, 
"i 'TMVA::ECellValue' - 0 - cell_value i - 'Int_t' 0 - nbin "
"U 'TMVA::PDEFoamKernelBase' - 0 'NULL' kernel", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RootPlot2dim",1199,G__G__TMVA3_324_0_63, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'TString' - 11 - filename u 'TString' - 0 - opt "
"g - 'Bool_t' 0 'kTRUE' createCanvas g - 'Bool_t' 0 'kTRUE' colors", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCellValue",1181,G__G__TMVA3_324_0_64, 102, -1, G__defined_typename("Float_t"), 0, 3, 1, 1, 0, 
"u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - xvec i 'TMVA::ECellValue' - 0 - cv "
"U 'TMVA::PDEFoamKernelBase' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCellValue",1181,G__G__TMVA3_324_0_65, 117, G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 0, 2, 1, 1, 0, 
"u 'map<int,float,less<int>,allocator<pair<const int,float> > >' 'map<Int_t,Float_t>' 11 - xvec i 'TMVA::ECellValue' - 0 - cv", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCellValue",1181,G__G__TMVA3_324_0_66, 102, -1, G__defined_typename("Float_t"), 0, 2, 1, 1, 0, 
"U 'TMVA::PDEFoamCell' - 10 - cell i 'TMVA::ECellValue' - 0 - cv", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA3_324_0_67, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoam::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_324_0_68, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoam::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_324_0_69, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoam::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_324_0_70, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoam::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_324_0_74, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_324_0_75, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoam::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_324_0_76, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoam::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_324_0_77, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoam::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_324_0_78, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoam::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PDEFoam", 730, G__G__TMVA3_324_0_79, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_324_0_80, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoam' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLPDEFoamDiscriminant(void) {
   /* TMVA::PDEFoamDiscriminant */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminant));
   G__memfunc_setup("PDEFoamDiscriminant",1857,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminant), -1, 0, 1, 1, 2, 0, "u 'TMVA::PDEFoamDiscriminant' - 11 - -", "Copy Constructor  NOT USED", (void*) NULL, 0);
   G__memfunc_setup("PDEFoamDiscriminant",1857,G__G__TMVA3_402_0_2, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminant), -1, 0, 0, 1, 1, 0, "", "Default constructor (used only by ROOT streamer)", (void*) NULL, 0);
   G__memfunc_setup("PDEFoamDiscriminant",1857,G__G__TMVA3_402_0_3, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminant), -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - - h - 'UInt_t' 0 - -", "Principal user-defined constructor", (void*) NULL, 0);
   G__memfunc_setup("FillFoamCells",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TMVA::Event' - 10 - ev f - 'Float_t' 0 - wt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Finalize",818,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Project2",777,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TH2D), -1, 0, 5, 1, 1, 0, 
"i - 'Int_t' 0 - - i - 'Int_t' 0 - - "
"i 'TMVA::ECellValue' - 0 - - U 'TMVA::PDEFoamKernelBase' - 0 - - "
"h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA3_402_0_7, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoamDiscriminant::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_402_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamDiscriminant::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_402_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoamDiscriminant::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_402_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoamDiscriminant::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_402_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_402_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamDiscriminant::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_402_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamDiscriminant::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_402_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamDiscriminant::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_402_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamDiscriminant::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PDEFoamDiscriminant", 1983, G__G__TMVA3_402_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_402_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminant), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamDiscriminant' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLPDEFoamDecisionTree(void) {
   /* TMVA::PDEFoamDecisionTree */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTree));
   G__memfunc_setup("Explore",735,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TMVA::PDEFoamCell' - 0 - Cell", "Exploration of the cell", (void*) NULL, 1);
   G__memfunc_setup("PDEFoamDecisionTree",1818,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTree), -1, 0, 1, 1, 2, 0, "u 'TMVA::PDEFoamDecisionTree' - 11 - -", "Copy Constructor  NOT USED", (void*) NULL, 0);
   G__memfunc_setup("PDEFoamDecisionTree",1818,G__G__TMVA3_404_0_3, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTree), -1, 0, 0, 1, 1, 0, "", "Default constructor (used only by ROOT streamer)", (void*) NULL, 0);
   G__memfunc_setup("PDEFoamDecisionTree",1818,G__G__TMVA3_404_0_4, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTree), -1, 0, 3, 1, 1, 0, 
"u 'TString' - 11 - - U 'TMVA::SeparationBase' - 0 - sepType "
"h - 'UInt_t' 0 - cls", "Principal user-defined constructor", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA3_404_0_5, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoamDecisionTree::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_404_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamDecisionTree::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_404_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoamDecisionTree::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_404_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoamDecisionTree::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_404_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_404_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamDecisionTree::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_404_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamDecisionTree::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_404_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamDecisionTree::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_404_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamDecisionTree::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PDEFoamDecisionTree", 1944, G__G__TMVA3_404_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_404_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTree), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamDecisionTree' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLPDEFoamDiscriminantDensity(void) {
   /* TMVA::PDEFoamDiscriminantDensity */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminantDensity));
   G__memfunc_setup("PDEFoamDiscriminantDensity",2593,G__G__TMVA3_405_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminantDensity), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PDEFoamDiscriminantDensity",2593,G__G__TMVA3_405_0_2, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminantDensity), -1, 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 0 - box h - 'UInt_t' 0 - cls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PDEFoamDiscriminantDensity",2593,G__G__TMVA3_405_0_3, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminantDensity), -1, 0, 1, 1, 1, 0, "u 'TMVA::PDEFoamDiscriminantDensity' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Density",736,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - Xarg d - 'Double_t' 1 - event_density", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA3_405_0_5, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoamDiscriminantDensity::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_405_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamDiscriminantDensity::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_405_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoamDiscriminantDensity::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_405_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoamDiscriminantDensity::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_405_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_405_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamDiscriminantDensity::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_405_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamDiscriminantDensity::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_405_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamDiscriminantDensity::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_405_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamDiscriminantDensity::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PDEFoamDiscriminantDensity", 2719, G__G__TMVA3_405_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_405_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminantDensity), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamDiscriminantDensity' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLPDEFoamEventDensity(void) {
   /* TMVA::PDEFoamEventDensity */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEventDensity));
   G__memfunc_setup("PDEFoamEventDensity",1854,G__G__TMVA3_406_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEventDensity), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PDEFoamEventDensity",1854,G__G__TMVA3_406_0_2, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEventDensity), -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 0 - box", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PDEFoamEventDensity",1854,G__G__TMVA3_406_0_3, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEventDensity), -1, 0, 1, 1, 1, 0, "u 'TMVA::PDEFoamEventDensity' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Density",736,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - Xarg d - 'Double_t' 1 - event_density", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA3_406_0_5, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoamEventDensity::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_406_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamEventDensity::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_406_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoamEventDensity::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_406_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoamEventDensity::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_406_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_406_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamEventDensity::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_406_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamEventDensity::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_406_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamEventDensity::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_406_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamEventDensity::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PDEFoamEventDensity", 1980, G__G__TMVA3_406_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_406_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEventDensity), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamEventDensity' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLPDEFoamTargetDensity(void) {
   /* TMVA::PDEFoamTargetDensity */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTargetDensity));
   G__memfunc_setup("PDEFoamTargetDensity",1955,G__G__TMVA3_407_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTargetDensity), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PDEFoamTargetDensity",1955,G__G__TMVA3_407_0_2, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTargetDensity), -1, 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 0 - box h - 'UInt_t' 0 - target", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PDEFoamTargetDensity",1955,G__G__TMVA3_407_0_3, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTargetDensity), -1, 0, 1, 1, 1, 0, "u 'TMVA::PDEFoamTargetDensity' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Density",736,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - Xarg d - 'Double_t' 1 - event_density", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA3_407_0_5, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoamTargetDensity::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_407_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamTargetDensity::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_407_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoamTargetDensity::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_407_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoamTargetDensity::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_407_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_407_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamTargetDensity::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_407_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamTargetDensity::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_407_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamTargetDensity::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_407_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamTargetDensity::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PDEFoamTargetDensity", 2081, G__G__TMVA3_407_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_407_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTargetDensity), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamTargetDensity' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLPDEFoamDecisionTreeDensity(void) {
   /* TMVA::PDEFoamDecisionTreeDensity */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTreeDensity));
   G__memfunc_setup("PDEFoamDecisionTreeDensity",2554,G__G__TMVA3_408_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTreeDensity), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PDEFoamDecisionTreeDensity",2554,G__G__TMVA3_408_0_2, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTreeDensity), -1, 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 0 - box h - 'UInt_t' 0 - cls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PDEFoamDecisionTreeDensity",2554,G__G__TMVA3_408_0_3, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTreeDensity), -1, 0, 1, 1, 1, 0, "u 'TMVA::PDEFoamDecisionTreeDensity' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Density",736,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - Xarg d - 'Double_t' 1 - event_density", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FillHistograms",1448,G__G__TMVA3_408_0_5, 121, -1, -1, 0, 5, 1, 1, 0, 
"u 'TMVA::Volume' - 1 - - u 'vector<TH1D*,allocator<TH1D*> >' 'vector<TH1D*>' 1 - - "
"u 'vector<TH1D*,allocator<TH1D*> >' 'vector<TH1D*>' 1 - - u 'vector<TH1D*,allocator<TH1D*> >' 'vector<TH1D*>' 1 - - "
"u 'vector<TH1D*,allocator<TH1D*> >' 'vector<TH1D*>' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA3_408_0_6, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoamDecisionTreeDensity::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_408_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamDecisionTreeDensity::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_408_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoamDecisionTreeDensity::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_408_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoamDecisionTreeDensity::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_408_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_408_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamDecisionTreeDensity::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_408_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamDecisionTreeDensity::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_408_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamDecisionTreeDensity::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_408_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamDecisionTreeDensity::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PDEFoamDecisionTreeDensity", 2680, G__G__TMVA3_408_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_408_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTreeDensity), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamDecisionTreeDensity' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLPDEFoamEvent(void) {
   /* TMVA::PDEFoamEvent */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEvent));
   G__memfunc_setup("PDEFoamEvent",1118,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEvent), -1, 0, 1, 1, 2, 0, "u 'TMVA::PDEFoamEvent' - 11 - -", "Copy Constructor  NOT USED", (void*) NULL, 0);
   G__memfunc_setup("PDEFoamEvent",1118,G__G__TMVA3_413_0_2, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEvent), -1, 0, 0, 1, 1, 0, "", "Default constructor (used only by ROOT streamer)", (void*) NULL, 0);
   G__memfunc_setup("PDEFoamEvent",1118,G__G__TMVA3_413_0_3, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEvent), -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - -", "Principal user-defined constructor", (void*) NULL, 0);
   G__memfunc_setup("FillFoamCells",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TMVA::Event' - 10 - ev f - 'Float_t' 0 - wt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA3_413_0_5, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoamEvent::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_413_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamEvent::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_413_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoamEvent::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_413_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoamEvent::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_413_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_413_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamEvent::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_413_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamEvent::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_413_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamEvent::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_413_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamEvent::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PDEFoamEvent", 1244, G__G__TMVA3_413_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_413_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamEvent), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLPDEFoamMultiTarget(void) {
   /* TMVA::PDEFoamMultiTarget */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamMultiTarget));
   G__memfunc_setup("PDEFoamMultiTarget",1742,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamMultiTarget), -1, 0, 1, 1, 2, 0, "u 'TMVA::PDEFoamMultiTarget' - 11 - -", "Copy Constructor  NOT USED", (void*) NULL, 0);
   G__memfunc_setup("CalculateMpv",1217,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"u 'map<int,float,less<int>,allocator<pair<const int,float> > >' 'map<Int_t,Float_t>' 1 - - u 'vector<TMVA::PDEFoamCell*,allocator<TMVA::PDEFoamCell*> >' - 11 - -", "Calculate mpv target", (void*) NULL, 1);
   G__memfunc_setup("CalculateMean",1295,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"u 'map<int,float,less<int>,allocator<pair<const int,float> > >' 'map<Int_t,Float_t>' 1 - - u 'vector<TMVA::PDEFoamCell*,allocator<TMVA::PDEFoamCell*> >' - 11 - -", "Calculate mean target", (void*) NULL, 1);
   G__memfunc_setup("PDEFoamMultiTarget",1742,G__G__TMVA3_415_0_4, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamMultiTarget), -1, 0, 0, 1, 1, 0, "", "Default constructor (used only by ROOT streamer)", (void*) NULL, 0);
   G__memfunc_setup("PDEFoamMultiTarget",1742,G__G__TMVA3_415_0_5, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamMultiTarget), -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - - i 'TMVA::ETargetSelection' - 0 - -", "Principal user-defined constructor", (void*) NULL, 0);
   G__memfunc_setup("GetCellValue",1181,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 0, 2, 1, 1, 0, 
"u 'map<int,float,less<int>,allocator<pair<const int,float> > >' 'map<Int_t,Float_t>' 11 - - i 'TMVA::ECellValue' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA3_415_0_7, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoamMultiTarget::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_415_0_8, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamMultiTarget::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_415_0_9, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoamMultiTarget::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_415_0_10, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoamMultiTarget::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_415_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_415_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamMultiTarget::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_415_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamMultiTarget::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_415_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamMultiTarget::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_415_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamMultiTarget::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PDEFoamMultiTarget", 1868, G__G__TMVA3_415_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_415_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamMultiTarget), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamMultiTarget' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLPDEFoamTarget(void) {
   /* TMVA::PDEFoamTarget */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTarget));
   G__memfunc_setup("CellValueIsUndefined",1995,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'TMVA::PDEFoamCell' - 0 - cell", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAverageNeighborsValue",2425,(G__InterfaceMethod) NULL, 102, -1, G__defined_typename("Float_t"), 0, 2, 1, 2, 0, 
"u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - - i 'TMVA::ECellValue' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PDEFoamTarget",1219,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTarget), -1, 0, 1, 1, 2, 0, "u 'TMVA::PDEFoamTarget' - 11 - -", "Copy Constructor  NOT USED", (void*) NULL, 0);
   G__memfunc_setup("PDEFoamTarget",1219,G__G__TMVA3_416_0_4, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTarget), -1, 0, 0, 1, 1, 0, "", "Default constructor (used only by ROOT streamer)", (void*) NULL, 0);
   G__memfunc_setup("PDEFoamTarget",1219,G__G__TMVA3_416_0_5, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTarget), -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - - h - 'UInt_t' 0 - -", "Principal user-defined constructor", (void*) NULL, 0);
   G__memfunc_setup("FillFoamCells",1277,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TMVA::Event' - 10 - ev f - 'Float_t' 0 - wt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Finalize",818,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCellValue",1181,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 3, 1, 1, 0, 
"u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - xvec i 'TMVA::ECellValue' - 0 - cv "
"U 'TMVA::PDEFoamKernelBase' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA3_416_0_9, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoamTarget::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_416_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamTarget::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_416_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoamTarget::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_416_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoamTarget::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_416_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_416_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamTarget::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_416_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamTarget::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_416_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamTarget::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_416_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamTarget::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PDEFoamTarget", 1345, G__G__TMVA3_416_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_416_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamTarget), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamTarget' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLPDEFoamKernelTrivial(void) {
   /* TMVA::PDEFoamKernelTrivial */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelTrivial));
   G__memfunc_setup("PDEFoamKernelTrivial",1944,G__G__TMVA3_417_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelTrivial), -1, 0, 0, 1, 1, 0, "", "Constructor", (void*) NULL, 0);
   G__memfunc_setup("PDEFoamKernelTrivial",1944,G__G__TMVA3_417_0_2, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelTrivial), -1, 0, 1, 1, 1, 0, "u 'TMVA::PDEFoamKernelTrivial' - 11 - -", "Copy Constructor", (void*) NULL, 0);
   G__memfunc_setup("Estimate",828,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 3, 1, 1, 0, 
"U 'TMVA::PDEFoam' - 0 - - u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - - "
"i 'TMVA::ECellValue' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA3_417_0_4, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoamKernelTrivial::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_417_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamKernelTrivial::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_417_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoamKernelTrivial::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_417_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoamKernelTrivial::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_417_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_417_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamKernelTrivial::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_417_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamKernelTrivial::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_417_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamKernelTrivial::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_417_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamKernelTrivial::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PDEFoamKernelTrivial", 2070, G__G__TMVA3_417_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_417_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelTrivial), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamKernelTrivial' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLPDEFoamKernelLinN(void) {
   /* TMVA::PDEFoamKernelLinN */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelLinN));
   G__memfunc_setup("WeightLinNeighbors",1836,(G__InterfaceMethod) NULL, 102, -1, G__defined_typename("Float_t"), 0, 4, 1, 2, 0, 
"U 'TMVA::PDEFoam' - 0 - - u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - - "
"i 'TMVA::ECellValue' - 0 - - g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAverageNeighborsValue",2425,(G__InterfaceMethod) NULL, 102, -1, G__defined_typename("Float_t"), 0, 3, 1, 2, 0, 
"U 'TMVA::PDEFoam' - 0 - - u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - - "
"i 'TMVA::ECellValue' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PDEFoamKernelLinN",1582,G__G__TMVA3_418_0_3, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelLinN), -1, 0, 0, 1, 1, 0, "", "Constructor", (void*) NULL, 0);
   G__memfunc_setup("PDEFoamKernelLinN",1582,G__G__TMVA3_418_0_4, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelLinN), -1, 0, 1, 1, 1, 0, "u 'TMVA::PDEFoamKernelLinN' - 11 - -", "Copy Constructor", (void*) NULL, 0);
   G__memfunc_setup("Estimate",828,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 3, 1, 1, 0, 
"U 'TMVA::PDEFoam' - 0 - - u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - - "
"i 'TMVA::ECellValue' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA3_418_0_6, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoamKernelLinN::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_418_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamKernelLinN::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_418_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoamKernelLinN::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_418_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoamKernelLinN::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_418_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_418_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamKernelLinN::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_418_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamKernelLinN::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_418_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamKernelLinN::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_418_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamKernelLinN::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PDEFoamKernelLinN", 1708, G__G__TMVA3_418_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_418_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelLinN), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamKernelLinN' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLPDEFoamKernelGauss(void) {
   /* TMVA::PDEFoamKernelGauss */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelGauss));
   G__memfunc_setup("WeightGaus",1016,(G__InterfaceMethod) NULL, 102, -1, G__defined_typename("Float_t"), 0, 3, 1, 2, 0, 
"U 'TMVA::PDEFoam' - 0 - - U 'TMVA::PDEFoamCell' - 0 - - "
"u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAverageNeighborsValue",2425,(G__InterfaceMethod) NULL, 102, -1, G__defined_typename("Float_t"), 0, 3, 1, 2, 0, 
"U 'TMVA::PDEFoam' - 0 - - u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - - "
"i 'TMVA::ECellValue' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PDEFoamKernelGauss",1728,G__G__TMVA3_419_0_3, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelGauss), -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - sigma", "Constructor", (void*) NULL, 0);
   G__memfunc_setup("PDEFoamKernelGauss",1728,G__G__TMVA3_419_0_4, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelGauss), -1, 0, 1, 1, 1, 0, "u 'TMVA::PDEFoamKernelGauss' - 11 - -", "Copy Constructor", (void*) NULL, 0);
   G__memfunc_setup("Estimate",828,(G__InterfaceMethod) NULL,102, -1, G__defined_typename("Float_t"), 0, 3, 1, 1, 0, 
"U 'TMVA::PDEFoam' - 0 - - u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - - "
"i 'TMVA::ECellValue' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA3_419_0_6, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoamKernelGauss::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_419_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamKernelGauss::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_419_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoamKernelGauss::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_419_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoamKernelGauss::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_419_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_419_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamKernelGauss::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_419_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamKernelGauss::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_419_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamKernelGauss::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_419_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamKernelGauss::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PDEFoamKernelGauss", 1854, G__G__TMVA3_419_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_419_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelGauss), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamKernelGauss' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLBDTEventWrapper(void) {
   /* TMVA::BDTEventWrapper */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLBDTEventWrapper));
   G__memfunc_setup("BDTEventWrapper",1469,G__G__TMVA3_420_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLBDTEventWrapper), -1, 0, 1, 1, 1, 0, "U 'TMVA::Event' - 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator<",936,G__G__TMVA3_420_0_2, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TMVA::BDTEventWrapper' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCumulativeWeight",1971,G__G__TMVA3_420_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
"g - 'Bool_t' 0 - type d - 'Double_t' 0 - weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCumulativeWeight",1959,G__G__TMVA3_420_0_4, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "g - 'Bool_t' 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVarIndex",1101,G__G__TMVA3_420_0_5, 121, -1, -1, 0, 1, 3, 1, 0, "i - 'Int_t' 0 - iVar", (char*)NULL, (void*) G__func2void( (void (*)(Int_t))(&TMVA::BDTEventWrapper::SetVarIndex) ), 0);
   G__memfunc_setup("GetVal",579,G__G__TMVA3_420_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator*",918,G__G__TMVA3_420_0_7, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEvent), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("BDTEventWrapper", 1469, G__G__TMVA3_420_0_8, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLBDTEventWrapper), -1, 0, 1, 1, 1, 0, "u 'TMVA::BDTEventWrapper' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~BDTEventWrapper", 1595, G__G__TMVA3_420_0_9, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLCCTreeWrapper(void) {
   /* TMVA::CCTreeWrapper */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrapper));
   G__memfunc_setup("CCTreeWrapper",1271,G__G__TMVA3_531_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrapper), -1, 0, 2, 1, 1, 0, 
"U 'TMVA::DecisionTree' - 0 - T U 'TMVA::SeparationBase' - 0 - qualityIndex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckEvent",992,G__G__TMVA3_531_0_2, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'TMVA::Event' - 11 - e g - 'Bool_t' 0 'false' useYesNoLeaf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TestTreeQuality",1561,G__G__TMVA3_531_0_3, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "U 'vector<TMVA::Event*,allocator<TMVA::Event*> >' 'TMVA::CCTreeWrapper::EventList' 10 - validationSample", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TestTreeQuality",1561,G__G__TMVA3_531_0_4, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "U 'TMVA::DataSet' - 10 - validationSample", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneNode",912,G__G__TMVA3_531_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::CCTreeWrapper::CCTreeNode' - 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitTree",804,G__G__TMVA3_531_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::CCTreeWrapper::CCTreeNode' - 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRoot",708,G__G__TMVA3_531_0_7, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrappercLcLCCTreeNode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("CCTreeWrapper", 1271, G__G__TMVA3_531_0_8, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrapper), -1, 0, 1, 1, 1, 0, "u 'TMVA::CCTreeWrapper' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~CCTreeWrapper", 1397, G__G__TMVA3_531_0_9, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_531_0_10, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrapper), -1, 1, 1, 1, 1, 0, "u 'TMVA::CCTreeWrapper' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLCCPruner(void) {
   /* TMVA::CCPruner */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCPruner));
   G__memfunc_setup("CCPruner",770,G__G__TMVA3_533_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCPruner), -1, 0, 3, 1, 1, 0, 
"U 'TMVA::DecisionTree' - 0 - t_max U 'vector<TMVA::Event*,allocator<TMVA::Event*> >' 'TMVA::CCPruner::EventList' 10 - validationSample "
"U 'TMVA::SeparationBase' - 0 'NULL' qualityIndex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CCPruner",770,G__G__TMVA3_533_0_2, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCPruner), -1, 0, 3, 1, 1, 0, 
"U 'TMVA::DecisionTree' - 0 - t_max U 'TMVA::DataSet' - 10 - validationSample "
"U 'TMVA::SeparationBase' - 0 'NULL' qualityIndex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPruneStrength",1669,G__G__TMVA3_533_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '-1.0' alpha", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Optimize",849,G__G__TMVA3_533_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptimalPruneSequence",2361,G__G__TMVA3_533_0_5, 117, G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgR), G__defined_typename("vector<TMVA::DecisionTreeNode*>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptimalQualityIndex",2263,G__G__TMVA3_533_0_6, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptimalPruneStrength",2383,G__G__TMVA3_533_0_7, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("CCPruner", 770, G__G__TMVA3_533_0_8, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCPruner), -1, 0, 1, 1, 1, 0, "u 'TMVA::CCPruner' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~CCPruner", 896, G__G__TMVA3_533_0_9, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLCostComplexityPruneTool(void) {
   /* TMVA::CostComplexityPruneTool */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool));
   G__memfunc_setup("CostComplexityPruneTool",2415,G__G__TMVA3_541_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool), -1, 0, 1, 1, 1, 0, "U 'TMVA::SeparationBase' - 0 'NULL' qualityIndex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculatePruningInfo",2045,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPruningInfo), -1, 0, 3, 1, 1, 0, 
"U 'TMVA::DecisionTree' - 0 - dt U 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'TMVA::IPruneTool::EventSample' 10 'NULL' testEvents "
"g - 'Bool_t' 0 'kFALSE' isAutomatic", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitTreePruningMetaData",2312,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TMVA::DecisionTreeNode' - 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Optimize",849,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"U 'TMVA::DecisionTree' - 0 - dt d - 'Double_t' 0 - weights", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("CostComplexityPruneTool", 2415, G__G__TMVA3_541_0_6, (int) ('i'), 
G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool), -1, 0, 1, 1, 1, 0, "u 'TMVA::CostComplexityPruneTool' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~CostComplexityPruneTool", 2541, G__G__TMVA3_541_0_7, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA3_541_0_8, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool), -1, 1, 1, 1, 1, 0, "u 'TMVA::CostComplexityPruneTool' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLSVEvent(void) {
   /* TMVA::SVEvent */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent));
   G__memfunc_setup("SVEvent",683,G__G__TMVA3_542_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SVEvent",683,G__G__TMVA3_542_0_2, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent), -1, 0, 3, 1, 1, 0, 
"U 'TMVA::Event' - 10 - - f - 'Float_t' 0 - - "
"g - 'Bool_t' 0 'kFALSE' isSignal", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SVEvent",683,G__G__TMVA3_542_0_3, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent), -1, 0, 4, 1, 1, 0, 
"U 'vector<float,allocator<float> >' 'vector<Float_t>' 10 - - f - 'Float_t' 0 - alpha "
"i - 'Int_t' 0 - typeFlag h - 'UInt_t' 0 - ns", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SVEvent",683,G__G__TMVA3_542_0_4, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent), -1, 0, 4, 1, 1, 0, 
"U 'vector<float,allocator<float> >' 'vector<Float_t>' 10 - svector f - 'Float_t' 0 - alpha "
"f - 'Float_t' 0 - alpha_p i - 'Int_t' 0 - typeFlag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAlpha",786,G__G__TMVA3_542_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - alpha", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAlpha_p",993,G__G__TMVA3_542_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - alpha", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetErrorCache",1290,G__G__TMVA3_542_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - err_cache", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIsShrinked",1312,G__G__TMVA3_542_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - isshrinked", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLine",692,G__G__TMVA3_542_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'Float_t' 0 - line", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIdx",593,G__G__TMVA3_542_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNs",493,G__G__TMVA3_542_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - ns", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateErrorCache",1601,G__G__TMVA3_542_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - upercache", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDataVector",1293,G__G__TMVA3_542_0_13, 85, G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAlpha",774,G__G__TMVA3_542_0_14, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAlpha_p",981,G__G__TMVA3_542_0_15, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDeltaAlpha",1264,G__G__TMVA3_542_0_16, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetErrorCache",1278,G__G__TMVA3_542_0_17, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTypeFlag",1084,G__G__TMVA3_542_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNVar",663,G__G__TMVA3_542_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIdx",581,G__G__TMVA3_542_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLine",680,G__G__TMVA3_542_0_21, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNs",481,G__G__TMVA3_542_0_22, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCweight",1003,G__G__TMVA3_542_0_23, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTarget",903,G__G__TMVA3_542_0_24, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInI0a",589,G__G__TMVA3_542_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInI0b",590,G__G__TMVA3_542_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInI0",492,G__G__TMVA3_542_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInI1",493,G__G__TMVA3_542_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInI2",494,G__G__TMVA3_542_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInI3",495,G__G__TMVA3_542_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,G__G__TMVA3_542_0_31, 121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintData",903,G__G__TMVA3_542_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA3_542_0_33, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::SVEvent::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_542_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SVEvent::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_542_0_35, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::SVEvent::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_542_0_36, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::SVEvent::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA3_542_0_37, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA3_542_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__TMVA3_542_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_542_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_542_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SVEvent::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_542_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::SVEvent::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_542_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SVEvent::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_542_0_44, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::SVEvent::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("SVEvent", 683, G__G__TMVA3_542_0_45, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent), -1, 0, 1, 1, 1, 0, "u 'TMVA::SVEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~SVEvent", 809, G__G__TMVA3_542_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLOptimizeConfigParameters(void) {
   /* TMVA::OptimizeConfigParameters */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters));
   G__memfunc_setup("OptimizeConfigParameters",2491,G__G__TMVA3_586_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters), -1, 0, 4, 1, 1, 0, 
"U 'TMVA::MethodBase' - 40 - method u 'map<TString,TMVA::Interval*,less<TString>,allocator<pair<const TString,TMVA::Interval*> > >' 'map<TString,TMVA::Interval*>' 0 - tuneParameters "
"u 'TString' - 0 '\"Separation\"' fomType u 'TString' - 0 '\"GA\"' optimizationType", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("optimize",881,G__G__TMVA3_586_0_2, 117, G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR), G__defined_typename("map<TString,Double_t>"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetScanIndices",1380,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<int>"), 0, 2, 1, 4, 0, 
"i - - 0 - val u 'vector<int,allocator<int> >' 'vector<int>' 0 - base", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("optimizeScan",1270,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("optimizeFit",1172,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EstimatorFunction",1790,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFOM",514,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethod",897,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMethodBase), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMVADists",1035,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSeparation",1334,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetROCIntegral",1338,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSigEffAtBkgEff",1582,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 0 '0.1' bkgEff", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBkgEffAtSigEff",1582,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 0 '0.5' sigEff", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBkgRejAtSigEff",1598,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 0 '0.5' sigEff", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA3_586_0_16, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::OptimizeConfigParameters::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA3_586_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::OptimizeConfigParameters::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA3_586_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::OptimizeConfigParameters::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA3_586_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::OptimizeConfigParameters::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_586_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_586_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::OptimizeConfigParameters::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_586_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::OptimizeConfigParameters::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_586_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::OptimizeConfigParameters::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_586_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::OptimizeConfigParameters::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("OptimizeConfigParameters", 2491, G__G__TMVA3_586_0_28, (int) ('i'), 
G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters), -1, 0, 1, 1, 1, 0, "u 'TMVA::OptimizeConfigParameters' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~OptimizeConfigParameters", 2617, G__G__TMVA3_586_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncG__TMVA3() {
}

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();

}

static void G__cpp_setup_global1() {
}

static void G__cpp_setup_global2() {
}

static void G__cpp_setup_global3() {
}

static void G__cpp_setup_global4() {
}

static void G__cpp_setup_global5() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__TMVA3() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
  G__cpp_setup_global3();
  G__cpp_setup_global4();
  G__cpp_setup_global5();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {
}

static void G__cpp_setup_func5() {
}

static void G__cpp_setup_func6() {
}

static void G__cpp_setup_func7() {
}

static void G__cpp_setup_func8() {
}

static void G__cpp_setup_func9() {
}

static void G__cpp_setup_func10() {
}

static void G__cpp_setup_func11() {
}

static void G__cpp_setup_func12() {
}

static void G__cpp_setup_func13() {
}

static void G__cpp_setup_func14() {
}

static void G__cpp_setup_func15() {
}

static void G__cpp_setup_func16() {
}

static void G__cpp_setup_func17() {
}

static void G__cpp_setup_func18() {
}

static void G__cpp_setup_func19() {
}

static void G__cpp_setup_func20() {
}

static void G__cpp_setup_func21() {
}

static void G__cpp_setup_func22() {
}

static void G__cpp_setup_func23() {
}

static void G__cpp_setup_func24() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__TMVA3() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
  G__cpp_setup_func6();
  G__cpp_setup_func7();
  G__cpp_setup_func8();
  G__cpp_setup_func9();
  G__cpp_setup_func10();
  G__cpp_setup_func11();
  G__cpp_setup_func12();
  G__cpp_setup_func13();
  G__cpp_setup_func14();
  G__cpp_setup_func15();
  G__cpp_setup_func16();
  G__cpp_setup_func17();
  G__cpp_setup_func18();
  G__cpp_setup_func19();
  G__cpp_setup_func20();
  G__cpp_setup_func21();
  G__cpp_setup_func22();
  G__cpp_setup_func23();
  G__cpp_setup_func24();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__TMVA3LN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_basic_istreamlEcharcOchar_traitslEchargRsPgR = { "basic_istream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TObjArray = { "TObjArray" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVA = { "TMVA" , 110 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLMsgLogger = { "TMVA::MsgLogger" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLConfig = { "TMVA::Config" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting = { "TMVA::Config::VariablePlotting" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames = { "TMVA::Config::IONames" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TH1 = { "TH1" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TH1F = { "TH1F" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TF1 = { "TF1" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLKDEKernel = { "TMVA::KDEKernel" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelType = { "TMVA::KDEKernel::EKernelType" , 101 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelIter = { "TMVA::KDEKernel::EKernelIter" , 101 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelBorder = { "TMVA::KDEKernel::EKernelBorder" , 101 , -1 };
G__linked_taginfo G__G__TMVA3LN_TRandom3 = { "TRandom3" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLInterval = { "TMVA::Interval" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLLogInterval = { "TMVA::LogInterval" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLEMsgType = { "TMVA::EMsgType" , 101 , -1 };
G__linked_taginfo G__G__TMVA3LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR = { "map<TString,TMVA::Types::EMVA,less<TString>,allocator<pair<const TString,TMVA::Types::EMVA> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR = { "map<TMVA::EMsgType,string,less<TMVA::EMsgType>,allocator<pair<const TMVA::EMsgType,string> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLConfigurable = { "TMVA::Configurable" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLOptionlEboolgR = { "TMVA::Option<bool>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlEboolcOallocatorlEboolgRsPgR = { "vector<bool,allocator<bool> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<bool,allocator<bool> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLOptionlEboolmUgR = { "TMVA::Option<bool*>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLOptionlEfloatgR = { "TMVA::Option<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR = { "vector<float,allocator<float> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<float,allocator<float> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLIFitterTarget = { "TMVA::IFitterTarget" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLFitterBase = { "TMVA::FitterBase" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR = { "vector<TMVA::Interval*,allocator<TMVA::Interval*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::Interval*,allocator<TMVA::Interval*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<double,allocator<double> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLMCFitter = { "TMVA::MCFitter" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLGeneticFitter = { "TMVA::GeneticFitter" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter = { "TMVA::SimulatedAnnealingFitter" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLMinuitWrapper = { "TMVA::MinuitWrapper" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLMinuitFitter = { "TMVA::MinuitFitter" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMinuit = { "TMinuit" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TH1D = { "TH1D" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TH2D = { "TH2D" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TObjString = { "TObjString" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMatrixTlEdoublegR = { "TMatrixT<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLTimer = { "TMVA::Timer" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoamCell = { "TMVA::PDEFoamCell" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoamVect = { "TMVA::PDEFoamVect" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoamDensityBase = { "TMVA::PDEFoamDensityBase" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoamKernelBase = { "TMVA::PDEFoamKernelBase" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoam = { "TMVA::PDEFoam" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLEDTSeparation = { "TMVA::EDTSeparation" , 101 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLEFoamType = { "TMVA::EFoamType" , 101 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLECellValue = { "TMVA::ECellValue" , 101 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLVolume = { "TMVA::Volume" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLNode = { "TMVA::Node" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLEvent = { "TMVA::Event" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLBinaryTree = { "TMVA::BinaryTree" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLBinarySearchTree = { "TMVA::BinarySearchTree" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR = { "vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR = { "vector<TMVA::Event*,allocator<TMVA::Event*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::Event*,allocator<TMVA::Event*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR = { "pair<double,const TMVA::Event*>" , 115 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR = { "vector<pair<double,const TMVA::Event*>,allocator<pair<double,const TMVA::Event*> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<double,const TMVA::Event*>,allocator<pair<double,const TMVA::Event*> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR = { "vector<float*,allocator<float*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<float*,allocator<float*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TRef = { "TRef" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR = { "vector<TMVA::PDEFoamCell*,allocator<TMVA::PDEFoamCell*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::PDEFoamCell*,allocator<TMVA::PDEFoamCell*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_maplEintcOfloatcOlesslEintgRcOallocatorlEpairlEconstsPintcOfloatgRsPgRsPgR = { "map<int,float,less<int>,allocator<pair<const int,float> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminant = { "TMVA::PDEFoamDiscriminant" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLSeparationBase = { "TMVA::SeparationBase" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTree = { "TMVA::PDEFoamDecisionTree" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminantDensity = { "TMVA::PDEFoamDiscriminantDensity" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoamEventDensity = { "TMVA::PDEFoamEventDensity" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoamTargetDensity = { "TMVA::PDEFoamTargetDensity" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTreeDensity = { "TMVA::PDEFoamDecisionTreeDensity" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlETH1DmUcOallocatorlETH1DmUgRsPgR = { "vector<TH1D*,allocator<TH1D*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETH1DmUcOallocatorlETH1DmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TH1D*,allocator<TH1D*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoamEvent = { "TMVA::PDEFoamEvent" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLETargetSelection = { "TMVA::ETargetSelection" , 101 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoamMultiTarget = { "TMVA::PDEFoamMultiTarget" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoamTarget = { "TMVA::PDEFoamTarget" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoamKernelTrivial = { "TMVA::PDEFoamKernelTrivial" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoamKernelLinN = { "TMVA::PDEFoamKernelLinN" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoamKernelGauss = { "TMVA::PDEFoamKernelGauss" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLBDTEventWrapper = { "TMVA::BDTEventWrapper" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLDecisionTreeNode = { "TMVA::DecisionTreeNode" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR = { "map<string,TObjArray*,less<string>,allocator<pair<const string,TObjArray*> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLDataSet = { "TMVA::DataSet" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR = { "vector<TMVA::VariableInfo,allocator<TMVA::VariableInfo> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::VariableInfo,allocator<TMVA::VariableInfo> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR = { "vector<TMVA::ClassInfo*,allocator<TMVA::ClassInfo*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::ClassInfo*,allocator<TMVA::ClassInfo*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLDecisionTree = { "TMVA::DecisionTree" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR = { "vector<const TMVA::Event*,allocator<const TMVA::Event*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const TMVA::Event*,allocator<const TMVA::Event*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR = { "vector<vector<TMVA::Event*,allocator<TMVA::Event*> >*,allocator<vector<TMVA::Event*,allocator<TMVA::Event*> >*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<TMVA::Event*,allocator<TMVA::Event*> >*,allocator<vector<TMVA::Event*,allocator<TMVA::Event*> >*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_maplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgR = { "map<TString,TMVA::Results*,less<TString>,allocator<pair<const TString,TMVA::Results*> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR = { "vector<map<TString,TMVA::Results*,less<TString>,allocator<pair<const TString,TMVA::Results*> > >,allocator<map<TString,TMVA::Results*,less<TString>,allocator<pair<const TString,TMVA::Results*> > > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<map<TString,TMVA::Results*,less<TString>,allocator<pair<const TString,TMVA::Results*> > >,allocator<map<TString,TMVA::Results*,less<TString>,allocator<pair<const TString,TMVA::Results*> > > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlEcharcOallocatorlEchargRsPgR = { "vector<char,allocator<char> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR = { "reverse_iterator<vector<char,allocator<char> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_pairlEfloatcOlongsPlonggR = { "pair<float,long long>" , 115 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR = { "vector<pair<float,long long>*,allocator<pair<float,long long>*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<float,long long>*,allocator<pair<float,long long>*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR = { "vector<vector<pair<float,long long>*,allocator<pair<float,long long>*> >,allocator<vector<pair<float,long long>*,allocator<pair<float,long long>*> > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<pair<float,long long>*,allocator<pair<float,long long>*> >,allocator<vector<pair<float,long long>*,allocator<pair<float,long long>*> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR = { "vector<long long,allocator<long long> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcLcLiteratorgR = { "reverse_iterator<vector<long long,allocator<long long> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR = { "vector<vector<long long,allocator<long long> >,allocator<vector<long long,allocator<long long> > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<long long,allocator<long long> >,allocator<vector<long long,allocator<long long> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLCCTreeWrapper = { "TMVA::CCTreeWrapper" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLCCTreeWrappercLcLCCTreeNode = { "TMVA::CCTreeWrapper::CCTreeNode" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLCCPruner = { "TMVA::CCPruner" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgR = { "vector<TMVA::DecisionTreeNode*,allocator<TMVA::DecisionTreeNode*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::DecisionTreeNode*,allocator<TMVA::DecisionTreeNode*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPruningInfo = { "TMVA::PruningInfo" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLIPruneTool = { "TMVA::IPruneTool" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool = { "TMVA::CostComplexityPruneTool" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLSVEvent = { "TMVA::SVEvent" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgR = { "vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR = { "vector<vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> >,allocator<vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> >,allocator<vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR = { "vector<TMVA::Ranking*,allocator<TMVA::Ranking*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::Ranking*,allocator<TMVA::Ranking*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLMethodBase = { "TMVA::MethodBase" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR = { "map<TString,double,less<TString>,allocator<pair<const TString,double> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR = { "vector<vector<float,allocator<float> >,allocator<vector<float,allocator<float> > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<float,allocator<float> >,allocator<vector<float,allocator<float> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR = { "vector<const vector<TMVA::Event*,allocator<TMVA::Event*> >*,allocator<const vector<TMVA::Event*,allocator<TMVA::Event*> >*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const vector<TMVA::Event*,allocator<TMVA::Event*> >*,allocator<const vector<TMVA::Event*,allocator<TMVA::Event*> >*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters = { "TMVA::OptimizeConfigParameters" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_maplETStringcOTMVAcLcLIntervalmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIntervalmUgRsPgRsPgR = { "map<TString,TMVA::Interval*,less<TString>,allocator<pair<const TString,TMVA::Interval*> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA3LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR = { "map<vector<double,allocator<double> >,double,less<vector<double,allocator<double> > >,allocator<pair<const vector<double,allocator<double> >,double> > >" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__TMVA3() {
  G__G__TMVA3LN_TClass.tagnum = -1 ;
  G__G__TMVA3LN_TBuffer.tagnum = -1 ;
  G__G__TMVA3LN_TMemberInspector.tagnum = -1 ;
  G__G__TMVA3LN_TObject.tagnum = -1 ;
  G__G__TMVA3LN_TNamed.tagnum = -1 ;
  G__G__TMVA3LN_TString.tagnum = -1 ;
  G__G__TMVA3LN_basic_istreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_TObjArray.tagnum = -1 ;
  G__G__TMVA3LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_TMVA.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLMsgLogger.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLConfig.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames.tagnum = -1 ;
  G__G__TMVA3LN_TH1.tagnum = -1 ;
  G__G__TMVA3LN_TH1F.tagnum = -1 ;
  G__G__TMVA3LN_TF1.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLKDEKernel.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelType.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelIter.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelBorder.tagnum = -1 ;
  G__G__TMVA3LN_TRandom3.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLInterval.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLLogInterval.tagnum = -1 ;
  G__G__TMVA3LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLEMsgType.tagnum = -1 ;
  G__G__TMVA3LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLConfigurable.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLOptionlEboolgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlEboolcOallocatorlEboolgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLOptionlEboolmUgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLOptionlEfloatgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLIFitterTarget.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLFitterBase.tagnum = -1 ;
  G__G__TMVA3LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLMCFitter.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLGeneticFitter.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLMinuitWrapper.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLMinuitFitter.tagnum = -1 ;
  G__G__TMVA3LN_TMinuit.tagnum = -1 ;
  G__G__TMVA3LN_TVectorTlEfloatgR.tagnum = -1 ;
  G__G__TMVA3LN_TVectorTlEdoublegR.tagnum = -1 ;
  G__G__TMVA3LN_TH1D.tagnum = -1 ;
  G__G__TMVA3LN_TMatrixTBaselEfloatgR.tagnum = -1 ;
  G__G__TMVA3LN_TMatrixTBaselEdoublegR.tagnum = -1 ;
  G__G__TMVA3LN_TH2D.tagnum = -1 ;
  G__G__TMVA3LN_TObjString.tagnum = -1 ;
  G__G__TMVA3LN_TMatrixTlEdoublegR.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLTimer.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLPDEFoamCell.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLPDEFoamVect.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLPDEFoamDensityBase.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLPDEFoamKernelBase.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLPDEFoam.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLEDTSeparation.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLEFoamType.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLECellValue.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLVolume.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLNode.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLEvent.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLBinaryTree.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLBinarySearchTree.tagnum = -1 ;
  G__G__TMVA3LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_TRef.tagnum = -1 ;
  G__G__TMVA3LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_maplEintcOfloatcOlesslEintgRcOallocatorlEpairlEconstsPintcOfloatgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminant.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLSeparationBase.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTree.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminantDensity.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLPDEFoamEventDensity.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLPDEFoamTargetDensity.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTreeDensity.tagnum = -1 ;
  G__G__TMVA3LN_vectorlETH1DmUcOallocatorlETH1DmUgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlETH1DmUcOallocatorlETH1DmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLPDEFoamEvent.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLETargetSelection.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLPDEFoamMultiTarget.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLPDEFoamTarget.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLPDEFoamKernelTrivial.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLPDEFoamKernelLinN.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLPDEFoamKernelGauss.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLBDTEventWrapper.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLDecisionTreeNode.tagnum = -1 ;
  G__G__TMVA3LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLDataSet.tagnum = -1 ;
  G__G__TMVA3LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLDecisionTree.tagnum = -1 ;
  G__G__TMVA3LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_maplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlEcharcOallocatorlEchargRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_pairlEfloatcOlongsPlonggR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLCCTreeWrapper.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLCCTreeWrappercLcLCCTreeNode.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLCCPruner.tagnum = -1 ;
  G__G__TMVA3LN_vectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLPruningInfo.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLIPruneTool.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLSVEvent.tagnum = -1 ;
  G__G__TMVA3LN_vectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLMethodBase.tagnum = -1 ;
  G__G__TMVA3LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters.tagnum = -1 ;
  G__G__TMVA3LN_maplETStringcOTMVAcLcLIntervalmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIntervalmUgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA3LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__TMVA3() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TClass);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TObject);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TNamed);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TString);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_basic_istreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TObjArray);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVA),0,-1,0,(char*)NULL,G__setup_memvarTMVA,G__setup_memfuncTMVA);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLMsgLogger);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLConfig),sizeof(TMVA::Config),-1,263424,"Singleton class for global configuration settings",G__setup_memvarTMVAcLcLConfig,G__setup_memfuncTMVAcLcLConfig);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting),sizeof(TMVA::Config::VariablePlotting),-1,262144,(char*)NULL,G__setup_memvarTMVAcLcLConfigcLcLVariablePlotting,G__setup_memfuncTMVAcLcLConfigcLcLVariablePlotting);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames),sizeof(TMVA::Config::IONames),-1,262144,(char*)NULL,G__setup_memvarTMVAcLcLConfigcLcLIONames,G__setup_memfuncTMVAcLcLConfigcLcLIONames);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TH1);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TH1F);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TF1);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLKDEKernel),sizeof(TMVA::KDEKernel),-1,263424,"Kernel density estimator for PDF smoothing",G__setup_memvarTMVAcLcLKDEKernel,G__setup_memfuncTMVAcLcLKDEKernel);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelType);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelIter);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelBorder);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TRandom3);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLInterval),sizeof(TMVA::Interval),-1,296448,"Interval definition, continous and discrete",G__setup_memvarTMVAcLcLInterval,G__setup_memfuncTMVAcLcLInterval);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLLogInterval),sizeof(TMVA::LogInterval),-1,296448,"Interval definition, continous and discrete",G__setup_memvarTMVAcLcLLogInterval,G__setup_memfuncTMVAcLcLLogInterval);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLEMsgType);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLConfigurable);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLOptionlEboolgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEboolcOallocatorlEboolgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLOptionlEboolmUgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETStringcOallocatorlETStringgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLOptionlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLIFitterTarget),sizeof(TMVA::IFitterTarget),-1,263425,"base class for a fitter \"target\"",G__setup_memvarTMVAcLcLIFitterTarget,G__setup_memfuncTMVAcLcLIFitterTarget);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLFitterBase),sizeof(TMVA::FitterBase),-1,324610,"Baseclass for fitters",G__setup_memvarTMVAcLcLFitterBase,G__setup_memfuncTMVAcLcLFitterBase);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLMCFitter),sizeof(TMVA::MCFitter),-1,324608,"Fitter using Monte Carlo sampling of parameters ",G__setup_memvarTMVAcLcLMCFitter,G__setup_memfuncTMVAcLcLMCFitter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLGeneticFitter),sizeof(TMVA::GeneticFitter),-1,324608,"Fitter using a Genetic Algorithm",G__setup_memvarTMVAcLcLGeneticFitter,G__setup_memfuncTMVAcLcLGeneticFitter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter),sizeof(TMVA::SimulatedAnnealingFitter),-1,324608,"Fitter using a Simulated Annealing Algorithm",G__setup_memvarTMVAcLcLSimulatedAnnealingFitter,G__setup_memfuncTMVAcLcLSimulatedAnnealingFitter);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLMinuitWrapper),sizeof(TMVA::MinuitWrapper),-1,324608,"Wrapper around TMinuit",G__setup_memvarTMVAcLcLMinuitWrapper,G__setup_memfuncTMVAcLcLMinuitWrapper);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLMinuitFitter),sizeof(TMVA::MinuitFitter),-1,324609,"Fitter using a Genetic Algorithm",G__setup_memvarTMVAcLcLMinuitFitter,G__setup_memfuncTMVAcLcLMinuitFitter);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMinuit);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TVectorTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TVectorTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TH1D);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTBaselEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTBaselEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TH2D);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TObjString);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLTimer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell),sizeof(TMVA::PDEFoamCell),-1,325376,"Single cell of FOAM",G__setup_memvarTMVAcLcLPDEFoamCell,G__setup_memfuncTMVAcLcLPDEFoamCell);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect),sizeof(TMVA::PDEFoamVect),-1,327424,"n-dimensional vector with dynamical allocation",G__setup_memvarTMVAcLcLPDEFoamVect,G__setup_memfuncTMVAcLcLPDEFoamVect);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoamDensityBase),sizeof(TMVA::PDEFoamDensityBase),-1,325377,"PDEFoam event density interface",G__setup_memvarTMVAcLcLPDEFoamDensityBase,G__setup_memfuncTMVAcLcLPDEFoamDensityBase);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelBase),sizeof(TMVA::PDEFoamKernelBase),-1,292609,"PDEFoam kernel interface",G__setup_memvarTMVAcLcLPDEFoamKernelBase,G__setup_memfuncTMVAcLcLPDEFoamKernelBase);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoam),sizeof(TMVA::PDEFoam),-1,325376,"Tree of PDEFoamCells",G__setup_memvarTMVAcLcLPDEFoam,G__setup_memfuncTMVAcLcLPDEFoam);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLEDTSeparation);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLEFoamType);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLECellValue);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLVolume);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLNode);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLEvent);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLBinaryTree);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLBinarySearchTree);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEintcOallocatorlEintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TRef);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_maplEintcOfloatcOlesslEintgRcOallocatorlEpairlEconstsPintcOfloatgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminant),sizeof(TMVA::PDEFoamDiscriminant),-1,325376,"Tree of PDEFoamCells",G__setup_memvarTMVAcLcLPDEFoamDiscriminant,G__setup_memfuncTMVAcLcLPDEFoamDiscriminant);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLSeparationBase);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTree),sizeof(TMVA::PDEFoamDecisionTree),-1,325376,"Decision tree like PDEFoam",G__setup_memvarTMVAcLcLPDEFoamDecisionTree,G__setup_memfuncTMVAcLcLPDEFoamDecisionTree);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoamDiscriminantDensity),sizeof(TMVA::PDEFoamDiscriminantDensity),-1,325376,"Class for Discriminant density",G__setup_memvarTMVAcLcLPDEFoamDiscriminantDensity,G__setup_memfuncTMVAcLcLPDEFoamDiscriminantDensity);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoamEventDensity),sizeof(TMVA::PDEFoamEventDensity),-1,325376,"Class for Event density",G__setup_memvarTMVAcLcLPDEFoamEventDensity,G__setup_memfuncTMVAcLcLPDEFoamEventDensity);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoamTargetDensity),sizeof(TMVA::PDEFoamTargetDensity),-1,325376,"Class for Target density",G__setup_memvarTMVAcLcLPDEFoamTargetDensity,G__setup_memfuncTMVAcLcLPDEFoamTargetDensity);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoamDecisionTreeDensity),sizeof(TMVA::PDEFoamDecisionTreeDensity),-1,325376,"Class for decision tree like PDEFoam density",G__setup_memvarTMVAcLcLPDEFoamDecisionTreeDensity,G__setup_memfuncTMVAcLcLPDEFoamDecisionTreeDensity);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETH1DmUcOallocatorlETH1DmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETH1DmUcOallocatorlETH1DmUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoamEvent),sizeof(TMVA::PDEFoamEvent),-1,325376,"Tree of PDEFoamCells",G__setup_memvarTMVAcLcLPDEFoamEvent,G__setup_memfuncTMVAcLcLPDEFoamEvent);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLETargetSelection);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoamMultiTarget),sizeof(TMVA::PDEFoamMultiTarget),-1,325376,"Tree of PDEFoamCells",G__setup_memvarTMVAcLcLPDEFoamMultiTarget,G__setup_memfuncTMVAcLcLPDEFoamMultiTarget);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoamTarget),sizeof(TMVA::PDEFoamTarget),-1,325376,"Tree of PDEFoamCells",G__setup_memvarTMVAcLcLPDEFoamTarget,G__setup_memfuncTMVAcLcLPDEFoamTarget);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelTrivial),sizeof(TMVA::PDEFoamKernelTrivial),-1,292608,"trivial PDEFoam kernel estimator",G__setup_memvarTMVAcLcLPDEFoamKernelTrivial,G__setup_memfuncTMVAcLcLPDEFoamKernelTrivial);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelLinN),sizeof(TMVA::PDEFoamKernelLinN),-1,292608,"next neighbor PDEFoam kernel estimator",G__setup_memvarTMVAcLcLPDEFoamKernelLinN,G__setup_memfuncTMVAcLcLPDEFoamKernelLinN);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoamKernelGauss),sizeof(TMVA::PDEFoamKernelGauss),-1,325120,"Gaussian PDEFoam kernel estimator",G__setup_memvarTMVAcLcLPDEFoamKernelGauss,G__setup_memfuncTMVAcLcLPDEFoamKernelGauss);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLBDTEventWrapper),sizeof(TMVA::BDTEventWrapper),-1,295936,(char*)NULL,G__setup_memvarTMVAcLcLBDTEventWrapper,G__setup_memfuncTMVAcLcLBDTEventWrapper);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLDecisionTreeNode);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLDataSet);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLDecisionTree);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_maplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEcharcOallocatorlEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_pairlEfloatcOlongsPlonggR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLCCTreeWrapper),sizeof(TMVA::CCTreeWrapper),-1,295936,(char*)NULL,G__setup_memvarTMVAcLcLCCTreeWrapper,G__setup_memfuncTMVAcLcLCCTreeWrapper);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLCCTreeWrappercLcLCCTreeNode);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLCCPruner),sizeof(TMVA::CCPruner),-1,295936,(char*)NULL,G__setup_memvarTMVAcLcLCCPruner,G__setup_memfuncTMVAcLcLCCPruner);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPruningInfo);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLIPruneTool);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool),sizeof(TMVA::CostComplexityPruneTool),-1,263424,(char*)NULL,G__setup_memvarTMVAcLcLCostComplexityPruneTool,G__setup_memfuncTMVAcLcLCostComplexityPruneTool);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLSVEvent),sizeof(TMVA::SVEvent),-1,296192,"Event for SVM",G__setup_memvarTMVAcLcLSVEvent,G__setup_memfuncTMVAcLcLSVEvent);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLMethodBase);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters),sizeof(TMVA::OptimizeConfigParameters),-1,295936,"Interface to different separation critiera used in training algorithms",G__setup_memvarTMVAcLcLOptimizeConfigParameters,G__setup_memfuncTMVAcLcLOptimizeConfigParameters);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_maplETStringcOTMVAcLcLIntervalmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIntervalmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA3LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR);
}
extern "C" void G__cpp_setupG__TMVA3(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__TMVA3()");
  G__set_cpp_environmentG__TMVA3();
  G__cpp_setup_tagtableG__TMVA3();

  G__cpp_setup_inheritanceG__TMVA3();

  G__cpp_setup_typetableG__TMVA3();

  G__cpp_setup_memvarG__TMVA3();

  G__cpp_setup_memfuncG__TMVA3();
  G__cpp_setup_globalG__TMVA3();
  G__cpp_setup_funcG__TMVA3();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__TMVA3();
  return;
}
class G__cpp_setup_initG__TMVA3 {
  public:
    G__cpp_setup_initG__TMVA3() { G__add_setup_func("G__TMVA3",(G__incsetup)(&G__cpp_setupG__TMVA3)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__TMVA3() { G__remove_setup_func("G__TMVA3"); }
};
G__cpp_setup_initG__TMVA3 G__cpp_setup_initializerG__TMVA3;