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

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

#define R__DICTIONARY_FILENAME G__TMVA2
#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__TMVA2.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::Tools Tools;
      #else
      class Tools  {
         public:
         //friend XX;
         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TMVA::Tools::EWelcomeMessage EWelcomeMessage;
         #else
         enum EWelcomeMessage  {
         };
         #endif

         #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
         typedef ::TMVA::Tools::ECitation ECitation;
         #else
         enum ECitation  {
         };
         #endif

         :: TString fRegexp; //
         ::TMVA::MsgLogger* fLogger; //
         ::TXMLEngine* fXMLEngine; //
      };
      #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/QuickMVAProbEstimator.h", 10,
                     ::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 TMVAcLcLTSpline2_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLTSpline2(void *p);
   static void deleteArray_TMVAcLcLTSpline2(void *p);
   static void destruct_TMVAcLcLTSpline2(void *p);

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

namespace ROOTDict {
   void TMVAcLcLTSpline1_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLTSpline1(void *p);
   static void deleteArray_TMVAcLcLTSpline1(void *p);
   static void destruct_TMVAcLcLTSpline1(void *p);

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

namespace ROOTDict {
   void TMVAcLcLPDF_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLPDF(void *p);
   static void deleteArray_TMVAcLcLPDF(void *p);
   static void destruct_TMVAcLcLPDF(void *p);

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

namespace ROOTDict {
   void TMVAcLcLNode_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLNode(void *p);
   static void deleteArray_TMVAcLcLNode(void *p);
   static void destruct_TMVAcLcLNode(void *p);

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

namespace ROOTDict {
   void TMVAcLcLBinaryTree_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLBinaryTree(void *p);
   static void deleteArray_TMVAcLcLBinaryTree(void *p);
   static void destruct_TMVAcLcLBinaryTree(void *p);

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

namespace ROOTDict {
   void TMVAcLcLBinarySearchTreeNode_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLBinarySearchTreeNode(void *p = 0);
   static void *newArray_TMVAcLcLBinarySearchTreeNode(Long_t size, void *p);
   static void delete_TMVAcLcLBinarySearchTreeNode(void *p);
   static void deleteArray_TMVAcLcLBinarySearchTreeNode(void *p);
   static void destruct_TMVAcLcLBinarySearchTreeNode(void *p);

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

namespace ROOTDict {
   void TMVAcLcLBinarySearchTree_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLBinarySearchTree(void *p = 0);
   static void *newArray_TMVAcLcLBinarySearchTree(Long_t size, void *p);
   static void delete_TMVAcLcLBinarySearchTree(void *p);
   static void deleteArray_TMVAcLcLBinarySearchTree(void *p);
   static void destruct_TMVAcLcLBinarySearchTree(void *p);

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

namespace ROOTDict {
   void TMVAcLcLTimer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLTimer(void *p = 0);
   static void *newArray_TMVAcLcLTimer(Long_t size, void *p);
   static void delete_TMVAcLcLTimer(void *p);
   static void deleteArray_TMVAcLcLTimer(void *p);
   static void destruct_TMVAcLcLTimer(void *p);

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

namespace ROOTDict {
   void TMVAcLcLRootFinder_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLRootFinder(void *p);
   static void deleteArray_TMVAcLcLRootFinder(void *p);
   static void destruct_TMVAcLcLRootFinder(void *p);

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

namespace ROOTDict {
   void TMVAcLcLSeparationBase_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLSeparationBase(void *p);
   static void deleteArray_TMVAcLcLSeparationBase(void *p);
   static void destruct_TMVAcLcLSeparationBase(void *p);

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

namespace ROOTDict {
   void TMVAcLcLCrossEntropy_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLCrossEntropy(void *p = 0);
   static void *newArray_TMVAcLcLCrossEntropy(Long_t size, void *p);
   static void delete_TMVAcLcLCrossEntropy(void *p);
   static void deleteArray_TMVAcLcLCrossEntropy(void *p);
   static void destruct_TMVAcLcLCrossEntropy(void *p);

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

namespace ROOTDict {
   void TMVAcLcLDecisionTreeNode_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLDecisionTreeNode(void *p = 0);
   static void *newArray_TMVAcLcLDecisionTreeNode(Long_t size, void *p);
   static void delete_TMVAcLcLDecisionTreeNode(void *p);
   static void deleteArray_TMVAcLcLDecisionTreeNode(void *p);
   static void destruct_TMVAcLcLDecisionTreeNode(void *p);

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

namespace ROOTDict {
   void TMVAcLcLRegressionVariance_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLRegressionVariance(void *p = 0);
   static void *newArray_TMVAcLcLRegressionVariance(Long_t size, void *p);
   static void delete_TMVAcLcLRegressionVariance(void *p);
   static void deleteArray_TMVAcLcLRegressionVariance(void *p);
   static void destruct_TMVAcLcLRegressionVariance(void *p);

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

namespace ROOTDict {
   void TMVAcLcLDecisionTree_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLDecisionTree(void *p = 0);
   static void *newArray_TMVAcLcLDecisionTree(Long_t size, void *p);
   static void delete_TMVAcLcLDecisionTree(void *p);
   static void deleteArray_TMVAcLcLDecisionTree(void *p);
   static void destruct_TMVAcLcLDecisionTree(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMisClassificationError_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLMisClassificationError(void *p = 0);
   static void *newArray_TMVAcLcLMisClassificationError(Long_t size, void *p);
   static void delete_TMVAcLcLMisClassificationError(void *p);
   static void deleteArray_TMVAcLcLMisClassificationError(void *p);
   static void destruct_TMVAcLcLMisClassificationError(void *p);

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

namespace ROOTDict {
   void TMVAcLcLSdivSqrtSplusB_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLSdivSqrtSplusB(void *p = 0);
   static void *newArray_TMVAcLcLSdivSqrtSplusB(Long_t size, void *p);
   static void delete_TMVAcLcLSdivSqrtSplusB(void *p);
   static void deleteArray_TMVAcLcLSdivSqrtSplusB(void *p);
   static void destruct_TMVAcLcLSdivSqrtSplusB(void *p);

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

namespace ROOTDict {
   void TMVAcLcLTools_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMVAcLcLTools_Dictionary();
   static void delete_TMVAcLcLTools(void *p);
   static void deleteArray_TMVAcLcLTools(void *p);
   static void destruct_TMVAcLcLTools(void *p);

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

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLReader_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLReader(void *p = 0);
   static void *newArray_TMVAcLcLReader(Long_t size, void *p);
   static void delete_TMVAcLcLReader(void *p);
   static void deleteArray_TMVAcLcLReader(void *p);
   static void destruct_TMVAcLcLReader(void *p);

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

namespace ROOTDict {
   void TMVAcLcLGeneticGenes_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLGeneticGenes(void *p = 0);
   static void *newArray_TMVAcLcLGeneticGenes(Long_t size, void *p);
   static void delete_TMVAcLcLGeneticGenes(void *p);
   static void deleteArray_TMVAcLcLGeneticGenes(void *p);
   static void destruct_TMVAcLcLGeneticGenes(void *p);

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

namespace ROOTDict {
   void TMVAcLcLGeneticRange_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLGeneticRange(void *p);
   static void deleteArray_TMVAcLcLGeneticRange(void *p);
   static void destruct_TMVAcLcLGeneticRange(void *p);

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

namespace ROOTDict {
   void TMVAcLcLGeneticPopulation_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLGeneticPopulation(void *p);
   static void deleteArray_TMVAcLcLGeneticPopulation(void *p);
   static void destruct_TMVAcLcLGeneticPopulation(void *p);

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

namespace ROOTDict {
   void TMVAcLcLGeneticAlgorithm_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLGeneticAlgorithm(void *p);
   static void deleteArray_TMVAcLcLGeneticAlgorithm(void *p);
   static void destruct_TMVAcLcLGeneticAlgorithm(void *p);

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

namespace ROOTDict {
   void TMVAcLcLGiniIndex_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLGiniIndex(void *p = 0);
   static void *newArray_TMVAcLcLGiniIndex(Long_t size, void *p);
   static void delete_TMVAcLcLGiniIndex(void *p);
   static void deleteArray_TMVAcLcLGiniIndex(void *p);
   static void destruct_TMVAcLcLGiniIndex(void *p);

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

namespace ROOTDict {
   void TMVAcLcLGiniIndexWithLaplace_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLGiniIndexWithLaplace(void *p = 0);
   static void *newArray_TMVAcLcLGiniIndexWithLaplace(Long_t size, void *p);
   static void delete_TMVAcLcLGiniIndexWithLaplace(void *p);
   static void deleteArray_TMVAcLcLGiniIndexWithLaplace(void *p);
   static void destruct_TMVAcLcLGiniIndexWithLaplace(void *p);

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

namespace ROOTDict {
   void TMVAcLcLSimulatedAnnealing_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLSimulatedAnnealing(void *p);
   static void deleteArray_TMVAcLcLSimulatedAnnealing(void *p);
   static void destruct_TMVAcLcLSimulatedAnnealing(void *p);

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

namespace ROOTDict {
   void TMVAcLcLQuickMVAProbEstimator_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLQuickMVAProbEstimator(void *p = 0);
   static void *newArray_TMVAcLcLQuickMVAProbEstimator(Long_t size, void *p);
   static void delete_TMVAcLcLQuickMVAProbEstimator(void *p);
   static void deleteArray_TMVAcLcLQuickMVAProbEstimator(void *p);
   static void destruct_TMVAcLcLQuickMVAProbEstimator(void *p);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLTSpline2(void *p) {
      delete ((::TMVA::TSpline2*)p);
   }
   static void deleteArray_TMVAcLcLTSpline2(void *p) {
      delete [] ((::TMVA::TSpline2*)p);
   }
   static void destruct_TMVAcLcLTSpline2(void *p) {
      typedef ::TMVA::TSpline2 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::TSpline2

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLTSpline1(void *p) {
      delete ((::TMVA::TSpline1*)p);
   }
   static void deleteArray_TMVAcLcLTSpline1(void *p) {
      delete [] ((::TMVA::TSpline1*)p);
   }
   static void destruct_TMVAcLcLTSpline1(void *p) {
      typedef ::TMVA::TSpline1 current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::TSpline1

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void PDF::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::PDF.
      TClass *R__cl = ::TMVA::PDF::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseHistogram", &fUseHistogram);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPDFName", &fPDFName);
      R__insp.InspectMember(fPDFName, "fPDFName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNsmooth", &fNsmooth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinNsmooth", &fMinNsmooth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxNsmooth", &fMaxNsmooth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNSmoothHist", &fNSmoothHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInterpolMethod", &fInterpolMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSpline", &fSpline);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPDFHist", &fPDFHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHist", &fHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistOriginal", &fHistOriginal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fGraph", &fGraph);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIGetVal", &fIGetVal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHistAvgEvtPerBin", &fHistAvgEvtPerBin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHistDefinedNBins", &fHistDefinedNBins);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKDEtypeString", &fKDEtypeString);
      R__insp.InspectMember(fKDEtypeString, "fKDEtypeString.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKDEiterString", &fKDEiterString);
      R__insp.InspectMember(fKDEiterString, "fKDEiterString.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBorderMethodString", &fBorderMethodString);
      R__insp.InspectMember(fBorderMethodString, "fBorderMethodString.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInterpolateString", &fInterpolateString);
      R__insp.InspectMember(fInterpolateString, "fInterpolateString.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKDEtype", &fKDEtype);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKDEiter", &fKDEiter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKDEborder", &fKDEborder);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFineFactor", &fFineFactor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReadingVersion", &fReadingVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCheckHist", &fCheckHist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormalize", &fNormalize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSuffix", &fSuffix);
      R__insp.InspectMember(fSuffix, "fSuffix.");
      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::Configurable baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLPDF(void *p) {
      delete ((::TMVA::PDF*)p);
   }
   static void deleteArray_TMVAcLcLPDF(void *p) {
      delete [] ((::TMVA::PDF*)p);
   }
   static void destruct_TMVAcLcLPDF(void *p) {
      typedef ::TMVA::PDF current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::PDF

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLBinaryTree(void *p) {
      delete ((::TMVA::BinaryTree*)p);
   }
   static void deleteArray_TMVAcLcLBinaryTree(void *p) {
      delete [] ((::TMVA::BinaryTree*)p);
   }
   static void destruct_TMVAcLcLBinaryTree(void *p) {
      typedef ::TMVA::BinaryTree current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::BinaryTree

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void BinarySearchTreeNode::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::BinarySearchTreeNode.
      TClass *R__cl = ::TMVA::BinarySearchTreeNode::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEventV", (void*)&fEventV);
      R__insp.InspectMember("vector<Float_t>", (void*)&fEventV, "fEventV.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTargets", (void*)&fTargets);
      R__insp.InspectMember("vector<Float_t>", (void*)&fTargets, "fTargets.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWeight", &fWeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClass", &fClass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelector", &fSelector);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::Node baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLBinarySearchTreeNode(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::BinarySearchTreeNode : new ::TMVA::BinarySearchTreeNode;
   }
   static void *newArray_TMVAcLcLBinarySearchTreeNode(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::BinarySearchTreeNode[nElements] : new ::TMVA::BinarySearchTreeNode[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLBinarySearchTreeNode(void *p) {
      delete ((::TMVA::BinarySearchTreeNode*)p);
   }
   static void deleteArray_TMVAcLcLBinarySearchTreeNode(void *p) {
      delete [] ((::TMVA::BinarySearchTreeNode*)p);
   }
   static void destruct_TMVAcLcLBinarySearchTreeNode(void *p) {
      typedef ::TMVA::BinarySearchTreeNode current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::BinarySearchTreeNode

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void BinarySearchTree::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::BinarySearchTree.
      TClass *R__cl = ::TMVA::BinarySearchTree::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPeriod", &fPeriod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentDepth", &fCurrentDepth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatisticsIsValid", &fStatisticsIsValid);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMeans[2]", fMeans);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRMS[2]", fRMS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMin[2]", fMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMax[2]", fMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSum[2]", fSum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumSq[2]", fSumSq);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNEventsW[2]", fNEventsW);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumOfWeights", &fSumOfWeights);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCanNormalize", &fCanNormalize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormalizeTreeTable", (void*)&fNormalizeTreeTable);
      R__insp.InspectMember("vector<std::pair<Double_t,const TMVA::Event*> >", (void*)&fNormalizeTreeTable, "fNormalizeTreeTable.", false);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::BinaryTree baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLBinarySearchTree(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::BinarySearchTree : new ::TMVA::BinarySearchTree;
   }
   static void *newArray_TMVAcLcLBinarySearchTree(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::BinarySearchTree[nElements] : new ::TMVA::BinarySearchTree[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLBinarySearchTree(void *p) {
      delete ((::TMVA::BinarySearchTree*)p);
   }
   static void deleteArray_TMVAcLcLBinarySearchTree(void *p) {
      delete [] ((::TMVA::BinarySearchTree*)p);
   }
   static void destruct_TMVAcLcLBinarySearchTree(void *p) {
      typedef ::TMVA::BinarySearchTree current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::BinarySearchTree

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLTimer(void *p) {
      return  p ? new(p) ::TMVA::Timer : new ::TMVA::Timer;
   }
   static void *newArray_TMVAcLcLTimer(Long_t nElements, void *p) {
      return p ? new(p) ::TMVA::Timer[nElements] : new ::TMVA::Timer[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLTimer(void *p) {
      delete ((::TMVA::Timer*)p);
   }
   static void deleteArray_TMVAcLcLTimer(void *p) {
      delete [] ((::TMVA::Timer*)p);
   }
   static void destruct_TMVAcLcLTimer(void *p) {
      typedef ::TMVA::Timer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::Timer

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void RootFinder::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::RootFinder.
      TClass *R__cl = ::TMVA::RootFinder::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRootMin", &fRootMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRootMax", &fRootMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxIter", &fMaxIter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAbsTol", &fAbsTol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGetRootVal", &fGetRootVal);
      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_TMVAcLcLRootFinder(void *p) {
      delete ((::TMVA::RootFinder*)p);
   }
   static void deleteArray_TMVAcLcLRootFinder(void *p) {
      delete [] ((::TMVA::RootFinder*)p);
   }
   static void destruct_TMVAcLcLRootFinder(void *p) {
      typedef ::TMVA::RootFinder current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::RootFinder

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLCrossEntropy(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::CrossEntropy : new ::TMVA::CrossEntropy;
   }
   static void *newArray_TMVAcLcLCrossEntropy(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::CrossEntropy[nElements] : new ::TMVA::CrossEntropy[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLCrossEntropy(void *p) {
      delete ((::TMVA::CrossEntropy*)p);
   }
   static void deleteArray_TMVAcLcLCrossEntropy(void *p) {
      delete [] ((::TMVA::CrossEntropy*)p);
   }
   static void destruct_TMVAcLcLCrossEntropy(void *p) {
      typedef ::TMVA::CrossEntropy current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::CrossEntropy

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void DecisionTree::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::DecisionTree.
      TClass *R__cl = ::TMVA::DecisionTree::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNvars", &fNvars);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNCuts", &fNCuts);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseFisherCuts", &fUseFisherCuts);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinLinCorrForFisher", &fMinLinCorrForFisher);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseExclusiveVars", &fUseExclusiveVars);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSepType", &fSepType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRegType", &fRegType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinSize", &fMinSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinNodeSize", &fMinNodeSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinSepGain", &fMinSepGain);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseSearchTree", &fUseSearchTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPruneStrength", &fPruneStrength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPruneMethod", &fPruneMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNNodesBeforePruning", &fNNodesBeforePruning);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNodePurityLimit", &fNodePurityLimit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRandomisedTree", &fRandomisedTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseNvars", &fUseNvars);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUsePoissonNvars", &fUsePoissonNvars);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMyTrandom", &fMyTrandom);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVariableImportance", (void*)&fVariableImportance);
      R__insp.InspectMember("vector<Double_t>", (void*)&fVariableImportance, "fVariableImportance.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxDepth", &fMaxDepth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigClass", &fSigClass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTreeID", &fTreeID);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAnalysisType", &fAnalysisType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataSetInfo", &fDataSetInfo);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::BinaryTree baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLDecisionTree(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::DecisionTree : new ::TMVA::DecisionTree;
   }
   static void *newArray_TMVAcLcLDecisionTree(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::DecisionTree[nElements] : new ::TMVA::DecisionTree[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLDecisionTree(void *p) {
      delete ((::TMVA::DecisionTree*)p);
   }
   static void deleteArray_TMVAcLcLDecisionTree(void *p) {
      delete [] ((::TMVA::DecisionTree*)p);
   }
   static void destruct_TMVAcLcLDecisionTree(void *p) {
      typedef ::TMVA::DecisionTree current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::DecisionTree

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void DecisionTreeNode::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::DecisionTreeNode.
      TClass *R__cl = ::TMVA::DecisionTreeNode::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFisherCoeff", (void*)&fFisherCoeff);
      R__insp.InspectMember("vector<Double_t>", (void*)&fFisherCoeff, "fFisherCoeff.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCutValue", &fCutValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCutType", &fCutType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSelector", &fSelector);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fResponse", &fResponse);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRMS", &fRMS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNodeType", &fNodeType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPurity", &fPurity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsTerminalNode", &fIsTerminalNode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrainInfo", &fTrainInfo);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::Node baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLDecisionTreeNode(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::DecisionTreeNode : new ::TMVA::DecisionTreeNode;
   }
   static void *newArray_TMVAcLcLDecisionTreeNode(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::DecisionTreeNode[nElements] : new ::TMVA::DecisionTreeNode[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLDecisionTreeNode(void *p) {
      delete ((::TMVA::DecisionTreeNode*)p);
   }
   static void deleteArray_TMVAcLcLDecisionTreeNode(void *p) {
      delete [] ((::TMVA::DecisionTreeNode*)p);
   }
   static void destruct_TMVAcLcLDecisionTreeNode(void *p) {
      typedef ::TMVA::DecisionTreeNode current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::DecisionTreeNode

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLMisClassificationError(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::MisClassificationError : new ::TMVA::MisClassificationError;
   }
   static void *newArray_TMVAcLcLMisClassificationError(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::MisClassificationError[nElements] : new ::TMVA::MisClassificationError[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLMisClassificationError(void *p) {
      delete ((::TMVA::MisClassificationError*)p);
   }
   static void deleteArray_TMVAcLcLMisClassificationError(void *p) {
      delete [] ((::TMVA::MisClassificationError*)p);
   }
   static void destruct_TMVAcLcLMisClassificationError(void *p) {
      typedef ::TMVA::MisClassificationError current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MisClassificationError

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void Node::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::Node.
      TClass *R__cl = ::TMVA::Node::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParent", &fParent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLeft", &fLeft);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRight", &fRight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPos", &fPos);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDepth", &fDepth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fParentTree", &fParentTree);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLNode(void *p) {
      delete ((::TMVA::Node*)p);
   }
   static void deleteArray_TMVAcLcLNode(void *p) {
      delete [] ((::TMVA::Node*)p);
   }
   static void destruct_TMVAcLcLNode(void *p) {
      typedef ::TMVA::Node current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::Node

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLSdivSqrtSplusB(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::SdivSqrtSplusB : new ::TMVA::SdivSqrtSplusB;
   }
   static void *newArray_TMVAcLcLSdivSqrtSplusB(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::SdivSqrtSplusB[nElements] : new ::TMVA::SdivSqrtSplusB[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLSdivSqrtSplusB(void *p) {
      delete ((::TMVA::SdivSqrtSplusB*)p);
   }
   static void deleteArray_TMVAcLcLSdivSqrtSplusB(void *p) {
      delete [] ((::TMVA::SdivSqrtSplusB*)p);
   }
   static void destruct_TMVAcLcLSdivSqrtSplusB(void *p) {
      typedef ::TMVA::SdivSqrtSplusB current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::SdivSqrtSplusB

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void SeparationBase::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::SeparationBase.
      TClass *R__cl = ::TMVA::SeparationBase::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(), "fPrecisionCut", &fPrecisionCut);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLSeparationBase(void *p) {
      delete ((::TMVA::SeparationBase*)p);
   }
   static void deleteArray_TMVAcLcLSeparationBase(void *p) {
      delete [] ((::TMVA::SeparationBase*)p);
   }
   static void destruct_TMVAcLcLSeparationBase(void *p) {
      typedef ::TMVA::SeparationBase current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::SeparationBase

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLRegressionVariance(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::RegressionVariance : new ::TMVA::RegressionVariance;
   }
   static void *newArray_TMVAcLcLRegressionVariance(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::RegressionVariance[nElements] : new ::TMVA::RegressionVariance[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLRegressionVariance(void *p) {
      delete ((::TMVA::RegressionVariance*)p);
   }
   static void deleteArray_TMVAcLcLRegressionVariance(void *p) {
      delete [] ((::TMVA::RegressionVariance*)p);
   }
   static void destruct_TMVAcLcLRegressionVariance(void *p) {
      typedef ::TMVA::RegressionVariance current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::RegressionVariance

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

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::Tools*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRegexp", &sobj->fRegexp);
      R__insp.InspectMember(const_cast<  TString &>( sobj->fRegexp ), "fRegexp.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &sobj->fLogger);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXMLEngine", &sobj->fXMLEngine);
   }

}

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLTools(void *p) {
      delete ((::TMVA::Tools*)p);
   }
   static void deleteArray_TMVAcLcLTools(void *p) {
      delete [] ((::TMVA::Tools*)p);
   }
   static void destruct_TMVAcLcLTools(void *p) {
      typedef ::TMVA::Tools current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::Tools

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void Reader::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::Reader.
      TClass *R__cl = ::TMVA::Reader::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataSetManager", &fDataSetManager);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataSetInfo", (void*)&fDataSetInfo);
      R__insp.InspectMember("TMVA::DataSetInfo", (void*)&fDataSetInfo, "fDataSetInfo.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataInputHandler", (void*)&fDataInputHandler);
      R__insp.InspectMember("TMVA::DataInputHandler", (void*)&fDataInputHandler, "fDataInputHandler.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVerbose", &fVerbose);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSilent", &fSilent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fColor", &fColor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCalculateError", &fCalculateError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMvaEventError", &fMvaEventError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMvaEventErrorUpper", &fMvaEventErrorUpper);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMethodMap", (void*)&fMethodMap);
      R__insp.InspectMember("map<TString,IMethod*>", (void*)&fMethodMap, "fMethodMap.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTmpEvalVec", (void*)&fTmpEvalVec);
      R__insp.InspectMember("vector<Float_t>", (void*)&fTmpEvalVec, "fTmpEvalVec.", false);
      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::Configurable baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLReader(void *p) {
      return  p ? new(p) ::TMVA::Reader : new ::TMVA::Reader;
   }
   static void *newArray_TMVAcLcLReader(Long_t nElements, void *p) {
      return p ? new(p) ::TMVA::Reader[nElements] : new ::TMVA::Reader[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLReader(void *p) {
      delete ((::TMVA::Reader*)p);
   }
   static void deleteArray_TMVAcLcLReader(void *p) {
      delete [] ((::TMVA::Reader*)p);
   }
   static void destruct_TMVAcLcLReader(void *p) {
      typedef ::TMVA::Reader current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::Reader

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void GeneticAlgorithm::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::GeneticAlgorithm.
      TClass *R__cl = ::TMVA::GeneticAlgorithm::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConvCounter", &fConvCounter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConvValue", &fConvValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSuccessList", (void*)&fSuccessList);
      R__insp.InspectMember("deque<Int_t>", (void*)&fSuccessList, "fSuccessList.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastResult", &fLastResult);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSpread", &fSpread);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMirror", &fMirror);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFirstTime", &fFirstTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMakeCopies", &fMakeCopies);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPopulationSize", &fPopulationSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPopulation", &fPopulation);
      R__insp.InspectMember(fPopulation, "fPopulation.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBestFitness", &fBestFitness);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLGeneticAlgorithm(void *p) {
      delete ((::TMVA::GeneticAlgorithm*)p);
   }
   static void deleteArray_TMVAcLcLGeneticAlgorithm(void *p) {
      delete [] ((::TMVA::GeneticAlgorithm*)p);
   }
   static void destruct_TMVAcLcLGeneticAlgorithm(void *p) {
      typedef ::TMVA::GeneticAlgorithm current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::GeneticAlgorithm

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLGeneticGenes(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::GeneticGenes : new ::TMVA::GeneticGenes;
   }
   static void *newArray_TMVAcLcLGeneticGenes(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::GeneticGenes[nElements] : new ::TMVA::GeneticGenes[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLGeneticGenes(void *p) {
      delete ((::TMVA::GeneticGenes*)p);
   }
   static void deleteArray_TMVAcLcLGeneticGenes(void *p) {
      delete [] ((::TMVA::GeneticGenes*)p);
   }
   static void destruct_TMVAcLcLGeneticGenes(void *p) {
      typedef ::TMVA::GeneticGenes current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::GeneticGenes

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void GeneticPopulation::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::GeneticPopulation.
      TClass *R__cl = ::TMVA::GeneticPopulation::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGenePool", (void*)&fGenePool);
      R__insp.InspectMember("vector<TMVA::GeneticGenes>", (void*)&fGenePool, "fGenePool.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRanges", (void*)&fRanges);
      R__insp.InspectMember("vector<TMVA::GeneticRange*>", (void*)&fRanges, "fRanges.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRandomGenerator", &fRandomGenerator);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPopulationSizeLimit", &fPopulationSizeLimit);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLGeneticPopulation(void *p) {
      delete ((::TMVA::GeneticPopulation*)p);
   }
   static void deleteArray_TMVAcLcLGeneticPopulation(void *p) {
      delete [] ((::TMVA::GeneticPopulation*)p);
   }
   static void destruct_TMVAcLcLGeneticPopulation(void *p) {
      typedef ::TMVA::GeneticPopulation current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::GeneticPopulation

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void GeneticRange::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::GeneticRange.
      TClass *R__cl = ::TMVA::GeneticRange::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrom", &fFrom);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTo", &fTo);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbins", &fNbins);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInterval", &fInterval);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTotalLength", &fTotalLength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRandomGenerator", &fRandomGenerator);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLGeneticRange(void *p) {
      delete ((::TMVA::GeneticRange*)p);
   }
   static void deleteArray_TMVAcLcLGeneticRange(void *p) {
      delete [] ((::TMVA::GeneticRange*)p);
   }
   static void destruct_TMVAcLcLGeneticRange(void *p) {
      typedef ::TMVA::GeneticRange current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::GeneticRange

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLGiniIndex(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::GiniIndex : new ::TMVA::GiniIndex;
   }
   static void *newArray_TMVAcLcLGiniIndex(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::GiniIndex[nElements] : new ::TMVA::GiniIndex[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLGiniIndex(void *p) {
      delete ((::TMVA::GiniIndex*)p);
   }
   static void deleteArray_TMVAcLcLGiniIndex(void *p) {
      delete [] ((::TMVA::GiniIndex*)p);
   }
   static void destruct_TMVAcLcLGiniIndex(void *p) {
      typedef ::TMVA::GiniIndex current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::GiniIndex

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLGiniIndexWithLaplace(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::GiniIndexWithLaplace : new ::TMVA::GiniIndexWithLaplace;
   }
   static void *newArray_TMVAcLcLGiniIndexWithLaplace(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::GiniIndexWithLaplace[nElements] : new ::TMVA::GiniIndexWithLaplace[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLGiniIndexWithLaplace(void *p) {
      delete ((::TMVA::GiniIndexWithLaplace*)p);
   }
   static void deleteArray_TMVAcLcLGiniIndexWithLaplace(void *p) {
      delete [] ((::TMVA::GiniIndexWithLaplace*)p);
   }
   static void destruct_TMVAcLcLGiniIndexWithLaplace(void *p) {
      typedef ::TMVA::GiniIndexWithLaplace current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::GiniIndexWithLaplace

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void SimulatedAnnealing::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::SimulatedAnnealing.
      TClass *R__cl = ::TMVA::SimulatedAnnealing::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKernelTemperature", &fKernelTemperature);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRandom", &fRandom);
      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(), "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);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fProgress", &fProgress);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLSimulatedAnnealing(void *p) {
      delete ((::TMVA::SimulatedAnnealing*)p);
   }
   static void deleteArray_TMVAcLcLSimulatedAnnealing(void *p) {
      delete [] ((::TMVA::SimulatedAnnealing*)p);
   }
   static void destruct_TMVAcLcLSimulatedAnnealing(void *p) {
      typedef ::TMVA::SimulatedAnnealing current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::SimulatedAnnealing

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void QuickMVAProbEstimator::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::QuickMVAProbEstimator.
      TClass *R__cl = ::TMVA::QuickMVAProbEstimator::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvtVector", (void*)&fEvtVector);
      R__insp.InspectMember("vector<EventInfo>", (void*)&fEvtVector, "fEvtVector.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsSorted", &fIsSorted);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNMin", &fNMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNMax", &fNMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLQuickMVAProbEstimator(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::QuickMVAProbEstimator : new ::TMVA::QuickMVAProbEstimator;
   }
   static void *newArray_TMVAcLcLQuickMVAProbEstimator(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::QuickMVAProbEstimator[nElements] : new ::TMVA::QuickMVAProbEstimator[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLQuickMVAProbEstimator(void *p) {
      delete ((::TMVA::QuickMVAProbEstimator*)p);
   }
   static void deleteArray_TMVAcLcLQuickMVAProbEstimator(void *p) {
      delete [] ((::TMVA::QuickMVAProbEstimator*)p);
   }
   static void destruct_TMVAcLcLQuickMVAProbEstimator(void *p) {
      typedef ::TMVA::QuickMVAProbEstimator current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::QuickMVAProbEstimator

/********************************************************
* G__TMVA2.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__TMVA2();

extern "C" void G__set_cpp_environmentG__TMVA2() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TMVA/TSpline2.h");
  G__add_compiledheader("TMVA/TSpline1.h");
  G__add_compiledheader("TMVA/PDF.h");
  G__add_compiledheader("TMVA/BinaryTree.h");
  G__add_compiledheader("TMVA/BinarySearchTreeNode.h");
  G__add_compiledheader("TMVA/BinarySearchTree.h");
  G__add_compiledheader("TMVA/Timer.h");
  G__add_compiledheader("TMVA/RootFinder.h");
  G__add_compiledheader("TMVA/CrossEntropy.h");
  G__add_compiledheader("TMVA/DecisionTree.h");
  G__add_compiledheader("TMVA/DecisionTreeNode.h");
  G__add_compiledheader("TMVA/MisClassificationError.h");
  G__add_compiledheader("TMVA/Node.h");
  G__add_compiledheader("TMVA/SdivSqrtSplusB.h");
  G__add_compiledheader("TMVA/SeparationBase.h");
  G__add_compiledheader("TMVA/RegressionVariance.h");
  G__add_compiledheader("TMVA/Tools.h");
  G__add_compiledheader("TMVA/Reader.h");
  G__add_compiledheader("TMVA/GeneticAlgorithm.h");
  G__add_compiledheader("TMVA/GeneticGenes.h");
  G__add_compiledheader("TMVA/GeneticPopulation.h");
  G__add_compiledheader("TMVA/GeneticRange.h");
  G__add_compiledheader("TMVA/GiniIndex.h");
  G__add_compiledheader("TMVA/GiniIndexWithLaplace.h");
  G__add_compiledheader("TMVA/SimulatedAnnealing.h");
  G__add_compiledheader("TMVA/QuickMVAProbEstimator.h");
  G__cpp_reset_tagtableG__TMVA2();
}
#include <new>
extern "C" int G__cpp_dllrevG__TMVA2() { return(30051515); }

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

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

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

static int G__G__TMVA2_149_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*) libp->para[1].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_149_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::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__TMVA2_149_0_6(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__TMVA2_149_0_7(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__TMVA2_149_0_8(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) ;
}

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

static int G__G__TMVA2_149_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMVA::operator<(*(TMVA::GeneticGenes*) libp->para[0].ref, *(TMVA::GeneticGenes*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::TSpline2 G__TTMVAcLcLTSpline2;
static int G__G__TMVA2_150_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::TSpline2*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::TSpline2*) (soff+(sizeof(TMVA::TSpline2)*i)))->~G__TTMVAcLcLTSpline2();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::TSpline2*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::TSpline2*) (soff))->~G__TTMVAcLcLTSpline2();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::TSpline1 G__TTMVAcLcLTSpline1;
static int G__G__TMVA2_151_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::TSpline1*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::TSpline1*) (soff+(sizeof(TMVA::TSpline1)*i)))->~G__TTMVAcLcLTSpline1();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::TSpline1*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::TSpline1*) (soff))->~G__TTMVAcLcLTSpline1();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__G__TMVA2_230_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::PDF* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDF(
*(TString*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
, (TMVA::PDF::EInterpolateMethod) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TMVA::PDF(
*(TString*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
, (TMVA::PDF::EInterpolateMethod) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])
, (Bool_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDF(
*(TString*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
, (TMVA::PDF::EInterpolateMethod) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TMVA::PDF(
*(TString*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
, (TMVA::PDF::EInterpolateMethod) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDF(
*(TString*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
, (TMVA::PDF::EInterpolateMethod) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TMVA::PDF(
*(TString*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
, (TMVA::PDF::EInterpolateMethod) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDF(
*(TString*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
, (TMVA::PDF::EInterpolateMethod) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TMVA::PDF(
*(TString*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
, (TMVA::PDF::EInterpolateMethod) G__int(libp->para[2]), (Int_t) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDF(
*(TString*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
, (TMVA::PDF::EInterpolateMethod) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::PDF(
*(TString*) libp->para[0].ref, (TH1*) G__int(libp->para[1])
, (TMVA::PDF::EInterpolateMethod) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::PDF(*(TString*) libp->para[0].ref, (TH1*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMVA::PDF(*(TString*) libp->para[0].ref, (TH1*) 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__TMVA2LN_TMVAcLcLPDF));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__TMVA2_230_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TMVA::PDF*) G__getstructoffset())->GetValInverse((Double_t) G__double(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TMVA::PDF*) G__getstructoffset())->GetValInverse((Double_t) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__TMVA2_230_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 105, (long) ((TMVA::PDF*) G__getstructoffset())->GetHistNBins((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TMVA::PDF*) G__getstructoffset())->GetHistNBins());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::PDF G__TTMVAcLcLPDF;
static int G__G__TMVA2_230_0_53(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::PDF*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::PDF*) (soff+(sizeof(TMVA::PDF)*i)))->~G__TTMVAcLcLPDF();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::PDF*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::PDF*) (soff))->~G__TTMVAcLcLPDF();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

static int G__G__TMVA2_255_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMVA::Node*) G__getstructoffset())->GoesRight(*(TMVA::Event*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_255_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMVA::Node*) G__getstructoffset())->GoesLeft(*(TMVA::Event*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

static int G__G__TMVA2_255_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TMVA::Node*) G__getstructoffset())->AddXMLTo((void*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_255_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMVA::Node*) G__getstructoffset())->ReadXML((void*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Node*) G__getstructoffset())->ReadXML((void*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__TMVA2_255_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 99, (long) ((const TMVA::Node*) G__getstructoffset())->GetPos());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__TMVA2_255_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((TMVA::Node*) G__getstructoffset())->ReadDataRecord(*(istream*) libp->para[0].ref, (UInt_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TMVA::Node*) G__getstructoffset())->ReadDataRecord(*(istream*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_255_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMVA::Node*) G__getstructoffset())->ReadAttributes((void*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Node*) G__getstructoffset())->ReadAttributes((void*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::Node G__TTMVAcLcLNode;
static int G__G__TMVA2_255_0_42(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::Node*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::Node*) (soff+(sizeof(TMVA::Node)*i)))->~G__TTMVAcLcLNode();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::Node*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::Node*) (soff))->~G__TTMVAcLcLNode();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* TMVA::BinaryTree */
static int G__G__TMVA2_257_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((const TMVA::BinaryTree*) G__getstructoffset())->CreateNode((UInt_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((const TMVA::BinaryTree*) G__getstructoffset())->CreateNode());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__TMVA2_257_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMVA::BinaryTree*) G__getstructoffset())->Read(*(istream*) libp->para[0].ref, (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::BinaryTree*) G__getstructoffset())->Read(*(istream*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_257_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((const TMVA::BinaryTree*) G__getstructoffset())->AddXMLTo((void*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_257_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMVA::BinaryTree*) G__getstructoffset())->ReadXML((void*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::BinaryTree*) G__getstructoffset())->ReadXML((void*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::BinaryTree G__TTMVAcLcLBinaryTree;
static int G__G__TMVA2_257_0_32(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::BinaryTree*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::BinaryTree*) (soff+(sizeof(TMVA::BinaryTree)*i)))->~G__TTMVAcLcLBinaryTree();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::BinaryTree*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::BinaryTree*) (soff))->~G__TTMVAcLcLBinaryTree();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* TMVA::BinarySearchTreeNode */
static int G__G__TMVA2_258_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::BinarySearchTreeNode* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::BinarySearchTreeNode((TMVA::Event*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMVA::BinarySearchTreeNode((TMVA::Event*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::BinarySearchTreeNode((TMVA::Event*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TMVA::BinarySearchTreeNode((TMVA::Event*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TMVA::BinarySearchTreeNode[n];
       } else {
         p = new((void*) gvp) TMVA::BinarySearchTreeNode[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TMVA::BinarySearchTreeNode;
       } else {
         p = new((void*) gvp) TMVA::BinarySearchTreeNode;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinarySearchTreeNode));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__TMVA2_258_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMVA::BinarySearchTreeNode*) G__getstructoffset())->EqualsMe(*(TMVA::Event*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__TMVA2_258_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TMVA::BinarySearchTreeNode*) G__getstructoffset())->GetSelector());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__TMVA2_258_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::BinarySearchTreeNode*) G__getstructoffset())->GetWeight());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::BinarySearchTreeNode G__TTMVAcLcLBinarySearchTreeNode;
static int G__G__TMVA2_258_0_33(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::BinarySearchTreeNode*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::BinarySearchTreeNode*) (soff+(sizeof(TMVA::BinarySearchTreeNode)*i)))->~G__TTMVAcLcLBinarySearchTreeNode();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::BinarySearchTreeNode*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::BinarySearchTreeNode*) (soff))->~G__TTMVAcLcLBinarySearchTreeNode();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

static int G__G__TMVA2_266_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) TMVA::BinarySearchTree::CreateFromXML((void*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) TMVA::BinarySearchTree::CreateFromXML((void*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_266_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMVA::BinarySearchTree*) G__getstructoffset())->Search((TMVA::Event*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__TMVA2_266_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((TMVA::BinarySearchTree*) G__getstructoffset())->SearchVolume((TMVA::Volume*) G__int(libp->para[0]), (vector<const TMVA::BinarySearchTreeNode*>*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((TMVA::BinarySearchTree*) G__getstructoffset())->SearchVolume((TMVA::Volume*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_266_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((TMVA::BinarySearchTree*) G__getstructoffset())->Fill(*(vector<TMVA::Event*>*) libp->para[0].ref, *(vector<Int_t>*) libp->para[1].ref
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((TMVA::BinarySearchTree*) G__getstructoffset())->Fill(*(vector<TMVA::Event*>*) libp->para[0].ref, *(vector<Int_t>*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_266_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((TMVA::BinarySearchTree*) G__getstructoffset())->Fill(*(vector<TMVA::Event*>*) libp->para[0].ref, (Int_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((TMVA::BinarySearchTree*) G__getstructoffset())->Fill(*(vector<TMVA::Event*>*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__TMVA2_266_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TMVA::BinarySearchTree*) G__getstructoffset())->Mean((TMVA::Types::ESBType) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_266_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TMVA::BinarySearchTree*) G__getstructoffset())->RMS((TMVA::Types::ESBType) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_266_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TMVA::BinarySearchTree*) G__getstructoffset())->Min((TMVA::Types::ESBType) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_266_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TMVA::BinarySearchTree*) G__getstructoffset())->Max((TMVA::Types::ESBType) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_266_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 105, (long) ((TMVA::BinarySearchTree*) G__getstructoffset())->SearchVolumeWithMaxLimit((TMVA::Volume*) G__int(libp->para[0]), (vector<const TMVA::BinarySearchTreeNode*>*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 105, (long) ((TMVA::BinarySearchTree*) G__getstructoffset())->SearchVolumeWithMaxLimit((TMVA::Volume*) G__int(libp->para[0]), (vector<const TMVA::BinarySearchTreeNode*>*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TMVA::BinarySearchTree*) G__getstructoffset())->SearchVolumeWithMaxLimit((TMVA::Volume*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_266_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((TMVA::BinarySearchTree*) G__getstructoffset())->RMS((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::BinarySearchTree G__TTMVAcLcLBinarySearchTree;
static int G__G__TMVA2_266_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::BinarySearchTree*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::BinarySearchTree*) (soff+(sizeof(TMVA::BinarySearchTree)*i)))->~G__TTMVAcLcLBinarySearchTree();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::BinarySearchTree*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::BinarySearchTree*) (soff))->~G__TTMVAcLcLBinarySearchTree();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* TMVA::Timer */
static int G__G__TMVA2_286_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::Timer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Timer((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMVA::Timer((const char*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Timer((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TMVA::Timer((const char*) G__int(libp->para[0]));
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TMVA::Timer[n];
       } else {
         p = new((void*) gvp) TMVA::Timer[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TMVA::Timer;
       } else {
         p = new((void*) gvp) TMVA::Timer;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTimer));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_286_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::Timer* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Timer(
(Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::Timer(
(Int_t) G__int(libp->para[0]), (const char*) G__int(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::Timer((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMVA::Timer((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Timer((Int_t) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TMVA::Timer((Int_t) G__int(libp->para[0]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTimer));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__TMVA2_286_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         TString* pobj;
         TString xobj = ((TMVA::Timer*) G__getstructoffset())->GetElapsedTime((Bool_t) G__int(libp->para[0]));
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         TString* pobj;
         TString xobj = ((TMVA::Timer*) G__getstructoffset())->GetElapsedTime();
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__TMVA2_286_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TMVA::Timer*) G__getstructoffset())->GetLeftTime((Int_t) G__int(libp->para[0]));
         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__TMVA2_286_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMVA::Timer*) G__getstructoffset())->DrawProgressBar((Int_t) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Timer*) G__getstructoffset())->DrawProgressBar((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::Timer G__TTMVAcLcLTimer;
static int G__G__TMVA2_286_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: 1
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::Timer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::Timer*) (soff+(sizeof(TMVA::Timer)*i)))->~G__TTMVAcLcLTimer();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::Timer*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::Timer*) (soff))->~G__TTMVAcLcLTimer();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::RootFinder G__TTMVAcLcLRootFinder;
static int G__G__TMVA2_287_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::RootFinder*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::RootFinder*) (soff+(sizeof(TMVA::RootFinder)*i)))->~G__TTMVAcLcLRootFinder();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::RootFinder*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::RootFinder*) (soff))->~G__TTMVAcLcLRootFinder();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* TMVA::SeparationBase */
static int G__G__TMVA2_288_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::SeparationBase*) G__getstructoffset())->GetSeparationGain(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_288_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::SeparationBase*) G__getstructoffset())->GetSeparationIndex(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::SeparationBase G__TTMVAcLcLSeparationBase;
static int G__G__TMVA2_288_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::SeparationBase*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::SeparationBase*) (soff+(sizeof(TMVA::SeparationBase)*i)))->~G__TTMVAcLcLSeparationBase();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::SeparationBase*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::SeparationBase*) (soff))->~G__TTMVAcLcLSeparationBase();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::CrossEntropy G__TTMVAcLcLCrossEntropy;
static int G__G__TMVA2_289_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::CrossEntropy*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::CrossEntropy*) (soff+(sizeof(TMVA::CrossEntropy)*i)))->~G__TTMVAcLcLCrossEntropy();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::CrossEntropy*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::CrossEntropy*) (soff))->~G__TTMVAcLcLCrossEntropy();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

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

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

static int G__G__TMVA2_300_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::DecisionTreeNode*) G__getstructoffset())->SetFisherCoeff((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__TMVA2_300_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetFisherCoeff((Int_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__TMVA2_300_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 115, (long) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetSelector());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__TMVA2_300_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetCutValue());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__TMVA2_300_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetPurity());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__TMVA2_300_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetResponse());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__TMVA2_300_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetRMS());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__TMVA2_300_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetNSigEvents());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_300_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetNBkgEvents());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_300_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetNEvents());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_300_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetNSigEvents_unweighted());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_300_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetNBkgEvents_unweighted());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_300_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetNEvents_unweighted());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_300_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetNSigEvents_unboosted());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_300_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetNBkgEvents_unboosted());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_300_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetNEvents_unboosted());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__TMVA2_300_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetSeparationIndex());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__TMVA2_300_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetSeparationGain());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__TMVA2_300_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetSumTarget());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_300_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetSumTarget2());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

static int G__G__TMVA2_300_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetSampleMin((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_300_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::DecisionTreeNode*) G__getstructoffset())->GetSampleMax((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_300_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::DecisionTreeNode*) G__getstructoffset())->SetSampleMin((UInt_t) 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__TMVA2_300_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::DecisionTreeNode*) G__getstructoffset())->SetSampleMax((UInt_t) 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__TMVA2_300_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::DecisionTreeNode::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::DecisionTreeNode G__TTMVAcLcLDecisionTreeNode;
static int G__G__TMVA2_300_0_110(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::DecisionTreeNode*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::DecisionTreeNode*) (soff+(sizeof(TMVA::DecisionTreeNode)*i)))->~G__TTMVAcLcLDecisionTreeNode();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::DecisionTreeNode*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::DecisionTreeNode*) (soff))->~G__TTMVAcLcLDecisionTreeNode();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

static int G__G__TMVA2_301_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::RegressionVariance*) G__getstructoffset())->GetSeparationGain(*(Double_t*) G__Doubleref(&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]), *(Double_t*) G__Doubleref(&libp->para[5])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_301_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::RegressionVariance*) G__getstructoffset())->GetSeparationIndex(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_301_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TMVA::RegressionVariance*) G__getstructoffset())->GetName();
         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__TMVA2_301_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::RegressionVariance::Class());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::RegressionVariance G__TTMVAcLcLRegressionVariance;
static int G__G__TMVA2_301_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::RegressionVariance*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::RegressionVariance*) (soff+(sizeof(TMVA::RegressionVariance)*i)))->~G__TTMVAcLcLRegressionVariance();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::RegressionVariance*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::RegressionVariance*) (soff))->~G__TTMVAcLcLRegressionVariance();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__G__TMVA2_385_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::DecisionTree* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 12:
     //m: 12
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::DecisionTree(
(TMVA::SeparationBase*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TMVA::DataSetInfo*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (UInt_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9])
, (Float_t) G__double(libp->para[10]), (Int_t) G__int(libp->para[11]));
     } else {
       p = new((void*) gvp) TMVA::DecisionTree(
(TMVA::SeparationBase*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TMVA::DataSetInfo*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (UInt_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9])
, (Float_t) G__double(libp->para[10]), (Int_t) G__int(libp->para[11]));
     }
     break;
   case 11:
     //m: 11
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::DecisionTree(
(TMVA::SeparationBase*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TMVA::DataSetInfo*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (UInt_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9])
, (Float_t) G__double(libp->para[10]));
     } else {
       p = new((void*) gvp) TMVA::DecisionTree(
(TMVA::SeparationBase*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TMVA::DataSetInfo*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (UInt_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9])
, (Float_t) G__double(libp->para[10]));
     }
     break;
   case 10:
     //m: 10
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::DecisionTree(
(TMVA::SeparationBase*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TMVA::DataSetInfo*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (UInt_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9]));
     } else {
       p = new((void*) gvp) TMVA::DecisionTree(
(TMVA::SeparationBase*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TMVA::DataSetInfo*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (UInt_t) G__int(libp->para[8]), (Int_t) G__int(libp->para[9]));
     }
     break;
   case 9:
     //m: 9
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::DecisionTree(
(TMVA::SeparationBase*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TMVA::DataSetInfo*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (UInt_t) G__int(libp->para[8]));
     } else {
       p = new((void*) gvp) TMVA::DecisionTree(
(TMVA::SeparationBase*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TMVA::DataSetInfo*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7])
, (UInt_t) G__int(libp->para[8]));
     }
     break;
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::DecisionTree(
(TMVA::SeparationBase*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TMVA::DataSetInfo*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TMVA::DecisionTree(
(TMVA::SeparationBase*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TMVA::DataSetInfo*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]), (Bool_t) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::DecisionTree(
(TMVA::SeparationBase*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TMVA::DataSetInfo*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TMVA::DecisionTree(
(TMVA::SeparationBase*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TMVA::DataSetInfo*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5])
, (Int_t) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::DecisionTree(
(TMVA::SeparationBase*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TMVA::DataSetInfo*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TMVA::DecisionTree(
(TMVA::SeparationBase*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TMVA::DataSetInfo*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]), (Bool_t) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::DecisionTree(
(TMVA::SeparationBase*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TMVA::DataSetInfo*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TMVA::DecisionTree(
(TMVA::SeparationBase*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TMVA::DataSetInfo*) G__int(libp->para[3])
, (UInt_t) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::DecisionTree(
(TMVA::SeparationBase*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TMVA::DataSetInfo*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TMVA::DecisionTree(
(TMVA::SeparationBase*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]), (TMVA::DataSetInfo*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::DecisionTree(
(TMVA::SeparationBase*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::DecisionTree(
(TMVA::SeparationBase*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTree));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__TMVA2_385_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) TMVA::DecisionTree::CreateFromXML((void*) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) TMVA::DecisionTree::CreateFromXML((void*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_385_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 104, (long) ((TMVA::DecisionTree*) G__getstructoffset())->BuildTree(*(TMVA::DecisionTree::EventConstList*) libp->para[0].ref, (TMVA::DecisionTreeNode*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 104, (long) ((TMVA::DecisionTree*) G__getstructoffset())->BuildTree(*(TMVA::DecisionTree::EventConstList*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_385_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::DecisionTree*) G__getstructoffset())->TrainNode(*(TMVA::DecisionTree::EventConstList*) libp->para[0].ref, (TMVA::DecisionTreeNode*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_385_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::DecisionTree*) G__getstructoffset())->TrainNodeFast(*(TMVA::DecisionTree::EventConstList*) libp->para[0].ref, (TMVA::DecisionTreeNode*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_385_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::DecisionTree*) G__getstructoffset())->TrainNodeFull(*(TMVA::DecisionTree::EventConstList*) libp->para[0].ref, (TMVA::DecisionTreeNode*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_385_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::DecisionTree*) G__getstructoffset())->GetRandomisedVariables((Bool_t*) G__int(libp->para[0]), (UInt_t*) G__int(libp->para[1])
, *(UInt_t*) G__UIntref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_385_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<Double_t>* pobj;
         vector<Double_t> xobj = ((TMVA::DecisionTree*) G__getstructoffset())->GetFisherCoefficients(*(TMVA::DecisionTree::EventConstList*) libp->para[0].ref, (UInt_t) G__int(libp->para[1])
, (UInt_t*) G__int(libp->para[2]));
         pobj = new vector<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__TMVA2_385_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::DecisionTree*) G__getstructoffset())->FillTree(*(TMVA::DecisionTree::EventList*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_385_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::DecisionTree*) G__getstructoffset())->FillEvent(*(TMVA::Event*) libp->para[0].ref, (TMVA::DecisionTreeNode*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_385_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const TMVA::DecisionTree*) G__getstructoffset())->CheckEvent((TMVA::Event*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TMVA::DecisionTree*) G__getstructoffset())->CheckEvent((TMVA::Event*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_385_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMVA::DecisionTree*) G__getstructoffset())->GetEventNode(*(TMVA::Event*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_385_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<Double_t>* pobj;
         vector<Double_t> xobj = ((TMVA::DecisionTree*) G__getstructoffset())->GetVariableImportance();
         pobj = new vector<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__TMVA2_385_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::DecisionTree*) G__getstructoffset())->GetVariableImportance((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__TMVA2_385_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TMVA::DecisionTree*) G__getstructoffset())->GetNode((ULong_t) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::DecisionTree G__TTMVAcLcLDecisionTree;
static int G__G__TMVA2_385_0_62(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::DecisionTree*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::DecisionTree*) (soff+(sizeof(TMVA::DecisionTree)*i)))->~G__TTMVAcLcLDecisionTree();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::DecisionTree*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::DecisionTree*) (soff))->~G__TTMVAcLcLDecisionTree();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::MisClassificationError G__TTMVAcLcLMisClassificationError;
static int G__G__TMVA2_391_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::MisClassificationError*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::MisClassificationError*) (soff+(sizeof(TMVA::MisClassificationError)*i)))->~G__TTMVAcLcLMisClassificationError();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::MisClassificationError*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::MisClassificationError*) (soff))->~G__TTMVAcLcLMisClassificationError();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::SdivSqrtSplusB G__TTMVAcLcLSdivSqrtSplusB;
static int G__G__TMVA2_392_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::SdivSqrtSplusB*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::SdivSqrtSplusB*) (soff+(sizeof(TMVA::SdivSqrtSplusB)*i)))->~G__TTMVAcLcLSdivSqrtSplusB();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::SdivSqrtSplusB*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::SdivSqrtSplusB*) (soff))->~G__TTMVAcLcLSdivSqrtSplusB();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

static int G__G__TMVA2_406_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 10:
      ((TMVA::Tools*) G__getstructoffset())->ComputeStat(
*(vector<TMVA::Event*>*) libp->para[0].ref, (vector<Float_t>*) G__int(libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4]), *(Double_t*) G__Doubleref(&libp->para[5])
, *(Double_t*) G__Doubleref(&libp->para[6]), *(Double_t*) G__Doubleref(&libp->para[7])
, (Int_t) G__int(libp->para[8]), (Bool_t) G__int(libp->para[9]));
      G__setnull(result7);
      break;
   case 9:
      ((TMVA::Tools*) G__getstructoffset())->ComputeStat(
*(vector<TMVA::Event*>*) libp->para[0].ref, (vector<Float_t>*) G__int(libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
, *(Double_t*) G__Doubleref(&libp->para[4]), *(Double_t*) G__Doubleref(&libp->para[5])
, *(Double_t*) G__Doubleref(&libp->para[6]), *(Double_t*) G__Doubleref(&libp->para[7])
, (Int_t) G__int(libp->para[8]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::Tools*) G__getstructoffset())->ComputeVariance((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Int_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TMVA::Tools*) G__getstructoffset())->projNormTH1F(
(TTree*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref, (Int_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])
, *(TString*) libp->para[6].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((TMVA::Tools*) G__getstructoffset())->NormHist((TH1*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((TMVA::Tools*) G__getstructoffset())->NormHist((TH1*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TMVA::Tools*) G__getstructoffset())->ParseFormatLine(*((TString*) G__int(libp->para[0])), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TMVA::Tools*) G__getstructoffset())->ParseFormatLine(*((TString*) G__int(libp->para[0]))));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TMVA::Tools*) G__getstructoffset())->ParseANNOptionString(*((TString*) G__int(libp->para[0])), (Int_t) G__int(libp->para[1])
, (vector<Int_t>*) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__TMVA2_406_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TMVA::Tools*) G__getstructoffset())->CalcCovarianceMatrices(*(vector<TMVA::Event*,allocator<TMVA::Event*> >*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (TMVA::VariableTransformBase*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TMVA::Tools*) G__getstructoffset())->CalcCovarianceMatrices(*(vector<TMVA::Event*,allocator<TMVA::Event*> >*) libp->para[0].ref, (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letint(result7, 85, (long) ((TMVA::Tools*) G__getstructoffset())->CalcCovarianceMatrices(*(vector<const TMVA::Event*,allocator<const TMVA::Event*> >*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (TMVA::VariableTransformBase*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 85, (long) ((TMVA::Tools*) G__getstructoffset())->CalcCovarianceMatrices(*(vector<const TMVA::Event*,allocator<const TMVA::Event*> >*) libp->para[0].ref, (Int_t) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__TMVA2_406_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TMVA::Tools*) G__getstructoffset())->CheckSplines((TH1*) G__int(libp->para[0]), (TSpline*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__TMVA2_406_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<Double_t>* pobj;
         vector<Double_t> xobj = ((TMVA::Tools*) G__getstructoffset())->MVADiff(*(vector<Double_t>*) libp->para[0].ref, *(vector<Double_t>*) libp->para[1].ref);
         pobj = new vector<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__TMVA2_406_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Tools*) G__getstructoffset())->Scale(*(vector<Double_t>*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Tools*) G__getstructoffset())->Scale(*(vector<Float_t>*) libp->para[0].ref, (Float_t) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMVA::Tools*) G__getstructoffset())->UsefulSortDescending(*(vector<std::vector<Double_t> >*) libp->para[0].ref, (vector<TString>*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Tools*) G__getstructoffset())->UsefulSortDescending(*(vector<std::vector<Double_t> >*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMVA::Tools*) G__getstructoffset())->UsefulSortAscending(*(vector<std::vector<Double_t> >*) libp->para[0].ref, (vector<TString>*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Tools*) G__getstructoffset())->UsefulSortAscending(*(vector<std::vector<Double_t> >*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Tools*) G__getstructoffset())->UsefulSortDescending(*(vector<Double_t>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Tools*) G__getstructoffset())->UsefulSortAscending(*(vector<Double_t>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TMVA::Tools*) G__getstructoffset())->GetIndexMaxElement(*(vector<Double_t>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TMVA::Tools*) G__getstructoffset())->GetIndexMinElement(*(vector<Double_t>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TMVA::Tools*) G__getstructoffset())->ContainsRegularExpression(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         TString* pobj;
         TString xobj = ((TMVA::Tools*) G__getstructoffset())->ReplaceRegularExpressions(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         TString* pobj;
         TString xobj = ((TMVA::Tools*) G__getstructoffset())->ReplaceRegularExpressions(*(TString*) libp->para[0].ref);
         pobj = new TString(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TMVA::Tools*) G__getstructoffset())->FormattedOutput(*(vector<Double_t>*) libp->para[0].ref, *(vector<TString>*) libp->para[1].ref
, *((const TString*) G__int(libp->para[2])), *((const TString*) G__int(libp->para[3]))
, *(TMVA::MsgLogger*) libp->para[4].ref, *((TString*) G__int(libp->para[5])));
      G__setnull(result7);
      break;
   case 5:
      ((TMVA::Tools*) G__getstructoffset())->FormattedOutput(*(vector<Double_t>*) libp->para[0].ref, *(vector<TString>*) libp->para[1].ref
, *((const TString*) G__int(libp->para[2])), *((const TString*) G__int(libp->para[3]))
, *(TMVA::MsgLogger*) libp->para[4].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Tools*) G__getstructoffset())->FormattedOutput(*(TMatrixD*) libp->para[0].ref, *(vector<TString>*) libp->para[1].ref
, *(TMVA::MsgLogger*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Tools*) G__getstructoffset())->FormattedOutput(*(TMatrixD*) libp->para[0].ref, *(vector<TString>*) libp->para[1].ref
, *(vector<TString>*) libp->para[2].ref, *(TMVA::MsgLogger*) libp->para[3].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Tools*) G__getstructoffset())->WriteFloatArbitraryPrecision((Float_t) G__double(libp->para[0]), *(ostream*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Tools*) G__getstructoffset())->ReadFloatArbitraryPrecision(*(Float_t*) G__Floatref(&libp->para[0]), *(istream*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TMVA::Tools*) G__getstructoffset())->GetXTitleWithUnit(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
         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__TMVA2_406_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TMVA::Tools*) G__getstructoffset())->GetYTitleWithUnit(*(TH1*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (Bool_t) G__int(libp->para[2]));
         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__TMVA2_406_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::Tools*) G__getstructoffset())->GetMutualInformation(*(TH2F*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::Tools*) G__getstructoffset())->GetCorrelationRatio(*(TH2F*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TMVA::Tools*) G__getstructoffset())->TransposeHist(*(TH2F*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMVA::Tools*) G__getstructoffset())->CheckForSilentOption(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const TMVA::Tools*) G__getstructoffset())->CheckForVerboseOption(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__TMVA2_406_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMVA::Tools*) G__getstructoffset())->TMVAWelcomeMessage(*(TMVA::MsgLogger*) libp->para[0].ref, (TMVA::Tools::EWelcomeMessage) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Tools*) G__getstructoffset())->TMVAWelcomeMessage(*(TMVA::MsgLogger*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__TMVA2_406_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMVA::Tools*) G__getstructoffset())->TMVACitation(*(TMVA::MsgLogger*) libp->para[0].ref, (TMVA::Tools::ECitation) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Tools*) G__getstructoffset())->TMVACitation(*(TMVA::MsgLogger*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TString>* pobj;
         const vector<TString> xobj = ((const TMVA::Tools*) G__getstructoffset())->SplitString(*(TString*) libp->para[0].ref, (const char) G__int(libp->para[1]));
         pobj = new vector<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__TMVA2_406_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::MsgLogger& obj = ((const TMVA::Tools*) G__getstructoffset())->Log();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TMVA::Tools*) G__getstructoffset())->StringFromInt((Long_t) G__int(libp->para[0]));
         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__TMVA2_406_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TMVA::Tools*) G__getstructoffset())->StringFromDouble((Double_t) G__double(libp->para[0]));
         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__TMVA2_406_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Tools*) G__getstructoffset())->WriteTMatrixDToXML((void*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TMatrixD*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Tools*) G__getstructoffset())->WriteTVectorDToXML((void*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVectorD*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Tools*) G__getstructoffset())->ReadTMatrixDFromXML((void*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TMatrixD*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Tools*) G__getstructoffset())->ReadTVectorDFromXML((void*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TVectorD*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TMVA::Tools*) G__getstructoffset())->HistoHasEquidistantBins(*(TH1*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TMVA::Tools*) G__getstructoffset())->HasAttr((void*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Tools*) G__getstructoffset())->ReadAttr((void*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, *(TString*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__TMVA2_406_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 89, (long) ((TMVA::Tools*) G__getstructoffset())->AddChild((void*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (bool) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 89, (long) ((TMVA::Tools*) G__getstructoffset())->AddChild((void*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2])));
      break;
   case 2:
      G__letint(result7, 89, (long) ((TMVA::Tools*) G__getstructoffset())->AddChild((void*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TMVA::Tools*) G__getstructoffset())->AddRawLine((void*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TMVA::Tools*) G__getstructoffset())->AddComment((void*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 89, (long) ((TMVA::Tools*) G__getstructoffset())->GetParent((void*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 89, (long) ((TMVA::Tools*) G__getstructoffset())->GetChild((void*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 89, (long) ((TMVA::Tools*) G__getstructoffset())->GetChild((void*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 89, (long) ((TMVA::Tools*) G__getstructoffset())->GetNextChild((void*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 89, (long) ((TMVA::Tools*) G__getstructoffset())->GetNextChild((void*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TMVA::Tools*) G__getstructoffset())->GetContent((void*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_406_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((TMVA::Tools*) G__getstructoffset())->GetName((void*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

// automatic destructor
typedef TMVA::Tools G__TTMVAcLcLTools;
static int G__G__TMVA2_406_0_72(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::Tools*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::Tools*) (soff+(sizeof(TMVA::Tools)*i)))->~G__TTMVAcLcLTools();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::Tools*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::Tools*) (soff))->~G__TTMVAcLcLTools();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::Reader */
static int G__G__TMVA2_453_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::Reader* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Reader(*(TString*) libp->para[0].ref, (Bool_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMVA::Reader(*(TString*) libp->para[0].ref, (Bool_t) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Reader(*(TString*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) TMVA::Reader(*(TString*) libp->para[0].ref);
     }
     break;
   case 0:
     int n = G__getaryconstruct();
     if (n) {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TMVA::Reader[n];
       } else {
         p = new((void*) gvp) TMVA::Reader[n];
       }
     } else {
       if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
         p = new TMVA::Reader;
       } else {
         p = new((void*) gvp) TMVA::Reader;
       }
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLReader));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_453_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::Reader* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Reader(
*(vector<std::string>*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (Bool_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::Reader(
*(vector<std::string>*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (Bool_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Reader(*(vector<std::string>*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TMVA::Reader(*(vector<std::string>*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Reader(*(vector<std::string>*) libp->para[0].ref);
     } else {
       p = new((void*) gvp) TMVA::Reader(*(vector<std::string>*) libp->para[0].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLReader));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__TMVA2_453_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TMVA::Reader*) G__getstructoffset())->BookMVA(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_453_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TMVA::Reader*) G__getstructoffset())->BookMVA((TMVA::Types::EMVA) G__int(libp->para[0]), (const char*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_453_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TMVA::Reader*) G__getstructoffset())->FindMVA(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_453_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TMVA::Reader*) G__getstructoffset())->FindCutsMVA(*(TString*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_453_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((TMVA::Reader*) G__getstructoffset())->EvaluateMVA(*(vector<Float_t>*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((TMVA::Reader*) G__getstructoffset())->EvaluateMVA(*(vector<Float_t>*) libp->para[0].ref, *(TString*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_453_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((TMVA::Reader*) G__getstructoffset())->EvaluateMVA(*(vector<Double_t>*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((TMVA::Reader*) G__getstructoffset())->EvaluateMVA(*(vector<Double_t>*) libp->para[0].ref, *(TString*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_453_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((TMVA::Reader*) G__getstructoffset())->EvaluateMVA((TMVA::MethodBase*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((TMVA::Reader*) G__getstructoffset())->EvaluateMVA((TMVA::MethodBase*) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_453_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((TMVA::Reader*) G__getstructoffset())->EvaluateMVA(*(TString*) libp->para[0].ref, (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((TMVA::Reader*) G__getstructoffset())->EvaluateMVA(*(TString*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__TMVA2_453_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const vector<Float_t>& obj = ((TMVA::Reader*) G__getstructoffset())->EvaluateRegression(*(TString*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const vector<Float_t>& obj = ((TMVA::Reader*) G__getstructoffset())->EvaluateRegression(*(TString*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_453_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const vector<Float_t>& obj = ((TMVA::Reader*) G__getstructoffset())->EvaluateRegression((TMVA::MethodBase*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const vector<Float_t>& obj = ((TMVA::Reader*) G__getstructoffset())->EvaluateRegression((TMVA::MethodBase*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_453_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 102, (double) ((TMVA::Reader*) G__getstructoffset())->EvaluateRegression((UInt_t) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 102, (double) ((TMVA::Reader*) G__getstructoffset())->EvaluateRegression((UInt_t) G__int(libp->para[0]), *(TString*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_453_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const vector<Float_t>& obj = ((TMVA::Reader*) G__getstructoffset())->EvaluateMulticlass(*(TString*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const vector<Float_t>& obj = ((TMVA::Reader*) G__getstructoffset())->EvaluateMulticlass(*(TString*) libp->para[0].ref);
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_453_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const vector<Float_t>& obj = ((TMVA::Reader*) G__getstructoffset())->EvaluateMulticlass((TMVA::MethodBase*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 1:
      {
         const vector<Float_t>& obj = ((TMVA::Reader*) G__getstructoffset())->EvaluateMulticlass((TMVA::MethodBase*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_453_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 102, (double) ((TMVA::Reader*) G__getstructoffset())->EvaluateMulticlass((UInt_t) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 102, (double) ((TMVA::Reader*) G__getstructoffset())->EvaluateMulticlass((UInt_t) G__int(libp->para[0]), *(TString*) libp->para[1].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_453_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      G__letdouble(result7, 100, (double) ((TMVA::Reader*) G__getstructoffset())->GetProba(*(TString*) libp->para[0].ref, (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((TMVA::Reader*) G__getstructoffset())->GetProba(*(TString*) libp->para[0].ref, (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((TMVA::Reader*) G__getstructoffset())->GetProba(*(TString*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_453_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((TMVA::Reader*) G__getstructoffset())->GetRarity(*(TString*) libp->para[0].ref, (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((TMVA::Reader*) G__getstructoffset())->GetRarity(*(TString*) libp->para[0].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__TMVA2_453_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Reader*) G__getstructoffset())->AddVariable(*(TString*) libp->para[0].ref, (Float_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_453_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Reader*) G__getstructoffset())->AddVariable(*(TString*) libp->para[0].ref, (Int_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_453_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Reader*) G__getstructoffset())->AddSpectator(*(TString*) libp->para[0].ref, (Float_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_453_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Reader*) G__getstructoffset())->AddSpectator(*(TString*) libp->para[0].ref, (Int_t*) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::Reader G__TTMVAcLcLReader;
static int G__G__TMVA2_453_0_53(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::Reader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::Reader*) (soff+(sizeof(TMVA::Reader)*i)))->~G__TTMVAcLcLReader();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::Reader*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::Reader*) (soff))->~G__TTMVAcLcLReader();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::GeneticGenes G__TTMVAcLcLGeneticGenes;
static int G__G__TMVA2_466_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::GeneticGenes*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::GeneticGenes*) (soff+(sizeof(TMVA::GeneticGenes)*i)))->~G__TTMVAcLcLGeneticGenes();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::GeneticGenes*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::GeneticGenes*) (soff))->~G__TTMVAcLcLGeneticGenes();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__G__TMVA2_468_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letdouble(result7, 100, (double) ((TMVA::GeneticRange*) G__getstructoffset())->Random((Bool_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Bool_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letdouble(result7, 100, (double) ((TMVA::GeneticRange*) G__getstructoffset())->Random((Bool_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (Double_t) G__double(libp->para[2])));
      break;
   case 2:
      G__letdouble(result7, 100, (double) ((TMVA::GeneticRange*) G__getstructoffset())->Random((Bool_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((TMVA::GeneticRange*) G__getstructoffset())->Random((Bool_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((TMVA::GeneticRange*) G__getstructoffset())->Random());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::GeneticRange G__TTMVAcLcLGeneticRange;
static int G__G__TMVA2_468_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: 0
   //has_own_delete1arg: 0
   //has_own_delete2arg: 0
   //
   if (!soff) {
     return(1);
   }
   if (n) {
     if (gvp == (char*)G__PVOID) {
       delete[] (TMVA::GeneticRange*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::GeneticRange*) (soff+(sizeof(TMVA::GeneticRange)*i)))->~G__TTMVAcLcLGeneticRange();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::GeneticRange*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::GeneticRange*) (soff))->~G__TTMVAcLcLGeneticRange();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* TMVA::GeneticPopulation */
static int G__G__TMVA2_469_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::GeneticPopulation* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::GeneticPopulation(
*(vector<TMVA::Interval*>*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::GeneticPopulation(
*(vector<TMVA::Interval*>*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::GeneticPopulation(*(vector<TMVA::Interval*>*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMVA::GeneticPopulation(*(vector<TMVA::Interval*>*) libp->para[0].ref, (Int_t) 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__TMVA2LN_TMVAcLcLGeneticPopulation));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__TMVA2_469_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TMVA::GeneticPopulation*) G__getstructoffset())->Mutate((Double_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3])
, (Bool_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TMVA::GeneticPopulation*) G__getstructoffset())->Mutate((Double_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TMVA::GeneticPopulation*) G__getstructoffset())->Mutate((Double_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Bool_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TMVA::GeneticPopulation*) G__getstructoffset())->Mutate((Double_t) G__double(libp->para[0]), (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::GeneticPopulation*) G__getstructoffset())->Mutate((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TMVA::GeneticPopulation*) G__getstructoffset())->Mutate();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

static int G__G__TMVA2_469_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMVA::GeneticPopulation*) G__getstructoffset())->Print(*(ostream*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::GeneticPopulation*) G__getstructoffset())->Print(*(ostream*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_469_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TMVA::GeneticPopulation*) G__getstructoffset())->VariableDistribution((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])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_469_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         vector<Double_t>* pobj;
         vector<Double_t> xobj = ((TMVA::GeneticPopulation*) G__getstructoffset())->VariableDistribution((Int_t) G__int(libp->para[0]));
         pobj = new vector<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__TMVA2_469_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::GeneticPopulation*) G__getstructoffset())->MakeCopies((int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__TMVA2_469_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMVA::GeneticPopulation*) G__getstructoffset())->GiveHint(*(vector<Double_t>*) libp->para[0].ref, (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::GeneticPopulation*) G__getstructoffset())->GiveHint(*(vector<Double_t>*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::GeneticPopulation G__TTMVAcLcLGeneticPopulation;
static int G__G__TMVA2_469_0_38(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::GeneticPopulation*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::GeneticPopulation*) (soff+(sizeof(TMVA::GeneticPopulation)*i)))->~G__TTMVAcLcLGeneticPopulation();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::GeneticPopulation*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::GeneticPopulation*) (soff))->~G__TTMVAcLcLGeneticPopulation();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

static int G__G__TMVA2_482_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 103, (long) ((TMVA::GeneticAlgorithm*) G__getstructoffset())->HasConverged((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 103, (long) ((TMVA::GeneticAlgorithm*) G__getstructoffset())->HasConverged((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 103, (long) ((TMVA::GeneticAlgorithm*) G__getstructoffset())->HasConverged());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_482_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::GeneticAlgorithm*) G__getstructoffset())->SpreadControl((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA2_482_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::GeneticAlgorithm*) 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__TMVA2_482_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::GeneticAlgorithm*) G__getstructoffset())->CalculateFitness());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::GeneticAlgorithm G__TTMVAcLcLGeneticAlgorithm;
static int G__G__TMVA2_482_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::GeneticAlgorithm*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::GeneticAlgorithm*) (soff+(sizeof(TMVA::GeneticAlgorithm)*i)))->~G__TTMVAcLcLGeneticAlgorithm();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::GeneticAlgorithm*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::GeneticAlgorithm*) (soff))->~G__TTMVAcLcLGeneticAlgorithm();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::GiniIndex G__TTMVAcLcLGiniIndex;
static int G__G__TMVA2_486_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::GiniIndex*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::GiniIndex*) (soff+(sizeof(TMVA::GiniIndex)*i)))->~G__TTMVAcLcLGiniIndex();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::GiniIndex*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::GiniIndex*) (soff))->~G__TTMVAcLcLGiniIndex();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::GiniIndexWithLaplace G__TTMVAcLcLGiniIndexWithLaplace;
static int G__G__TMVA2_487_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::GiniIndexWithLaplace*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::GiniIndexWithLaplace*) (soff+(sizeof(TMVA::GiniIndexWithLaplace)*i)))->~G__TTMVAcLcLGiniIndexWithLaplace();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::GiniIndexWithLaplace*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::GiniIndexWithLaplace*) (soff))->~G__TTMVAcLcLGiniIndexWithLaplace();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

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

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

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

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

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

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

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

static int G__G__TMVA2_489_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::SimulatedAnnealing*) G__getstructoffset())->SetOptions(
(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]), (Double_t) G__double(libp->para[7])
, (Bool_t) G__int(libp->para[8]), (Bool_t) G__int(libp->para[9]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::SimulatedAnnealing G__TTMVAcLcLSimulatedAnnealing;
static int G__G__TMVA2_489_0_32(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::SimulatedAnnealing*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::SimulatedAnnealing*) (soff+(sizeof(TMVA::SimulatedAnnealing)*i)))->~G__TTMVAcLcLSimulatedAnnealing();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::SimulatedAnnealing*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::SimulatedAnnealing*) (soff))->~G__TTMVAcLcLSimulatedAnnealing();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}


/* TMVA::QuickMVAProbEstimator */
static int G__G__TMVA2_491_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) TMVA::QuickMVAProbEstimator::compare(*((TMVA::QuickMVAProbEstimator::EventInfo*) G__int(libp->para[0])), *((TMVA::QuickMVAProbEstimator::EventInfo*) G__int(libp->para[1]))));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// automatic destructor
typedef TMVA::QuickMVAProbEstimator G__TTMVAcLcLQuickMVAProbEstimator;
static int G__G__TMVA2_491_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::QuickMVAProbEstimator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       for (int i = n - 1; i >= 0; --i) {
         ((TMVA::QuickMVAProbEstimator*) (soff+(sizeof(TMVA::QuickMVAProbEstimator)*i)))->~G__TTMVAcLcLQuickMVAProbEstimator();
       }
       G__setgvp((long)gvp);
     }
   } else {
     if (gvp == (char*)G__PVOID) {
       delete (TMVA::QuickMVAProbEstimator*) soff;
     } else {
       G__setgvp((long) G__PVOID);
       ((TMVA::QuickMVAProbEstimator*) (soff))->~G__TTMVAcLcLQuickMVAProbEstimator();
       G__setgvp((long)gvp);
     }
   }
   G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* TMVA */

/* TMVA::TSpline2 */

/* TMVA::TSpline1 */

/* TMVA::PDF */

/* TMVA::Node */

/* TMVA::BinaryTree */

/* TMVA::BinarySearchTreeNode */

/* TMVA::BinarySearchTree */

/* TMVA::Timer */

/* TMVA::RootFinder */

/* TMVA::SeparationBase */

/* TMVA::CrossEntropy */

/* TMVA::DecisionTreeNode */

/* TMVA::RegressionVariance */

/* TMVA::DecisionTree */

/* TMVA::MisClassificationError */

/* TMVA::SdivSqrtSplusB */

/* TMVA::Tools */

/* TMVA::Reader */

/* TMVA::GeneticGenes */

/* TMVA::GeneticRange */

/* TMVA::GeneticPopulation */

/* TMVA::GeneticAlgorithm */

/* TMVA::GiniIndex */

/* TMVA::GiniIndexWithLaplace */

/* TMVA::SimulatedAnnealing */

/* TMVA::QuickMVAProbEstimator */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__TMVA2 {
 public:
  G__Sizep2memfuncG__TMVA2(): p(&G__Sizep2memfuncG__TMVA2::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__TMVA2::*p)();
};

size_t G__get_sizep2memfuncG__TMVA2()
{
  G__Sizep2memfuncG__TMVA2 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__TMVA2() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline2))) {
     TMVA::TSpline2 *G__Lderived;
     G__Lderived=(TMVA::TSpline2*)0x1000;
     {
       TSpline *G__Lpbase=(TSpline*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline2),G__get_linked_tagnum(&G__G__TMVA2LN_TSpline),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline2),G__get_linked_tagnum(&G__G__TMVA2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline2),G__get_linked_tagnum(&G__G__TMVA2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline2),G__get_linked_tagnum(&G__G__TMVA2LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline2),G__get_linked_tagnum(&G__G__TMVA2LN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline2),G__get_linked_tagnum(&G__G__TMVA2LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline1))) {
     TMVA::TSpline1 *G__Lderived;
     G__Lderived=(TMVA::TSpline1*)0x1000;
     {
       TSpline *G__Lpbase=(TSpline*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline1),G__get_linked_tagnum(&G__G__TMVA2LN_TSpline),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline1),G__get_linked_tagnum(&G__G__TMVA2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline1),G__get_linked_tagnum(&G__G__TMVA2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttLine *G__Lpbase=(TAttLine*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline1),G__get_linked_tagnum(&G__G__TMVA2LN_TAttLine),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttFill *G__Lpbase=(TAttFill*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline1),G__get_linked_tagnum(&G__G__TMVA2LN_TAttFill),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TAttMarker *G__Lpbase=(TAttMarker*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline1),G__get_linked_tagnum(&G__G__TMVA2LN_TAttMarker),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLPDF))) {
     TMVA::PDF *G__Lderived;
     G__Lderived=(TMVA::PDF*)0x1000;
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLPDF),G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLPDF),G__get_linked_tagnum(&G__G__TMVA2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinarySearchTreeNode))) {
     TMVA::BinarySearchTreeNode *G__Lderived;
     G__Lderived=(TMVA::BinarySearchTreeNode*)0x1000;
     {
       TMVA::Node *G__Lpbase=(TMVA::Node*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinarySearchTreeNode),G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLNode),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinarySearchTree))) {
     TMVA::BinarySearchTree *G__Lderived;
     G__Lderived=(TMVA::BinarySearchTree*)0x1000;
     {
       TMVA::BinaryTree *G__Lpbase=(TMVA::BinaryTree*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinarySearchTree),G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinaryTree),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTimer))) {
     TMVA::Timer *G__Lderived;
     G__Lderived=(TMVA::Timer*)0x1000;
     {
       TStopwatch *G__Lpbase=(TStopwatch*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTimer),G__get_linked_tagnum(&G__G__TMVA2LN_TStopwatch),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTimer),G__get_linked_tagnum(&G__G__TMVA2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLRootFinder))) {
     TMVA::RootFinder *G__Lderived;
     G__Lderived=(TMVA::RootFinder*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLRootFinder),G__get_linked_tagnum(&G__G__TMVA2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLCrossEntropy))) {
     TMVA::CrossEntropy *G__Lderived;
     G__Lderived=(TMVA::CrossEntropy*)0x1000;
     {
       TMVA::SeparationBase *G__Lpbase=(TMVA::SeparationBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLCrossEntropy),G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSeparationBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTreeNode))) {
     TMVA::DecisionTreeNode *G__Lderived;
     G__Lderived=(TMVA::DecisionTreeNode*)0x1000;
     {
       TMVA::Node *G__Lpbase=(TMVA::Node*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTreeNode),G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLNode),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTree))) {
     TMVA::DecisionTree *G__Lderived;
     G__Lderived=(TMVA::DecisionTree*)0x1000;
     {
       TMVA::BinaryTree *G__Lpbase=(TMVA::BinaryTree*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTree),G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinaryTree),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMisClassificationError))) {
     TMVA::MisClassificationError *G__Lderived;
     G__Lderived=(TMVA::MisClassificationError*)0x1000;
     {
       TMVA::SeparationBase *G__Lpbase=(TMVA::SeparationBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMisClassificationError),G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSeparationBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSdivSqrtSplusB))) {
     TMVA::SdivSqrtSplusB *G__Lderived;
     G__Lderived=(TMVA::SdivSqrtSplusB*)0x1000;
     {
       TMVA::SeparationBase *G__Lpbase=(TMVA::SeparationBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSdivSqrtSplusB),G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSeparationBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLReader))) {
     TMVA::Reader *G__Lderived;
     G__Lderived=(TMVA::Reader*)0x1000;
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLReader),G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLReader),G__get_linked_tagnum(&G__G__TMVA2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGiniIndex))) {
     TMVA::GiniIndex *G__Lderived;
     G__Lderived=(TMVA::GiniIndex*)0x1000;
     {
       TMVA::SeparationBase *G__Lpbase=(TMVA::SeparationBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGiniIndex),G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSeparationBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGiniIndexWithLaplace))) {
     TMVA::GiniIndexWithLaplace *G__Lderived;
     G__Lderived=(TMVA::GiniIndexWithLaplace*)0x1000;
     {
       TMVA::SeparationBase *G__Lpbase=(TMVA::SeparationBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGiniIndexWithLaplace),G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSeparationBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__TMVA2() {

   /* Setting up typedef entry */
   G__search_typename2("Short_t",115,-1,0,-1);
   G__setnewtype(-1,"Signed Short integer 2 bytes (short)",0);
   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("ULong_t",107,-1,0,-1);
   G__setnewtype(-1,"Unsigned long integer 8 bytes (unsigned 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__TMVA2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA2LN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA2LN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorD",117,G__get_linked_tagnum(&G__G__TMVA2LN_TVectorTlEdoublegR),0,-1);
   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__TMVA2LN_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__TMVA2LN_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__TMVA2LN_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__TMVA2LN_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__TMVA2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMVAVersion_t",104,-1,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVA));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,TMVA::Types::EMVA>",117,G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<EMsgType,std::string>",117,G__get_linked_tagnum(&G__G__TMVA2LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TMVA::EMsgType,string>",117,G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Option<Bool_t>",117,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLOptionlEboolgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVA));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<bool>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEboolcOallocatorlEboolgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Option<Bool_t*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLOptionlEboolmUgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVA));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Option<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLOptionlEfloatgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVA));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<float>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatcOallocatorlEfloatgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatcOallocatorlEfloatgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEdoublecOallocatorlEdoublegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEdoublecOallocatorlEdoublegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<double>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const TMVA::BinarySearchTreeNode*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::Event*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Int_t>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Double_t,const TMVA::Event*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2LN_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__TMVA2LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<double,const TMVA::Event*> >",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Double_t (*)(Double_t)",49,-1,0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA2LN_TMatrixTBaselEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA2LN_TMatrixTBaselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,TObjArray*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*,less<string> >",117,G__get_linked_tagnum(&G__G__TMVA2LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA2LN_TMatrixTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixD",117,G__get_linked_tagnum(&G__G__TMVA2LN_TMatrixTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Float_t*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<float*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<VariableInfo>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::VariableInfo>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<ClassInfo*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::ClassInfo*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("EventList",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTree));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const TMVA::Event*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("EventConstList",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTree));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSym<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA2LN_TMatrixTSymlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixDSym",117,G__get_linked_tagnum(&G__G__TMVA2LN_TMatrixTSymlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Char_t,UInt_t>",117,G__get_linked_tagnum(&G__G__TMVA2LN_pairlEcharcOunsignedsPintgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::pair<Char_t,UInt_t> >",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<Char_t,UInt_t> >",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<char,unsigned int> >",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Char_t>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEcharcOallocatorlEchargRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEcharcOallocatorlEchargRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEcharcOallocatorlEchargRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<char>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEcharcOallocatorlEchargRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMatrixDSym*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMatrixTSym<double>*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Event*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTools));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const Event*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTools));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<Double_t> >",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<Double_t> >",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<double,allocator<double> > >",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TreeInfo>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::TreeInfo>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,std::vector<TreeInfo> >",117,G__get_linked_tagnum(&G__G__TMVA2LN_maplETStringcOvectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgRcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOvectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,vector<TMVA::TreeInfo,allocator<TMVA::TreeInfo> > >",117,G__get_linked_tagnum(&G__G__TMVA2LN_maplETStringcOvectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgRcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOvectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,vector<TMVA::TreeInfo,allocator<TMVA::TreeInfo> >,less<TString> >",117,G__get_linked_tagnum(&G__G__TMVA2LN_maplETStringcOvectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgRcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOvectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,Bool_t>",117,G__get_linked_tagnum(&G__G__TMVA2LN_maplEstringcOboolcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOboolgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,Bool_t>",117,G__get_linked_tagnum(&G__G__TMVA2LN_maplEstringcOboolcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOboolgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,bool>",117,G__get_linked_tagnum(&G__G__TMVA2LN_maplEstringcOboolcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOboolgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,bool,less<string> >",117,G__get_linked_tagnum(&G__G__TMVA2LN_maplEstringcOboolcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOboolgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::string>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<string>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEstringcOallocatorlEstringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<string>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,IMethod*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_maplETStringcOTMVAcLcLIMethodmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIMethodmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,TMVA::IMethod*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_maplETStringcOTMVAcLcLIMethodmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIMethodmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,TMVA::IMethod*,less<TString> >",117,G__get_linked_tagnum(&G__G__TMVA2LN_maplETStringcOTMVAcLcLIMethodmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIMethodmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::Interval*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::GeneticGenes>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLGeneticGenescOallocatorlETMVAcLcLGeneticGenesgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLGeneticGenescOallocatorlETMVAcLcLGeneticGenesgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLGeneticGenescOallocatorlETMVAcLcLGeneticGenesgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLGeneticGenescOallocatorlETMVAcLcLGeneticGenesgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLGeneticGenescOallocatorlETMVAcLcLGeneticGenesgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::GeneticRange*>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLGeneticRangemUcOallocatorlETMVAcLcLGeneticRangemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLGeneticRangemUcOallocatorlETMVAcLcLGeneticRangemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLGeneticRangemUcOallocatorlETMVAcLcLGeneticRangemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLGeneticRangemUcOallocatorlETMVAcLcLGeneticRangemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLGeneticRangemUcOallocatorlETMVAcLcLGeneticRangemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("deque<Int_t>",117,G__get_linked_tagnum(&G__G__TMVA2LN_dequelEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("deque<int>",117,G__get_linked_tagnum(&G__G__TMVA2LN_dequelEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<EventInfo>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfocOallocatorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfogRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfocOallocatorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfogRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfocOallocatorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfocOallocatorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfogRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfocOallocatorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::QuickMVAProbEstimator::EventInfo>",117,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfocOallocatorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfogRsPgR),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__TMVA2LN_TMVA));
   {
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2LN_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__TMVA2LN_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__TMVA2LN_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__TMVA2LN_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__TMVA2LN_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__TMVA2LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kSILENT=%lldLL",(long long)TMVA::kSILENT).data(),0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::TSpline2 */
static void G__setup_memvarTMVAcLcLTSpline2(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline2));
   { TMVA::TSpline2 *p; p=(TMVA::TSpline2*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TGraph),-1,-1,4,"fGraph=",0,"graph that is splined");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::TSpline1 */
static void G__setup_memvarTMVAcLcLTSpline1(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline1));
   { TMVA::TSpline1 *p; p=(TMVA::TSpline1*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TGraph),-1,-1,4,"fGraph=",0,"graph that is splined");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::PDF */
static void G__setup_memvarTMVAcLcLPDF(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLPDF));
   { TMVA::PDF *p; p=(TMVA::PDF*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLPDFcLcLEInterpolateMethod),-1,-2,1,G__FastAllocString(2048).Format("kSpline0=%lldLL",(long long)TMVA::PDF::kSpline0).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLPDFcLcLEInterpolateMethod),-1,-2,1,G__FastAllocString(2048).Format("kSpline1=%lldLL",(long long)TMVA::PDF::kSpline1).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLPDFcLcLEInterpolateMethod),-1,-2,1,G__FastAllocString(2048).Format("kSpline2=%lldLL",(long long)TMVA::PDF::kSpline2).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLPDFcLcLEInterpolateMethod),-1,-2,1,G__FastAllocString(2048).Format("kSpline3=%lldLL",(long long)TMVA::PDF::kSpline3).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLPDFcLcLEInterpolateMethod),-1,-2,1,G__FastAllocString(2048).Format("kSpline5=%lldLL",(long long)TMVA::PDF::kSpline5).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLPDFcLcLEInterpolateMethod),-1,-2,1,G__FastAllocString(2048).Format("kKDE=%lldLL",(long long)TMVA::PDF::kKDE).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseHistogram=",0,"spline0 uses histogram as reference");
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"fgNbin_PdfHist=0LL",0,"number of bins in high-binned reference histogram");
   G__memvar_setup((void*)G__PVOID,103,0,1,-1,G__defined_typename("Bool_t"),-2,4,"fgManualIntegration=0ULL",0,"manual integration (sum over bins) or DGAUSS");
   G__memvar_setup((void*)0,100,0,1,-1,G__defined_typename("Double_t"),-2,4,"fgEpsilon=",0,"minimum PDF return");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TString),-1,-1,4,"fPDFName=",0,"for output");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNsmooth=",0,"Min number of smoothing iterations");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMinNsmooth=",0,"Min number of smoothing iterations");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMaxNsmooth=",0,"Max number of smoothing iterations");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TH1),-1,-1,4,"fNSmoothHist=",0,"number of smooth for each bin");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLPDFcLcLEInterpolateMethod),-1,-1,4,"fInterpolMethod=",0,"interpolation method");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TSpline),-1,-1,4,"fSpline=",0,"! the used spline type");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TH1),-1,-1,4,"fPDFHist=",0,"the high-binned histogram corresponding to the PDF");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TH1),-1,-1,4,"fHist=",0,"copy of input histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TH1),-1,-1,4,"fHistOriginal=",0,"the input histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TGraph),-1,-1,4,"fGraph=",0,"! needed to create PDF from histogram");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TF1),-1,-1,4,"fIGetVal=",0,"integration interface");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fHistAvgEvtPerBin=",0,"avg event per source hist bin");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fHistDefinedNBins=",0,"source hist bin num set by user");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TString),-1,-1,4,"fKDEtypeString=",0,"strings used to read definitions");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TString),-1,-1,4,"fKDEiterString=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TString),-1,-1,4,"fBorderMethodString=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TString),-1,-1,4,"fInterpolateString=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLKDEKernelcLcLEKernelType),-1,-1,4,"fKDEtype=",0,"Kernel type to use for KDE");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLKDEKernelcLcLEKernelIter),-1,-1,4,"fKDEiter=",0,"Number of iterations (adaptive or not)");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLKDEKernelcLcLEKernelBorder),-1,-1,4,"fKDEborder=",0,"The method to take care about \"border\" effects (string)");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fFineFactor=",0,"fine tuning factor for Adaptive KDE");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fReadingVersion=",0,"the TMVA version of the weight file");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fCheckHist=",0,"check of source histogram");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNormalize=",0,"normalize histogram (false for cumulative distribution used in GaussTranform)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TString),-1,-1,4,"fSuffix=",0,"! the suffix for options");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"! message logger");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLPDF),-1,-2,4,"fgThisPDF=",0,"this PDF pointer ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::Node */
static void G__setup_memvarTMVAcLcLNode(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLNode));
   { TMVA::Node *p; p=(TMVA::Node*)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__TMVA2LN_TMVAcLcLNode),-1,-1,2,"fParent=",0,"the previous (parent) node");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLNode),-1,-1,2,"fLeft=",0,"pointers to the two \"daughter\" nodes");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLNode),-1,-1,2,"fRight=",0,"pointers to the two \"daughter\" nodes");
   G__memvar_setup((void*)0,99,0,0,-1,-1,-1,2,"fPos=",0,"position, i.e. it is a left (l) or right (r) daughter ");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fDepth=",0,"depth of the node within the tree (seen from root node)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinaryTree),-1,-1,2,"fParentTree=",0,"pointer to the parent tree to which the Node belongs ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgCount=",0,"counter of all nodes present.. for debug.. to spot memory leaks...");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::BinaryTree */
static void G__setup_memvarTMVAcLcLBinaryTree(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinaryTree));
   { TMVA::BinaryTree *p; p=(TMVA::BinaryTree*)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__TMVA2LN_TMVAcLcLNode),-1,-1,2,"fRoot=",0,"the root node of the tree");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fNNodes=",0,"total number of nodes in the tree (counted)");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fDepth=",0,"maximal depth in tree reached");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMsgLogger),-1,-2,2,"fgLogger=",0,"message logger, static to save resources    ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::BinarySearchTreeNode */
static void G__setup_memvarTMVAcLcLBinarySearchTreeNode(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinarySearchTreeNode));
   { TMVA::BinarySearchTreeNode *p; p=(TMVA::BinarySearchTreeNode*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fEventV=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fTargets=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fWeight=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fClass=",0,(char*)NULL);
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,4,"fSelector=",0,"index of variable used in node selection (decision tree) ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::BinarySearchTree */
static void G__setup_memvarTMVAcLcLBinarySearchTree(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinarySearchTree));
   { TMVA::BinarySearchTree *p; p=(TMVA::BinarySearchTree*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fPeriod=",0,"periode (number of event variables)");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fCurrentDepth=",0,"internal variable, counting the depth of the tree during insertion    ");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fStatisticsIsValid=",0,"flag if last stat calculation is still valid, set to false if new node is insert");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fMeans[2]=",0,"mean for signal and background for each variable");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fRMS[2]=",0,"RMS for signal and background for each variable");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fMin[2]=",0,"RMS for signal and background for each variable");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fMax[2]=",0,"RMS for signal and background for each variable");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fSum[2]=",0,"Sum for signal and background for each variable");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fSumSq[2]=",0,"Squared Sum for signal and background for each variable");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNEventsW[2]=",0,"Number of events per class, taking into account event weights");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSumOfWeights=",0,"Total number of events (weigthed) counted during filling");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fCanNormalize=",0,"the tree can be normalised");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR),G__defined_typename("vector<std::pair<Double_t,const TMVA::Event*> >"),-1,4,"fNormalizeTreeTable=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::Timer */
static void G__setup_memvarTMVAcLcLTimer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTimer));
   { TMVA::Timer *p; p=(TMVA::Timer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNcounts=",0,"reference number of \"counts\" ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TString),-1,-1,4,"fPrefix=",0,"prefix for outputs");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fColourfulOutput=",0,"flag for use of colors");
   G__memvar_setup((void*)0,117,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TString),-1,-2,4,"fgClassName=",0,"used for output");
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"fgNbins=0LL",0,"number of bins in progress bar");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"the output logger");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::RootFinder */
static void G__setup_memvarTMVAcLcLRootFinder(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLRootFinder));
   { TMVA::RootFinder *p; p=(TMVA::RootFinder*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRootMin=",0,"minimum root value");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRootMax=",0,"maximum root value");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMaxIter=",0,"maximum number of iterations");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAbsTol=",0,"absolute tolerance deviation");
   G__memvar_setup((void*)0,49,0,0,-1,G__defined_typename("Double_t (*)(Double_t)"),-1,4,"fGetRootVal=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"! message logger");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::SeparationBase */
static void G__setup_memvarTMVAcLcLSeparationBase(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSeparationBase));
   { TMVA::SeparationBase *p; p=(TMVA::SeparationBase*)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__TMVA2LN_TString),-1,-1,2,"fName=",0,"name of the concrete Separation Index impementation");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fPrecisionCut=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::CrossEntropy */
static void G__setup_memvarTMVAcLcLCrossEntropy(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLCrossEntropy));
   { TMVA::CrossEntropy *p; p=(TMVA::CrossEntropy*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::DecisionTreeNode */
static void G__setup_memvarTMVAcLcLDecisionTreeNode(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTreeNode));
   { TMVA::DecisionTreeNode *p; p=(TMVA::DecisionTreeNode*)0x1000; if (p) { }
   G__memvar_setup((void*)(&TMVA::DecisionTreeNode::fgIsTraining),103,0,0,-1,-1,-2,1,"fgIsTraining=",0,"static variable to flag training phase in which we need fTrainInfo");
   G__memvar_setup((void*)(&TMVA::DecisionTreeNode::fgTmva_Version_Code),104,0,0,-1,G__defined_typename("UInt_t"),-2,1,"fgTmva_Version_Code=",0,"set only when read from weightfile ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMsgLogger),-1,-2,2,"fgLogger=",0,"static because there is a huge number of nodes...");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,2,"fFisherCoeff=",0,"the fisher coeff (offset at the last element)");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fCutValue=",0,"cut value appplied on this node to discriminate bkg against sig");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fCutType=",0,"true: if event variable > cutValue ==> signal , false otherwise");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,2,"fSelector=",0,"index of variable used in node selection (decision tree)");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fResponse=",0,"response value in case of regression");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fRMS=",0,"response RMS of the regression node");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNodeType=",0,"Type of node: -1 == Bkg-leaf, 1 == Signal-leaf, 0 = internal");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fPurity=",0,"the node purity");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fIsTerminalNode=",0,"! flag to set node as terminal (i.e., without deleting its descendants)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDTNodeTrainingInfo),-1,-1,2,"fTrainInfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::RegressionVariance */
static void G__setup_memvarTMVAcLcLRegressionVariance(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLRegressionVariance));
   { TMVA::RegressionVariance *p; p=(TMVA::RegressionVariance*)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__TMVA2LN_TString),-1,-1,2,"fName=",0,"name of the concrete Separation Index impementation");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::DecisionTree */
static void G__setup_memvarTMVAcLcLDecisionTree(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTree));
   { TMVA::DecisionTree *p; p=(TMVA::DecisionTree*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"fgRandomSeed=0LL",0,"set nonzero for debugging and zero for random seeds");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTreecLcLEPruneMethod),-1,-2,1,G__FastAllocString(2048).Format("kExpectedErrorPruning=%lldLL",(long long)TMVA::DecisionTree::kExpectedErrorPruning).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTreecLcLEPruneMethod),-1,-2,1,G__FastAllocString(2048).Format("kCostComplexityPruning=%lldLL",(long long)TMVA::DecisionTree::kCostComplexityPruning).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTreecLcLEPruneMethod),-1,-2,1,G__FastAllocString(2048).Format("kNoPruning=%lldLL",(long long)TMVA::DecisionTree::kNoPruning).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNvars=",0,"number of variables used to separate S and B");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNCuts=",0,"number of grid point in variable cut scans");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseFisherCuts=",0,"use multivariate splits using the Fisher criterium");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMinLinCorrForFisher=",0,"the minimum linear correlation between two variables demanded for use in fisher criterium in node splitting");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseExclusiveVars=",0,"individual variables already used in fisher criterium are not anymore analysed individually for node splitting");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSeparationBase),-1,-1,4,"fSepType=",0,"the separation crition");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLRegressionVariance),-1,-1,4,"fRegType=",0,"the separation crition used in Regression");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMinSize=",0,"min number of events in node");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMinNodeSize=",0,"min fraction of training events in node");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMinSepGain=",0,"min number of separation gain to perform node splitting");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseSearchTree=",0,"cut scan done with binary trees or simple event loop.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPruneStrength=",0,"a parameter to set the \"amount\" of pruning..needs to be adjusted ");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTreecLcLEPruneMethod),-1,-1,4,"fPruneMethod=",0,"method used for prunig ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNNodesBeforePruning=",0,"remember this one (in case of pruning, it allows to monitor the before/after");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNodePurityLimit=",0,"purity limit to decide whether a node is signal");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fRandomisedTree=",0,"choose at each node splitting a random set of variables ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fUseNvars=",0,"the number of variables used in randomised trees;");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUsePoissonNvars=",0,"use \"fUseNvars\" not as fixed number but as mean of a possion distr. in each split");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TRandom3),-1,-1,4,"fMyTrandom=",0,"random number generator for randomised trees");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fVariableImportance=",0,"the relative importance of the different variables ");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fMaxDepth=",0,"max depth");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fSigClass=",0,"class which is treated as signal when building the tree");
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"fgDebugLevel=0LL",0,"debug level determining some printout/control plots etc.");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTreeID=",0,"just an ID number given to the tree.. makes debugging easier as tree knows who he is.");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTypescLcLEAnalysisType),-1,-1,4,"fAnalysisType=",0,"kClassification(=0=false) or kRegression(=1=true)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDataSetInfo),-1,-1,4,"fDataSetInfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MisClassificationError */
static void G__setup_memvarTMVAcLcLMisClassificationError(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMisClassificationError));
   { TMVA::MisClassificationError *p; p=(TMVA::MisClassificationError*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::SdivSqrtSplusB */
static void G__setup_memvarTMVAcLcLSdivSqrtSplusB(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSdivSqrtSplusB));
   { TMVA::SdivSqrtSplusB *p; p=(TMVA::SdivSqrtSplusB*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::Tools */
static void G__setup_memvarTMVAcLcLTools(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTools));
   { TMVA::Tools *p; p=(TMVA::Tools*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLToolscLcLEWelcomeMessage),-1,-2,1,G__FastAllocString(2048).Format("kStandardWelcomeMsg=%lldLL",(long long)TMVA::Tools::kStandardWelcomeMsg).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLToolscLcLEWelcomeMessage),-1,-2,1,G__FastAllocString(2048).Format("kIsometricWelcomeMsg=%lldLL",(long long)TMVA::Tools::kIsometricWelcomeMsg).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLToolscLcLEWelcomeMessage),-1,-2,1,G__FastAllocString(2048).Format("kBlockWelcomeMsg=%lldLL",(long long)TMVA::Tools::kBlockWelcomeMsg).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLToolscLcLEWelcomeMessage),-1,-2,1,G__FastAllocString(2048).Format("kLeanWelcomeMsg=%lldLL",(long long)TMVA::Tools::kLeanWelcomeMsg).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLToolscLcLEWelcomeMessage),-1,-2,1,G__FastAllocString(2048).Format("kLogoWelcomeMsg=%lldLL",(long long)TMVA::Tools::kLogoWelcomeMsg).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLToolscLcLEWelcomeMessage),-1,-2,1,G__FastAllocString(2048).Format("kSmall1WelcomeMsg=%lldLL",(long long)TMVA::Tools::kSmall1WelcomeMsg).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLToolscLcLEWelcomeMessage),-1,-2,1,G__FastAllocString(2048).Format("kSmall2WelcomeMsg=%lldLL",(long long)TMVA::Tools::kSmall2WelcomeMsg).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLToolscLcLEWelcomeMessage),-1,-2,1,G__FastAllocString(2048).Format("kOriginalWelcomeMsgColor=%lldLL",(long long)TMVA::Tools::kOriginalWelcomeMsgColor).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLToolscLcLEWelcomeMessage),-1,-2,1,G__FastAllocString(2048).Format("kOriginalWelcomeMsgBW=%lldLL",(long long)TMVA::Tools::kOriginalWelcomeMsgBW).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLToolscLcLECitation),-1,-2,1,G__FastAllocString(2048).Format("kPlainText=%lldLL",(long long)TMVA::Tools::kPlainText).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLToolscLcLECitation),-1,-2,1,G__FastAllocString(2048).Format("kBibTeX=%lldLL",(long long)TMVA::Tools::kBibTeX).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLToolscLcLECitation),-1,-2,1,G__FastAllocString(2048).Format("kLaTeX=%lldLL",(long long)TMVA::Tools::kLaTeX).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLToolscLcLECitation),-1,-2,1,G__FastAllocString(2048).Format("kHtmlLink=%lldLL",(long long)TMVA::Tools::kHtmlLink).data(),0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fRegexp)-(long)(p)),117,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TString),-1,-1,1,"fRegexp=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fLogger)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMsgLogger),-1,-1,1,"fLogger=",0,(char*)NULL);
   G__memvar_setup((void*)(&TMVA::Tools::fgTools),85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTools),-1,-2,1,"fgTools=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fXMLEngine)-(long)(p)),85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TXMLEngine),-1,-1,1,"fXMLEngine=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::Reader */
static void G__setup_memvarTMVAcLcLReader(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLReader));
   { TMVA::Reader *p; p=(TMVA::Reader*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDataSetManager),-1,-1,4,"fDataSetManager=",0,"DSMTEST");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDataSetInfo),-1,-1,4,"fDataSetInfo=",0,"the data set");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDataInputHandler),-1,-1,4,"fDataInputHandler=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fVerbose=",0,"verbosity");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSilent=",0,"silent mode");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fColor=",0,"color mode");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fCalculateError=",0,"error calculation mode");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMvaEventError=",0,"per-event error returned by MVA");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMvaEventErrorUpper=",0,"per-event error returned by MVA");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_maplETStringcOTMVAcLcLIMethodmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIMethodmUgRsPgRsPgR),G__defined_typename("map<TString,IMethod*>"),-1,4,"fMethodMap=",0,"map of methods");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fTmpEvalVec=",0,"temporary evaluation vector (if user input is v<double>)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"message logger");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::GeneticGenes */
static void G__setup_memvarTMVAcLcLGeneticGenes(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticGenes));
   { TMVA::GeneticGenes *p; p=(TMVA::GeneticGenes*)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__TMVA2LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fFactors=",0,"stores the factors (coefficients) of one individual");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fFitness=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::GeneticRange */
static void G__setup_memvarTMVAcLcLGeneticRange(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticRange));
   { TMVA::GeneticRange *p; p=(TMVA::GeneticRange*)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,4,"fFrom=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTo=",0,"the constraints of the coefficient");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNbins=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLInterval),-1,-1,4,"fInterval=",0,"holds the complete information of the interval");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTotalLength=",0,"the distance between the lower and upper constraints");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TRandom3),-1,-1,4,"fRandomGenerator=",0,"the randomGenerator for calculating the new values");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::GeneticPopulation */
static void G__setup_memvarTMVAcLcLGeneticPopulation(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticPopulation));
   { TMVA::GeneticPopulation *p; p=(TMVA::GeneticPopulation*)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__TMVA2LN_vectorlETMVAcLcLGeneticGenescOallocatorlETMVAcLcLGeneticGenesgRsPgR),G__defined_typename("vector<TMVA::GeneticGenes>"),-1,4,"fGenePool=",0,"the \"genePool\" where the individuals of the current generation are stored");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLGeneticRangemUcOallocatorlETMVAcLcLGeneticRangemUgRsPgR),G__defined_typename("vector<TMVA::GeneticRange*>"),-1,4,"fRanges=",0,"contains the ranges inbetween the values of the coefficients have to be");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TRandom3),-1,-1,4,"fRandomGenerator=",0,"random Generator for this population");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"message logger");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPopulationSizeLimit=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::GeneticAlgorithm */
static void G__setup_memvarTMVAcLcLGeneticAlgorithm(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticAlgorithm));
   { TMVA::GeneticAlgorithm *p; p=(TMVA::GeneticAlgorithm*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fConvCounter)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fConvCounter=",0,"converging? ... keeps track of the number of improvements");
   G__memvar_setup((void*)0,117,1,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLIFitterTarget),-1,-1,2,"fFitterTarget=",0,"the fitter target");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fConvValue=",0,"keeps track of the quantity of improvement");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_dequelEintcOallocatorlEintgRsPgR),G__defined_typename("deque<Int_t>"),-1,2,"fSuccessList=",0,"to adjust the stepSize      ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fLastResult=",0,"remembers the last obtained result (for internal use)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fSpread=",0,"regulates the spread of the value change at mutation (sigma)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMirror=",0,"new values for mutation are mirror-mapped if outside of constraints");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fFirstTime=",0,"if true its the first time, so no evolution yet");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fMakeCopies=",0,"if true, the population will make copies of the first individuals");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fPopulationSize=",0,"the size of the population");
   G__memvar_setup((void*)0,117,1,1,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR),G__defined_typename("vector<TMVA::Interval*>"),-1,2,"fRanges=",0,"parameter ranges");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticPopulation),-1,-1,2,"fPopulation=",0,"contains and controls the \"individual\"");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,2,"fBestFitness=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMsgLogger),-1,-1,2,"fLogger=",0,"message logger");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::GiniIndex */
static void G__setup_memvarTMVAcLcLGiniIndex(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGiniIndex));
   { TMVA::GiniIndex *p; p=(TMVA::GiniIndex*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::GiniIndexWithLaplace */
static void G__setup_memvarTMVAcLcLGiniIndexWithLaplace(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGiniIndexWithLaplace));
   { TMVA::GiniIndexWithLaplace *p; p=(TMVA::GiniIndexWithLaplace*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::SimulatedAnnealing */
static void G__setup_memvarTMVAcLcLSimulatedAnnealing(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSimulatedAnnealing));
   { TMVA::SimulatedAnnealing *p; p=(TMVA::SimulatedAnnealing*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSimulatedAnnealingcLcLEKernelTemperature),-1,-2,4,"kSqrt=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSimulatedAnnealingcLcLEKernelTemperature),-1,-2,4,"kIncreasingAdaptive=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSimulatedAnnealingcLcLEKernelTemperature),-1,-2,4,"kDecreasingAdaptive=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSimulatedAnnealingcLcLEKernelTemperature),-1,-2,4,"kLog=3LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSimulatedAnnealingcLcLEKernelTemperature),-1,-2,4,"kHomo=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSimulatedAnnealingcLcLEKernelTemperature),-1,-2,4,"kSin=5LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSimulatedAnnealingcLcLEKernelTemperature),-1,-2,4,"kGeo=6LL",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSimulatedAnnealingcLcLEKernelTemperature),-1,-1,4,"fKernelTemperature=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,1,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLIFitterTarget),-1,-1,4,"fFitterTarget=",0,"the fitter target");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TRandom),-1,-1,4,"fRandom=",0,"random generator");
   G__memvar_setup((void*)0,117,1,1,G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR),G__defined_typename("vector<TMVA::Interval*>"),-1,4,"fRanges=",0,"parameter ranges");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMaxCalls=",0,"maximum number of minimisation calls");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fInitialTemperature=",0,"initial temperature");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMinTemperature=",0,"mimimum temperature");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEps=",0,"epsilon");
   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__TMVA2LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"message logger");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fProgress=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::QuickMVAProbEstimator */
static void G__setup_memvarTMVAcLcLQuickMVAProbEstimator(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLQuickMVAProbEstimator));
   { TMVA::QuickMVAProbEstimator *p; p=(TMVA::QuickMVAProbEstimator*)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__TMVA2LN_vectorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfocOallocatorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfogRsPgR),G__defined_typename("vector<EventInfo>"),-1,4,"fEvtVector=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIsSorted=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNMin=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNMax=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA2LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__TMVA2() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTMVA(void) {
   /* TMVA */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVA));
   G__memfunc_setup("Endl",387,G__G__TMVA2_149_0_1, 117, G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2_149_0_2, 117, G__get_linked_tagnum(&G__G__TMVA2LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os u 'TMVA::PDF' - 11 - tree", (char*)NULL, (void*) G__func2void( (ostream& (*)(ostream&, const TMVA::PDF&))(&TMVA::operator<<) ), 0);
   G__memfunc_setup("operator>>",1000,G__G__TMVA2_149_0_3, 117, G__get_linked_tagnum(&G__G__TMVA2LN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr u 'TMVA::PDF' - 1 - tree", (char*)NULL, (void*) G__func2void( (istream& (*)(istream&, TMVA::PDF&))(&TMVA::operator>>) ), 0);
   G__memfunc_setup("operator<<",996,G__G__TMVA2_149_0_4, 117, G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2_149_0_5, 117, G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2_149_0_6, 117, G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2_149_0_7, 117, G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2_149_0_8, 117, G__get_linked_tagnum(&G__G__TMVA2LN_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__memfunc_setup("gTools",632,G__G__TMVA2_149_0_9, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTools), -1, 1, 0, 1, 1, 0, "", "global accessor", (void*) G__func2void( (TMVA::Tools& (*)())(&TMVA::gTools) ), 0);
   G__memfunc_setup("operator<",936,G__G__TMVA2_149_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'TMVA::GeneticGenes' - 11 - - u 'TMVA::GeneticGenes' - 11 - -", (char*)NULL, (void*) G__func2void( (Bool_t (*)(const TMVA::GeneticGenes&, const TMVA::GeneticGenes&))(&TMVA::operator<) ), 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLTSpline2(void) {
   /* TMVA::TSpline2 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline2));
   G__memfunc_setup("TSpline2",753,G__G__TMVA2_150_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline2), -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - title U 'TGraph' - 0 - theGraph", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BuildCoeff",979,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetKnot",700,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - i d - 'Double_t' 1 - x "
"d - 'Double_t' 1 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Quadrax",726,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 7, 1, 4, 8, 
"f - 'Float_t' 0 - dm f - 'Float_t' 0 - dm1 "
"f - 'Float_t' 0 - dm2 f - 'Float_t' 0 - dm3 "
"f - 'Float_t' 0 - cos1 f - 'Float_t' 0 - cos2 "
"f - 'Float_t' 0 - cos3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA2_150_0_6, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TSpline2::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_150_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TSpline2::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_150_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TSpline2::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_150_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TSpline2::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2_150_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__TMVA2_150_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TSpline2::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_150_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TSpline2::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_150_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TSpline2::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_150_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TSpline2::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TSpline2", 753, G__G__TMVA2_150_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline2), -1, 0, 1, 1, 1, 0, "u 'TMVA::TSpline2' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSpline2", 879, G__G__TMVA2_150_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLTSpline1(void) {
   /* TMVA::TSpline1 */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline1));
   G__memfunc_setup("TSpline1",752,G__G__TMVA2_151_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline1), -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - title U 'TGraph' - 0 - theGraph", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BuildCoeff",979,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetKnot",700,(G__InterfaceMethod) NULL,121, -1, -1, 0, 3, 1, 1, 8, 
"i - 'Int_t' 0 - i d - 'Double_t' 1 - x "
"d - 'Double_t' 1 - y", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetGraph",786,G__G__TMVA2_151_0_5, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TGraph), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA2_151_0_6, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TSpline1::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_151_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TSpline1::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_151_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TSpline1::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_151_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TSpline1::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2_151_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__TMVA2_151_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TSpline1::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_151_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TSpline1::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_151_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TSpline1::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_151_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TSpline1::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TSpline1", 752, G__G__TMVA2_151_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTSpline1), -1, 0, 1, 1, 1, 0, "u 'TMVA::TSpline1' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSpline1", 878, G__G__TMVA2_151_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLPDF(void) {
   /* TMVA::PDF */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLPDF));
   G__memfunc_setup("PDF",218,G__G__TMVA2_230_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLPDF), -1, 0, 2, 5, 1, 0, 
"u 'TString' - 11 - name g - 'Bool_t' 0 'kTRUE' norm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PDF",218,G__G__TMVA2_230_0_2, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLPDF), -1, 0, 7, 5, 1, 0, 
"u 'TString' - 11 - name U 'TH1' - 10 - theHist "
"i 'TMVA::PDF::EInterpolateMethod' - 0 'kSpline2' method i - 'Int_t' 0 '0' minnsmooth "
"i - 'Int_t' 0 '0' maxnsmooth g - 'Bool_t' 0 'kFALSE' checkHist "
"g - 'Bool_t' 0 'kTRUE' norm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PDF",218,G__G__TMVA2_230_0_3, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLPDF), -1, 0, 7, 5, 1, 0, 
"u 'TString' - 11 - name U 'TH1' - 10 - theHist "
"i 'TMVA::KDEKernel::EKernelType' - 0 - ktype i 'TMVA::KDEKernel::EKernelIter' - 0 - kiter "
"i 'TMVA::KDEKernel::EKernelBorder' - 0 - kborder f - 'Float_t' 0 - FineFactor "
"g - 'Bool_t' 0 'kTRUE' norm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PDF",218,G__G__TMVA2_230_0_4, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLPDF), -1, 0, 5, 5, 1, 0, 
"u 'TString' - 11 - name u 'TString' - 11 - options "
"u 'TString' - 11 '\"\"' suffix U 'TMVA::PDF' - 0 '0' defaultPDF "
"g - 'Bool_t' 0 'kTRUE' norm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildPDF",714,G__G__TMVA2_230_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TH1' - 10 - theHist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVal",579,G__G__TMVA2_230_0_6, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValInverse",1311,G__G__TMVA2_230_0_7, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 - y g - 'Bool_t' 0 'kFALSE' isMonotonouslyIncreasingFunction", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddXMLTo",701,G__G__TMVA2_230_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadXML",621,G__G__TMVA2_230_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - pdfnode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPDFHist",914,G__G__TMVA2_230_0_10, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TH1), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGraph",786,G__G__TMVA2_230_0_11, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TGraph), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOriginalHist",1517,G__G__TMVA2_230_0_12, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TH1), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSmoothedHist",1531,G__G__TMVA2_230_0_13, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TH1), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNSmoothHist",1408,G__G__TMVA2_230_0_14, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TH1), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIntegral",1110,G__G__TMVA2_230_0_15, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSpline",907,G__G__TMVA2_230_0_16, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TSpline), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNBins",762,G__G__TMVA2_230_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXmin",700,G__G__TMVA2_230_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXmax",702,G__G__TMVA2_230_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ValidatePDF",1028,G__G__TMVA2_230_0_20, 121, -1, -1, 0, 1, 1, 1, 8, "U 'TH1' - 0 '0' original", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHistNBins",1170,G__G__TMVA2_230_0_21, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 '0' evtNum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInterpolMethod",1742,G__G__TMVA2_230_0_22, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLPDFcLcLEInterpolateMethod), -1, 0, 0, 1, 1, 0, "", (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("SetReadingVersion",1740,G__G__TMVA2_230_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - rv", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReadingVersion",1728,G__G__TMVA2_230_0_25, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessOptions",1483,G__G__TMVA2_230_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclareOptions",1436,G__G__TMVA2_230_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckHist",886,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillSplineToHist",1613,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildKDEPDF",926,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SmoothHistogram",1576,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillHistToGraph",1492,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIntegral",1110,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPdfHistBinWidth",1771,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseHistogram",1243,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindBinInverse",1398,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 7, 1, 4, 8, 
"U 'TH1' - 10 - histogram i - 'Int_t' 1 - lowerBin "
"i - 'Int_t' 1 - higherBin d - 'Double_t' 1 - lowerBinValue "
"d - 'Double_t' 1 - higherBinValue d - 'Double_t' 0 - y "
"g - 'Bool_t' 0 'kFALSE' isMonotonouslyIncreasingFunction", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildSplinePDF",1333,(G__InterfaceMethod) NULL, 121, -1, -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__TMVA2LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ThisPDF",626,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLPDF), -1, 0, 0, 3, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IGetVal",652,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 3, 4, 0, 
"D - 'Double_t' 0 - - D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA2_230_0_41, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDF::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_230_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDF::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_230_0_43, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDF::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_230_0_44, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDF::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2_230_0_48, 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__TMVA2_230_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDF::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_230_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDF::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_230_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDF::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_230_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDF::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~PDF", 344, G__G__TMVA2_230_0_53, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLNode(void) {
   /* TMVA::Node */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLNode));
   G__memfunc_setup("CreateNode",986,G__G__TMVA2_255_0_4, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GoesRight",908,G__G__TMVA2_255_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TMVA::Event' - 11 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GoesLeft",793,G__G__TMVA2_255_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TMVA::Event' - 11 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetLeft",683,G__G__TMVA2_255_0_7, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRight",798,G__G__TMVA2_255_0_8, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParent",906,G__G__TMVA2_255_0_9, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLeft",695,G__G__TMVA2_255_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::Node' - 0 - l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRight",810,G__G__TMVA2_255_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::Node' - 0 - r", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParent",918,G__G__TMVA2_255_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::Node' - 0 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CountMeAndAllDaughters",2190,G__G__TMVA2_255_0_13, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,G__G__TMVA2_255_0_14, 121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PrintRec",807,G__G__TMVA2_255_0_15, 121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddXMLTo",701,G__G__TMVA2_255_0_16, 89, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadXML",621,G__G__TMVA2_255_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - node h - 'UInt_t' 0 'TMVA_VERSION_CODE' tmva_Version_Code", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAttributesToNode",1913,G__G__TMVA2_255_0_18, 121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - node", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AddContentToNode",1581,G__G__TMVA2_255_0_19, 121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_stringstream<char,char_traits<char>,allocator<char> >' 'stringstream' 1 - s", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetDepth",801,G__G__TMVA2_255_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDepth",789,G__G__TMVA2_255_0_21, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPos",606,G__G__TMVA2_255_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "c - - 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPos",594,G__G__TMVA2_255_0_23, 99, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParentTree",1306,G__G__TMVA2_255_0_24, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinaryTree), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParentTree",1318,G__G__TMVA2_255_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::BinaryTree' - 0 - t", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCount",809,G__G__TMVA2_255_0_26, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadDataRecord",1365,G__G__TMVA2_255_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - - h - 'UInt_t' 0 'TMVA_VERSION_CODE' tmva_Version_Code", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadAttributes",1443,G__G__TMVA2_255_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - node h - 'UInt_t' 0 'TMVA_VERSION_CODE' tmva_Version_Code", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadContent",1111,G__G__TMVA2_255_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_stringstream<char,char_traits<char>,allocator<char> >' 'stringstream' 1 - s", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__TMVA2_255_0_30, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::Node::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_255_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Node::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_255_0_32, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::Node::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_255_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::Node::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA2_255_0_34, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA2_255_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__TMVA2_255_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA2_255_0_37, 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__TMVA2_255_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Node::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_255_0_39, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Node::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_255_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Node::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_255_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Node::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~Node", 516, G__G__TMVA2_255_0_42, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA2_255_0_43, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLNode), -1, 1, 1, 1, 1, 0, "u 'TMVA::Node' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLBinaryTree(void) {
   /* TMVA::BinaryTree */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinaryTree));
   G__memfunc_setup("CreateNode",986,G__G__TMVA2_257_0_2, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLNode), -1, 0, 1, 1, 1, 8, "h - 'UInt_t' 0 '0' size", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CreateTree",996,G__G__TMVA2_257_0_3, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinaryTree), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ClassName",887,G__G__TMVA2_257_0_4, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetRoot",720,G__G__TMVA2_257_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::Node' - 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRoot",708,G__G__TMVA2_257_0_6, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNNodes",871,G__G__TMVA2_257_0_7, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CountNodes",1026,G__G__TMVA2_257_0_8, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 0, "U 'TMVA::Node' - 0 'NULL' n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTotalTreeDepth",1705,G__G__TMVA2_257_0_9, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTotalTreeDepth",1717,G__G__TMVA2_257_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - depth", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTotalTreeDepth",1717,G__G__TMVA2_257_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::Node' - 0 'NULL' n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLeftDaughter",1503,G__G__TMVA2_257_0_12, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLNode), -1, 0, 1, 1, 1, 0, "U 'TMVA::Node' - 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRightDaughter",1618,G__G__TMVA2_257_0_13, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLNode), -1, 0, 1, 1, 1, 0, "U 'TMVA::Node' - 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,G__G__TMVA2_257_0_14, 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("Read",380,G__G__TMVA2_257_0_15, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr h - 'UInt_t' 0 'TMVA_VERSION_CODE' tmva_Version_Code", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddXMLTo",701,G__G__TMVA2_257_0_16, 89, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadXML",621,G__G__TMVA2_257_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - node h - 'UInt_t' 0 'TMVA_VERSION_CODE' tmva_Version_Code", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeleteNode",985,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TMVA::Node' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA2_257_0_20, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::BinaryTree::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_257_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::BinaryTree::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_257_0_22, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::BinaryTree::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_257_0_23, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::BinaryTree::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA2_257_0_24, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA2_257_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__TMVA2_257_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA2_257_0_27, 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__TMVA2_257_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::BinaryTree::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_257_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::BinaryTree::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_257_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::BinaryTree::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_257_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::BinaryTree::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~BinaryTree", 1139, G__G__TMVA2_257_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA2_257_0_33, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinaryTree), -1, 1, 1, 1, 1, 0, "u 'TMVA::BinaryTree' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLBinarySearchTreeNode(void) {
   /* TMVA::BinarySearchTreeNode */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinarySearchTreeNode));
   G__memfunc_setup("BinarySearchTreeNode",2001,G__G__TMVA2_258_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinarySearchTreeNode), -1, 0, 2, 1, 1, 0, 
"U 'TMVA::Event' - 10 'NULL' e h - 'UInt_t' 0 '0' signalClass", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BinarySearchTreeNode",2001,G__G__TMVA2_258_0_2, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinarySearchTreeNode), -1, 0, 2, 1, 1, 0, 
"U 'TMVA::BinarySearchTreeNode' - 0 - parent c - - 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BinarySearchTreeNode",2001,G__G__TMVA2_258_0_3, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinarySearchTreeNode), -1, 0, 2, 1, 1, 0, 
"u 'TMVA::BinarySearchTreeNode' - 11 - n U 'TMVA::BinarySearchTreeNode' - 0 'NULL' parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateNode",986,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GoesRight",908,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TMVA::Event' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GoesLeft",793,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TMVA::Event' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EqualsMe",797,G__G__TMVA2_258_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TMVA::Event' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSelector",1133,G__G__TMVA2_258_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelector",1121,G__G__TMVA2_258_0_9, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEventV",888,G__G__TMVA2_258_0_10, 117, G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWeight",904,G__G__TMVA2_258_0_11, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClass",790,G__G__TMVA2_258_0_12, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTargets",1018,G__G__TMVA2_258_0_13, 117, G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,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("PrintRec",807,(G__InterfaceMethod) NULL,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("AddAttributesToNode",1913,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - node", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddContentToNode",1581,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_stringstream<char,char_traits<char>,allocator<char> >' 'stringstream' 1 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadAttributes",1443,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"Y - - 0 - node h - 'UInt_t' 0 'TMVA_VERSION_CODE' tmva_Version_Code", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadDataRecord",1365,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - is h - 'UInt_t' 0 'TMVA_VERSION_CODE' tmva_Version_Code", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadContent",1111,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'basic_stringstream<char,char_traits<char>,allocator<char> >' 'stringstream' 1 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA2_258_0_21, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::BinarySearchTreeNode::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_258_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::BinarySearchTreeNode::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_258_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::BinarySearchTreeNode::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_258_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::BinarySearchTreeNode::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2_258_0_28, 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__TMVA2_258_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::BinarySearchTreeNode::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_258_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::BinarySearchTreeNode::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_258_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::BinarySearchTreeNode::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_258_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::BinarySearchTreeNode::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~BinarySearchTreeNode", 2127, G__G__TMVA2_258_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA2_258_0_34, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinarySearchTreeNode), -1, 1, 1, 1, 1, 0, "u 'TMVA::BinarySearchTreeNode' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLBinarySearchTree(void) {
   /* TMVA::BinarySearchTree */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinarySearchTree));
   G__memfunc_setup("BinarySearchTree",1611,G__G__TMVA2_266_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinarySearchTree), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BinarySearchTree",1611,G__G__TMVA2_266_0_2, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinarySearchTree), -1, 0, 1, 1, 1, 0, "u 'TMVA::BinarySearchTree' - 11 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateNode",986,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLNode), -1, 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateTree",996,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinaryTree), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateFromXML",1241,G__G__TMVA2_266_0_5, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinarySearchTree), -1, 0, 2, 3, 1, 0, 
"Y - - 0 - node h - 'UInt_t' 0 'TMVA_VERSION_CODE' tmva_Version_Code", (char*)NULL, (void*) G__func2void( (TMVA::BinarySearchTree* (*)(void*, UInt_t))(&TMVA::BinarySearchTree::CreateFromXML) ), 0);
   G__memfunc_setup("ClassName",887,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Search",598,G__G__TMVA2_266_0_7, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinarySearchTreeNode), -1, 0, 1, 1, 1, 8, "U 'TMVA::Event' - 0 - event", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Insert",629,G__G__TMVA2_266_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::Event' - 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSumOfWeights",1509,G__G__TMVA2_266_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSumOfWeights",1509,G__G__TMVA2_266_0_10, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - theType", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPeriode",1012,G__G__TMVA2_266_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPeriode",1000,G__G__TMVA2_266_0_12, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SearchVolume",1230,G__G__TMVA2_266_0_13, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"U 'TMVA::Volume' - 0 - - U 'vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >' 'vector<const TMVA::BinarySearchTreeNode*>' 0 '0' events", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fill",391,G__G__TMVA2_266_0_14, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' 'vector<TMVA::Event*>' 11 - events u 'vector<int,allocator<int> >' 'vector<Int_t>' 11 - theVars "
"i - 'Int_t' 0 '-1' theType", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fill",391,G__G__TMVA2_266_0_15, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' 'vector<TMVA::Event*>' 11 - events i - 'Int_t' 0 '-1' theType", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NormalizeTree",1345,G__G__TMVA2_266_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcStatistics",1438,G__G__TMVA2_266_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::Node' - 0 '0' n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,G__G__TMVA2_266_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::Node' - 0 '0' n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mean",385,G__G__TMVA2_266_0_19, 102, -1, G__defined_typename("Float_t"), 0, 2, 1, 1, 0, 
"i 'TMVA::Types::ESBType' - 0 - sb h - 'UInt_t' 0 - var", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RMS",242,G__G__TMVA2_266_0_20, 102, -1, G__defined_typename("Float_t"), 0, 2, 1, 1, 0, 
"i 'TMVA::Types::ESBType' - 0 - sb h - 'UInt_t' 0 - var", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Min",292,G__G__TMVA2_266_0_21, 102, -1, G__defined_typename("Float_t"), 0, 2, 1, 1, 0, 
"i 'TMVA::Types::ESBType' - 0 - sb h - 'UInt_t' 0 - var", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Max",294,G__G__TMVA2_266_0_22, 102, -1, G__defined_typename("Float_t"), 0, 2, 1, 1, 0, 
"i 'TMVA::Types::ESBType' - 0 - sb h - 'UInt_t' 0 - var", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SearchVolumeWithMaxLimit",2447,G__G__TMVA2_266_0_23, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"U 'TMVA::Volume' - 0 - - U 'vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >' 'vector<const TMVA::BinarySearchTreeNode*>' 0 '0' events "
"i - 'Int_t' 0 '-1' -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RMS",242,G__G__TMVA2_266_0_24, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - var", "attention! class 0 is taken as signal!", (void*) NULL, 0);
   G__memfunc_setup("SetNormalize",1245,G__G__TMVA2_266_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - norm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Insert",629,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"U 'TMVA::Event' - 10 - - U 'TMVA::Node' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Search",598,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinarySearchTreeNode), -1, 0, 2, 1, 4, 8, 
"U 'TMVA::Event' - 0 - - U 'TMVA::Node' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InVolume",815,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 8, 
"u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - - U 'TMVA::Volume' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DestroyNode",1136,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TMVA::BinarySearchTreeNode' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NormalizeTree",1345,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"u 'vector<pair<double,const TMVA::Event*>,allocator<pair<double,const TMVA::Event*> > >::iterator' - 0 - - u 'vector<pair<double,const TMVA::Event*>,allocator<pair<double,const TMVA::Event*> > >::iterator' - 0 - - "
"h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SearchVolume",1230,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 4, 1, 4, 0, 
"U 'TMVA::Node' - 0 - - U 'TMVA::Volume' - 0 - - "
"i - 'Int_t' 0 - - U 'vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >' 'vector<const TMVA::BinarySearchTreeNode*>' 0 - events", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA2_266_0_32, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::BinarySearchTree::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_266_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::BinarySearchTree::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_266_0_34, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::BinarySearchTree::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_266_0_35, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::BinarySearchTree::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2_266_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__TMVA2_266_0_40, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::BinarySearchTree::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_266_0_41, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::BinarySearchTree::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_266_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::BinarySearchTree::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_266_0_43, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::BinarySearchTree::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~BinarySearchTree", 1737, G__G__TMVA2_266_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__TMVA2_266_0_45, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinarySearchTree), -1, 1, 1, 1, 1, 0, "u 'TMVA::BinarySearchTree' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLTimer(void) {
   /* TMVA::Timer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTimer));
   G__memfunc_setup("Timer",513,G__G__TMVA2_286_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTimer), -1, 0, 2, 1, 1, 0, 
"C - - 10 '\"\"' prefix g - 'Bool_t' 0 'kTRUE' colourfulOutput", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Timer",513,G__G__TMVA2_286_0_2, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTimer), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - ncounts C - - 10 '\"\"' prefix "
"g - 'Bool_t' 0 'kTRUE' colourfulOutput", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,G__G__TMVA2_286_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ncounts", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reset",515,G__G__TMVA2_286_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetElapsedTime",1389,G__G__TMVA2_286_0_5, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TString), -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' Scientific", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ElapsedSeconds",1421,G__G__TMVA2_286_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLeftTime",1082,G__G__TMVA2_286_0_7, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TString), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - icounts", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawProgressBar",1528,G__G__TMVA2_286_0_8, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - - u 'TString' - 11 '\"\"' comment", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawProgressBar",1528,G__G__TMVA2_286_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawProgressBar",1528,G__G__TMVA2_286_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SecToText",899,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TString), -1, 0, 2, 1, 4, 8, 
"d - 'Double_t' 0 - - g - 'Bool_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA2_286_0_13, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::Timer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_286_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Timer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_286_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::Timer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_286_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::Timer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2_286_0_20, 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__TMVA2_286_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Timer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_286_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Timer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_286_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Timer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_286_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Timer::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("Timer", 513, G__G__TMVA2_286_0_25, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTimer), -1, 0, 1, 1, 1, 0, "u 'TMVA::Timer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~Timer", 639, G__G__TMVA2_286_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__TMVA2_286_0_27, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTimer), -1, 1, 1, 1, 1, 0, "u 'TMVA::Timer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLRootFinder(void) {
   /* TMVA::RootFinder */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLRootFinder));
   G__memfunc_setup("RootFinder",1020,G__G__TMVA2_287_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLRootFinder), -1, 0, 5, 1, 1, 0, 
"1 - 'Double_t (*)(Double_t)' 0 - rootVal d - 'Double_t' 0 - rootMin "
"d - 'Double_t' 0 - rootMax i - 'Int_t' 0 '100' maxIterations "
"d - 'Double_t' 0 '0.0' absTolerance", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Root",420,G__G__TMVA2_287_0_2, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - refValue", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA2_287_0_4, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::RootFinder::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_287_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::RootFinder::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_287_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::RootFinder::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_287_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::RootFinder::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2_287_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__TMVA2_287_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::RootFinder::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_287_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::RootFinder::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_287_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::RootFinder::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_287_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::RootFinder::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("RootFinder", 1020, G__G__TMVA2_287_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLRootFinder), -1, 0, 1, 1, 1, 0, "u 'TMVA::RootFinder' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~RootFinder", 1146, G__G__TMVA2_287_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__TMVA2_287_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLRootFinder), -1, 1, 1, 1, 1, 0, "u 'TMVA::RootFinder' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLSeparationBase(void) {
   /* TMVA::SeparationBase */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSeparationBase));
   G__memfunc_setup("GetSeparationGain",1717,G__G__TMVA2_288_0_3, 100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 0, 
"d - 'Double_t' 11 - nSelS d - 'Double_t' 11 - nSelB "
"d - 'Double_t' 11 - nTotS d - 'Double_t' 11 - nTotB", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSeparationIndex",1838,G__G__TMVA2_288_0_4, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 11 - s d - 'Double_t' 11 - b", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetName",673,G__G__TMVA2_288_0_5, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TString), -1, 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA2_288_0_6, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::SeparationBase::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_288_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SeparationBase::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_288_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::SeparationBase::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_288_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::SeparationBase::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA2_288_0_10, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA2_288_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__TMVA2_288_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__TMVA2_288_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__TMVA2_288_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SeparationBase::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_288_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::SeparationBase::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_288_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SeparationBase::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_288_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::SeparationBase::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~SeparationBase", 1551, G__G__TMVA2_288_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__TMVA2_288_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSeparationBase), -1, 1, 1, 1, 1, 0, "u 'TMVA::SeparationBase' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLCrossEntropy(void) {
   /* TMVA::CrossEntropy */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLCrossEntropy));
   G__memfunc_setup("CrossEntropy",1275,G__G__TMVA2_289_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLCrossEntropy), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CrossEntropy",1275,G__G__TMVA2_289_0_2, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLCrossEntropy), -1, 0, 1, 1, 1, 0, "u 'TMVA::CrossEntropy' - 11 - g", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSeparationIndex",1838,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 11 - s d - 'Double_t' 11 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA2_289_0_4, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::CrossEntropy::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_289_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::CrossEntropy::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_289_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::CrossEntropy::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_289_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::CrossEntropy::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2_289_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__TMVA2_289_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::CrossEntropy::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_289_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::CrossEntropy::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_289_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::CrossEntropy::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_289_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::CrossEntropy::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~CrossEntropy", 1401, G__G__TMVA2_289_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__TMVA2_289_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLCrossEntropy), -1, 1, 1, 1, 1, 0, "u 'TMVA::CrossEntropy' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLDecisionTreeNode(void) {
   /* TMVA::DecisionTreeNode */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTreeNode));
   G__memfunc_setup("DecisionTreeNode",1604,G__G__TMVA2_300_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTreeNode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DecisionTreeNode",1604,G__G__TMVA2_300_0_2, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTreeNode), -1, 0, 2, 1, 1, 0, 
"U 'TMVA::Node' - 0 - p c - - 0 - pos", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DecisionTreeNode",1604,G__G__TMVA2_300_0_3, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTreeNode), -1, 0, 2, 1, 1, 0, 
"u 'TMVA::DecisionTreeNode' - 11 - n U 'TMVA::DecisionTreeNode' - 0 'NULL' parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateNode",986,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNFisherCoeff",1470,G__G__TMVA2_300_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nvars", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNFisherCoeff",1458,G__G__TMVA2_300_0_6, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFisherCoeff",1392,G__G__TMVA2_300_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - ivar d - 'Double_t' 0 - coeff", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFisherCoeff",1380,G__G__TMVA2_300_0_8, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - ivar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GoesRight",908,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TMVA::Event' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GoesLeft",793,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TMVA::Event' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetSelector",1133,G__G__TMVA2_300_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "s - 'Short_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSelector",1121,G__G__TMVA2_300_0_12, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCutValue",1109,G__G__TMVA2_300_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCutValue",1097,G__G__TMVA2_300_0_14, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCutType",1018,G__G__TMVA2_300_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCutType",1006,G__G__TMVA2_300_0_16, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNodeType",1108,G__G__TMVA2_300_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNodeType",1096,G__G__TMVA2_300_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPurity",941,G__G__TMVA2_300_0_19, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPurity",953,G__G__TMVA2_300_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetResponse",1147,G__G__TMVA2_300_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetResponse",1135,G__G__TMVA2_300_0_22, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRMS",542,G__G__TMVA2_300_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRMS",530,G__G__TMVA2_300_0_24, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNSigEvents",1298,G__G__TMVA2_300_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNBkgEvents",1283,G__G__TMVA2_300_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNEvents",1007,G__G__TMVA2_300_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - nev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNSigEvents_unweighted",2469,G__G__TMVA2_300_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNBkgEvents_unweighted",2454,G__G__TMVA2_300_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNEvents_unweighted",2178,G__G__TMVA2_300_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - nev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNSigEvents_unboosted",2372,G__G__TMVA2_300_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNBkgEvents_unboosted",2357,G__G__TMVA2_300_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNEvents_unboosted",2081,G__G__TMVA2_300_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - nev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IncrementNSigEvents",1931,G__G__TMVA2_300_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IncrementNBkgEvents",1916,G__G__TMVA2_300_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IncrementNEvents",1640,G__G__TMVA2_300_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - nev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IncrementNSigEvents_unweighted",3102,G__G__TMVA2_300_0_37, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IncrementNBkgEvents_unweighted",3087,G__G__TMVA2_300_0_38, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IncrementNEvents_unweighted",2811,G__G__TMVA2_300_0_39, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNSigEvents",1286,G__G__TMVA2_300_0_40, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNBkgEvents",1271,G__G__TMVA2_300_0_41, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNEvents",995,G__G__TMVA2_300_0_42, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNSigEvents_unweighted",2457,G__G__TMVA2_300_0_43, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNBkgEvents_unweighted",2442,G__G__TMVA2_300_0_44, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNEvents_unweighted",2166,G__G__TMVA2_300_0_45, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNSigEvents_unboosted",2360,G__G__TMVA2_300_0_46, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNBkgEvents_unboosted",2345,G__G__TMVA2_300_0_47, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNEvents_unboosted",2069,G__G__TMVA2_300_0_48, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSeparationIndex",1850,G__G__TMVA2_300_0_49, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - sep", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSeparationIndex",1838,G__G__TMVA2_300_0_50, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSeparationGain",1729,G__G__TMVA2_300_0_51, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - sep", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSeparationGain",1717,G__G__TMVA2_300_0_52, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,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("PrintRec",807,(G__InterfaceMethod) NULL,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("AddAttributesToNode",1913,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - node", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddContentToNode",1581,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_stringstream<char,char_traits<char>,allocator<char> >' 'stringstream' 1 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClearNodeAndAllDaughters",2368,G__G__TMVA2_300_0_57, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLeft",683,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTreeNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRight",798,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTreeNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParent",906,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTreeNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLeft",695,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::Node' - 0 - l", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetRight",810,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::Node' - 0 - r", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParent",918,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::Node' - 0 - p", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetNodeR",772,G__G__TMVA2_300_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNodeR",760,G__G__TMVA2_300_0_65, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSubTreeR",1080,G__G__TMVA2_300_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - r", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSubTreeR",1068,G__G__TMVA2_300_0_67, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAlpha",786,G__G__TMVA2_300_0_68, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - alpha", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAlpha",774,G__G__TMVA2_300_0_69, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAlphaMinSubtree",1808,G__G__TMVA2_300_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - g", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAlphaMinSubtree",1796,G__G__TMVA2_300_0_71, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNTerminal",1206,G__G__TMVA2_300_0_72, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNTerminal",1194,G__G__TMVA2_300_0_73, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNBValidation",1479,G__G__TMVA2_300_0_74, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNSValidation",1496,G__G__TMVA2_300_0_75, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNBValidation",1467,G__G__TMVA2_300_0_76, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNSValidation",1484,G__G__TMVA2_300_0_77, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSumTarget",1224,G__G__TMVA2_300_0_78, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSumTarget2",1274,G__G__TMVA2_300_0_79, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - t2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddToSumTarget",1384,G__G__TMVA2_300_0_80, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddToSumTarget2",1434,G__G__TMVA2_300_0_81, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - t2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSumTarget",1212,G__G__TMVA2_300_0_82, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSumTarget2",1262,G__G__TMVA2_300_0_83, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetValidationData",1928,G__G__TMVA2_300_0_84, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsTerminal",1016,G__G__TMVA2_300_0_85, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTerminal",1128,G__G__TMVA2_300_0_86, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintPrune",1047,G__G__TMVA2_300_0_87, 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("PrintRecPrune",1329,G__G__TMVA2_300_0_88, 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("SetCC",434,G__G__TMVA2_300_0_89, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCC",422,G__G__TMVA2_300_0_90, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSampleMin",1190,G__G__TMVA2_300_0_91, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - ivar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSampleMax",1192,G__G__TMVA2_300_0_92, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - ivar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSampleMin",1202,G__G__TMVA2_300_0_93, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - ivar f - 'Float_t' 0 - xmin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSampleMax",1204,G__G__TMVA2_300_0_94, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - ivar f - 'Float_t' 0 - xmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadAttributes",1443,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"Y - - 0 - node h - 'UInt_t' 0 'TMVA_VERSION_CODE' tmva_Version_Code", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadDataRecord",1365,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - is h - 'UInt_t' 0 'TMVA_VERSION_CODE' tmva_Version_Code", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadContent",1111,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'basic_stringstream<char,char_traits<char>,allocator<char> >' 'stringstream' 1 - s", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA2_300_0_98, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::DecisionTreeNode::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_300_0_99, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::DecisionTreeNode::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_300_0_100, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::DecisionTreeNode::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_300_0_101, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::DecisionTreeNode::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2_300_0_105, 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__TMVA2_300_0_106, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::DecisionTreeNode::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_300_0_107, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::DecisionTreeNode::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_300_0_108, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::DecisionTreeNode::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_300_0_109, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::DecisionTreeNode::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~DecisionTreeNode", 1730, G__G__TMVA2_300_0_110, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA2_300_0_111, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTreeNode), -1, 1, 1, 1, 1, 0, "u 'TMVA::DecisionTreeNode' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLRegressionVariance(void) {
   /* TMVA::RegressionVariance */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLRegressionVariance));
   G__memfunc_setup("RegressionVariance",1866,G__G__TMVA2_301_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLRegressionVariance), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegressionVariance",1866,G__G__TMVA2_301_0_2, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLRegressionVariance), -1, 0, 1, 1, 1, 0, "u 'TMVA::RegressionVariance' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSeparationGain",1717,G__G__TMVA2_301_0_3, 100, -1, G__defined_typename("Double_t"), 0, 6, 1, 1, 0, 
"d - 'Double_t' 11 - nLeft d - 'Double_t' 11 - targetLeft "
"d - 'Double_t' 11 - target2Left d - 'Double_t' 11 - nTot "
"d - 'Double_t' 11 - targetTot d - 'Double_t' 11 - target2Tot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSeparationIndex",1838,G__G__TMVA2_301_0_4, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 11 - n d - 'Double_t' 11 - target "
"d - 'Double_t' 11 - target2", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetName",673,G__G__TMVA2_301_0_5, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA2_301_0_6, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::RegressionVariance::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_301_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::RegressionVariance::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_301_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::RegressionVariance::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_301_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::RegressionVariance::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA2_301_0_10, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA2_301_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__TMVA2_301_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__TMVA2_301_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__TMVA2_301_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::RegressionVariance::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_301_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::RegressionVariance::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_301_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::RegressionVariance::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_301_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::RegressionVariance::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~RegressionVariance", 1992, G__G__TMVA2_301_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__TMVA2_301_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLRegressionVariance), -1, 1, 1, 1, 1, 0, "u 'TMVA::RegressionVariance' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLDecisionTree(void) {
   /* TMVA::DecisionTree */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTree));
   G__memfunc_setup("DecisionTree",1214,G__G__TMVA2_385_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTree), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DecisionTree",1214,G__G__TMVA2_385_0_2, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTree), -1, 0, 12, 1, 1, 0, 
"U 'TMVA::SeparationBase' - 0 - sepType f - 'Float_t' 0 - minSize "
"i - 'Int_t' 0 - nCuts U 'TMVA::DataSetInfo' - 0 'NULL' - "
"h - 'UInt_t' 0 '0' cls g - 'Bool_t' 0 'kFALSE' randomisedTree "
"i - 'Int_t' 0 '0' useNvars g - 'Bool_t' 0 'kFALSE' usePoissonNvars "
"h - 'UInt_t' 0 '9999999' nMaxDepth i - 'Int_t' 0 'fgRandomSeed' iSeed "
"f - 'Float_t' 0 '0.5' purityLimit i - 'Int_t' 0 '0' treeID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DecisionTree",1214,G__G__TMVA2_385_0_3, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTree), -1, 0, 1, 1, 1, 0, "u 'TMVA::DecisionTree' - 11 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRoot",708,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTreeNode), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateNode",986,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTreeNode), -1, 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateTree",996,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLBinaryTree), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateFromXML",1241,G__G__TMVA2_385_0_7, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTree), -1, 0, 2, 3, 1, 0, 
"Y - - 0 - node h - 'UInt_t' 0 'TMVA_VERSION_CODE' tmva_Version_Code", (char*)NULL, (void*) G__func2void( (TMVA::DecisionTree* (*)(void*, UInt_t))(&TMVA::DecisionTree::CreateFromXML) ), 0);
   G__memfunc_setup("ClassName",887,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BuildTree",896,G__G__TMVA2_385_0_9, 104, -1, G__defined_typename("UInt_t"), 0, 2, 1, 1, 0, 
"u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'TMVA::DecisionTree::EventConstList' 11 - eventSample U 'TMVA::DecisionTreeNode' - 0 'NULL' node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrainNode",900,G__G__TMVA2_385_0_10, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'TMVA::DecisionTree::EventConstList' 11 - eventSample U 'TMVA::DecisionTreeNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrainNodeFast",1298,G__G__TMVA2_385_0_11, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'TMVA::DecisionTree::EventConstList' 11 - eventSample U 'TMVA::DecisionTreeNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrainNodeFull",1303,G__G__TMVA2_385_0_12, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'TMVA::DecisionTree::EventConstList' 11 - eventSample U 'TMVA::DecisionTreeNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRandomisedVariables",2239,G__G__TMVA2_385_0_13, 121, -1, -1, 0, 3, 1, 1, 0, 
"G - 'Bool_t' 0 - useVariable H - 'UInt_t' 0 - variableMap "
"h - 'UInt_t' 1 - nVars", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFisherCoefficients",2131,G__G__TMVA2_385_0_14, 117, G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<Double_t>"), 0, 3, 1, 1, 0, 
"u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'TMVA::DecisionTree::EventConstList' 11 - eventSample h - 'UInt_t' 0 - nFisherVars "
"H - 'UInt_t' 0 - mapVarInFisher", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillTree",791,G__G__TMVA2_385_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' 'TMVA::DecisionTree::EventList' 11 - eventSample", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillEvent",905,G__G__TMVA2_385_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMVA::Event' - 11 - event U 'TMVA::DecisionTreeNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckEvent",992,G__G__TMVA2_385_0_17, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"U 'TMVA::Event' - 10 - - g - 'Bool_t' 0 'kFALSE' UseYesNoLeaf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEventNode",1192,G__G__TMVA2_385_0_18, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTreeNode), -1, 0, 1, 1, 1, 8, "u 'TMVA::Event' - 11 - e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVariableImportance",2136,G__G__TMVA2_385_0_19, 117, G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<Double_t>"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVariableImportance",2136,G__G__TMVA2_385_0_20, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - ivar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearTree",887,G__G__TMVA2_385_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPruneMethod",1431,G__G__TMVA2_385_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TMVA::DecisionTree::EPruneMethod' - 0 'kCostComplexityPruning' m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneTree",922,G__G__TMVA2_385_0_23, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "U 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'TMVA::DecisionTree::EventConstList' 10 'NULL' validationSample", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPruneStrength",1669,G__G__TMVA2_385_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPruneStrength",1657,G__G__TMVA2_385_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ApplyValidationSample",2163,G__G__TMVA2_385_0_26, 121, -1, -1, 0, 1, 1, 1, 8, "U 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'TMVA::DecisionTree::EventConstList' 10 - validationSample", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TestPrunedTreeQuality",2183,G__G__TMVA2_385_0_27, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"U 'TMVA::DecisionTreeNode' - 10 'NULL' dt i - 'Int_t' 0 '0' mode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckEventWithPrunedTree",2426,G__G__TMVA2_385_0_28, 121, -1, -1, 0, 1, 1, 1, 8, "U 'TMVA::Event' - 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSumWeights",1328,G__G__TMVA2_385_0_29, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "U 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'TMVA::DecisionTree::EventConstList' 10 - validationSample", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNodePurityLimit",1854,G__G__TMVA2_385_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - p", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNodePurityLimit",1842,G__G__TMVA2_385_0_31, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DescendTree",1094,G__G__TMVA2_385_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::Node' - 0 'NULL' n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetParentTreeInNodes",2006,G__G__TMVA2_385_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::Node' - 0 'NULL' n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNode",678,G__G__TMVA2_385_0_34, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLNode), -1, 0, 2, 1, 1, 0, 
"k - 'ULong_t' 0 - sequence h - 'UInt_t' 0 - depth", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CleanTree",883,G__G__TMVA2_385_0_35, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 0, "U 'TMVA::DecisionTreeNode' - 0 'NULL' node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneNode",912,G__G__TMVA2_385_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::DecisionTreeNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PruneNodeInPlace",1580,G__G__TMVA2_385_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::DecisionTreeNode' - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNNodesBeforePruning",2205,G__G__TMVA2_385_0_38, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CountLeafNodes",1402,G__G__TMVA2_385_0_39, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 0, "U 'TMVA::Node' - 0 'NULL' n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTreeID",841,G__G__TMVA2_385_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - treeID", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTreeID",829,G__G__TMVA2_385_0_41, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRegression",1236,G__G__TMVA2_385_0_42, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAnalysisType",1554,G__G__TMVA2_385_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TMVA::Types::EAnalysisType' - 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAnalysisType",1542,G__G__TMVA2_385_0_44, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTypescLcLEAnalysisType), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUseFisherCuts",1625,G__G__TMVA2_385_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinLinCorrForFisher",2193,G__G__TMVA2_385_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - min", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUseExclusiveVars",1965,G__G__TMVA2_385_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNVars",790,G__G__TMVA2_385_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SamplePurity",1263,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' 'TMVA::DecisionTree::EventList' 0 - eventSample", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA2_385_0_50, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::DecisionTree::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_385_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::DecisionTree::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_385_0_52, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::DecisionTree::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_385_0_53, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::DecisionTree::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2_385_0_57, 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__TMVA2_385_0_58, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::DecisionTree::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_385_0_59, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::DecisionTree::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_385_0_60, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::DecisionTree::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_385_0_61, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::DecisionTree::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~DecisionTree", 1340, G__G__TMVA2_385_0_62, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA2_385_0_63, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDecisionTree), -1, 1, 1, 1, 1, 0, "u 'TMVA::DecisionTree' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMisClassificationError(void) {
   /* TMVA::MisClassificationError */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMisClassificationError));
   G__memfunc_setup("MisClassificationError",2271,G__G__TMVA2_391_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMisClassificationError), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MisClassificationError",2271,G__G__TMVA2_391_0_2, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMisClassificationError), -1, 0, 1, 1, 1, 0, "u 'TMVA::MisClassificationError' - 11 - g", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSeparationIndex",1838,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 11 - s d - 'Double_t' 11 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA2_391_0_4, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MisClassificationError::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_391_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MisClassificationError::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_391_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MisClassificationError::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_391_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MisClassificationError::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2_391_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__TMVA2_391_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MisClassificationError::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_391_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MisClassificationError::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_391_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MisClassificationError::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_391_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MisClassificationError::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MisClassificationError", 2397, G__G__TMVA2_391_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__TMVA2_391_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMisClassificationError), -1, 1, 1, 1, 1, 0, "u 'TMVA::MisClassificationError' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLSdivSqrtSplusB(void) {
   /* TMVA::SdivSqrtSplusB */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSdivSqrtSplusB));
   G__memfunc_setup("SdivSqrtSplusB",1433,G__G__TMVA2_392_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSdivSqrtSplusB), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SdivSqrtSplusB",1433,G__G__TMVA2_392_0_2, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSdivSqrtSplusB), -1, 0, 1, 1, 1, 0, "u 'TMVA::SdivSqrtSplusB' - 11 - g", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSeparationGain",1717,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 0, 
"d - 'Double_t' 11 - nSelS d - 'Double_t' 11 - nSelB "
"d - 'Double_t' 11 - nTotS d - 'Double_t' 11 - nTotB", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSeparationIndex",1838,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 11 - s d - 'Double_t' 11 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA2_392_0_5, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::SdivSqrtSplusB::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_392_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SdivSqrtSplusB::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_392_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::SdivSqrtSplusB::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_392_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::SdivSqrtSplusB::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2_392_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__TMVA2_392_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SdivSqrtSplusB::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_392_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::SdivSqrtSplusB::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_392_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SdivSqrtSplusB::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_392_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::SdivSqrtSplusB::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~SdivSqrtSplusB", 1559, G__G__TMVA2_392_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__TMVA2_392_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSdivSqrtSplusB), -1, 1, 1, 1, 1, 0, "u 'TMVA::SdivSqrtSplusB' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLTools(void) {
   /* TMVA::Tools */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTools));
   G__memfunc_setup("Tools",529,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTools), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Instance",821,G__G__TMVA2_406_0_2, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTools), -1, 1, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TMVA::Tools& (*)())(&TMVA::Tools::Instance) ), 0);
   G__memfunc_setup("DestroyInstance",1567,G__G__TMVA2_406_0_3, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::Tools::DestroyInstance) ), 0);
   G__memfunc_setup("ComputeStat",1145,G__G__TMVA2_406_0_4, 121, -1, -1, 0, 10, 1, 1, 0, 
"u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' 'vector<TMVA::Event*>' 11 - - U 'vector<float,allocator<float> >' 'vector<Float_t>' 0 - - "
"d - 'Double_t' 1 - - d - 'Double_t' 1 - - "
"d - 'Double_t' 1 - - d - 'Double_t' 1 - - "
"d - 'Double_t' 1 - - d - 'Double_t' 1 - - "
"i - 'Int_t' 0 - signalClass g - 'Bool_t' 0 'kFALSE' norm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeVariance",1542,G__G__TMVA2_406_0_5, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - sumx2 d - 'Double_t' 0 - sumx "
"i - 'Int_t' 0 - nx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("projNormTH1F",1130,G__G__TMVA2_406_0_6, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TH1), -1, 0, 7, 1, 1, 0, 
"U 'TTree' - 0 - theTree u 'TString' - 11 - theVarName "
"u 'TString' - 11 - name i - 'Int_t' 0 - nbins "
"d - 'Double_t' 0 - xmin d - 'Double_t' 0 - xmax "
"u 'TString' - 11 - cut", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NormHist",820,G__G__TMVA2_406_0_7, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"U 'TH1' - 0 - theHist d - 'Double_t' 0 '1.0' norm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ParseFormatLine",1516,G__G__TMVA2_406_0_8, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TList), -1, 0, 2, 1, 1, 0, 
"u 'TString' - 0 - theString C - - 10 '\":\"' sep", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ParseANNOptionString",1992,G__G__TMVA2_406_0_9, 85, G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 3, 1, 1, 0, 
"u 'TString' - 0 - theOptions i - 'Int_t' 0 - nvar "
"U 'vector<int,allocator<int> >' 'vector<Int_t>' 0 - nodes", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSQRootMatrix",1501,G__G__TMVA2_406_0_10, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 1, 1, 1, 0, "U 'TMatrixTSym<double>' 'TMatrixDSym' 0 - symMat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcCovarianceMatrices",2214,G__G__TMVA2_406_0_11, 85, G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgR), G__defined_typename("vector<TMatrixDSym*>"), 0, 3, 1, 1, 0, 
"u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - events i - 'Int_t' 0 - maxCls "
"U 'TMVA::VariableTransformBase' - 0 '0' transformBase", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcCovarianceMatrices",2214,G__G__TMVA2_406_0_12, 85, G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgR), G__defined_typename("vector<TMatrixDSym*>"), 0, 3, 1, 1, 0, 
"u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' - 11 - events i - 'Int_t' 0 - maxCls "
"U 'TMVA::VariableTransformBase' - 0 '0' transformBase", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCorrelationMatrix",2071,G__G__TMVA2_406_0_13, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMatrixTlEdoublegR), G__defined_typename("TMatrixD"), 0, 1, 1, 1, 1, "U 'TMatrixT<double>' 'TMatrixD' 10 - covMat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckSplines",1212,G__G__TMVA2_406_0_14, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"U 'TH1' - 10 - - U 'TSpline' - 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NormVariable",1218,G__G__TMVA2_406_0_15, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - x d - 'Double_t' 0 - xmin "
"d - 'Double_t' 0 - xmax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSeparation",1334,G__G__TMVA2_406_0_16, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"U 'TH1' - 0 - S U 'TH1' - 0 - B", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSeparation",1334,G__G__TMVA2_406_0_17, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"u 'TMVA::PDF' - 11 - pdfS u 'TMVA::PDF' - 11 - pdfB", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MVADiff",605,G__G__TMVA2_406_0_18, 117, G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<Double_t>"), 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - - u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Scale",488,G__G__TMVA2_406_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - - d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Scale",488,G__G__TMVA2_406_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - - f - 'Float_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UsefulSortDescending",2064,G__G__TMVA2_406_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >' 'vector<std::vector<Double_t> >' 1 - - U 'vector<TString,allocator<TString> >' 'vector<TString>' 0 '0' vs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UsefulSortAscending",1960,G__G__TMVA2_406_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >' 'vector<std::vector<Double_t> >' 1 - - U 'vector<TString,allocator<TString> >' 'vector<TString>' 0 '0' vs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UsefulSortDescending",2064,G__G__TMVA2_406_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UsefulSortAscending",1960,G__G__TMVA2_406_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIndexMaxElement",1800,G__G__TMVA2_406_0_25, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIndexMinElement",1798,G__G__TMVA2_406_0_26, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ContainsRegularExpression",2625,G__G__TMVA2_406_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TString' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReplaceRegularExpressions",2609,G__G__TMVA2_406_0_28, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TString), -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - s u 'TString' - 11 '\"+\"' replace", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FormattedOutput",1591,G__G__TMVA2_406_0_29, 121, -1, -1, 0, 6, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - - u 'vector<TString,allocator<TString> >' 'vector<TString>' 11 - - "
"u 'TString' - 10 - titleVars u 'TString' - 10 - titleValues "
"u 'TMVA::MsgLogger' - 1 - logger u 'TString' - 0 '\"%+1.3f\"' format", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FormattedOutput",1591,G__G__TMVA2_406_0_30, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 11 - - u 'vector<TString,allocator<TString> >' 'vector<TString>' 11 - - "
"u 'TMVA::MsgLogger' - 1 - logger", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FormattedOutput",1591,G__G__TMVA2_406_0_31, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 11 - - u 'vector<TString,allocator<TString> >' 'vector<TString>' 11 - vert "
"u 'vector<TString,allocator<TString> >' 'vector<TString>' 11 - horiz u 'TMVA::MsgLogger' - 1 - logger", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteFloatArbitraryPrecision",2909,G__G__TMVA2_406_0_32, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 0 - val u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadFloatArbitraryPrecision",2766,G__G__TMVA2_406_0_33, 121, -1, -1, 0, 2, 1, 1, 0, 
"f - 'Float_t' 1 - val u 'basic_istream<char,char_traits<char> >' 'istream' 1 - is", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetXTitleWithUnit",1718,G__G__TMVA2_406_0_34, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TString), -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - title u 'TString' - 11 - unit", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYTitleWithUnit",1719,G__G__TMVA2_406_0_35, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TString), -1, 0, 3, 1, 1, 0, 
"u 'TH1' - 11 - h u 'TString' - 11 - unit "
"g - 'Bool_t' 0 - normalised", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMutualInformation",2078,G__G__TMVA2_406_0_36, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'TH2F' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCorrelationRatio",1953,G__G__TMVA2_406_0_37, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'TH2F' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TransposeHist",1367,G__G__TMVA2_406_0_38, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TH2F), -1, 0, 1, 1, 1, 0, "u 'TH2F' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckForSilentOption",2029,G__G__TMVA2_406_0_39, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckForVerboseOption",2132,G__G__TMVA2_406_0_40, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Color",511,G__G__TMVA2_406_0_41, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TString), -1, 1, 1, 1, 1, 1, "u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMVAWelcomeMessage",1737,G__G__TMVA2_406_0_42, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMVAWelcomeMessage",1737,G__G__TMVA2_406_0_43, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMVA::MsgLogger' - 1 - logger i 'TMVA::Tools::EWelcomeMessage' - 0 'kStandardWelcomeMsg' m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMVAVersionMessage",1763,G__G__TMVA2_406_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMVA::MsgLogger' - 1 - logger", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ROOTVersionMessage",1775,G__G__TMVA2_406_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMVA::MsgLogger' - 1 - logger", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMVACitation",1139,G__G__TMVA2_406_0_46, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TMVA::MsgLogger' - 1 - logger i 'TMVA::Tools::ECitation' - 0 'kPlainText' citType", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SplitString",1155,G__G__TMVA2_406_0_47, 117, G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETStringcOallocatorlETStringgRsPgR), G__defined_typename("vector<TString>"), 0, 2, 1, 1, 8, 
"u 'TString' - 11 - theOpt c - - 10 - separator", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,G__G__TMVA2_406_0_48, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StringFromInt",1334,G__G__TMVA2_406_0_49, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TString), -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("StringFromDouble",1638,G__G__TMVA2_406_0_50, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TString), -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteTMatrixDToXML",1740,G__G__TMVA2_406_0_51, 121, -1, -1, 0, 3, 1, 1, 0, 
"Y - - 0 - node C - - 10 - name "
"U 'TMatrixT<double>' 'TMatrixD' 0 - mat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteTVectorDToXML",1738,G__G__TMVA2_406_0_52, 121, -1, -1, 0, 3, 1, 1, 0, 
"Y - - 0 - node C - - 10 - name "
"U 'TVectorT<double>' 'TVectorD' 0 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTMatrixDFromXML",1806,G__G__TMVA2_406_0_53, 121, -1, -1, 0, 3, 1, 1, 0, 
"Y - - 0 - node C - - 10 - name "
"U 'TMatrixT<double>' 'TMatrixD' 0 - mat", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTVectorDFromXML",1804,G__G__TMVA2_406_0_54, 121, -1, -1, 0, 3, 1, 1, 0, 
"Y - - 0 - node C - - 10 - name "
"U 'TVectorT<double>' 'TVectorD' 0 - vec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HistoHasEquidistantBins",2362,G__G__TMVA2_406_0_55, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'TH1' - 11 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAttr",695,G__G__TMVA2_406_0_56, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"Y - - 0 - node C - - 10 - attrname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadAttr",791,G__G__TMVA2_406_0_57, 121, -1, -1, 0, 3, 1, 1, 0, 
"Y - - 0 - node C - - 10 - attrname "
"u 'TString' - 1 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddAttr",676,G__G__TMVA2_406_0_58, 121, -1, -1, 0, 3, 1, 1, 0, 
"Y - - 0 - node C - - 10 - attrname "
"C - - 10 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddChild",749,G__G__TMVA2_406_0_59, 89, -1, -1, 0, 4, 1, 1, 0, 
"Y - - 0 - parent C - - 10 - childname "
"C - - 10 '0' content g - - 0 'false' isRootNode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddRawLine",955,G__G__TMVA2_406_0_60, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"Y - - 0 - node C - - 10 - raw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddComment",988,G__G__TMVA2_406_0_61, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"Y - - 0 - node C - - 10 - comment", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetParent",906,G__G__TMVA2_406_0_62, 89, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - child", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetChild",772,G__G__TMVA2_406_0_63, 89, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - parent C - - 10 '0' childname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNextChild",1187,G__G__TMVA2_406_0_64, 89, -1, -1, 0, 2, 1, 1, 0, 
"Y - - 0 - prevchild C - - 10 '0' childname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetContent",1019,G__G__TMVA2_406_0_65, 67, -1, -1, 0, 1, 1, 1, 1, "Y - - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,G__G__TMVA2_406_0_66, 67, -1, -1, 0, 1, 1, 1, 1, "Y - - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("xmlengine",967,G__G__TMVA2_406_0_67, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TXMLEngine), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("xmlenginebuffersize",2044,G__G__TMVA2_406_0_68, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCumulativeDist",1747,G__G__TMVA2_406_0_69, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TH1), -1, 0, 1, 1, 1, 0, "U 'TH1' - 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetYMean_binX",1258,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 0, 
"u 'TH2' - 11 - - i - 'Int_t' 0 - bin_x", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("Tools", 529, G__G__TMVA2_406_0_71, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLTools), -1, 0, 1, 1, 1, 0, "u 'TMVA::Tools' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~Tools", 655, G__G__TMVA2_406_0_72, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLReader(void) {
   /* TMVA::Reader */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLReader));
   G__memfunc_setup("Reader",595,G__G__TMVA2_453_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLReader), -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 '\"\"' theOption g - 'Bool_t' 0 '0' verbose", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reader",595,G__G__TMVA2_453_0_2, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLReader), -1, 0, 3, 1, 1, 0, 
"u 'vector<string,allocator<string> >' 'vector<std::string>' 1 - varNames u 'TString' - 11 '\"\"' theOption "
"g - 'Bool_t' 0 '0' verbose", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reader",595,G__G__TMVA2_453_0_3, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLReader), -1, 0, 3, 1, 1, 0, 
"u 'string' - 11 - varNames u 'TString' - 11 - theOption "
"g - 'Bool_t' 0 '0' verbose", "format: \"var1:var2:...\"", (void*) NULL, 0);
   G__memfunc_setup("Reader",595,G__G__TMVA2_453_0_4, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLReader), -1, 0, 3, 1, 1, 0, 
"u 'vector<TString,allocator<TString> >' 'vector<TString>' 1 - varNames u 'TString' - 11 '\"\"' theOption "
"g - 'Bool_t' 0 '0' verbose", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Reader",595,G__G__TMVA2_453_0_5, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLReader), -1, 0, 3, 1, 1, 0, 
"u 'TString' - 11 - varNames u 'TString' - 11 - theOption "
"g - 'Bool_t' 0 '0' verbose", "format: \"var1:var2:...\"", (void*) NULL, 0);
   G__memfunc_setup("BookMVA",623,G__G__TMVA2_453_0_6, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLIMethod), -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - methodTag u 'TString' - 11 - weightfile", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BookMVA",623,G__G__TMVA2_453_0_7, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLIMethod), -1, 0, 2, 1, 1, 0, 
"i 'TMVA::Types::EMVA' - 0 - methodType C - - 10 - xmlstr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindMVA",613,G__G__TMVA2_453_0_8, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLIMethod), -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - methodTag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindCutsMVA",1028,G__G__TMVA2_453_0_9, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMethodCuts), -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - methodTag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvaluateMVA",1051,G__G__TMVA2_453_0_10, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - - u 'TString' - 11 - methodTag "
"d - 'Double_t' 0 '0' aux", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvaluateMVA",1051,G__G__TMVA2_453_0_11, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - - u 'TString' - 11 - methodTag "
"d - 'Double_t' 0 '0' aux", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvaluateMVA",1051,G__G__TMVA2_453_0_12, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"U 'TMVA::MethodBase' - 0 - method d - 'Double_t' 0 '0' aux", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvaluateMVA",1051,G__G__TMVA2_453_0_13, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'TString' - 11 - methodTag d - 'Double_t' 0 '0' aux", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMVAError",1038,G__G__TMVA2_453_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMVAErrorLower",1559,G__G__TMVA2_453_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMVAErrorUpper",1562,G__G__TMVA2_453_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvaluateRegression",1880,G__G__TMVA2_453_0_17, 117, G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 2, 1, 1, 1, 
"u 'TString' - 11 - methodTag d - 'Double_t' 0 '0' aux", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvaluateRegression",1880,G__G__TMVA2_453_0_18, 117, G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 2, 1, 1, 1, 
"U 'TMVA::MethodBase' - 0 - method d - 'Double_t' 0 '0' aux", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvaluateRegression",1880,G__G__TMVA2_453_0_19, 102, -1, G__defined_typename("Float_t"), 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 - tgtNumber u 'TString' - 11 - methodTag "
"d - 'Double_t' 0 '0' aux", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvaluateMulticlass",1880,G__G__TMVA2_453_0_20, 117, G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 2, 1, 1, 1, 
"u 'TString' - 11 - methodTag d - 'Double_t' 0 '0' aux", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvaluateMulticlass",1880,G__G__TMVA2_453_0_21, 117, G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 2, 1, 1, 1, 
"U 'TMVA::MethodBase' - 0 - method d - 'Double_t' 0 '0' aux", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvaluateMulticlass",1880,G__G__TMVA2_453_0_22, 102, -1, G__defined_typename("Float_t"), 0, 3, 1, 1, 0, 
"h - 'UInt_t' 0 - clsNumber u 'TString' - 11 - methodTag "
"d - 'Double_t' 0 '0' aux", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProba",788,G__G__TMVA2_453_0_23, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"u 'TString' - 11 - methodTag d - 'Double_t' 0 '0.5' ap_sig "
"d - 'Double_t' 0 '-9999999' mvaVal", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRarity",923,G__G__TMVA2_453_0_24, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"u 'TString' - 11 - methodTag d - 'Double_t' 0 '-9999999' mvaVal", (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("Verbose",726,G__G__TMVA2_453_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVerbose",1026,G__G__TMVA2_453_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DataInfo",774,G__G__TMVA2_453_0_28, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDataSetInfo), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DataInfo",774,G__G__TMVA2_453_0_29, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLDataSetInfo), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddVariable",1071,G__G__TMVA2_453_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - expression F - 'Float_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddVariable",1071,G__G__TMVA2_453_0_31, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - expression I - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddSpectator",1214,G__G__TMVA2_453_0_32, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - expression F - 'Float_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddSpectator",1214,G__G__TMVA2_453_0_33, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - expression I - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethodTypeFromFile",2103,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TString), -1, 0, 1, 1, 4, 0, "u 'TString' - 11 - filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BookMVA",623,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLIMethod), -1, 0, 2, 1, 4, 0, 
"i 'TMVA::Types::EMVA' - 0 - method u 'TString' - 11 - weightfile", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DecodeVarNames",1377,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'string' - 11 - varNames", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DecodeVarNames",1377,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TString' - 11 - varNames", (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, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA2_453_0_41, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::Reader::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_453_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Reader::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_453_0_43, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::Reader::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_453_0_44, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::Reader::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2_453_0_48, 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__TMVA2_453_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Reader::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_453_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Reader::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_453_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Reader::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_453_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Reader::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~Reader", 721, G__G__TMVA2_453_0_53, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLGeneticGenes(void) {
   /* TMVA::GeneticGenes */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticGenes));
   G__memfunc_setup("GeneticGenes",1201,G__G__TMVA2_466_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticGenes), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GeneticGenes",1201,G__G__TMVA2_466_0_2, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticGenes), -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFactors",1010,G__G__TMVA2_466_0_3, 117, G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<Double_t>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetFitness",1032,G__G__TMVA2_466_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - fitness", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitness",1020,G__G__TMVA2_466_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA2_466_0_6, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::GeneticGenes::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_466_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GeneticGenes::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_466_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::GeneticGenes::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_466_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::GeneticGenes::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA2_466_0_10, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA2_466_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__TMVA2_466_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__TMVA2_466_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__TMVA2_466_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GeneticGenes::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_466_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::GeneticGenes::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_466_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GeneticGenes::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_466_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::GeneticGenes::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("GeneticGenes", 1201, G__G__TMVA2_466_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticGenes), -1, 0, 1, 1, 1, 0, "u 'TMVA::GeneticGenes' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~GeneticGenes", 1327, G__G__TMVA2_466_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__TMVA2_466_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticGenes), -1, 1, 1, 1, 1, 0, "u 'TMVA::GeneticGenes' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLGeneticRange(void) {
   /* TMVA::GeneticRange */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticRange));
   G__memfunc_setup("GeneticRange",1196,G__G__TMVA2_468_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticRange), -1, 0, 2, 1, 1, 0, 
"U 'TRandom3' - 0 - rnd U 'TMVA::Interval' - 0 - interval", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Random",609,G__G__TMVA2_468_0_2, 100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 0, 
"g - 'Bool_t' 0 'kFALSE' near d - 'Double_t' 0 '0' value "
"d - 'Double_t' 0 '0.1' spread g - 'Bool_t' 0 'kFALSE' mirror", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RandomDiscrete",1428,G__G__TMVA2_468_0_3, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFrom",692,G__G__TMVA2_468_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTo",483,G__G__TMVA2_468_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTotalLength",1414,G__G__TMVA2_468_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReMap",469,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReMapMirror",1104,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA2_468_0_9, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::GeneticRange::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_468_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GeneticRange::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_468_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::GeneticRange::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_468_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::GeneticRange::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA2_468_0_13, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA2_468_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__TMVA2_468_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA2_468_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__TMVA2_468_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GeneticRange::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_468_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::GeneticRange::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_468_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GeneticRange::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_468_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::GeneticRange::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("GeneticRange", 1196, G__G__TMVA2_468_0_21, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticRange), -1, 0, 1, 1, 1, 0, "u 'TMVA::GeneticRange' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~GeneticRange", 1322, G__G__TMVA2_468_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__TMVA2_468_0_23, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticRange), -1, 1, 1, 1, 1, 0, "u 'TMVA::GeneticRange' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLGeneticPopulation(void) {
   /* TMVA::GeneticPopulation */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticPopulation));
   G__memfunc_setup("GeneticPopulation",1770,G__G__TMVA2_469_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticPopulation), -1, 0, 3, 1, 1, 0, 
"u 'vector<TMVA::Interval*,allocator<TMVA::Interval*> >' 'vector<TMVA::Interval*>' 11 - ranges i - 'Int_t' 0 - size "
"h - 'UInt_t' 0 '0' seed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRandomSeed",1294,G__G__TMVA2_469_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 '0' seed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeChildren",1191,G__G__TMVA2_469_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Mutate",624,G__G__TMVA2_469_0_4, 121, -1, -1, 0, 5, 1, 1, 0, 
"d - 'Double_t' 0 '20' probability i - 'Int_t' 0 '0' startIndex "
"g - 'Bool_t' 0 'kFALSE' near d - 'Double_t' 0 '0.1' spread "
"g - 'Bool_t' 0 'kFALSE' mirror", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGenes",786,G__G__TMVA2_469_0_5, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticGenes), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPopulationSize",1766,G__G__TMVA2_469_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFitness",1020,G__G__TMVA2_469_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGenePool",1081,G__G__TMVA2_469_0_8, 117, G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLGeneticGenescOallocatorlETMVAcLcLGeneticGenesgRsPgR), G__defined_typename("vector<TMVA::GeneticGenes>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRanges",896,G__G__TMVA2_469_0_9, 117, G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLGeneticRangemUcOallocatorlETMVAcLcLGeneticRangemUgRsPgR), G__defined_typename("vector<TMVA::GeneticRange*>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGenePool",1081,G__G__TMVA2_469_0_10, 117, G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLGeneticGenescOallocatorlETMVAcLcLGeneticGenesgRsPgR), G__defined_typename("vector<TMVA::GeneticGenes>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRanges",896,G__G__TMVA2_469_0_11, 117, G__get_linked_tagnum(&G__G__TMVA2LN_vectorlETMVAcLcLGeneticRangemUcOallocatorlETMVAcLcLGeneticRangemUgRsPgR), G__defined_typename("vector<TMVA::GeneticRange*>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,G__G__TMVA2_469_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '-1' untilIndex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,G__G__TMVA2_469_0_13, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - out i - 'Int_t' 0 '-1' utilIndex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("VariableDistribution",2086,G__G__TMVA2_469_0_14, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TH1F), -1, 0, 4, 1, 1, 0, 
"i - 'Int_t' 0 - varNumber i - 'Int_t' 0 - bins "
"i - 'Int_t' 0 - min i - 'Int_t' 0 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("VariableDistribution",2086,G__G__TMVA2_469_0_15, 117, G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<Double_t>"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - varNumber", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeCopies",993,G__G__TMVA2_469_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - number", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NextGeneration",1451,G__G__TMVA2_469_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPopulation",1332,G__G__TMVA2_469_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::GeneticPopulation' - 0 - strangers", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPopulation",1332,G__G__TMVA2_469_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMVA::GeneticPopulation' - 1 - strangers", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrimPopulation",1479,G__G__TMVA2_469_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GiveHint",798,G__G__TMVA2_469_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - hint d - 'Double_t' 0 '0' fitness", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sort",424,G__G__TMVA2_469_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeSex",686,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticGenes), -1, 0, 2, 1, 4, 0, 
"u 'TMVA::GeneticGenes' - 0 - male u 'TMVA::GeneticGenes' - 0 - female", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA2_469_0_25, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::GeneticPopulation::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_469_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GeneticPopulation::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_469_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::GeneticPopulation::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_469_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::GeneticPopulation::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA2_469_0_29, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA2_469_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__TMVA2_469_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA2_469_0_32, 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__TMVA2_469_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GeneticPopulation::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_469_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::GeneticPopulation::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_469_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GeneticPopulation::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_469_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::GeneticPopulation::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("GeneticPopulation", 1770, G__G__TMVA2_469_0_37, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticPopulation), -1, 0, 1, 1, 1, 0, "u 'TMVA::GeneticPopulation' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~GeneticPopulation", 1896, G__G__TMVA2_469_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA2_469_0_39, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticPopulation), -1, 1, 1, 1, 1, 0, "u 'TMVA::GeneticPopulation' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLGeneticAlgorithm(void) {
   /* TMVA::GeneticAlgorithm */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticAlgorithm));
   G__memfunc_setup("GeneticAlgorithm",1638,G__G__TMVA2_482_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticAlgorithm), -1, 0, 4, 1, 1, 0, 
"u 'TMVA::IFitterTarget' - 1 - target i - 'Int_t' 0 - populationSize "
"u 'vector<TMVA::Interval*,allocator<TMVA::Interval*> >' 'vector<TMVA::Interval*>' 11 - ranges h - 'UInt_t' 0 '0' seed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Init",404,G__G__TMVA2_482_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasConverged",1209,G__G__TMVA2_482_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '10' steps d - 'Double_t' 0 '0.1' ratio", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SpreadControl",1344,G__G__TMVA2_482_0_4, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - steps i - 'Int_t' 0 - ofSteps "
"d - 'Double_t' 0 - factor", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NewFitness",1030,G__G__TMVA2_482_0_5, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - oldValue d - 'Double_t' 0 - newValue", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CalculateFitness",1642,G__G__TMVA2_482_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Evolution",965,G__G__TMVA2_482_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetGeneticPopulation",2058,G__G__TMVA2_482_0_8, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticPopulation), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSpread",895,G__G__TMVA2_482_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSpread",907,G__G__TMVA2_482_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMakeCopies",1293,G__G__TMVA2_482_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMakeCopies",1281,G__G__TMVA2_482_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA2_482_0_14, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::GeneticAlgorithm::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_482_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GeneticAlgorithm::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_482_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::GeneticAlgorithm::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_482_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::GeneticAlgorithm::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA2_482_0_18, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA2_482_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__TMVA2_482_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA2_482_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__TMVA2_482_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GeneticAlgorithm::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_482_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::GeneticAlgorithm::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_482_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GeneticAlgorithm::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_482_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::GeneticAlgorithm::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("GeneticAlgorithm", 1638, G__G__TMVA2_482_0_26, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGeneticAlgorithm), -1, 0, 1, 1, 1, 0, "u 'TMVA::GeneticAlgorithm' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~GeneticAlgorithm", 1764, G__G__TMVA2_482_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLGiniIndex(void) {
   /* TMVA::GiniIndex */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGiniIndex));
   G__memfunc_setup("GiniIndex",895,G__G__TMVA2_486_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGiniIndex), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GiniIndex",895,G__G__TMVA2_486_0_2, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGiniIndex), -1, 0, 1, 1, 1, 0, "u 'TMVA::GiniIndex' - 11 - g", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSeparationIndex",1838,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 11 - s d - 'Double_t' 11 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA2_486_0_4, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::GiniIndex::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_486_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GiniIndex::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_486_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::GiniIndex::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_486_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::GiniIndex::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2_486_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__TMVA2_486_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GiniIndex::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_486_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::GiniIndex::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_486_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GiniIndex::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_486_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::GiniIndex::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~GiniIndex", 1021, G__G__TMVA2_486_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__TMVA2_486_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGiniIndex), -1, 1, 1, 1, 1, 0, "u 'TMVA::GiniIndex' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLGiniIndexWithLaplace(void) {
   /* TMVA::GiniIndexWithLaplace */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGiniIndexWithLaplace));
   G__memfunc_setup("GiniIndexWithLaplace",1997,G__G__TMVA2_487_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGiniIndexWithLaplace), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GiniIndexWithLaplace",1997,G__G__TMVA2_487_0_2, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGiniIndexWithLaplace), -1, 0, 1, 1, 1, 0, "u 'TMVA::GiniIndexWithLaplace' - 11 - g", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSeparationIndex",1838,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 11 - s d - 'Double_t' 11 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA2_487_0_4, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::GiniIndexWithLaplace::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_487_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GiniIndexWithLaplace::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_487_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::GiniIndexWithLaplace::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_487_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::GiniIndexWithLaplace::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA2LN_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__TMVA2_487_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__TMVA2_487_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GiniIndexWithLaplace::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_487_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::GiniIndexWithLaplace::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_487_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GiniIndexWithLaplace::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_487_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::GiniIndexWithLaplace::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~GiniIndexWithLaplace", 2123, G__G__TMVA2_487_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__TMVA2_487_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLGiniIndexWithLaplace), -1, 1, 1, 1, 1, 0, "u 'TMVA::GiniIndexWithLaplace' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLSimulatedAnnealing(void) {
   /* TMVA::SimulatedAnnealing */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSimulatedAnnealing));
   G__memfunc_setup("SimulatedAnnealing",1845,G__G__TMVA2_489_0_1, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSimulatedAnnealing), -1, 0, 2, 1, 1, 0, 
"u 'TMVA::IFitterTarget' - 1 - target u 'vector<TMVA::Interval*,allocator<TMVA::Interval*> >' 'vector<TMVA::Interval*>' 11 - ranges", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Minimize",834,G__G__TMVA2_489_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, 0);
   G__memfunc_setup("SetMaxCalls",1089,G__G__TMVA2_489_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - mc", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInitTemp",1110,G__G__TMVA2_489_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - it", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinTemp",998,G__G__TMVA2_489_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - min", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAccuracy",1111,G__G__TMVA2_489_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - eps", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTemperatureScale",1954,G__G__TMVA2_489_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - scale", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAdaptiveSpeed",1611,G__G__TMVA2_489_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - speed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOptions",1048,G__G__TMVA2_489_0_9, 121, -1, -1, 0, 10, 1, 1, 0, 
"i - 'Int_t' 0 - maxCalls d - 'Double_t' 0 - initialTemperature "
"d - 'Double_t' 0 - minTemperature d - 'Double_t' 0 - eps "
"u 'TString' - 0 - kernelTemperatureS d - 'Double_t' 0 - temperatureScale "
"d - 'Double_t' 0 - adaptiveSpeed d - 'Double_t' 0 - temperatureAdaptiveStep "
"g - 'Bool_t' 0 - useDefaultScale g - 'Bool_t' 0 - useDefaultTemperature", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillWithRandomValues",2036,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - parameters", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReWriteParameters",1750,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - from u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - to", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenerateNewTemperature",2275,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"d - 'Double_t' 1 - currentTemperature i - 'Int_t' 0 - Iter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenerateNeighbour",1742,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - parameters u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - oldParameters "
"d - 'Double_t' 0 - currentTemperature", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ShouldGoIn",988,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 4, 0, 
"d - 'Double_t' 0 - currentFit d - 'Double_t' 0 - localFit "
"d - 'Double_t' 0 - currentTemperature", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDefaultScale",1497,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenerateMaxTemperature",2271,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - parameters", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GenerateNeighbour",1742,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA2LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<Double_t>"), 0, 2, 1, 4, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - parameters d - 'Double_t' 0 - currentTemperature", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA2_489_0_19, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::SimulatedAnnealing::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_489_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SimulatedAnnealing::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_489_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::SimulatedAnnealing::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_489_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::SimulatedAnnealing::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA2_489_0_23, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA2_489_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__TMVA2_489_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA2_489_0_26, 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__TMVA2_489_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SimulatedAnnealing::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_489_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::SimulatedAnnealing::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_489_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SimulatedAnnealing::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_489_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::SimulatedAnnealing::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("SimulatedAnnealing", 1845, G__G__TMVA2_489_0_31, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLSimulatedAnnealing), -1, 0, 1, 1, 1, 0, "u 'TMVA::SimulatedAnnealing' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~SimulatedAnnealing", 1971, G__G__TMVA2_489_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLQuickMVAProbEstimator(void) {
   /* TMVA::QuickMVAProbEstimator */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLQuickMVAProbEstimator));
   G__memfunc_setup("compare",743,G__G__TMVA2_491_0_1, 103, -1, -1, 0, 2, 3, 1, 0, 
"u 'TMVA::QuickMVAProbEstimator::EventInfo' - 0 - e1 u 'TMVA::QuickMVAProbEstimator::EventInfo' - 0 - e2", (char*)NULL, (void*) G__func2void( (bool (*)(TMVA::QuickMVAProbEstimator::EventInfo, TMVA::QuickMVAProbEstimator::EventInfo))(&TMVA::QuickMVAProbEstimator::compare) ), 0);
   G__memfunc_setup("QuickMVAProbEstimator",2092,G__G__TMVA2_491_0_2, 105, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLQuickMVAProbEstimator), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '40' nMin i - 'Int_t' 0 '5000' nMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddEvent",779,G__G__TMVA2_491_0_3, 121, -1, -1, 0, 3, 1, 1, 0, 
"d - 'Double_t' 0 - val d - 'Double_t' 0 - weight "
"i - 'Int_t' 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMVAProbAt",1100,G__G__TMVA2_491_0_4, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA2_491_0_6, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::QuickMVAProbEstimator::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA2_491_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::QuickMVAProbEstimator::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA2_491_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::QuickMVAProbEstimator::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA2_491_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::QuickMVAProbEstimator::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA2_491_0_10, 85, G__get_linked_tagnum(&G__G__TMVA2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA2_491_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__TMVA2_491_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__TMVA2_491_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__TMVA2_491_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::QuickMVAProbEstimator::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA2_491_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::QuickMVAProbEstimator::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA2_491_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::QuickMVAProbEstimator::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA2_491_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::QuickMVAProbEstimator::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("QuickMVAProbEstimator", 2092, G__G__TMVA2_491_0_18, (int) ('i'), 
G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLQuickMVAProbEstimator), -1, 0, 1, 1, 1, 0, "u 'TMVA::QuickMVAProbEstimator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~QuickMVAProbEstimator", 2218, G__G__TMVA2_491_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__TMVA2_491_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA2LN_TMVAcLcLQuickMVAProbEstimator), -1, 1, 1, 1, 1, 0, "u 'TMVA::QuickMVAProbEstimator' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncG__TMVA2() {
}

/*********************************************************
* 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() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__TMVA2() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
  G__cpp_setup_global3();
  G__cpp_setup_global4();
}

/*********************************************************
* 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() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__TMVA2() {
  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();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__TMVA2LN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_basic_istreamlEcharcOchar_traitslEchargRsPgR = { "basic_istream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_string = { "string" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR = { "basic_stringstream<char,char_traits<char>,allocator<char> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TAttLine = { "TAttLine" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TAttFill = { "TAttFill" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TAttMarker = { "TAttMarker" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TH1 = { "TH1" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TH1F = { "TH1F" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TF1 = { "TF1" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TSpline = { "TSpline" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TGraph = { "TGraph" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVA = { "TMVA" , 110 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLTSpline2 = { "TMVA::TSpline2" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLTSpline1 = { "TMVA::TSpline1" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLMsgLogger = { "TMVA::MsgLogger" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLKDEKernel = { "TMVA::KDEKernel" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLKDEKernelcLcLEKernelType = { "TMVA::KDEKernel::EKernelType" , 101 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLKDEKernelcLcLEKernelIter = { "TMVA::KDEKernel::EKernelIter" , 101 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLKDEKernelcLcLEKernelBorder = { "TMVA::KDEKernel::EKernelBorder" , 101 , -1 };
G__linked_taginfo G__G__TMVA2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLEMsgType = { "TMVA::EMsgType" , 101 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLTypes = { "TMVA::Types" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLTypescLcLEMVA = { "TMVA::Types::EMVA" , 101 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLTypescLcLEAnalysisType = { "TMVA::Types::EAnalysisType" , 101 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLTypescLcLESBType = { "TMVA::Types::ESBType" , 101 , -1 };
G__linked_taginfo G__G__TMVA2LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR = { "map<TString,TMVA::Types::EMVA,less<TString>,allocator<pair<const TString,TMVA::Types::EMVA> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR = { "map<TMVA::EMsgType,string,less<TMVA::EMsgType>,allocator<pair<const TMVA::EMsgType,string> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLConfigurable = { "TMVA::Configurable" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLOptionlEboolgR = { "TMVA::Option<bool>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlEboolcOallocatorlEboolgRsPgR = { "vector<bool,allocator<bool> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<bool,allocator<bool> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLOptionlEboolmUgR = { "TMVA::Option<bool*>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLOptionlEfloatgR = { "TMVA::Option<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlEfloatcOallocatorlEfloatgRsPgR = { "vector<float,allocator<float> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<float,allocator<float> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLPDF = { "TMVA::PDF" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLPDFcLcLEInterpolateMethod = { "TMVA::PDF::EInterpolateMethod" , 101 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLNode = { "TMVA::Node" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLEvent = { "TMVA::Event" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLBinaryTree = { "TMVA::BinaryTree" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLBinarySearchTreeNode = { "TMVA::BinarySearchTreeNode" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLVolume = { "TMVA::Volume" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<double,allocator<double> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TTree = { "TTree" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLBinarySearchTree = { "TMVA::BinarySearchTree" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR = { "vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR = { "vector<TMVA::Event*,allocator<TMVA::Event*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::Event*,allocator<TMVA::Event*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR = { "pair<double,const TMVA::Event*>" , 115 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR = { "vector<pair<double,const TMVA::Event*>,allocator<pair<double,const TMVA::Event*> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiterator = { "vector<pair<double,const TMVA::Event*>,allocator<pair<double,const TMVA::Event*> > >::iterator" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<double,const TMVA::Event*>,allocator<pair<double,const TMVA::Event*> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TStopwatch = { "TStopwatch" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLTimer = { "TMVA::Timer" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLRootFinder = { "TMVA::RootFinder" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLSeparationBase = { "TMVA::SeparationBase" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLCrossEntropy = { "TMVA::CrossEntropy" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TH2 = { "TH2" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TH2F = { "TH2F" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLDTNodeTrainingInfo = { "TMVA::DTNodeTrainingInfo" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLDecisionTreeNode = { "TMVA::DecisionTreeNode" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLRegressionVariance = { "TMVA::RegressionVariance" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR = { "map<string,TObjArray*,less<string>,allocator<pair<const string,TObjArray*> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMatrixTlEdoublegR = { "TMatrixT<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR = { "vector<float*,allocator<float*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<float*,allocator<float*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLVariableTransformBase = { "TMVA::VariableTransformBase" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLDataSetManager = { "TMVA::DataSetManager" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLDataSetInfo = { "TMVA::DataSetInfo" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR = { "vector<TMVA::VariableInfo,allocator<TMVA::VariableInfo> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::VariableInfo,allocator<TMVA::VariableInfo> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR = { "vector<TMVA::ClassInfo*,allocator<TMVA::ClassInfo*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::ClassInfo*,allocator<TMVA::ClassInfo*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TRandom3 = { "TRandom3" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLDecisionTree = { "TMVA::DecisionTree" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR = { "vector<const TMVA::Event*,allocator<const TMVA::Event*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const TMVA::Event*,allocator<const TMVA::Event*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLDecisionTreecLcLEPruneMethod = { "TMVA::DecisionTree::EPruneMethod" , 101 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLMisClassificationError = { "TMVA::MisClassificationError" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLSdivSqrtSplusB = { "TMVA::SdivSqrtSplusB" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TXMLEngine = { "TXMLEngine" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMatrixTSymlEdoublegR = { "TMatrixTSym<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_pairlEcharcOunsignedsPintgR = { "pair<char,unsigned int>" , 115 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgR = { "vector<pair<char,unsigned int>,allocator<pair<char,unsigned int> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<char,unsigned int>,allocator<pair<char,unsigned int> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlEcharcOallocatorlEchargRsPgR = { "vector<char,allocator<char> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR = { "reverse_iterator<vector<char,allocator<char> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLTools = { "TMVA::Tools" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgR = { "vector<TMatrixTSym<double>*,allocator<TMatrixTSym<double>*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMatrixTSym<double>*,allocator<TMatrixTSym<double>*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR = { "vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLToolscLcLEWelcomeMessage = { "TMVA::Tools::EWelcomeMessage" , 101 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLToolscLcLECitation = { "TMVA::Tools::ECitation" , 101 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLDataInputHandler = { "TMVA::DataInputHandler" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgR = { "vector<TMVA::TreeInfo,allocator<TMVA::TreeInfo> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::TreeInfo,allocator<TMVA::TreeInfo> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_maplETStringcOvectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgRcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOvectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgRsPgRsPgRsPgR = { "map<TString,vector<TMVA::TreeInfo,allocator<TMVA::TreeInfo> >,less<TString>,allocator<pair<const TString,vector<TMVA::TreeInfo,allocator<TMVA::TreeInfo> > > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_maplEstringcOboolcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOboolgRsPgRsPgR = { "map<string,bool,less<string>,allocator<pair<const string,bool> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLIMethod = { "TMVA::IMethod" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLMethodBase = { "TMVA::MethodBase" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLMethodCuts = { "TMVA::MethodCuts" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLReader = { "TMVA::Reader" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlEstringcOallocatorlEstringgRsPgR = { "vector<string,allocator<string> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<string,allocator<string> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_maplETStringcOTMVAcLcLIMethodmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIMethodmUgRsPgRsPgR = { "map<TString,TMVA::IMethod*,less<TString>,allocator<pair<const TString,TMVA::IMethod*> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLIFitterTarget = { "TMVA::IFitterTarget" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLGeneticGenes = { "TMVA::GeneticGenes" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLInterval = { "TMVA::Interval" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLGeneticRange = { "TMVA::GeneticRange" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLGeneticPopulation = { "TMVA::GeneticPopulation" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR = { "vector<TMVA::Interval*,allocator<TMVA::Interval*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::Interval*,allocator<TMVA::Interval*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlETMVAcLcLGeneticGenescOallocatorlETMVAcLcLGeneticGenesgRsPgR = { "vector<TMVA::GeneticGenes,allocator<TMVA::GeneticGenes> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLGeneticGenescOallocatorlETMVAcLcLGeneticGenesgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::GeneticGenes,allocator<TMVA::GeneticGenes> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlETMVAcLcLGeneticRangemUcOallocatorlETMVAcLcLGeneticRangemUgRsPgR = { "vector<TMVA::GeneticRange*,allocator<TMVA::GeneticRange*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLGeneticRangemUcOallocatorlETMVAcLcLGeneticRangemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::GeneticRange*,allocator<TMVA::GeneticRange*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLGeneticAlgorithm = { "TMVA::GeneticAlgorithm" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_dequelEintcOallocatorlEintgRsPgR = { "deque<int,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLGiniIndex = { "TMVA::GiniIndex" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLGiniIndexWithLaplace = { "TMVA::GiniIndexWithLaplace" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TRandom = { "TRandom" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLSimulatedAnnealing = { "TMVA::SimulatedAnnealing" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLSimulatedAnnealingcLcLEKernelTemperature = { "TMVA::SimulatedAnnealing::EKernelTemperature" , 101 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLQuickMVAProbEstimator = { "TMVA::QuickMVAProbEstimator" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_TMVAcLcLQuickMVAProbEstimatorcLcLEventInfo = { "TMVA::QuickMVAProbEstimator::EventInfo" , 115 , -1 };
G__linked_taginfo G__G__TMVA2LN_vectorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfocOallocatorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfogRsPgR = { "vector<TMVA::QuickMVAProbEstimator::EventInfo,allocator<TMVA::QuickMVAProbEstimator::EventInfo> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfocOallocatorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfogRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::QuickMVAProbEstimator::EventInfo,allocator<TMVA::QuickMVAProbEstimator::EventInfo> >::iterator>" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__TMVA2() {
  G__G__TMVA2LN_TClass.tagnum = -1 ;
  G__G__TMVA2LN_TBuffer.tagnum = -1 ;
  G__G__TMVA2LN_TMemberInspector.tagnum = -1 ;
  G__G__TMVA2LN_TObject.tagnum = -1 ;
  G__G__TMVA2LN_TNamed.tagnum = -1 ;
  G__G__TMVA2LN_TString.tagnum = -1 ;
  G__G__TMVA2LN_basic_istreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_string.tagnum = -1 ;
  G__G__TMVA2LN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_TList.tagnum = -1 ;
  G__G__TMVA2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_TAttLine.tagnum = -1 ;
  G__G__TMVA2LN_TAttFill.tagnum = -1 ;
  G__G__TMVA2LN_TAttMarker.tagnum = -1 ;
  G__G__TMVA2LN_TVectorTlEfloatgR.tagnum = -1 ;
  G__G__TMVA2LN_TVectorTlEdoublegR.tagnum = -1 ;
  G__G__TMVA2LN_TH1.tagnum = -1 ;
  G__G__TMVA2LN_TH1F.tagnum = -1 ;
  G__G__TMVA2LN_TF1.tagnum = -1 ;
  G__G__TMVA2LN_TSpline.tagnum = -1 ;
  G__G__TMVA2LN_TGraph.tagnum = -1 ;
  G__G__TMVA2LN_TMVA.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLTSpline2.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLTSpline1.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLMsgLogger.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLKDEKernel.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLKDEKernelcLcLEKernelType.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLKDEKernelcLcLEKernelIter.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLKDEKernelcLcLEKernelBorder.tagnum = -1 ;
  G__G__TMVA2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLEMsgType.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLTypes.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLTypescLcLEMVA.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLTypescLcLEAnalysisType.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLTypescLcLESBType.tagnum = -1 ;
  G__G__TMVA2LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLConfigurable.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLOptionlEboolgR.tagnum = -1 ;
  G__G__TMVA2LN_vectorlEboolcOallocatorlEboolgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLOptionlEboolmUgR.tagnum = -1 ;
  G__G__TMVA2LN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLOptionlEfloatgR.tagnum = -1 ;
  G__G__TMVA2LN_vectorlEfloatcOallocatorlEfloatgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLPDF.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLPDFcLcLEInterpolateMethod.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLNode.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLEvent.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLBinaryTree.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLBinarySearchTreeNode.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLVolume.tagnum = -1 ;
  G__G__TMVA2LN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_TTree.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLBinarySearchTree.tagnum = -1 ;
  G__G__TMVA2LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR.tagnum = -1 ;
  G__G__TMVA2LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_TStopwatch.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLTimer.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLRootFinder.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLSeparationBase.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLCrossEntropy.tagnum = -1 ;
  G__G__TMVA2LN_TMatrixTBaselEfloatgR.tagnum = -1 ;
  G__G__TMVA2LN_TMatrixTBaselEdoublegR.tagnum = -1 ;
  G__G__TMVA2LN_TH2.tagnum = -1 ;
  G__G__TMVA2LN_TH2F.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLDTNodeTrainingInfo.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLDecisionTreeNode.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLRegressionVariance.tagnum = -1 ;
  G__G__TMVA2LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_TMatrixTlEdoublegR.tagnum = -1 ;
  G__G__TMVA2LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLVariableTransformBase.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLDataSetManager.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLDataSetInfo.tagnum = -1 ;
  G__G__TMVA2LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_TRandom3.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLDecisionTree.tagnum = -1 ;
  G__G__TMVA2LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLDecisionTreecLcLEPruneMethod.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLMisClassificationError.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLSdivSqrtSplusB.tagnum = -1 ;
  G__G__TMVA2LN_TXMLEngine.tagnum = -1 ;
  G__G__TMVA2LN_TMatrixTSymlEdoublegR.tagnum = -1 ;
  G__G__TMVA2LN_pairlEcharcOunsignedsPintgR.tagnum = -1 ;
  G__G__TMVA2LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_vectorlEcharcOallocatorlEchargRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLTools.tagnum = -1 ;
  G__G__TMVA2LN_vectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLToolscLcLEWelcomeMessage.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLToolscLcLECitation.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLDataInputHandler.tagnum = -1 ;
  G__G__TMVA2LN_vectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_maplETStringcOvectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgRcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOvectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_maplEstringcOboolcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOboolgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLIMethod.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLMethodBase.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLMethodCuts.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLReader.tagnum = -1 ;
  G__G__TMVA2LN_vectorlEstringcOallocatorlEstringgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_maplETStringcOTMVAcLcLIMethodmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIMethodmUgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLIFitterTarget.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLGeneticGenes.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLInterval.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLGeneticRange.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLGeneticPopulation.tagnum = -1 ;
  G__G__TMVA2LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_vectorlETMVAcLcLGeneticGenescOallocatorlETMVAcLcLGeneticGenesgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLGeneticGenescOallocatorlETMVAcLcLGeneticGenesgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_vectorlETMVAcLcLGeneticRangemUcOallocatorlETMVAcLcLGeneticRangemUgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLGeneticRangemUcOallocatorlETMVAcLcLGeneticRangemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLGeneticAlgorithm.tagnum = -1 ;
  G__G__TMVA2LN_dequelEintcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLGiniIndex.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLGiniIndexWithLaplace.tagnum = -1 ;
  G__G__TMVA2LN_TRandom.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLSimulatedAnnealing.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLSimulatedAnnealingcLcLEKernelTemperature.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLQuickMVAProbEstimator.tagnum = -1 ;
  G__G__TMVA2LN_TMVAcLcLQuickMVAProbEstimatorcLcLEventInfo.tagnum = -1 ;
  G__G__TMVA2LN_vectorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfocOallocatorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfogRsPgR.tagnum = -1 ;
  G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfocOallocatorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfogRsPgRcLcLiteratorgR.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__TMVA2() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TClass);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TObject);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TNamed);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TString);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_basic_istreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_string);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_basic_stringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TList);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TAttLine);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TAttFill);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TAttMarker);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TVectorTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TVectorTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TH1);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TH1F);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TF1);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TSpline);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TGraph);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVA),0,-1,0,(char*)NULL,G__setup_memvarTMVA,G__setup_memfuncTMVA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLTSpline2),sizeof(TMVA::TSpline2),-1,324608,"Quadratic interpolation class (using quadrax)",G__setup_memvarTMVAcLcLTSpline2,G__setup_memfuncTMVAcLcLTSpline2);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLTSpline1),sizeof(TMVA::TSpline1),-1,324608,"Linear interpolation class",G__setup_memvarTMVAcLcLTSpline1,G__setup_memfuncTMVAcLcLTSpline1);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLMsgLogger);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLKDEKernel);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLKDEKernelcLcLEKernelType);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLKDEKernelcLcLEKernelIter);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLKDEKernelcLcLEKernelBorder);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLEMsgType);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLTypes);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLTypescLcLEMVA);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLTypescLcLEAnalysisType);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLTypescLcLESBType);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLConfigurable);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLOptionlEboolgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlEboolcOallocatorlEboolgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLOptionlEboolmUgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlETStringcOallocatorlETStringgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLOptionlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlEfloatcOallocatorlEfloatgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLPDF),sizeof(TMVA::PDF),-1,324608,"PDF wrapper for histograms",G__setup_memvarTMVAcLcLPDF,G__setup_memfuncTMVAcLcLPDF);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLPDFcLcLEInterpolateMethod);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLNode),sizeof(TMVA::Node),-1,296714,"Node for the BinarySearch or Decision Trees",G__setup_memvarTMVAcLcLNode,G__setup_memfuncTMVAcLcLNode);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLEvent);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLBinaryTree),sizeof(TMVA::BinaryTree),-1,263427,"Base class for BinarySearch and Decision Trees",G__setup_memvarTMVAcLcLBinaryTree,G__setup_memfuncTMVAcLcLBinaryTree);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLBinarySearchTreeNode),sizeof(TMVA::BinarySearchTreeNode),-1,296704,"Node for the BinarySearchTree",G__setup_memvarTMVAcLcLBinarySearchTreeNode,G__setup_memfuncTMVAcLcLBinarySearchTreeNode);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLVolume);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlEdoublecOallocatorlEdoublegRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TTree);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLBinarySearchTree),sizeof(TMVA::BinarySearchTree),-1,263936,"Binary search tree including volume search method  ",G__setup_memvarTMVAcLcLBinarySearchTree,G__setup_memfuncTMVAcLcLBinarySearchTree);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlEintcOallocatorlEintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TStopwatch);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLTimer),sizeof(TMVA::Timer),-1,324864,"Timing information for training and evaluation of MVA methods",G__setup_memvarTMVAcLcLTimer,G__setup_memfuncTMVAcLcLTimer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLRootFinder),sizeof(TMVA::RootFinder),-1,324608,"Root finding using Brents algorithm",G__setup_memvarTMVAcLcLRootFinder,G__setup_memfuncTMVAcLcLRootFinder);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLSeparationBase),sizeof(TMVA::SeparationBase),-1,263937,"Interface to different separation critiera used in training algorithms",G__setup_memvarTMVAcLcLSeparationBase,G__setup_memfuncTMVAcLcLSeparationBase);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLCrossEntropy),sizeof(TMVA::CrossEntropy),-1,263936,"Implementation of the CrossEntropy as separation criterion",G__setup_memvarTMVAcLcLCrossEntropy,G__setup_memfuncTMVAcLcLCrossEntropy);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMatrixTBaselEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMatrixTBaselEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TH2);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TH2F);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLDTNodeTrainingInfo);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLDecisionTreeNode),sizeof(TMVA::DecisionTreeNode),-1,296704,"Node for the Decision Tree ",G__setup_memvarTMVAcLcLDecisionTreeNode,G__setup_memfuncTMVAcLcLDecisionTreeNode);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLRegressionVariance),sizeof(TMVA::RegressionVariance),-1,263936,"Interface to different separation critiera used in training algorithms",G__setup_memvarTMVAcLcLRegressionVariance,G__setup_memfuncTMVAcLcLRegressionVariance);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMatrixTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLVariableTransformBase);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLDataSetManager);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLDataSetInfo);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TRandom3);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLDecisionTree),sizeof(TMVA::DecisionTree),-1,296704,"implementation of a Decision Tree",G__setup_memvarTMVAcLcLDecisionTree,G__setup_memfuncTMVAcLcLDecisionTree);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLDecisionTreecLcLEPruneMethod);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLMisClassificationError),sizeof(TMVA::MisClassificationError),-1,263936,"Implementation of the MisClassificationError as separation criterion",G__setup_memvarTMVAcLcLMisClassificationError,G__setup_memfuncTMVAcLcLMisClassificationError);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLSdivSqrtSplusB),sizeof(TMVA::SdivSqrtSplusB),-1,263936,"Implementation of the SdivSqrtSplusB as separation criterion",G__setup_memvarTMVAcLcLSdivSqrtSplusB,G__setup_memfuncTMVAcLcLSdivSqrtSplusB);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TXMLEngine);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMatrixTSymlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_pairlEcharcOunsignedsPintgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlEcharcOallocatorlEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLTools),sizeof(TMVA::Tools),-1,263424,(char*)NULL,G__setup_memvarTMVAcLcLTools,G__setup_memfuncTMVAcLcLTools);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLToolscLcLEWelcomeMessage);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLToolscLcLECitation);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLDataInputHandler);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_maplETStringcOvectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgRcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOvectorlETMVAcLcLTreeInfocOallocatorlETMVAcLcLTreeInfogRsPgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_maplEstringcOboolcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOboolgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLIMethod);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLMethodBase);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLMethodCuts);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLReader),sizeof(TMVA::Reader),-1,324864,"Interpret the trained MVAs in an analysis context",G__setup_memvarTMVAcLcLReader,G__setup_memfuncTMVAcLcLReader);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlEstringcOallocatorlEstringgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_maplETStringcOTMVAcLcLIMethodmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIMethodmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLIFitterTarget);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLGeneticGenes),sizeof(TMVA::GeneticGenes),-1,296192,"Genes definition for genetic algorithm",G__setup_memvarTMVAcLcLGeneticGenes,G__setup_memfuncTMVAcLcLGeneticGenes);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLInterval);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLGeneticRange),sizeof(TMVA::GeneticRange),-1,295936,"Range definition for genetic algorithm",G__setup_memvarTMVAcLcLGeneticRange,G__setup_memfuncTMVAcLcLGeneticRange);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLGeneticPopulation),sizeof(TMVA::GeneticPopulation),-1,295936,"Population definition for genetic algorithm",G__setup_memvarTMVAcLcLGeneticPopulation,G__setup_memfuncTMVAcLcLGeneticPopulation);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlETMVAcLcLGeneticGenescOallocatorlETMVAcLcLGeneticGenesgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLGeneticGenescOallocatorlETMVAcLcLGeneticGenesgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlETMVAcLcLGeneticRangemUcOallocatorlETMVAcLcLGeneticRangemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLGeneticRangemUcOallocatorlETMVAcLcLGeneticRangemUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLGeneticAlgorithm),sizeof(TMVA::GeneticAlgorithm),-1,295936,"Genetic algorithm controller",G__setup_memvarTMVAcLcLGeneticAlgorithm,G__setup_memfuncTMVAcLcLGeneticAlgorithm);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_dequelEintcOallocatorlEintgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLGiniIndex),sizeof(TMVA::GiniIndex),-1,263936,"Implementation of the GiniIndex as separation criterion",G__setup_memvarTMVAcLcLGiniIndex,G__setup_memfuncTMVAcLcLGiniIndex);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLGiniIndexWithLaplace),sizeof(TMVA::GiniIndexWithLaplace),-1,263936,"Implementation of the GiniIndexWithLaplace as separation criterion",G__setup_memvarTMVAcLcLGiniIndexWithLaplace,G__setup_memfuncTMVAcLcLGiniIndexWithLaplace);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TRandom);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLSimulatedAnnealing),sizeof(TMVA::SimulatedAnnealing),-1,295936,"Base class for Simulated Annealing fitting",G__setup_memvarTMVAcLcLSimulatedAnnealing,G__setup_memfuncTMVAcLcLSimulatedAnnealing);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLSimulatedAnnealingcLcLEKernelTemperature);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLQuickMVAProbEstimator),sizeof(TMVA::QuickMVAProbEstimator),-1,263424,"Interface to different separation critiera used in training algorithms",G__setup_memvarTMVAcLcLQuickMVAProbEstimator,G__setup_memfuncTMVAcLcLQuickMVAProbEstimator);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_TMVAcLcLQuickMVAProbEstimatorcLcLEventInfo);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_vectorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfocOallocatorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfogRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA2LN_reverse_iteratorlEvectorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfocOallocatorlETMVAcLcLQuickMVAProbEstimatorcLcLEventInfogRsPgRcLcLiteratorgR);
}
extern "C" void G__cpp_setupG__TMVA2(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__TMVA2()");
  G__set_cpp_environmentG__TMVA2();
  G__cpp_setup_tagtableG__TMVA2();

  G__cpp_setup_inheritanceG__TMVA2();

  G__cpp_setup_typetableG__TMVA2();

  G__cpp_setup_memvarG__TMVA2();

  G__cpp_setup_memfuncG__TMVA2();
  G__cpp_setup_globalG__TMVA2();
  G__cpp_setup_funcG__TMVA2();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__TMVA2();
  return;
}
class G__cpp_setup_initG__TMVA2 {
  public:
    G__cpp_setup_initG__TMVA2() { G__add_setup_func("G__TMVA2",(G__incsetup)(&G__cpp_setupG__TMVA2)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__TMVA2() { G__remove_setup_func("G__TMVA2"); }
};
G__cpp_setup_initG__TMVA2 G__cpp_setup_initializerG__TMVA2;