//
// File generated by ../bin/rootcint_tmp at Sat Jun 30 18:04:40 2018

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

#define R__DICTIONARY_FILENAME G__TMVA1
#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__TMVA1.h"

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

#ifndef G__ROOT
#define G__ROOT
#endif

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

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

// START OF SHADOWS

namespace ROOTShadow {
   namespace Shadow {
      namespace TMVA {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMVA::Event Event;
      #else
      class Event  {
         public:
         //friend XX;
         vector< Float_t > fValues; //the event values ; mutable, to be able to copy the dynamic values in there
         vector< Float_t > fValuesRearranged; //the event values ; mutable, to be able to copy the dynamic values in there
         vector< Float_t* >* fValuesDynamic; //the event values
         vector< Float_t > fTargets; //target values for regression
         vector< Float_t > fSpectators; //"visisting" variables not used in MVAs ; mutable, to be able to copy the dynamic values in there
         vector< UInt_t >* fVariableArrangement; //needed for MethodCategories, where we can train on other than the main variables
         unsigned int fClass; //class number
         double fWeight; //event weight (product of global and individual weights)
         double fBoostWeight; //internal weight to be set by boosting algorithm
         bool fDynamic; //is set when the dynamic values are taken
         bool fDoNotBoost; //mark event as not to be boosted (used to compensate for events with negative event weights
      };
      #endif
      } 
      namespace TMVA {
         namespace kNN {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMVA::kNN::Event Event;
      #else
      class Event  {
         public:
         //friend XX;
         ::TMVA::kNN::VarVec fVar; //coordinates (variables) for knn search
         ::TMVA::kNN::VarVec fTgt; //targets for regression analysis
         double fWeight; //event weight
         short fType; //event type ==0 or == 1, expand it to arbitrary class types? 
      };
      #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-v3.2.1/third_party/source/root_v5.34.36/tmva/inc/TMVA/MethodCategory.h", 53,
                     ::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 TMVAcLcLConfigurable_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLConfigurable(void *p = 0);
   static void *newArray_TMVAcLcLConfigurable(Long_t size, void *p);
   static void delete_TMVAcLcLConfigurable(void *p);
   static void deleteArray_TMVAcLcLConfigurable(void *p);
   static void destruct_TMVAcLcLConfigurable(void *p);

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

namespace ROOTDict {
   void TMVAcLcLEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMVAcLcLEvent_Dictionary();
   static void *new_TMVAcLcLEvent(void *p = 0);
   static void *newArray_TMVAcLcLEvent(Long_t size, void *p);
   static void delete_TMVAcLcLEvent(void *p);
   static void deleteArray_TMVAcLcLEvent(void *p);
   static void destruct_TMVAcLcLEvent(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::Event*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMVA::Event) == sizeof( ::ROOTShadow::Shadow::TMVA::Event));
      ::TMVA::Event *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TMVA::Event),0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::Event", "/home/mice/Grid/MAUS-v3.2.1/third_party/source/root_v5.34.36/tmva/inc/TMVA/Event.h", 52,
                  typeid(::TMVA::Event), ::ROOT::DefineBehavior(ptr, ptr),
                  &TMVAcLcLEvent_ShowMembers, &TMVAcLcLEvent_Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::Event) );
      instance.SetNew(&new_TMVAcLcLEvent);
      instance.SetNewArray(&newArray_TMVAcLcLEvent);
      instance.SetDelete(&delete_TMVAcLcLEvent);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLEvent);
      instance.SetDestructor(&destruct_TMVAcLcLEvent);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::Event*)
   {
      return GenerateInitInstanceLocal((::TMVA::Event*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::Event*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLMethodBase_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodBase(void *p);
   static void deleteArray_TMVAcLcLMethodBase(void *p);
   static void destruct_TMVAcLcLMethodBase(void *p);

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

namespace ROOTDict {
   void TMVAcLcLFactory_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLFactory(void *p);
   static void deleteArray_TMVAcLcLFactory(void *p);
   static void destruct_TMVAcLcLFactory(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodBoost_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodBoost(void *p);
   static void deleteArray_TMVAcLcLMethodBoost(void *p);
   static void destruct_TMVAcLcLMethodBoost(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodCuts_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodCuts(void *p);
   static void deleteArray_TMVAcLcLMethodCuts(void *p);
   static void destruct_TMVAcLcLMethodCuts(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodCompositeBase_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodCompositeBase(void *p);
   static void deleteArray_TMVAcLcLMethodCompositeBase(void *p);
   static void destruct_TMVAcLcLMethodCompositeBase(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodANNBase_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodANNBase(void *p);
   static void deleteArray_TMVAcLcLMethodANNBase(void *p);
   static void destruct_TMVAcLcLMethodANNBase(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodTMlpANN_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodTMlpANN(void *p);
   static void deleteArray_TMVAcLcLMethodTMlpANN(void *p);
   static void destruct_TMVAcLcLMethodTMlpANN(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodRuleFit_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodRuleFit(void *p);
   static void deleteArray_TMVAcLcLMethodRuleFit(void *p);
   static void destruct_TMVAcLcLMethodRuleFit(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodFisher_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodFisher(void *p);
   static void deleteArray_TMVAcLcLMethodFisher(void *p);
   static void destruct_TMVAcLcLMethodFisher(void *p);

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

namespace ROOTDict {
   void TMVAcLcLkNNcLcLEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMVAcLcLkNNcLcLEvent_Dictionary();
   static void *new_TMVAcLcLkNNcLcLEvent(void *p = 0);
   static void *newArray_TMVAcLcLkNNcLcLEvent(Long_t size, void *p);
   static void delete_TMVAcLcLkNNcLcLEvent(void *p);
   static void deleteArray_TMVAcLcLkNNcLcLEvent(void *p);
   static void destruct_TMVAcLcLkNNcLcLEvent(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::kNN::Event*)
   {
      // Make sure the shadow class has the right sizeof
      R__ASSERT(sizeof(::TMVA::kNN::Event) == sizeof( ::ROOTShadow::Shadow::TMVA::kNN::Event));
      ::TMVA::kNN::Event *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TMVA::kNN::Event),0);
      static ::ROOT::TGenericClassInfo 
         instance("TMVA::kNN::Event", "/home/mice/Grid/MAUS-v3.2.1/third_party/source/root_v5.34.36/tmva/inc/TMVA/ModulekNN.h", 65,
                  typeid(::TMVA::kNN::Event), ::ROOT::DefineBehavior(ptr, ptr),
                  &TMVAcLcLkNNcLcLEvent_ShowMembers, &TMVAcLcLkNNcLcLEvent_Dictionary, isa_proxy, 4,
                  sizeof(::TMVA::kNN::Event) );
      instance.SetNew(&new_TMVAcLcLkNNcLcLEvent);
      instance.SetNewArray(&newArray_TMVAcLcLkNNcLcLEvent);
      instance.SetDelete(&delete_TMVAcLcLkNNcLcLEvent);
      instance.SetDeleteArray(&deleteArray_TMVAcLcLkNNcLcLEvent);
      instance.SetDestructor(&destruct_TMVAcLcLkNNcLcLEvent);
      return &instance;
   }
   ROOT::TGenericClassInfo *GenerateInitInstance(const ::TMVA::kNN::Event*)
   {
      return GenerateInitInstanceLocal((::TMVA::kNN::Event*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::kNN::Event*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLMethodKNN_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodKNN(void *p);
   static void deleteArray_TMVAcLcLMethodKNN(void *p);
   static void destruct_TMVAcLcLMethodKNN(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodCFMlpANN_Utils_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodCFMlpANN_Utils(void *p);
   static void deleteArray_TMVAcLcLMethodCFMlpANN_Utils(void *p);
   static void destruct_TMVAcLcLMethodCFMlpANN_Utils(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodCFMlpANN_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodCFMlpANN(void *p);
   static void deleteArray_TMVAcLcLMethodCFMlpANN(void *p);
   static void destruct_TMVAcLcLMethodCFMlpANN(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodLikelihood_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodLikelihood(void *p);
   static void deleteArray_TMVAcLcLMethodLikelihood(void *p);
   static void destruct_TMVAcLcLMethodLikelihood(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodHMatrix_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodHMatrix(void *p);
   static void deleteArray_TMVAcLcLMethodHMatrix(void *p);
   static void destruct_TMVAcLcLMethodHMatrix(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodPDERS_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodPDERS(void *p);
   static void deleteArray_TMVAcLcLMethodPDERS(void *p);
   static void destruct_TMVAcLcLMethodPDERS(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodBDT_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodBDT(void *p);
   static void deleteArray_TMVAcLcLMethodBDT(void *p);
   static void destruct_TMVAcLcLMethodBDT(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodDT_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodDT(void *p);
   static void deleteArray_TMVAcLcLMethodDT(void *p);
   static void destruct_TMVAcLcLMethodDT(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodSVM_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodSVM(void *p);
   static void deleteArray_TMVAcLcLMethodSVM(void *p);
   static void destruct_TMVAcLcLMethodSVM(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodBayesClassifier_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodBayesClassifier(void *p);
   static void deleteArray_TMVAcLcLMethodBayesClassifier(void *p);
   static void destruct_TMVAcLcLMethodBayesClassifier(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodFDA_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodFDA(void *p);
   static void deleteArray_TMVAcLcLMethodFDA(void *p);
   static void destruct_TMVAcLcLMethodFDA(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodMLP_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodMLP(void *p);
   static void deleteArray_TMVAcLcLMethodMLP(void *p);
   static void destruct_TMVAcLcLMethodMLP(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodPDEFoam_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodPDEFoam(void *p);
   static void deleteArray_TMVAcLcLMethodPDEFoam(void *p);
   static void destruct_TMVAcLcLMethodPDEFoam(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodLD_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodLD(void *p);
   static void deleteArray_TMVAcLcLMethodLD(void *p);
   static void destruct_TMVAcLcLMethodLD(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMethodCategory_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLMethodCategory(void *p);
   static void deleteArray_TMVAcLcLMethodCategory(void *p);
   static void destruct_TMVAcLcLMethodCategory(void *p);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void Configurable::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::Configurable.
      TClass *R__cl = ::TMVA::Configurable::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptions", &fOptions);
      R__insp.InspectMember(fOptions, "fOptions.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLooseOptionCheckingEnabled", &fLooseOptionCheckingEnabled);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLastDeclaredOption", &fLastDeclaredOption);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fListOfOptions", &fListOfOptions);
      R__insp.InspectMember(fListOfOptions, "fListOfOptions.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConfigName", &fConfigName);
      R__insp.InspectMember(fConfigName, "fConfigName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConfigDescription", &fConfigDescription);
      R__insp.InspectMember(fConfigDescription, "fConfigDescription.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReferenceFile", &fReferenceFile);
      R__insp.InspectMember(fReferenceFile, "fReferenceFile.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
      TObject::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLConfigurable(void *p) {
      return  p ? new(p) ::TMVA::Configurable : new ::TMVA::Configurable;
   }
   static void *newArray_TMVAcLcLConfigurable(Long_t nElements, void *p) {
      return p ? new(p) ::TMVA::Configurable[nElements] : new ::TMVA::Configurable[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLConfigurable(void *p) {
      delete ((::TMVA::Configurable*)p);
   }
   static void deleteArray_TMVAcLcLConfigurable(void *p) {
      delete [] ((::TMVA::Configurable*)p);
   }
   static void destruct_TMVAcLcLConfigurable(void *p) {
      typedef ::TMVA::Configurable current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::Configurable

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

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::Event*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValues", (void*)&sobj->fValues);
      R__insp.InspectMember("vector<Float_t>", (void*)&sobj->fValues, "fValues.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValuesRearranged", (void*)&sobj->fValuesRearranged);
      R__insp.InspectMember("vector<Float_t>", (void*)&sobj->fValuesRearranged, "fValuesRearranged.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fValuesDynamic", &sobj->fValuesDynamic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTargets", (void*)&sobj->fTargets);
      R__insp.InspectMember("vector<Float_t>", (void*)&sobj->fTargets, "fTargets.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSpectators", (void*)&sobj->fSpectators);
      R__insp.InspectMember("vector<Float_t>", (void*)&sobj->fSpectators, "fSpectators.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVariableArrangement", &sobj->fVariableArrangement);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fClass", &sobj->fClass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWeight", &sobj->fWeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoostWeight", &sobj->fBoostWeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDynamic", &sobj->fDynamic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDoNotBoost", &sobj->fDoNotBoost);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLEvent(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::Event : new ::TMVA::Event;
   }
   static void *newArray_TMVAcLcLEvent(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::Event[nElements] : new ::TMVA::Event[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLEvent(void *p) {
      delete ((::TMVA::Event*)p);
   }
   static void deleteArray_TMVAcLcLEvent(void *p) {
      delete [] ((::TMVA::Event*)p);
   }
   static void destruct_TMVAcLcLEvent(void *p) {
      typedef ::TMVA::Event current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::Event

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

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::kNN::Event*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVar", (void*)&sobj->fVar);
      R__insp.InspectMember("TMVA::kNN::VarVec", (void*)&sobj->fVar, "fVar.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTgt", (void*)&sobj->fTgt);
      R__insp.InspectMember("TMVA::kNN::VarVec", (void*)&sobj->fTgt, "fTgt.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWeight", &sobj->fWeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &sobj->fType);
   }

}

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLkNNcLcLEvent(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::kNN::Event : new ::TMVA::kNN::Event;
   }
   static void *newArray_TMVAcLcLkNNcLcLEvent(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::kNN::Event[nElements] : new ::TMVA::kNN::Event[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLkNNcLcLEvent(void *p) {
      delete ((::TMVA::kNN::Event*)p);
   }
   static void deleteArray_TMVAcLcLkNNcLcLEvent(void *p) {
      delete [] ((::TMVA::kNN::Event*)p);
   }
   static void destruct_TMVAcLcLkNNcLcLEvent(void *p) {
      typedef ::TMVA::kNN::Event current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::kNN::Event

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void Factory::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::Factory.
      TClass *R__cl = ::TMVA::Factory::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(), "*fDataInputHandler", &fDataInputHandler);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDefaultTrfs", (void*)&fDefaultTrfs);
      R__insp.InspectMember("vector<TMVA::VariableTransformBase*>", (void*)&fDefaultTrfs, "fDefaultTrfs.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptions", &fOptions);
      R__insp.InspectMember(fOptions, "fOptions.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTransformations", &fTransformations);
      R__insp.InspectMember(fTransformations, "fTransformations.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVerbose", &fVerbose);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMethods", (void*)&fMethods);
      R__insp.InspectMember("TMVA::Factory::MVector", (void*)&fMethods, "fMethods.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fJobName", &fJobName);
      R__insp.InspectMember(fJobName, "fJobName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataAssignType", &fDataAssignType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrainAssignTree", (void*)&fTrainAssignTree);
      R__insp.InspectMember("vector<TTree*>", (void*)&fTrainAssignTree, "fTrainAssignTree.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestAssignTree", (void*)&fTestAssignTree);
      R__insp.InspectMember("vector<TTree*>", (void*)&fTestAssignTree, "fTestAssignTree.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fATreeType", &fATreeType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fATreeWeight", &fATreeWeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fATreeEvent", &fATreeEvent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAnalysisType", &fAnalysisType);
      //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_TMVAcLcLFactory(void *p) {
      delete ((::TMVA::Factory*)p);
   }
   static void deleteArray_TMVAcLcLFactory(void *p) {
      delete [] ((::TMVA::Factory*)p);
   }
   static void destruct_TMVAcLcLFactory(void *p) {
      typedef ::TMVA::Factory current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::Factory

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MethodBase::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MethodBase.
      TClass *R__cl = ::TMVA::MethodBase::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTmpEvent", &fTmpEvent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRanking", &fRanking);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInputVars", &fInputVars);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbins", &fNbins);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbinsMVAoutput", &fNbinsMVAoutput);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbinsH", &fNbinsH);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAnalysisType", &fAnalysisType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRegressionReturnVal", &fRegressionReturnVal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMulticlassReturnVal", &fMulticlassReturnVal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDisableWriting", &fDisableWriting);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSignalReferenceCut", &fSignalReferenceCut);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSignalReferenceCutOrientation", &fSignalReferenceCutOrientation);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVariableTransformType", &fVariableTransformType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fJobName", &fJobName);
      R__insp.InspectMember(fJobName, "fJobName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMethodName", &fMethodName);
      R__insp.InspectMember(fMethodName, "fMethodName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMethodType", &fMethodType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestvar", &fTestvar);
      R__insp.InspectMember(fTestvar, "fTestvar.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTMVATrainingVersion", &fTMVATrainingVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fROOTTrainingVersion", &fROOTTrainingVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConstructedFromWeightFile", &fConstructedFromWeightFile);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBaseDir", &fBaseDir);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMethodBaseDir", &fMethodBaseDir);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParentDir", &fParentDir);
      R__insp.InspectMember(fParentDir, "fParentDir.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFileDir", &fFileDir);
      R__insp.InspectMember(fFileDir, "fFileDir.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWeightFile", &fWeightFile);
      R__insp.InspectMember(fWeightFile, "fWeightFile.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEffS", &fEffS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDefaultPDF", &fDefaultPDF);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMVAPdfS", &fMVAPdfS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMVAPdfB", &fMVAPdfB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSplS", &fSplS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSplB", &fSplB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSpleffBvsS", &fSpleffBvsS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSplTrainS", &fSplTrainS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSplTrainB", &fSplTrainB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSplTrainEffBvsS", &fSplTrainEffBvsS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMeanS", &fMeanS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMeanB", &fMeanB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmsS", &fRmsS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRmsB", &fRmsB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmin", &fXmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmax", &fXmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVarTransformString", &fVarTransformString);
      R__insp.InspectMember(fVarTransformString, "fVarTransformString.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTransformationPointer", &fTransformationPointer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTransformation", (void*)&fTransformation);
      R__insp.InspectMember("TMVA::TransformationHandler", (void*)&fTransformation, "fTransformation.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVerbose", &fVerbose);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVerbosityLevelString", &fVerbosityLevelString);
      R__insp.InspectMember(fVerbosityLevelString, "fVerbosityLevelString.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVerbosityLevel", &fVerbosityLevel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHelp", &fHelp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHasMVAPdfs", &fHasMVAPdfs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIgnoreNegWeightsInTraining", &fIgnoreNegWeightsInTraining);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSignalClass", &fSignalClass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBackgroundClass", &fBackgroundClass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrainTime", &fTrainTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestTime", &fTestTime);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCutOrientation", &fCutOrientation);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSplRefS", &fSplRefS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSplRefB", &fSplRefB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSplTrainRefS", &fSplTrainRefS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSplTrainRefB", &fSplTrainRefB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEventCollections", (void*)&fEventCollections);
      R__insp.InspectMember("vector<const std::vector<TMVA::Event*>*>", (void*)&fEventCollections, "fEventCollections.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSetupCompleted", &fSetupCompleted);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormalise", &fNormalise);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseDecorr", &fUseDecorr);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVariableTransformTypeString", &fVariableTransformTypeString);
      R__insp.InspectMember(fVariableTransformTypeString, "fVariableTransformTypeString.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTxtWeightsOnly", &fTxtWeightsOnly);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbinsMVAPdf", &fNbinsMVAPdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNsmoothMVAPdf", &fNsmoothMVAPdf);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::IMethod baseClass1;
      baseClass1::ShowMembers(R__insp);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::Configurable baseClass2;
      baseClass2::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodBase(void *p) {
      delete ((::TMVA::MethodBase*)p);
   }
   static void deleteArray_TMVAcLcLMethodBase(void *p) {
      delete [] ((::TMVA::MethodBase*)p);
   }
   static void destruct_TMVAcLcLMethodBase(void *p) {
      typedef ::TMVA::MethodBase current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodBase

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MethodCompositeBase::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MethodCompositeBase.
      TClass *R__cl = ::TMVA::MethodCompositeBase::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentMethodIdx", &fCurrentMethodIdx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCurrentMethod", &fCurrentMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMethods", (void*)&fMethods);
      R__insp.InspectMember("vector<IMethod*>", (void*)&fMethods, "fMethods.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMethodWeight", (void*)&fMethodWeight);
      R__insp.InspectMember("vector<Double_t>", (void*)&fMethodWeight, "fMethodWeight.", false);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::MethodBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodCompositeBase(void *p) {
      delete ((::TMVA::MethodCompositeBase*)p);
   }
   static void deleteArray_TMVAcLcLMethodCompositeBase(void *p) {
      delete [] ((::TMVA::MethodCompositeBase*)p);
   }
   static void destruct_TMVAcLcLMethodCompositeBase(void *p) {
      typedef ::TMVA::MethodCompositeBase current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodCompositeBase

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MethodANNBase::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MethodANNBase.
      TClass *R__cl = ::TMVA::MethodANNBase::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNetwork", &fNetwork);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSynapses", &fSynapses);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fActivation", &fActivation);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fOutput", &fOutput);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fIdentity", &fIdentity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*frgen", &frgen);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInputCalculator", &fInputCalculator);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRegulatorIdx", (void*)&fRegulatorIdx);
      R__insp.InspectMember("vector<Int_t>", (void*)&fRegulatorIdx, "fRegulatorIdx.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRegulators", (void*)&fRegulators);
      R__insp.InspectMember("vector<Double_t>", (void*)&fRegulators, "fRegulators.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEstimator", &fEstimator);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEstimatorS", &fEstimatorS);
      R__insp.InspectMember(fEstimatorS, "fEstimatorS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEstimatorHistTrain", &fEstimatorHistTrain);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEstimatorHistTest", &fEstimatorHistTest);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEpochMonHistS", (void*)&fEpochMonHistS);
      R__insp.InspectMember("vector<TH1*>", (void*)&fEpochMonHistS, "fEpochMonHistS.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEpochMonHistB", (void*)&fEpochMonHistB);
      R__insp.InspectMember("vector<TH1*>", (void*)&fEpochMonHistB, "fEpochMonHistB.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEpochMonHistW", (void*)&fEpochMonHistW);
      R__insp.InspectMember("vector<TH1*>", (void*)&fEpochMonHistW, "fEpochMonHistW.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInvHessian", &fInvHessian);
      R__insp.InspectMember(fInvHessian, "fInvHessian.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseRegulator", &fUseRegulator);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRandomSeed", &fRandomSeed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNcycles", &fNcycles);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNeuronType", &fNeuronType);
      R__insp.InspectMember(fNeuronType, "fNeuronType.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNeuronInputType", &fNeuronInputType);
      R__insp.InspectMember(fNeuronInputType, "fNeuronInputType.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInputLayer", &fInputLayer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOutputNeurons", (void*)&fOutputNeurons);
      R__insp.InspectMember("vector<TNeuron*>", (void*)&fOutputNeurons, "fOutputNeurons.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLayerSpec", &fLayerSpec);
      R__insp.InspectMember(fLayerSpec, "fLayerSpec.");
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::MethodBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodANNBase(void *p) {
      delete ((::TMVA::MethodANNBase*)p);
   }
   static void deleteArray_TMVAcLcLMethodANNBase(void *p) {
      delete [] ((::TMVA::MethodANNBase*)p);
   }
   static void destruct_TMVAcLcLMethodANNBase(void *p) {
      typedef ::TMVA::MethodANNBase current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodANNBase

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MethodTMlpANN::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MethodTMlpANN.
      TClass *R__cl = ::TMVA::MethodTMlpANN::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLayerSpec", &fLayerSpec);
      R__insp.InspectMember(fLayerSpec, "fLayerSpec.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMLP", &fMLP);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLocalTrainingTree", &fLocalTrainingTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHiddenLayer", &fHiddenLayer);
      R__insp.InspectMember(fHiddenLayer, "fHiddenLayer.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNcycles", &fNcycles);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValidationFraction", &fValidationFraction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMLPBuildOptions", &fMLPBuildOptions);
      R__insp.InspectMember(fMLPBuildOptions, "fMLPBuildOptions.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLearningMethod", &fLearningMethod);
      R__insp.InspectMember(fLearningMethod, "fLearningMethod.");
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::MethodBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodTMlpANN(void *p) {
      delete ((::TMVA::MethodTMlpANN*)p);
   }
   static void deleteArray_TMVAcLcLMethodTMlpANN(void *p) {
      delete [] ((::TMVA::MethodTMlpANN*)p);
   }
   static void destruct_TMVAcLcLMethodTMlpANN(void *p) {
      typedef ::TMVA::MethodTMlpANN current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodTMlpANN

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MethodRuleFit::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MethodRuleFit.
      TClass *R__cl = ::TMVA::MethodRuleFit::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRuleFit", &fRuleFit);
      R__insp.InspectMember(fRuleFit, "fRuleFit.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEventSample", (void*)&fEventSample);
      R__insp.InspectMember("vector<TMVA::Event*>", (void*)&fEventSample, "fEventSample.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSignalFraction", &fSignalFraction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMonitorNtuple", &fMonitorNtuple);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTImportance", &fNTImportance);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTCoefficient", &fNTCoefficient);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTSupport", &fNTSupport);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTNcuts", &fNTNcuts);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTNvars", &fNTNvars);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTPtag", &fNTPtag);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTPss", &fNTPss);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTPsb", &fNTPsb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTPbs", &fNTPbs);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTPbb", &fNTPbb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTSSB", &fNTSSB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTType", &fNTType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRuleFitModuleS", &fRuleFitModuleS);
      R__insp.InspectMember(fRuleFitModuleS, "fRuleFitModuleS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseRuleFitJF", &fUseRuleFitJF);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRFWorkDir", &fRFWorkDir);
      R__insp.InspectMember(fRFWorkDir, "fRFWorkDir.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRFNrules", &fRFNrules);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRFNendnodes", &fRFNendnodes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fForest", (void*)&fForest);
      R__insp.InspectMember("vector<TMVA::DecisionTree*,allocator<TMVA::DecisionTree*> >", (void*)&fForest, "fForest.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTrees", &fNTrees);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTreeEveFrac", &fTreeEveFrac);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSepType", &fSepType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinFracNEve", &fMinFracNEve);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxFracNEve", &fMaxFracNEve);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNCuts", &fNCuts);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSepTypeS", &fSepTypeS);
      R__insp.InspectMember(fSepTypeS, "fSepTypeS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPruneMethodS", &fPruneMethodS);
      R__insp.InspectMember(fPruneMethodS, "fPruneMethodS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPruneMethod", &fPruneMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPruneStrength", &fPruneStrength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fForestTypeS", &fForestTypeS);
      R__insp.InspectMember(fForestTypeS, "fForestTypeS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseBoost", &fUseBoost);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGDPathEveFrac", &fGDPathEveFrac);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGDValidEveFrac", &fGDValidEveFrac);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGDTau", &fGDTau);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGDTauPrec", &fGDTauPrec);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGDTauMin", &fGDTauMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGDTauMax", &fGDTauMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGDTauScan", &fGDTauScan);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGDPathStep", &fGDPathStep);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGDNPathSteps", &fGDNPathSteps);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGDErrScale", &fGDErrScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimp", &fMinimp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fModelTypeS", &fModelTypeS);
      R__insp.InspectMember(fModelTypeS, "fModelTypeS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRuleMinDist", &fRuleMinDist);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLinQuantile", &fLinQuantile);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::MethodBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodRuleFit(void *p) {
      delete ((::TMVA::MethodRuleFit*)p);
   }
   static void deleteArray_TMVAcLcLMethodRuleFit(void *p) {
      delete [] ((::TMVA::MethodRuleFit*)p);
   }
   static void destruct_TMVAcLcLMethodRuleFit(void *p) {
      typedef ::TMVA::MethodRuleFit current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodRuleFit

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MethodCuts::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MethodCuts.
      TClass *R__cl = ::TMVA::MethodCuts::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFitMethodS", &fFitMethodS);
      R__insp.InspectMember(fFitMethodS, "fFitMethodS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFitMethod", &fFitMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEffMethodS", &fEffMethodS);
      R__insp.InspectMember(fEffMethodS, "fEffMethodS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEffMethod", &fEffMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFitParams", &fFitParams);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestSignalEff", &fTestSignalEff);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEffSMin", &fEffSMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEffSMax", &fEffSMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCutRangeMin", &fCutRangeMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCutRangeMax", &fCutRangeMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCutRange", (void*)&fCutRange);
      R__insp.InspectMember("vector<Interval*>", (void*)&fCutRange, "fCutRange.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinaryTreeS", &fBinaryTreeS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinaryTreeB", &fBinaryTreeB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCutMin", &fCutMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCutMax", &fCutMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTmpCutMin", &fTmpCutMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTmpCutMax", &fTmpCutMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAllVarsI", &fAllVarsI);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpar", &fNpar);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEffRef", &fEffRef);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRangeSign", &fRangeSign);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRandom", &fRandom);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMeanS", &fMeanS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMeanB", &fMeanB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRmsS", &fRmsS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRmsB", &fRmsB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEffBvsSLocal", &fEffBvsSLocal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVarHistS", &fVarHistS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVarHistB", &fVarHistB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVarHistS_smooth", &fVarHistS_smooth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVarHistB_smooth", &fVarHistB_smooth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVarPdfS", &fVarPdfS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVarPdfB", &fVarPdfB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNegEffWarning", &fNegEffWarning);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::MethodBase baseClass1;
      baseClass1::ShowMembers(R__insp);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::IFitterTarget baseClass2;
      baseClass2::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodCuts(void *p) {
      delete ((::TMVA::MethodCuts*)p);
   }
   static void deleteArray_TMVAcLcLMethodCuts(void *p) {
      delete [] ((::TMVA::MethodCuts*)p);
   }
   static void destruct_TMVAcLcLMethodCuts(void *p) {
      typedef ::TMVA::MethodCuts current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodCuts

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MethodFisher::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MethodFisher.
      TClass *R__cl = ::TMVA::MethodFisher::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMeanMatx", &fMeanMatx);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheMethod", &fTheMethod);
      R__insp.InspectMember(fTheMethod, "fTheMethod.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFisherMethod", &fFisherMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBetw", &fBetw);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWith", &fWith);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCov", &fCov);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumOfWeightsS", &fSumOfWeightsS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumOfWeightsB", &fSumOfWeightsB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDiscrimPow", &fDiscrimPow);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFisherCoeff", &fFisherCoeff);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fF0", &fF0);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::MethodBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodFisher(void *p) {
      delete ((::TMVA::MethodFisher*)p);
   }
   static void deleteArray_TMVAcLcLMethodFisher(void *p) {
      delete [] ((::TMVA::MethodFisher*)p);
   }
   static void destruct_TMVAcLcLMethodFisher(void *p) {
      typedef ::TMVA::MethodFisher current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodFisher

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MethodKNN::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MethodKNN.
      TClass *R__cl = ::TMVA::MethodKNN::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumOfWeightsS", &fSumOfWeightsS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumOfWeightsB", &fSumOfWeightsB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fModule", &fModule);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fnkNN", &fnkNN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBalanceDepth", &fBalanceDepth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScaleFrac", &fScaleFrac);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigmaFact", &fSigmaFact);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKernel", &fKernel);
      R__insp.InspectMember(fKernel, "fKernel.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrim", &fTrim);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseKernel", &fUseKernel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseWeight", &fUseWeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseLDA", &fUseLDA);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvent", (void*)&fEvent);
      R__insp.InspectMember("TMVA::kNN::EventVec", (void*)&fEvent, "fEvent.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLDA", (void*)&fLDA);
      R__insp.InspectMember("TMVA::LDA", (void*)&fLDA, "fLDA.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTreeOptDepth", &fTreeOptDepth);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::MethodBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodKNN(void *p) {
      delete ((::TMVA::MethodKNN*)p);
   }
   static void deleteArray_TMVAcLcLMethodKNN(void *p) {
      delete [] ((::TMVA::MethodKNN*)p);
   }
   static void destruct_TMVAcLcLMethodKNN(void *p) {
      typedef ::TMVA::MethodKNN current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodKNN

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MethodCFMlpANN::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MethodCFMlpANN.
      TClass *R__cl = ::TMVA::MethodCFMlpANN::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fData", &fData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fClass", &fClass);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNlayers", &fNlayers);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNcycles", &fNcycles);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNodes", &fNodes);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fYNN", &fYNN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLayerSpec", &fLayerSpec);
      R__insp.InspectMember(fLayerSpec, "fLayerSpec.");
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::MethodBase baseClass1;
      baseClass1::ShowMembers(R__insp);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::MethodCFMlpANN_Utils baseClass2;
      baseClass2::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodCFMlpANN(void *p) {
      delete ((::TMVA::MethodCFMlpANN*)p);
   }
   static void deleteArray_TMVAcLcLMethodCFMlpANN(void *p) {
      delete [] ((::TMVA::MethodCFMlpANN*)p);
   }
   static void destruct_TMVAcLcLMethodCFMlpANN(void *p) {
      typedef ::TMVA::MethodCFMlpANN current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodCFMlpANN

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MethodCFMlpANN_Utils::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MethodCFMlpANN_Utils.
      TClass *R__cl = ::TMVA::MethodCFMlpANN_Utils::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParam_1", (void*)&fParam_1);
      R__insp.InspectMember("TMVA::MethodCFMlpANN_Utils::", (void*)&fParam_1, "fParam_1.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVarn_1", (void*)&fVarn_1);
      R__insp.InspectMember("TMVA::MethodCFMlpANN_Utils::", (void*)&fVarn_1, "fVarn_1.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVarn2_1", (void*)&fVarn2_1);
      R__insp.InspectMember("TMVA::MethodCFMlpANN_Utils::VARn2", (void*)&fVarn2_1, "fVarn2_1.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVarn3_1", (void*)&fVarn3_1);
      R__insp.InspectMember("TMVA::MethodCFMlpANN_Utils::VARn2", (void*)&fVarn3_1, "fVarn3_1.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNeur_1", (void*)&fNeur_1);
      R__insp.InspectMember("TMVA::MethodCFMlpANN_Utils::", (void*)&fNeur_1, "fNeur_1.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDel_1", (void*)&fDel_1);
      R__insp.InspectMember("TMVA::MethodCFMlpANN_Utils::", (void*)&fDel_1, "fDel_1.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCost_1", (void*)&fCost_1);
      R__insp.InspectMember("TMVA::MethodCFMlpANN_Utils::", (void*)&fCost_1, "fCost_1.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodCFMlpANN_Utils(void *p) {
      delete ((::TMVA::MethodCFMlpANN_Utils*)p);
   }
   static void deleteArray_TMVAcLcLMethodCFMlpANN_Utils(void *p) {
      delete [] ((::TMVA::MethodCFMlpANN_Utils*)p);
   }
   static void destruct_TMVAcLcLMethodCFMlpANN_Utils(void *p) {
      typedef ::TMVA::MethodCFMlpANN_Utils current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodCFMlpANN_Utils

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MethodLikelihood::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MethodLikelihood.
      TClass *R__cl = ::TMVA::MethodLikelihood::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEpsilon", &fEpsilon);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTransformLikelihoodOutput", &fTransformLikelihoodOutput);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDropVariable", &fDropVariable);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistSig", &fHistSig);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistBgd", &fHistBgd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistSig_smooth", &fHistSig_smooth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistBgd_smooth", &fHistBgd_smooth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDefaultPDFLik", &fDefaultPDFLik);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPDFSig", &fPDFSig);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPDFBgd", &fPDFBgd);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNsmooth", &fNsmooth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNsmoothVarS", &fNsmoothVarS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fNsmoothVarB", &fNsmoothVarB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAverageEvtPerBin", &fAverageEvtPerBin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAverageEvtPerBinVarS", &fAverageEvtPerBinVarS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAverageEvtPerBinVarB", &fAverageEvtPerBinVarB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBorderMethodString", &fBorderMethodString);
      R__insp.InspectMember(fBorderMethodString, "fBorderMethodString.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKDEfineFactor", &fKDEfineFactor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKDEiterString", &fKDEiterString);
      R__insp.InspectMember(fKDEiterString, "fKDEiterString.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKDEtypeString", &fKDEtypeString);
      R__insp.InspectMember(fKDEtypeString, "fKDEtypeString.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInterpolateString", &fInterpolateString);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::MethodBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodLikelihood(void *p) {
      delete ((::TMVA::MethodLikelihood*)p);
   }
   static void deleteArray_TMVAcLcLMethodLikelihood(void *p) {
      delete [] ((::TMVA::MethodLikelihood*)p);
   }
   static void destruct_TMVAcLcLMethodLikelihood(void *p) {
      typedef ::TMVA::MethodLikelihood current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodLikelihood

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodHMatrix(void *p) {
      delete ((::TMVA::MethodHMatrix*)p);
   }
   static void deleteArray_TMVAcLcLMethodHMatrix(void *p) {
      delete [] ((::TMVA::MethodHMatrix*)p);
   }
   static void destruct_TMVAcLcLMethodHMatrix(void *p) {
      typedef ::TMVA::MethodHMatrix current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodHMatrix

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MethodPDERS::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MethodPDERS.
      TClass *R__cl = ::TMVA::MethodPDERS::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHelpVolume", &fHelpVolume);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFcnCall", &fFcnCall);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVolumeRange", &fVolumeRange);
      R__insp.InspectMember(fVolumeRange, "fVolumeRange.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKernelString", &fKernelString);
      R__insp.InspectMember(fKernelString, "fKernelString.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVRangeMode", &fVRangeMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKernelEstimator", &fKernelEstimator);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBinaryTree", &fBinaryTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDelta", &fDelta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fShift", &fShift);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAverageRMS", (void*)&fAverageRMS);
      R__insp.InspectMember("vector<Float_t>", (void*)&fAverageRMS, "fAverageRMS.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScaleS", &fScaleS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fScaleB", &fScaleB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDeltaFrac", &fDeltaFrac);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGaussSigma", &fGaussSigma);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGaussSigmaNorm", &fGaussSigmaNorm);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNRegOut", &fNRegOut);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNEventsMin", &fNEventsMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNEventsMax", &fNEventsMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxVIterations", &fMaxVIterations);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInitialScale", &fInitialScale);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInitializedVolumeEle", &fInitializedVolumeEle);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fkNNMin", &fkNNMin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fkNNMax", &fkNNMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMax_distance", &fMax_distance);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPrinted", &fPrinted);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormTree", &fNormTree);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::MethodBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodPDERS(void *p) {
      delete ((::TMVA::MethodPDERS*)p);
   }
   static void deleteArray_TMVAcLcLMethodPDERS(void *p) {
      delete [] ((::TMVA::MethodPDERS*)p);
   }
   static void destruct_TMVAcLcLMethodPDERS(void *p) {
      typedef ::TMVA::MethodPDERS current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodPDERS

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MethodBDT::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MethodBDT.
      TClass *R__cl = ::TMVA::MethodBDT::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEventSample", (void*)&fEventSample);
      R__insp.InspectMember("vector<const TMVA::Event*>", (void*)&fEventSample, "fEventSample.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValidationSample", (void*)&fValidationSample);
      R__insp.InspectMember("vector<const TMVA::Event*>", (void*)&fValidationSample, "fValidationSample.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSubSample", (void*)&fSubSample);
      R__insp.InspectMember("vector<const TMVA::Event*>", (void*)&fSubSample, "fSubSample.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTrainSample", &fTrainSample);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTrees", &fNTrees);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fForest", (void*)&fForest);
      R__insp.InspectMember("vector<TMVA::DecisionTree*,allocator<TMVA::DecisionTree*> >", (void*)&fForest, "fForest.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoostWeights", (void*)&fBoostWeights);
      R__insp.InspectMember("vector<double>", (void*)&fBoostWeights, "fBoostWeights.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigToBkgFraction", &fSigToBkgFraction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoostType", &fBoostType);
      R__insp.InspectMember(fBoostType, "fBoostType.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAdaBoostBeta", &fAdaBoostBeta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAdaBoostR2Loss", &fAdaBoostR2Loss);
      R__insp.InspectMember(fAdaBoostR2Loss, "fAdaBoostR2Loss.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTransitionPoint", &fTransitionPoint);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fShrinkage", &fShrinkage);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBaggedBoost", &fBaggedBoost);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBaggedGradBoost", &fBaggedGradBoost);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumOfWeights", &fSumOfWeights);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWeightedResiduals", (void*)&fWeightedResiduals);
      R__insp.InspectMember("map<const TMVA::Event*,std::pair<Double_t,Double_t> >", (void*)&fWeightedResiduals, "fWeightedResiduals.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fResiduals", (void*)&fResiduals);
      R__insp.InspectMember("map<const TMVA::Event*,std::vector<double> >", (void*)&fResiduals, "fResiduals.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSepType", &fSepType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSepTypeS", &fSepTypeS);
      R__insp.InspectMember(fSepTypeS, "fSepTypeS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinNodeEvents", &fMinNodeEvents);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinNodeSize", &fMinNodeSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinNodeSizeS", &fMinNodeSizeS);
      R__insp.InspectMember(fMinNodeSizeS, "fMinNodeSizeS.");
      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(), "fUseYesNoLeaf", &fUseYesNoLeaf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNodePurityLimit", &fNodePurityLimit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNNodesMax", &fNNodesMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxDepth", &fMaxDepth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPruneMethod", &fPruneMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPruneMethodS", &fPruneMethodS);
      R__insp.InspectMember(fPruneMethodS, "fPruneMethodS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPruneStrength", &fPruneStrength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFValidationEvents", &fFValidationEvents);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAutomatic", &fAutomatic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRandomisedTrees", &fRandomisedTrees);
      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(), "fUseNTrainEvents", &fUseNTrainEvents);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBaggedSampleFraction", &fBaggedSampleFraction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNegWeightTreatment", &fNegWeightTreatment);
      R__insp.InspectMember(fNegWeightTreatment, "fNegWeightTreatment.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNoNegWeightsInTraining", &fNoNegWeightsInTraining);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInverseBoostNegWeights", &fInverseBoostNegWeights);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPairNegWeightsGlobal", &fPairNegWeightsGlobal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrainWithNegWeights", &fTrainWithNegWeights);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDoBoostMonitor", &fDoBoostMonitor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMonitorNtuple", &fMonitorNtuple);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fITree", &fITree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoostWeight", &fBoostWeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorFraction", &fErrorFraction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCss", &fCss);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCts_sb", &fCts_sb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCtb_ss", &fCtb_ss);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCbb", &fCbb);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDoPreselection", &fDoPreselection);
      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(), "fLowSigCut", (void*)&fLowSigCut);
      R__insp.InspectMember("vector<Double_t>", (void*)&fLowSigCut, "fLowSigCut.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLowBkgCut", (void*)&fLowBkgCut);
      R__insp.InspectMember("vector<Double_t>", (void*)&fLowBkgCut, "fLowBkgCut.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighSigCut", (void*)&fHighSigCut);
      R__insp.InspectMember("vector<Double_t>", (void*)&fHighSigCut, "fHighSigCut.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHighBkgCut", (void*)&fHighBkgCut);
      R__insp.InspectMember("vector<Double_t>", (void*)&fHighBkgCut, "fHighBkgCut.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsLowSigCut", (void*)&fIsLowSigCut);
      R__insp.InspectMember("vector<Bool_t>", (void*)&fIsLowSigCut, "fIsLowSigCut.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsLowBkgCut", (void*)&fIsLowBkgCut);
      R__insp.InspectMember("vector<Bool_t>", (void*)&fIsLowBkgCut, "fIsLowBkgCut.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsHighSigCut", (void*)&fIsHighSigCut);
      R__insp.InspectMember("vector<Bool_t>", (void*)&fIsHighSigCut, "fIsHighSigCut.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsHighBkgCut", (void*)&fIsHighBkgCut);
      R__insp.InspectMember("vector<Bool_t>", (void*)&fIsHighBkgCut, "fIsHighBkgCut.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHistoricBool", &fHistoricBool);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::MethodBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodBDT(void *p) {
      delete ((::TMVA::MethodBDT*)p);
   }
   static void deleteArray_TMVAcLcLMethodBDT(void *p) {
      delete [] ((::TMVA::MethodBDT*)p);
   }
   static void destruct_TMVAcLcLMethodBDT(void *p) {
      typedef ::TMVA::MethodBDT current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodBDT

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MethodDT::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MethodDT.
      TClass *R__cl = ::TMVA::MethodDT::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEventSample", (void*)&fEventSample);
      R__insp.InspectMember("vector<Event*>", (void*)&fEventSample, "fEventSample.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTree", &fTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSepType", &fSepType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSepTypeS", &fSepTypeS);
      R__insp.InspectMember(fSepTypeS, "fSepTypeS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinNodeEvents", &fMinNodeEvents);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinNodeSize", &fMinNodeSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinNodeSizeS", &fMinNodeSizeS);
      R__insp.InspectMember(fMinNodeSizeS, "fMinNodeSizeS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNCuts", &fNCuts);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseYesNoLeaf", &fUseYesNoLeaf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNodePurityLimit", &fNodePurityLimit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxDepth", &fMaxDepth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorFraction", &fErrorFraction);
      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(), "fPruneMethodS", &fPruneMethodS);
      R__insp.InspectMember(fPruneMethodS, "fPruneMethodS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAutomatic", &fAutomatic);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRandomisedTrees", &fRandomisedTrees);
      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(), "fVariableImportance", (void*)&fVariableImportance);
      R__insp.InspectMember("vector<Double_t>", (void*)&fVariableImportance, "fVariableImportance.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDeltaPruneStrength", &fDeltaPruneStrength);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPruneBeforeBoost", &fPruneBeforeBoost);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::MethodBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodDT(void *p) {
      delete ((::TMVA::MethodDT*)p);
   }
   static void deleteArray_TMVAcLcLMethodDT(void *p) {
      delete [] ((::TMVA::MethodDT*)p);
   }
   static void destruct_TMVAcLcLMethodDT(void *p) {
      typedef ::TMVA::MethodDT current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodDT

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MethodSVM::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MethodSVM.
      TClass *R__cl = ::TMVA::MethodSVM::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCost", &fCost);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTolerance", &fTolerance);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxIter", &fMaxIter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNSubSets", &fNSubSets);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBparm", &fBparm);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGamma", &fGamma);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fWgSet", &fWgSet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInputData", &fInputData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSupportVectors", &fSupportVectors);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSVKernelFunction", &fSVKernelFunction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMinVars", &fMinVars);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaxVars", &fMaxVars);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheKernel", &fTheKernel);
      R__insp.InspectMember(fTheKernel, "fTheKernel.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDoubleSigmaSquared", &fDoubleSigmaSquared);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOrder", &fOrder);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTheta", &fTheta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKappa", &fKappa);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::MethodBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodSVM(void *p) {
      delete ((::TMVA::MethodSVM*)p);
   }
   static void deleteArray_TMVAcLcLMethodSVM(void *p) {
      delete [] ((::TMVA::MethodSVM*)p);
   }
   static void destruct_TMVAcLcLMethodSVM(void *p) {
      typedef ::TMVA::MethodSVM current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodSVM

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodBayesClassifier(void *p) {
      delete ((::TMVA::MethodBayesClassifier*)p);
   }
   static void deleteArray_TMVAcLcLMethodBayesClassifier(void *p) {
      delete [] ((::TMVA::MethodBayesClassifier*)p);
   }
   static void destruct_TMVAcLcLMethodBayesClassifier(void *p) {
      typedef ::TMVA::MethodBayesClassifier current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodBayesClassifier

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MethodFDA::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MethodFDA.
      TClass *R__cl = ::TMVA::MethodFDA::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFormulaStringP", &fFormulaStringP);
      R__insp.InspectMember(fFormulaStringP, "fFormulaStringP.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParRangeStringP", &fParRangeStringP);
      R__insp.InspectMember(fParRangeStringP, "fParRangeStringP.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFormulaStringT", &fFormulaStringT);
      R__insp.InspectMember(fFormulaStringT, "fFormulaStringT.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParRangeStringT", &fParRangeStringT);
      R__insp.InspectMember(fParRangeStringT, "fParRangeStringT.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFormula", &fFormula);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNPars", &fNPars);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fParRange", (void*)&fParRange);
      R__insp.InspectMember("vector<Interval*>", (void*)&fParRange, "fParRange.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBestPars", (void*)&fBestPars);
      R__insp.InspectMember("vector<Double_t>", (void*)&fBestPars, "fBestPars.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFitMethod", &fFitMethod);
      R__insp.InspectMember(fFitMethod, "fFitMethod.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fConverger", &fConverger);
      R__insp.InspectMember(fConverger, "fConverger.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFitter", &fFitter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fConvergerFitter", &fConvergerFitter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumOfWeightsSig", &fSumOfWeightsSig);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumOfWeightsBkg", &fSumOfWeightsBkg);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSumOfWeights", &fSumOfWeights);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOutputDimensions", &fOutputDimensions);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::MethodBase baseClass1;
      baseClass1::ShowMembers(R__insp);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::IFitterTarget baseClass2;
      baseClass2::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodFDA(void *p) {
      delete ((::TMVA::MethodFDA*)p);
   }
   static void deleteArray_TMVAcLcLMethodFDA(void *p) {
      delete [] ((::TMVA::MethodFDA*)p);
   }
   static void destruct_TMVAcLcLMethodFDA(void *p) {
      typedef ::TMVA::MethodFDA current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodFDA

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MethodMLP::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MethodMLP.
      TClass *R__cl = ::TMVA::MethodMLP::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseRegulator", &fUseRegulator);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCalculateErrors", &fCalculateErrors);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPrior", &fPrior);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPriorDev", (void*)&fPriorDev);
      R__insp.InspectMember("vector<Double_t>", (void*)&fPriorDev, "fPriorDev.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpdateLimit", &fUpdateLimit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrainingMethod", &fTrainingMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrainMethodS", &fTrainMethodS);
      R__insp.InspectMember(fTrainMethodS, "fTrainMethodS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSamplingFraction", &fSamplingFraction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSamplingEpoch", &fSamplingEpoch);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSamplingWeight", &fSamplingWeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSamplingTraining", &fSamplingTraining);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSamplingTesting", &fSamplingTesting);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastAlpha", &fLastAlpha);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTau", &fTau);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fResetStep", &fResetStep);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLearnRate", &fLearnRate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDecayRate", &fDecayRate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBPMode", &fBPMode);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBpModeS", &fBpModeS);
      R__insp.InspectMember(fBpModeS, "fBpModeS.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBatchSize", &fBatchSize);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestRate", &fTestRate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEpochMon", &fEpochMon);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGA_nsteps", &fGA_nsteps);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGA_preCalc", &fGA_preCalc);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGA_SC_steps", &fGA_SC_steps);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGA_SC_rate", &fGA_SC_rate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGA_SC_factor", &fGA_SC_factor);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDeviationsFromTargets", &fDeviationsFromTargets);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWeightRange", &fWeightRange);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::MethodANNBase baseClass1;
      baseClass1::ShowMembers(R__insp);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::IFitterTarget baseClass2;
      baseClass2::ShowMembers(R__insp);
      R__insp.GenericShowMembers("TMVA::ConvergenceTest", ( ::TMVA::ConvergenceTest *) (this ), false);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodMLP(void *p) {
      delete ((::TMVA::MethodMLP*)p);
   }
   static void deleteArray_TMVAcLcLMethodMLP(void *p) {
      delete [] ((::TMVA::MethodMLP*)p);
   }
   static void destruct_TMVAcLcLMethodMLP(void *p) {
      typedef ::TMVA::MethodMLP current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodMLP

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MethodBoost::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MethodBoost.
      TClass *R__cl = ::TMVA::MethodBoost::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoostNum", &fBoostNum);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoostType", &fBoostType);
      R__insp.InspectMember(fBoostType, "fBoostType.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTransformString", &fTransformString);
      R__insp.InspectMember(fTransformString, "fTransformString.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDetailedMonitoring", &fDetailedMonitoring);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAdaBoostBeta", &fAdaBoostBeta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRandomSeed", &fRandomSeed);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBaggedSampleFraction", &fBaggedSampleFraction);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoostedMethodName", &fBoostedMethodName);
      R__insp.InspectMember(fBoostedMethodName, "fBoostedMethodName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoostedMethodTitle", &fBoostedMethodTitle);
      R__insp.InspectMember(fBoostedMethodTitle, "fBoostedMethodTitle.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoostedMethodOptions", &fBoostedMethodOptions);
      R__insp.InspectMember(fBoostedMethodOptions, "fBoostedMethodOptions.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMonitorBoostedMethod", &fMonitorBoostedMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrainSigMVAHist", (void*)&fTrainSigMVAHist);
      R__insp.InspectMember("vector<TH1*>", (void*)&fTrainSigMVAHist, "fTrainSigMVAHist.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrainBgdMVAHist", (void*)&fTrainBgdMVAHist);
      R__insp.InspectMember("vector<TH1*>", (void*)&fTrainBgdMVAHist, "fTrainBgdMVAHist.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBTrainSigMVAHist", (void*)&fBTrainSigMVAHist);
      R__insp.InspectMember("vector<TH1*>", (void*)&fBTrainSigMVAHist, "fBTrainSigMVAHist.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBTrainBgdMVAHist", (void*)&fBTrainBgdMVAHist);
      R__insp.InspectMember("vector<TH1*>", (void*)&fBTrainBgdMVAHist, "fBTrainBgdMVAHist.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestSigMVAHist", (void*)&fTestSigMVAHist);
      R__insp.InspectMember("vector<TH1*>", (void*)&fTestSigMVAHist, "fTestSigMVAHist.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestBgdMVAHist", (void*)&fTestBgdMVAHist);
      R__insp.InspectMember("vector<TH1*>", (void*)&fTestBgdMVAHist, "fTestBgdMVAHist.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMonitorTree", &fMonitorTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoostWeight", &fBoostWeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMethodError", &fMethodError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fROC_training", &fROC_training);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOverlap_integral", &fOverlap_integral);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMVAvalues", &fMVAvalues);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataSetManager", &fDataSetManager);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHistoricOption", &fHistoricOption);
      R__insp.InspectMember(fHistoricOption, "fHistoricOption.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fHistoricBoolOption", &fHistoricBoolOption);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::MethodCompositeBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodBoost(void *p) {
      delete ((::TMVA::MethodBoost*)p);
   }
   static void deleteArray_TMVAcLcLMethodBoost(void *p) {
      delete [] ((::TMVA::MethodBoost*)p);
   }
   static void destruct_TMVAcLcLMethodBoost(void *p) {
      typedef ::TMVA::MethodBoost current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodBoost

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MethodPDEFoam::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MethodPDEFoam.
      TClass *R__cl = ::TMVA::MethodPDEFoam::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigBgSeparated", &fSigBgSeparated);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFrac", &fFrac);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDiscrErrCut", &fDiscrErrCut);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVolFrac", &fVolFrac);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fnCells", &fnCells);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fnActiveCells", &fnActiveCells);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fnSampl", &fnSampl);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fnBin", &fnBin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvPerBin", &fEvPerBin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCompress", &fCompress);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMultiTargetRegression", &fMultiTargetRegression);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNmin", &fNmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCutNmin", &fCutNmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxDepth", &fMaxDepth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKernelStr", &fKernelStr);
      R__insp.InspectMember(fKernelStr, "fKernelStr.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fKernel", &fKernel);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fKernelEstimator", &fKernelEstimator);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTargetSelectionStr", &fTargetSelectionStr);
      R__insp.InspectMember(fTargetSelectionStr, "fTargetSelectionStr.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTargetSelection", &fTargetSelection);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFillFoamWithOrigWeights", &fFillFoamWithOrigWeights);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseYesNoCell", &fUseYesNoCell);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDTLogic", &fDTLogic);
      R__insp.InspectMember(fDTLogic, "fDTLogic.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDTSeparation", &fDTSeparation);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPeekMax", &fPeekMax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmin", (void*)&fXmin);
      R__insp.InspectMember("vector<Float_t>", (void*)&fXmin, "fXmin.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmax", (void*)&fXmax);
      R__insp.InspectMember("vector<Float_t>", (void*)&fXmax, "fXmax.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFoam", (void*)&fFoam);
      R__insp.InspectMember("vector<PDEFoam*>", (void*)&fFoam, "fFoam.", false);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::MethodBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodPDEFoam(void *p) {
      delete ((::TMVA::MethodPDEFoam*)p);
   }
   static void deleteArray_TMVAcLcLMethodPDEFoam(void *p) {
      delete [] ((::TMVA::MethodPDEFoam*)p);
   }
   static void destruct_TMVAcLcLMethodPDEFoam(void *p) {
      typedef ::TMVA::MethodPDEFoam current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodPDEFoam

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodLD(void *p) {
      delete ((::TMVA::MethodLD*)p);
   }
   static void deleteArray_TMVAcLcLMethodLD(void *p) {
      delete [] ((::TMVA::MethodLD*)p);
   }
   static void destruct_TMVAcLcLMethodLD(void *p) {
      typedef ::TMVA::MethodLD current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodLD

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MethodCategory::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MethodCategory.
      TClass *R__cl = ::TMVA::MethodCategory::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMethods", (void*)&fMethods);
      R__insp.InspectMember("vector<IMethod*>", (void*)&fMethods, "fMethods.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCategoryCuts", (void*)&fCategoryCuts);
      R__insp.InspectMember("vector<TCut>", (void*)&fCategoryCuts, "fCategoryCuts.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCategorySpecIdx", (void*)&fCategorySpecIdx);
      R__insp.InspectMember("vector<UInt_t>", (void*)&fCategorySpecIdx, "fCategorySpecIdx.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVars", (void*)&fVars);
      R__insp.InspectMember("vector<TString>", (void*)&fVars, "fVars.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVarMaps", (void*)&fVarMaps);
      R__insp.InspectMember("vector<std::vector<UInt_t> >", (void*)&fVarMaps, "fVarMaps.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCatTree", &fCatTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCatFormulas", (void*)&fCatFormulas);
      R__insp.InspectMember("vector<TTreeFormula*>", (void*)&fCatFormulas, "fCatFormulas.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataSetManager", &fDataSetManager);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::MethodCompositeBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLMethodCategory(void *p) {
      delete ((::TMVA::MethodCategory*)p);
   }
   static void deleteArray_TMVAcLcLMethodCategory(void *p) {
      delete [] ((::TMVA::MethodCategory*)p);
   }
   static void destruct_TMVAcLcLMethodCategory(void *p) {
      typedef ::TMVA::MethodCategory current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MethodCategory

namespace ROOTDict {
   void vectorlEfloatmUgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEfloatmUgR_Dictionary();
   static void *new_vectorlEfloatmUgR(void *p = 0);
   static void *newArray_vectorlEfloatmUgR(Long_t size, void *p);
   static void delete_vectorlEfloatmUgR(void *p);
   static void deleteArray_vectorlEfloatmUgR(void *p);
   static void destruct_vectorlEfloatmUgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<float*>*)
   {
      vector<float*> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<float*>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<float*>", -2, "/home/mice/Grid/MAUS-v3.2.1/third_party/source/root_v5.34.36/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<float*>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlEfloatmUgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<float*>) );
      instance.SetNew(&new_vectorlEfloatmUgR);
      instance.SetNewArray(&newArray_vectorlEfloatmUgR);
      instance.SetDelete(&delete_vectorlEfloatmUgR);
      instance.SetDeleteArray(&deleteArray_vectorlEfloatmUgR);
      instance.SetDestructor(&destruct_vectorlEfloatmUgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<float*> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<float*>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlEfloatmUgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<float*> : new vector<float*>;
   }
   static void *newArray_vectorlEfloatmUgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<float*>[nElements] : new vector<float*>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEfloatmUgR(void *p) {
      delete ((vector<float*>*)p);
   }
   static void deleteArray_vectorlEfloatmUgR(void *p) {
      delete [] ((vector<float*>*)p);
   }
   static void destruct_vectorlEfloatmUgR(void *p) {
      typedef vector<float*> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<float*>

namespace ROOTDict {
   void vectorlEfloatgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEfloatgR_Dictionary();
   static void *new_vectorlEfloatgR(void *p = 0);
   static void *newArray_vectorlEfloatgR(Long_t size, void *p);
   static void delete_vectorlEfloatgR(void *p);
   static void deleteArray_vectorlEfloatgR(void *p);
   static void destruct_vectorlEfloatgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<float>*)
   {
      vector<float> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<float>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<float>", -2, "/home/mice/Grid/MAUS-v3.2.1/third_party/source/root_v5.34.36/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<float>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlEfloatgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<float>) );
      instance.SetNew(&new_vectorlEfloatgR);
      instance.SetNewArray(&newArray_vectorlEfloatgR);
      instance.SetDelete(&delete_vectorlEfloatgR);
      instance.SetDeleteArray(&deleteArray_vectorlEfloatgR);
      instance.SetDestructor(&destruct_vectorlEfloatgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<float> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<float>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlEfloatgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<float> : new vector<float>;
   }
   static void *newArray_vectorlEfloatgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<float>[nElements] : new vector<float>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEfloatgR(void *p) {
      delete ((vector<float>*)p);
   }
   static void deleteArray_vectorlEfloatgR(void *p) {
      delete [] ((vector<float>*)p);
   }
   static void destruct_vectorlEfloatgR(void *p) {
      typedef vector<float> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<float>

namespace ROOTDict {
   void vectorlEunsignedsPintgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEunsignedsPintgR_Dictionary();
   static void *new_vectorlEunsignedsPintgR(void *p = 0);
   static void *newArray_vectorlEunsignedsPintgR(Long_t size, void *p);
   static void delete_vectorlEunsignedsPintgR(void *p);
   static void deleteArray_vectorlEunsignedsPintgR(void *p);
   static void destruct_vectorlEunsignedsPintgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const vector<unsigned int>*)
   {
      vector<unsigned int> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<unsigned int>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<unsigned int>", -2, "/home/mice/Grid/MAUS-v3.2.1/third_party/source/root_v5.34.36/cint/cint/lib/prec_stl/vector", 49,
                  typeid(vector<unsigned int>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &vectorlEunsignedsPintgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<unsigned int>) );
      instance.SetNew(&new_vectorlEunsignedsPintgR);
      instance.SetNewArray(&newArray_vectorlEunsignedsPintgR);
      instance.SetDelete(&delete_vectorlEunsignedsPintgR);
      instance.SetDeleteArray(&deleteArray_vectorlEunsignedsPintgR);
      instance.SetDestructor(&destruct_vectorlEunsignedsPintgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::Pushback< vector<unsigned int> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<unsigned int>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_vectorlEunsignedsPintgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<unsigned int> : new vector<unsigned int>;
   }
   static void *newArray_vectorlEunsignedsPintgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<unsigned int>[nElements] : new vector<unsigned int>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEunsignedsPintgR(void *p) {
      delete ((vector<unsigned int>*)p);
   }
   static void deleteArray_vectorlEunsignedsPintgR(void *p) {
      delete [] ((vector<unsigned int>*)p);
   }
   static void destruct_vectorlEunsignedsPintgR(void *p) {
      typedef vector<unsigned int> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class vector<unsigned int>

/********************************************************
* G__TMVA1.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__TMVA1();

extern "C" void G__set_cpp_environmentG__TMVA1() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TMVA/Configurable.h");
  G__add_compiledheader("TMVA/Event.h");
  G__add_compiledheader("TMVA/Factory.h");
  G__add_compiledheader("TMVA/MethodBase.h");
  G__add_compiledheader("TMVA/MethodCompositeBase.h");
  G__add_compiledheader("TMVA/MethodANNBase.h");
  G__add_compiledheader("TMVA/MethodTMlpANN.h");
  G__add_compiledheader("TMVA/MethodRuleFit.h");
  G__add_compiledheader("TMVA/MethodCuts.h");
  G__add_compiledheader("TMVA/MethodFisher.h");
  G__add_compiledheader("TMVA/MethodKNN.h");
  G__add_compiledheader("TMVA/MethodCFMlpANN.h");
  G__add_compiledheader("TMVA/MethodCFMlpANN_Utils.h");
  G__add_compiledheader("TMVA/MethodLikelihood.h");
  G__add_compiledheader("TMVA/MethodHMatrix.h");
  G__add_compiledheader("TMVA/MethodPDERS.h");
  G__add_compiledheader("TMVA/MethodBDT.h");
  G__add_compiledheader("TMVA/MethodDT.h");
  G__add_compiledheader("TMVA/MethodSVM.h");
  G__add_compiledheader("TMVA/MethodBayesClassifier.h");
  G__add_compiledheader("TMVA/MethodFDA.h");
  G__add_compiledheader("TMVA/MethodMLP.h");
  G__add_compiledheader("TMVA/MethodBoost.h");
  G__add_compiledheader("TMVA/MethodPDEFoam.h");
  G__add_compiledheader("TMVA/MethodLD.h");
  G__add_compiledheader("TMVA/MethodCategory.h");
  G__cpp_reset_tagtableG__TMVA1();
}
#include <new>
extern "C" int G__cpp_dllrevG__TMVA1() { return(30051515); }

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

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

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

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

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

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

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

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

static int G__G__TMVA1_136_0_9(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__TMVA1_136_0_10(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) ;
}


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

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

static int G__G__TMVA1_164_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TMVA::Configurable*) G__getstructoffset())->PrintOptions();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__TMVA1_164_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TMVA::Configurable*) G__getstructoffset())->CheckForUnusedOptions();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__TMVA1_185_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::Event* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Event(
*(vector<Float_t>*) libp->para[0].ref, *(vector<Float_t>*) libp->para[1].ref
, *(vector<Float_t>*) libp->para[2].ref, (UInt_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     } else {
       p = new((void*) gvp) TMVA::Event(
*(vector<Float_t>*) libp->para[0].ref, *(vector<Float_t>*) libp->para[1].ref
, *(vector<Float_t>*) libp->para[2].ref, (UInt_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Event(
*(vector<Float_t>*) libp->para[0].ref, *(vector<Float_t>*) libp->para[1].ref
, *(vector<Float_t>*) libp->para[2].ref, (UInt_t) G__int(libp->para[3])
, (Double_t) G__double(libp->para[4]));
     } else {
       p = new((void*) gvp) TMVA::Event(
*(vector<Float_t>*) libp->para[0].ref, *(vector<Float_t>*) libp->para[1].ref
, *(vector<Float_t>*) libp->para[2].ref, (UInt_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::Event(
*(vector<Float_t>*) libp->para[0].ref, *(vector<Float_t>*) libp->para[1].ref
, *(vector<Float_t>*) libp->para[2].ref, (UInt_t) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TMVA::Event(
*(vector<Float_t>*) libp->para[0].ref, *(vector<Float_t>*) libp->para[1].ref
, *(vector<Float_t>*) 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::Event(
*(vector<Float_t>*) libp->para[0].ref, *(vector<Float_t>*) libp->para[1].ref
, *(vector<Float_t>*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) TMVA::Event(
*(vector<Float_t>*) libp->para[0].ref, *(vector<Float_t>*) libp->para[1].ref
, *(vector<Float_t>*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__TMVA1_185_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::Event* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Event(
*(vector<Float_t>*) libp->para[0].ref, (UInt_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     } else {
       p = new((void*) gvp) TMVA::Event(
*(vector<Float_t>*) libp->para[0].ref, (UInt_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Event(
*(vector<Float_t>*) libp->para[0].ref, (UInt_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::Event(
*(vector<Float_t>*) libp->para[0].ref, (UInt_t) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Event(*(vector<Float_t>*) libp->para[0].ref, (UInt_t) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMVA::Event(*(vector<Float_t>*) libp->para[0].ref, (UInt_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__TMVA1LN_TMVAcLcLEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__TMVA1_185_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Event*) G__getstructoffset())->SetVal((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__TMVA1_185_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Event*) G__getstructoffset())->SetTarget((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__TMVA1_185_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Event*) G__getstructoffset())->SetSpectator((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__TMVA1_185_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TMVA::Event*) G__getstructoffset())->SetVariableArrangement((vector<UInt_t>*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_185_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TMVA::Event*) G__getstructoffset())->SetDoNotBoost();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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


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

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

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

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

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

static int G__G__TMVA1_319_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         map<TString,Double_t>* pobj;
         map<TString,Double_t> xobj = ((TMVA::MethodBase*) G__getstructoffset())->OptimizeTuningParameters(*((TString*) G__int(libp->para[0])), *((TString*) G__int(libp->para[1])));
         pobj = new map<TString,Double_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         map<TString,Double_t>* pobj;
         map<TString,Double_t> xobj = ((TMVA::MethodBase*) G__getstructoffset())->OptimizeTuningParameters(*((TString*) G__int(libp->para[0])));
         pobj = new map<TString,Double_t>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         map<TString,Double_t>* pobj;
         map<TString,Double_t> xobj = ((TMVA::MethodBase*) G__getstructoffset())->OptimizeTuningParameters();
         pobj = new map<TString,Double_t>(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__TMVA1_319_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::MethodBase*) G__getstructoffset())->SetTuneParameters(*((map<TString,Double_t>*) G__int(libp->para[0])));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__TMVA1_319_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((TMVA::MethodBase*) G__getstructoffset())->GetKSTrainingVsTest((Char_t) G__int(libp->para[0]), *((TString*) G__int(libp->para[1]))));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((TMVA::MethodBase*) G__getstructoffset())->GetKSTrainingVsTest((Char_t) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__TMVA1_319_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::MethodBase*) G__getstructoffset())->TestRegression(
*(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])
, *(Double_t*) G__Doubleref(&libp->para[6]), *(Double_t*) G__Doubleref(&libp->para[7])
, *(Double_t*) G__Doubleref(&libp->para[8]), (TMVA::Types::ETreeType) G__int(libp->para[9]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__TMVA1_319_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<Float_t>& obj = ((TMVA::MethodBase*) G__getstructoffset())->GetRegressionValues((TMVA::Event*) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__TMVA1_319_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::MethodBase*) G__getstructoffset())->GetProba((TMVA::Event*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__TMVA1_319_0_32(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::MethodBase*) G__getstructoffset())->GetRarity((Double_t) G__double(libp->para[0]), (TMVA::Types::ESBType) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TMVA::MethodBase*) G__getstructoffset())->GetRarity((Double_t) G__double(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_319_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TMVA::MethodBase*) G__getstructoffset())->WriteStateToFile();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__TMVA1_319_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::MethodBase*) G__getstructoffset())->GetEfficiency(*(TString*) libp->para[0].ref, (TMVA::Types::ETreeType) G__int(libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__TMVA1_319_0_66(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::MethodBase*) G__getstructoffset())->GetROCIntegral((TMVA::PDF*) G__int(libp->para[0]), (TMVA::PDF*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TMVA::MethodBase*) G__getstructoffset())->GetROCIntegral((TMVA::PDF*) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TMVA::MethodBase*) G__getstructoffset())->GetROCIntegral());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__TMVA1_319_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMVA::MethodBase*) 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__TMVA1_319_0_69(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::MethodBase*) G__getstructoffset())->GetSeparation((TMVA::PDF*) G__int(libp->para[0]), (TMVA::PDF*) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const TMVA::MethodBase*) G__getstructoffset())->GetSeparation((TMVA::PDF*) G__int(libp->para[0])));
      break;
   case 0:
      G__letdouble(result7, 100, (double) ((const TMVA::MethodBase*) G__getstructoffset())->GetSeparation());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_319_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TMVA::MethodBase*) G__getstructoffset())->GetRegressionDeviation((UInt_t) G__int(libp->para[0]), (TMVA::Types::ETreeType) G__int(libp->para[1])
, *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__TMVA1_319_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TMVA::MethodBase*) G__getstructoffset())->GetMethodTypeName();
         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__TMVA1_319_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMVA::MethodBase*) G__getstructoffset())->GetMethodType());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__TMVA1_319_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TMVA::MethodBase*) G__getstructoffset())->GetProbaName();
         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__TMVA1_319_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TMVA::MethodBase*) G__getstructoffset())->GetWeightFileName();
         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__TMVA1_319_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TMVA::MethodBase*) G__getstructoffset())->SetTestvarName(*(TString*) libp->para[0].ref);
      G__setnull(result7);
      break;
   case 0:
      ((TMVA::MethodBase*) G__getstructoffset())->SetTestvarName();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__TMVA1_319_0_101(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TMVA::MethodBase*) G__getstructoffset())->GetTrainingTMVAVersionString();
         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__TMVA1_319_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TMVA::MethodBase*) G__getstructoffset())->GetTrainingROOTVersionString();
         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__TMVA1_319_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         const TMVA::TransformationHandler& obj = ((TMVA::MethodBase*) G__getstructoffset())->GetTransformationHandler((Bool_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 0:
      {
         const TMVA::TransformationHandler& obj = ((TMVA::MethodBase*) G__getstructoffset())->GetTransformationHandler();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_319_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      {
         const TMVA::TransformationHandler& obj = ((const TMVA::MethodBase*) G__getstructoffset())->GetTransformationHandler((Bool_t) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   case 0:
      {
         const TMVA::TransformationHandler& obj = ((const TMVA::MethodBase*) G__getstructoffset())->GetTransformationHandler();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__TMVA1_319_0_111(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMVA::MethodBase*) G__getstructoffset())->GetEvent((Long64_t) G__Longlong(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_319_0_112(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMVA::MethodBase*) G__getstructoffset())->GetEvent((Long64_t) G__Longlong(libp->para[0]), (TMVA::Types::ETreeType) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_319_0_113(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMVA::MethodBase*) G__getstructoffset())->GetTrainingEvent((Long64_t) G__Longlong(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_319_0_114(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMVA::MethodBase*) G__getstructoffset())->GetTestingEvent((Long64_t) G__Longlong(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_319_0_115(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<TMVA::Event*>& obj = ((TMVA::MethodBase*) G__getstructoffset())->GetEventCollection((TMVA::Types::ETreeType) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__TMVA1_319_0_117(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TMVA::MethodBase*) G__getstructoffset())->IsSignalLike((Double_t) G__double(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* TMVA::Factory */
static int G__G__TMVA1_323_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::Factory* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Factory(
*((TString*) G__int(libp->para[0])), (TFile*) G__int(libp->para[1])
, *((TString*) G__int(libp->para[2])));
     } else {
       p = new((void*) gvp) TMVA::Factory(
*((TString*) G__int(libp->para[0])), (TFile*) G__int(libp->para[1])
, *((TString*) G__int(libp->para[2])));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::Factory(*((TString*) G__int(libp->para[0])), (TFile*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMVA::Factory(*((TString*) G__int(libp->para[0])), (TFile*) 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__TMVA1LN_TMVAcLcLFactory));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

static int G__G__TMVA1_323_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Factory*) G__getstructoffset())->AddEvent(*(TString*) libp->para[0].ref, (TMVA::Types::ETreeType) G__int(libp->para[1])
, *(vector<Double_t>*) libp->para[2].ref, (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TMVA::Factory*) G__getstructoffset())->UserAssignEvents((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__TMVA1_323_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Factory*) G__getstructoffset())->SetInputTrees((TTree*) G__int(libp->para[0]), *(TCut*) libp->para[1].ref
, *(TCut*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      ((TMVA::Factory*) G__getstructoffset())->SetInputTrees((TTree*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TMVA::Factory*) G__getstructoffset())->SetInputTrees((TTree*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TMVA::Factory*) G__getstructoffset())->SetInputTrees((TTree*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TMVA::Factory*) G__getstructoffset())->AddSignalTree((TTree*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (TMVA::Types::ETreeType) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TMVA::Factory*) G__getstructoffset())->AddSignalTree((TTree*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Factory*) G__getstructoffset())->AddSignalTree((TTree*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TMVA::Factory*) G__getstructoffset())->AddSignalTree(*((TString*) G__int(libp->para[0])), (Double_t) G__double(libp->para[1])
, (TMVA::Types::ETreeType) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TMVA::Factory*) G__getstructoffset())->AddSignalTree(*((TString*) G__int(libp->para[0])), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Factory*) G__getstructoffset())->AddSignalTree(*((TString*) G__int(libp->para[0])));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Factory*) G__getstructoffset())->AddSignalTree((TTree*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, *(TString*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMVA::Factory*) G__getstructoffset())->SetSignalTree((TTree*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Factory*) G__getstructoffset())->SetSignalTree((TTree*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TMVA::Factory*) G__getstructoffset())->AddBackgroundTree((TTree*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (TMVA::Types::ETreeType) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TMVA::Factory*) G__getstructoffset())->AddBackgroundTree((TTree*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Factory*) G__getstructoffset())->AddBackgroundTree((TTree*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TMVA::Factory*) G__getstructoffset())->AddBackgroundTree(*((TString*) G__int(libp->para[0])), (Double_t) G__double(libp->para[1])
, (TMVA::Types::ETreeType) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TMVA::Factory*) G__getstructoffset())->AddBackgroundTree(*((TString*) G__int(libp->para[0])), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Factory*) G__getstructoffset())->AddBackgroundTree(*((TString*) G__int(libp->para[0])));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Factory*) G__getstructoffset())->AddBackgroundTree((TTree*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, *(TString*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMVA::Factory*) G__getstructoffset())->SetBackgroundTree((TTree*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Factory*) G__getstructoffset())->SetBackgroundTree((TTree*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__TMVA1_323_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TMVA::Factory*) G__getstructoffset())->AddRegressionTree((TTree*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
, (TMVA::Types::ETreeType) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TMVA::Factory*) G__getstructoffset())->AddRegressionTree((TTree*) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Factory*) G__getstructoffset())->AddRegressionTree((TTree*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Factory*) G__getstructoffset())->SetTree((TTree*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TMVA::Factory*) G__getstructoffset())->AddTree((TTree*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (Double_t) G__double(libp->para[2]), *(TCut*) libp->para[3].ref
, (TMVA::Types::ETreeType) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TMVA::Factory*) G__getstructoffset())->AddTree((TTree*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (Double_t) G__double(libp->para[2]), *(TCut*) libp->para[3].ref);
      G__setnull(result7);
      break;
   case 3:
      ((TMVA::Factory*) G__getstructoffset())->AddTree((TTree*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TMVA::Factory*) G__getstructoffset())->AddTree((TTree*) G__int(libp->para[0]), *(TString*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Factory*) G__getstructoffset())->AddTree((TTree*) G__int(libp->para[0]), *(TString*) libp->para[1].ref
, (Double_t) G__double(libp->para[2]), *(TCut*) libp->para[3].ref
, *(TString*) libp->para[4].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

static int G__G__TMVA1_323_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TMVA::Factory*) G__getstructoffset())->AddTarget(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref, (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TMVA::Factory*) G__getstructoffset())->AddTarget(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref, (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TMVA::Factory*) G__getstructoffset())->AddTarget(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref);
      G__setnull(result7);
      break;
   case 2:
      ((TMVA::Factory*) G__getstructoffset())->AddTarget(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Factory*) G__getstructoffset())->AddTarget(*(TString*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TMVA::Factory*) G__getstructoffset())->AddRegressionTarget(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref, (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TMVA::Factory*) G__getstructoffset())->AddRegressionTarget(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref, (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TMVA::Factory*) G__getstructoffset())->AddRegressionTarget(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref);
      G__setnull(result7);
      break;
   case 2:
      ((TMVA::Factory*) G__getstructoffset())->AddRegressionTarget(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Factory*) G__getstructoffset())->AddRegressionTarget(*(TString*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((TMVA::Factory*) G__getstructoffset())->AddSpectator(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref, (Double_t) G__double(libp->para[3])
, (Double_t) G__double(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((TMVA::Factory*) G__getstructoffset())->AddSpectator(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref, (Double_t) G__double(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((TMVA::Factory*) G__getstructoffset())->AddSpectator(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref
, *(TString*) libp->para[2].ref);
      G__setnull(result7);
      break;
   case 2:
      ((TMVA::Factory*) G__getstructoffset())->AddSpectator(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Factory*) G__getstructoffset())->AddSpectator(*(TString*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMVA::Factory*) G__getstructoffset())->SetWeightExpression(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Factory*) G__getstructoffset())->SetWeightExpression(*(TString*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMVA::Factory*) G__getstructoffset())->SetCut(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Factory*) G__getstructoffset())->SetCut(*(TString*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMVA::Factory*) G__getstructoffset())->SetCut(*(TCut*) libp->para[0].ref, *(TString*) libp->para[1].ref);
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Factory*) G__getstructoffset())->SetCut(*(TCut*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMVA::Factory*) G__getstructoffset())->AddCut(*(TString*) libp->para[0].ref, *(TString*) libp->para[1].ref);
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Factory*) G__getstructoffset())->AddCut(*(TString*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((TMVA::Factory*) G__getstructoffset())->AddCut(*(TCut*) libp->para[0].ref, *(TString*) libp->para[1].ref);
      G__setnull(result7);
      break;
   case 1:
      ((TMVA::Factory*) G__getstructoffset())->AddCut(*(TCut*) libp->para[0].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Factory*) G__getstructoffset())->PrepareTrainingAndTestTree(*(TCut*) libp->para[0].ref, *(TString*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::Factory*) G__getstructoffset())->PrepareTrainingAndTestTree(*((TCut*) G__int(libp->para[0])), *((TCut*) G__int(libp->para[1]))
, *(TString*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TMVA::Factory*) G__getstructoffset())->PrepareTrainingAndTestTree(*(TCut*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TMVA::Factory*) G__getstructoffset())->PrepareTrainingAndTestTree(*(TCut*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      ((TMVA::Factory*) G__getstructoffset())->PrepareTrainingAndTestTree(*(TCut*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]), *(TString*) libp->para[5].ref);
      G__setnull(result7);
      break;
   case 5:
      ((TMVA::Factory*) G__getstructoffset())->PrepareTrainingAndTestTree(*(TCut*) libp->para[0].ref, (Int_t) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__TMVA1_323_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TMVA::Factory*) G__getstructoffset())->BookMethod((TMVA::Types::EMVA) G__int(libp->para[0]), *((TString*) G__int(libp->para[1]))
, *((TString*) G__int(libp->para[2])), (TMVA::Types::EMVA) G__int(libp->para[3])
, *((TString*) G__int(libp->para[4]))));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__TMVA1_323_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((const TMVA::Factory*) G__getstructoffset())->MakeClass(*(TString*) libp->para[0].ref);
      G__setnull(result7);
      break;
   case 0:
      ((const TMVA::Factory*) G__getstructoffset())->MakeClass();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_323_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((const TMVA::Factory*) G__getstructoffset())->PrintHelpMessage(*(TString*) libp->para[0].ref);
      G__setnull(result7);
      break;
   case 0:
      ((const TMVA::Factory*) G__getstructoffset())->PrintHelpMessage();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__TMVA1_342_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MethodBoost* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodBoost(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::MethodBoost(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodBoost(*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TMVA::MethodBoost(*(TMVA::DataSetInfo*) 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__TMVA1LN_TMVAcLcLMethodBoost));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_342_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TMVA::MethodBoost*) G__getstructoffset())->BookMethod((TMVA::Types::EMVA) G__int(libp->para[0]), *((TString*) G__int(libp->para[1]))
, *((TString*) G__int(libp->para[2]))));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__TMVA1_420_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MethodCuts* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodCuts(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::MethodCuts(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodCuts(*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TMVA::MethodCuts(*(TMVA::DataSetInfo*) 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__TMVA1LN_TMVAcLcLMethodCuts));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_420_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) TMVA::MethodCuts::DynamicCast((TMVA::IMethod*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_420_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((TMVA::MethodCuts*) G__getstructoffset())->GetmuTransform((TTree*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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


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

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

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

static int G__G__TMVA1_487_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TMVA::MethodANNBase*) G__getstructoffset())->PrintNetwork();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__TMVA1_498_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MethodTMlpANN* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodTMlpANN(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::MethodTMlpANN(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodTMlpANN(*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TMVA::MethodTMlpANN(*(TMVA::DataSetInfo*) 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__TMVA1LN_TMVAcLcLMethodTMlpANN));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__TMVA1_584_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MethodRuleFit* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodRuleFit(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::MethodRuleFit(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodRuleFit(*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TMVA::MethodRuleFit(*(TMVA::DataSetInfo*) 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__TMVA1LN_TMVAcLcLMethodRuleFit));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__TMVA1_584_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TMVA::MethodRuleFit*) G__getstructoffset())->GetRFWorkDir();
         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__TMVA1_584_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMVA::MethodRuleFit*) G__getstructoffset())->GetRFNrules());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__TMVA1_636_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MethodFisher* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodFisher(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::MethodFisher(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodFisher(*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TMVA::MethodFisher(*(TMVA::DataSetInfo*) 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__TMVA1LN_TMVAcLcLMethodFisher));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__TMVA1_639_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::kNN::Event* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new TMVA::kNN::Event(
*(TMVA::kNN::VarVec*) libp->para[0].ref, (Double_t) G__double(libp->para[1])
, (Short_t) G__int(libp->para[2]), *(TMVA::kNN::VarVec*) libp->para[3].ref);
   } else {
     p = new((void*) gvp) TMVA::kNN::Event(
*(TMVA::kNN::VarVec*) libp->para[0].ref, (Double_t) G__double(libp->para[1])
, (Short_t) G__int(libp->para[2]), *(TMVA::kNN::VarVec*) libp->para[3].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLkNNcLcLEvent));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

static int G__G__TMVA1_639_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 102, (double) ((const TMVA::kNN::Event*) G__getstructoffset())->GetDist(*(TMVA::kNN::Event*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_639_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::kNN::Event*) G__getstructoffset())->SetTargets(*(TMVA::kNN::VarVec*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_639_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::kNN::VarVec& obj = ((const TMVA::kNN::Event*) G__getstructoffset())->GetTargets();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_639_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::kNN::VarVec& obj = ((const TMVA::kNN::Event*) G__getstructoffset())->GetVars();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_639_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TMVA::kNN::Event*) G__getstructoffset())->Print();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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


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

static int G__G__TMVA1_691_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MethodKNN* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodKNN(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::MethodKNN(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodKNN(*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TMVA::MethodKNN(*(TMVA::DataSetInfo*) 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__TMVA1LN_TMVAcLcLMethodKNN));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__TMVA1_699_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MethodCFMlpANN* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodCFMlpANN(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::MethodCFMlpANN(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodCFMlpANN(*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TMVA::MethodCFMlpANN(*(TMVA::DataSetInfo*) 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__TMVA1LN_TMVAcLcLMethodCFMlpANN));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__TMVA1_700_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MethodLikelihood* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodLikelihood(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::MethodLikelihood(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodLikelihood(*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TMVA::MethodLikelihood(*(TMVA::DataSetInfo*) 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__TMVA1LN_TMVAcLcLMethodLikelihood));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__TMVA1_701_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MethodHMatrix* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodHMatrix(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::MethodHMatrix(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodHMatrix(*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TMVA::MethodHMatrix(*(TMVA::DataSetInfo*) 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__TMVA1LN_TMVAcLcLMethodHMatrix));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

static int G__G__TMVA1_702_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MethodPDERS* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodPDERS(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::MethodPDERS(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodPDERS(*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TMVA::MethodPDERS(*(TMVA::DataSetInfo*) 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__TMVA1LN_TMVAcLcLMethodPDERS));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__TMVA1_705_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MethodBDT* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodBDT(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::MethodBDT(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodBDT(*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TMVA::MethodBDT(*(TMVA::DataSetInfo*) 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__TMVA1LN_TMVAcLcLMethodBDT));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__TMVA1_727_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MethodDT* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodDT(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::MethodDT(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodDT(*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TMVA::MethodDT(*(TMVA::DataSetInfo*) 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__TMVA1LN_TMVAcLcLMethodDT));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__TMVA1_731_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MethodSVM* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodSVM(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::MethodSVM(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodSVM(*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TMVA::MethodSVM(*(TMVA::DataSetInfo*) 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__TMVA1LN_TMVAcLcLMethodSVM));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__TMVA1_736_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MethodBayesClassifier* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodBayesClassifier(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::MethodBayesClassifier(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodBayesClassifier(*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TMVA::MethodBayesClassifier(*(TMVA::DataSetInfo*) 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__TMVA1LN_TMVAcLcLMethodBayesClassifier));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

static int G__G__TMVA1_738_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MethodFDA* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodFDA(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::MethodFDA(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodFDA(*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TMVA::MethodFDA(*(TMVA::DataSetInfo*) 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__TMVA1LN_TMVAcLcLMethodFDA));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

static int G__G__TMVA1_744_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MethodMLP* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodMLP(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::MethodMLP(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodMLP(*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TMVA::MethodMLP(*(TMVA::DataSetInfo*) 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__TMVA1LN_TMVAcLcLMethodMLP));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__TMVA1_791_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MethodPDEFoam* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodPDEFoam(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::MethodPDEFoam(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodPDEFoam(*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TMVA::MethodPDEFoam(*(TMVA::DataSetInfo*) 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__TMVA1LN_TMVAcLcLMethodPDEFoam));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

static int G__G__TMVA1_791_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TMVA::MethodPDEFoam*) G__getstructoffset())->WriteFoamsToFile();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__TMVA1_791_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TMVA::MethodPDEFoam*) G__getstructoffset())->ReadClonedFoamFromFile((TFile*) G__int(libp->para[0]), *(TString*) libp->para[1].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_791_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::MethodPDEFoam*) G__getstructoffset())->GetNCuts((TMVA::PDEFoamCell*) G__int(libp->para[0]), *(vector<UInt_t>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__TMVA1_791_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TMVA::MethodPDEFoam*) G__getstructoffset())->KernelToUInt((TMVA::MethodPDEFoam::EKernel) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_791_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TMVA::MethodPDEFoam*) G__getstructoffset())->UIntToKernel((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_791_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const TMVA::MethodPDEFoam*) G__getstructoffset())->TargetSelectionToUInt((TMVA::ETargetSelection) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_791_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TMVA::MethodPDEFoam*) G__getstructoffset())->UIntToTargetSelection((UInt_t) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

static int G__G__TMVA1_797_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MethodLD* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodLD(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::MethodLD(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodLD(*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TMVA::MethodLD(*(TMVA::DataSetInfo*) 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__TMVA1LN_TMVAcLcLMethodLD));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

static int G__G__TMVA1_802_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::MethodCategory* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodCategory(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMVA::MethodCategory(
*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TDirectory*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::MethodCategory(*(TMVA::DataSetInfo*) libp->para[0].ref, *(TString*) libp->para[1].ref);
     } else {
       p = new((void*) gvp) TMVA::MethodCategory(*(TMVA::DataSetInfo*) 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__TMVA1LN_TMVAcLcLMethodCategory));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA1_802_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((TMVA::MethodCategory*) G__getstructoffset())->AddMethod(*(TCut*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (TMVA::Types::EMVA) G__int(libp->para[2]), *(TString*) libp->para[3].ref
, *(TString*) libp->para[4].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* TMVA */

/* TMVA::Configurable */

/* TMVA::Event */

/* TMVA::MethodBase */

/* TMVA::Factory */

/* TMVA::MethodBoost */

/* TMVA::MethodCuts */

/* TMVA::MethodCompositeBase */

/* TMVA::MethodANNBase */

/* TMVA::MethodTMlpANN */

/* TMVA::MethodRuleFit */

/* TMVA::MethodFisher */

/* TMVA::kNN::Event */

/* TMVA::MethodKNN */

/* TMVA::MethodCFMlpANN_Utils */

/* TMVA::MethodCFMlpANN */

/* TMVA::MethodLikelihood */

/* TMVA::MethodHMatrix */

/* TMVA::MethodPDERS */

/* TMVA::MethodBDT */

/* TMVA::MethodDT */

/* TMVA::MethodSVM */

/* TMVA::MethodBayesClassifier */

/* TMVA::MethodFDA */

/* TMVA::MethodMLP */

/* TMVA::MethodPDEFoam */

/* TMVA::MethodLD */

/* TMVA::MethodCategory */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__TMVA1 {
 public:
  G__Sizep2memfuncG__TMVA1(): p(&G__Sizep2memfuncG__TMVA1::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__TMVA1::*p)();
};

size_t G__get_sizep2memfuncG__TMVA1()
{
  G__Sizep2memfuncG__TMVA1 a;
  G__setsizep2memfunc((int)a.sizep2memfunc());
  return((size_t)a.sizep2memfunc());
}


/*********************************************************
* virtual base class offset calculation interface
*********************************************************/

   /* Setting up class inheritance */
static long G__2vbo_TMVAcLcLMethodBase_TMVAcLcLIMethod_0(long pobject) {
  TMVA::MethodBase *G__Lderived=(TMVA::MethodBase*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodBoost_TMVAcLcLIMethod_2(long pobject) {
  TMVA::MethodBoost *G__Lderived=(TMVA::MethodBoost*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodCuts_TMVAcLcLIMethod_1(long pobject) {
  TMVA::MethodCuts *G__Lderived=(TMVA::MethodCuts*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodCompositeBase_TMVAcLcLIMethod_1(long pobject) {
  TMVA::MethodCompositeBase *G__Lderived=(TMVA::MethodCompositeBase*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodANNBase_TMVAcLcLIMethod_1(long pobject) {
  TMVA::MethodANNBase *G__Lderived=(TMVA::MethodANNBase*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodTMlpANN_TMVAcLcLIMethod_1(long pobject) {
  TMVA::MethodTMlpANN *G__Lderived=(TMVA::MethodTMlpANN*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodRuleFit_TMVAcLcLIMethod_1(long pobject) {
  TMVA::MethodRuleFit *G__Lderived=(TMVA::MethodRuleFit*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodFisher_TMVAcLcLIMethod_1(long pobject) {
  TMVA::MethodFisher *G__Lderived=(TMVA::MethodFisher*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodKNN_TMVAcLcLIMethod_1(long pobject) {
  TMVA::MethodKNN *G__Lderived=(TMVA::MethodKNN*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodCFMlpANN_TMVAcLcLIMethod_1(long pobject) {
  TMVA::MethodCFMlpANN *G__Lderived=(TMVA::MethodCFMlpANN*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodLikelihood_TMVAcLcLIMethod_1(long pobject) {
  TMVA::MethodLikelihood *G__Lderived=(TMVA::MethodLikelihood*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodHMatrix_TMVAcLcLIMethod_1(long pobject) {
  TMVA::MethodHMatrix *G__Lderived=(TMVA::MethodHMatrix*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodPDERS_TMVAcLcLIMethod_1(long pobject) {
  TMVA::MethodPDERS *G__Lderived=(TMVA::MethodPDERS*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodBDT_TMVAcLcLIMethod_1(long pobject) {
  TMVA::MethodBDT *G__Lderived=(TMVA::MethodBDT*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodDT_TMVAcLcLIMethod_1(long pobject) {
  TMVA::MethodDT *G__Lderived=(TMVA::MethodDT*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodSVM_TMVAcLcLIMethod_1(long pobject) {
  TMVA::MethodSVM *G__Lderived=(TMVA::MethodSVM*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodBayesClassifier_TMVAcLcLIMethod_1(long pobject) {
  TMVA::MethodBayesClassifier *G__Lderived=(TMVA::MethodBayesClassifier*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodFDA_TMVAcLcLIMethod_1(long pobject) {
  TMVA::MethodFDA *G__Lderived=(TMVA::MethodFDA*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodMLP_TMVAcLcLIMethod_2(long pobject) {
  TMVA::MethodMLP *G__Lderived=(TMVA::MethodMLP*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodPDEFoam_TMVAcLcLIMethod_1(long pobject) {
  TMVA::MethodPDEFoam *G__Lderived=(TMVA::MethodPDEFoam*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodLD_TMVAcLcLIMethod_1(long pobject) {
  TMVA::MethodLD *G__Lderived=(TMVA::MethodLD*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMethodCategory_TMVAcLcLIMethod_2(long pobject) {
  TMVA::MethodCategory *G__Lderived=(TMVA::MethodCategory*)pobject;
  TMVA::IMethod *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}


/*********************************************************
* Inheritance information setup/
*********************************************************/
extern "C" void G__cpp_setup_inheritanceG__TMVA1() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable))) {
     TMVA::Configurable *G__Lderived;
     G__Lderived=(TMVA::Configurable*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase))) {
     TMVA::MethodBase *G__Lderived;
     G__Lderived=(TMVA::MethodBase*)0x1000;
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodBase_TMVAcLcLIMethod_0,1,3);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLFactory))) {
     TMVA::Factory *G__Lderived;
     G__Lderived=(TMVA::Factory*)0x1000;
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLFactory),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLFactory),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBoost))) {
     TMVA::MethodBoost *G__Lderived;
     G__Lderived=(TMVA::MethodBoost*)0x1000;
     {
       TMVA::MethodCompositeBase *G__Lpbase=(TMVA::MethodCompositeBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBoost),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCompositeBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBoost),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBoost),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodBoost_TMVAcLcLIMethod_2,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBoost),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBoost),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCuts))) {
     TMVA::MethodCuts *G__Lderived;
     G__Lderived=(TMVA::MethodCuts*)0x1000;
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCuts),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCuts),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodCuts_TMVAcLcLIMethod_1,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCuts),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCuts),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TMVA::IFitterTarget *G__Lpbase=(TMVA::IFitterTarget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCuts),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIFitterTarget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCompositeBase))) {
     TMVA::MethodCompositeBase *G__Lderived;
     G__Lderived=(TMVA::MethodCompositeBase*)0x1000;
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCompositeBase),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCompositeBase),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodCompositeBase_TMVAcLcLIMethod_1,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCompositeBase),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCompositeBase),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodANNBase))) {
     TMVA::MethodANNBase *G__Lderived;
     G__Lderived=(TMVA::MethodANNBase*)0x1000;
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodANNBase),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodANNBase),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodANNBase_TMVAcLcLIMethod_1,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodANNBase),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodANNBase),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodTMlpANN))) {
     TMVA::MethodTMlpANN *G__Lderived;
     G__Lderived=(TMVA::MethodTMlpANN*)0x1000;
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodTMlpANN),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodTMlpANN),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodTMlpANN_TMVAcLcLIMethod_1,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodTMlpANN),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodTMlpANN),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodRuleFit))) {
     TMVA::MethodRuleFit *G__Lderived;
     G__Lderived=(TMVA::MethodRuleFit*)0x1000;
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodRuleFit),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodRuleFit),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodRuleFit_TMVAcLcLIMethod_1,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodRuleFit),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodRuleFit),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFisher))) {
     TMVA::MethodFisher *G__Lderived;
     G__Lderived=(TMVA::MethodFisher*)0x1000;
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFisher),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFisher),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodFisher_TMVAcLcLIMethod_1,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFisher),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFisher),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodKNN))) {
     TMVA::MethodKNN *G__Lderived;
     G__Lderived=(TMVA::MethodKNN*)0x1000;
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodKNN),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodKNN),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodKNN_TMVAcLcLIMethod_1,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodKNN),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodKNN),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN))) {
     TMVA::MethodCFMlpANN *G__Lderived;
     G__Lderived=(TMVA::MethodCFMlpANN*)0x1000;
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodCFMlpANN_TMVAcLcLIMethod_1,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TMVA::MethodCFMlpANN_Utils *G__Lpbase=(TMVA::MethodCFMlpANN_Utils*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_Utils),(long)G__Lpbase-(long)G__Lderived,4,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodLikelihood))) {
     TMVA::MethodLikelihood *G__Lderived;
     G__Lderived=(TMVA::MethodLikelihood*)0x1000;
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodLikelihood),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodLikelihood),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodLikelihood_TMVAcLcLIMethod_1,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodLikelihood),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodLikelihood),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodHMatrix))) {
     TMVA::MethodHMatrix *G__Lderived;
     G__Lderived=(TMVA::MethodHMatrix*)0x1000;
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodHMatrix),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodHMatrix),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodHMatrix_TMVAcLcLIMethod_1,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodHMatrix),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodHMatrix),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERS))) {
     TMVA::MethodPDERS *G__Lderived;
     G__Lderived=(TMVA::MethodPDERS*)0x1000;
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERS),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERS),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodPDERS_TMVAcLcLIMethod_1,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERS),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERS),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBDT))) {
     TMVA::MethodBDT *G__Lderived;
     G__Lderived=(TMVA::MethodBDT*)0x1000;
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBDT),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBDT),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodBDT_TMVAcLcLIMethod_1,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBDT),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBDT),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodDT))) {
     TMVA::MethodDT *G__Lderived;
     G__Lderived=(TMVA::MethodDT*)0x1000;
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodDT),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodDT),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodDT_TMVAcLcLIMethod_1,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodDT),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodDT),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodSVM))) {
     TMVA::MethodSVM *G__Lderived;
     G__Lderived=(TMVA::MethodSVM*)0x1000;
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodSVM),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodSVM),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodSVM_TMVAcLcLIMethod_1,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodSVM),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodSVM),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBayesClassifier))) {
     TMVA::MethodBayesClassifier *G__Lderived;
     G__Lderived=(TMVA::MethodBayesClassifier*)0x1000;
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBayesClassifier),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBayesClassifier),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodBayesClassifier_TMVAcLcLIMethod_1,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBayesClassifier),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBayesClassifier),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFDA))) {
     TMVA::MethodFDA *G__Lderived;
     G__Lderived=(TMVA::MethodFDA*)0x1000;
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFDA),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFDA),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodFDA_TMVAcLcLIMethod_1,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFDA),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFDA),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TMVA::IFitterTarget *G__Lpbase=(TMVA::IFitterTarget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFDA),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIFitterTarget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodMLP))) {
     TMVA::MethodMLP *G__Lderived;
     G__Lderived=(TMVA::MethodMLP*)0x1000;
     {
       TMVA::MethodANNBase *G__Lpbase=(TMVA::MethodANNBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodMLP),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodANNBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodMLP),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodMLP),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodMLP_TMVAcLcLIMethod_2,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodMLP),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodMLP),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TMVA::IFitterTarget *G__Lpbase=(TMVA::IFitterTarget*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodMLP),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIFitterTarget),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TMVA::ConvergenceTest *G__Lpbase=(TMVA::ConvergenceTest*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodMLP),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConvergenceTest),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDEFoam))) {
     TMVA::MethodPDEFoam *G__Lderived;
     G__Lderived=(TMVA::MethodPDEFoam*)0x1000;
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDEFoam),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDEFoam),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodPDEFoam_TMVAcLcLIMethod_1,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDEFoam),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDEFoam),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodLD))) {
     TMVA::MethodLD *G__Lderived;
     G__Lderived=(TMVA::MethodLD*)0x1000;
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodLD),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodLD),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodLD_TMVAcLcLIMethod_1,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodLD),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodLD),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCategory))) {
     TMVA::MethodCategory *G__Lderived;
     G__Lderived=(TMVA::MethodCategory*)0x1000;
     {
       TMVA::MethodCompositeBase *G__Lpbase=(TMVA::MethodCompositeBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCategory),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCompositeBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TMVA::MethodBase *G__Lpbase=(TMVA::MethodBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCategory),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCategory),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod),(long)G__2vbo_TMVAcLcLMethodCategory_TMVAcLcLIMethod_2,1,2);
     }
     {
       TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCategory),G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCategory),G__get_linked_tagnum(&G__G__TMVA1LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__TMVA1() {

   /* Setting up typedef entry */
   G__search_typename2("Char_t",99,-1,0,-1);
   G__setnewtype(-1,"Signed Character 1 byte (char)",0);
   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("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("Long64_t",110,-1,0,-1);
   G__setnewtype(-1,"Portable signed long integer 8 bytes",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1LN_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__TMVA1LN_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__TMVA1LN_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__TMVA1LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMVAVersion_t",104,-1,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVA));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,TMVA::Types::EMVA>",117,G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<EMsgType,std::string>",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TMVA::EMsgType,string>",117,G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Option<Bool_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLOptionlEboolgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVA));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<bool>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEboolcOallocatorlEboolgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Option<Bool_t*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLOptionlEboolmUgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVA));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Option<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLOptionlEfloatgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVA));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<float>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Float_t*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<float*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,TObjArray*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*,less<string> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Event*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::Event*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<Event*>*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<Event*>*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<TMVA::Event*,allocator<TMVA::Event*> >*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,Results*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,TMVA::Results*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,TMVA::Results*,less<TString> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::map<TString,Results*> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<map<TString,Results*> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<map<TString,TMVA::Results*,less<TString>,allocator<pair<const TString,TMVA::Results*> > > >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Char_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEcharcOallocatorlEchargRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEcharcOallocatorlEchargRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEcharcOallocatorlEchargRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<char>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEcharcOallocatorlEchargRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Int_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Float_t,Long64_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_pairlEfloatcOlongsPlonggR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::pair<Float_t,Long64_t>*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<Float_t,Long64_t>*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<float,long long>*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<std::pair<Float_t,Long64_t>*> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<pair<Float_t,Long64_t>*> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<pair<float,long long>*,allocator<pair<float,long long>*> > >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Long64_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<long long>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<Long64_t> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<Long64_t> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<long long,allocator<long long> > >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<IMethod*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLIMethodmUcOallocatorlETMVAcLcLIMethodmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLIMethodmUcOallocatorlETMVAcLcLIMethodmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLIMethodmUcOallocatorlETMVAcLcLIMethodmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLIMethodmUcOallocatorlETMVAcLcLIMethodmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLIMethodmUcOallocatorlETMVAcLcLIMethodmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::IMethod*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLIMethodmUcOallocatorlETMVAcLcLIMethodmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("MVector",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLIMethodmUcOallocatorlETMVAcLcLIMethodmUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLFactory));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<double>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::VariableTransformBase*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLVariableTransformBasemUcOallocatorlETMVAcLcLVariableTransformBasemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLVariableTransformBasemUcOallocatorlETMVAcLcLVariableTransformBasemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLVariableTransformBasemUcOallocatorlETMVAcLcLVariableTransformBasemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLVariableTransformBasemUcOallocatorlETMVAcLcLVariableTransformBasemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLVariableTransformBasemUcOallocatorlETMVAcLcLVariableTransformBasemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TTree*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETTreemUcOallocatorlETTreemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETTreemUcOallocatorlETTreemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETTreemUcOallocatorlETTreemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETTreemUcOallocatorlETTreemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETTreemUcOallocatorlETTreemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<VariableInfo>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::VariableInfo>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<ClassInfo*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::ClassInfo*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::TransformationHandler::VariableStat>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<TMVA::TransformationHandler::VariableStat> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<TMVA::TransformationHandler::VariableStat> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> > >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Ranking*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::Ranking*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,TMVA::Interval*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplETStringcOTMVAcLcLIntervalmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIntervalmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,TMVA::Interval*,less<TString> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplETStringcOTMVAcLcLIntervalmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIntervalmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,double>",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,double,less<TString> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::vector<Double_t>,Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<vector<Double_t>,Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<vector<double,allocator<double> >,double>",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<vector<double,allocator<double> >,double,less<vector<double,allocator<double> > > >",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<Float_t> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<Float_t> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<float,allocator<float> > >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const std::vector<TMVA::Event*>*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const vector<TMVA::Event*,allocator<TMVA::Event*> >*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTBaselEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTBaselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow_const<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTRow_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn_const<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTColumn_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag_const<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTDiag_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat_const<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTFlat_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub_const<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTSub_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow_const<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTSparseRow_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag_const<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTSparseDiag_constlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTRowlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTColumnlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTDiaglEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTFlatlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTSublEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTSparseRowlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTSparseDiaglEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementActionT<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TElementActionTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementPosActionT<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TElementPosActionTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TH1*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETH1mUcOallocatorlETH1mUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETH1mUcOallocatorlETH1mUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TNeuron*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLTNeuronmUcOallocatorlETMVAcLcLTNeuronmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLTNeuronmUcOallocatorlETMVAcLcLTNeuronmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLTNeuronmUcOallocatorlETMVAcLcLTNeuronmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLTNeuronmUcOallocatorlETMVAcLcLTNeuronmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLTNeuronmUcOallocatorlETMVAcLcLTNeuronmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::TNeuron*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLTNeuronmUcOallocatorlETMVAcLcLTNeuronmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTRow_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTColumn_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTDiag_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTFlat_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTSub_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTSparseRow_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTSparseDiag_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTRowlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTColumnlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTDiaglEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTFlatlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTSublEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTSparseRowlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTSparseDiaglEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementActionT<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TElementActionTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementPosActionT<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TElementPosActionTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSym<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTSymlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparse<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTSparselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const TMVA::BinarySearchTreeNode*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Double_t,const TMVA::Event*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1LN_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__TMVA1LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<double,const TMVA::Event*> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const TMVA::Event*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const TMVA::Node*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const TMVA::DecisionTree*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::Rule*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TH1F*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<UInt_t> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<UInt_t> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<unsigned int,allocator<unsigned int> > >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<Double_t> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<Double_t> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<double,allocator<double> > >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TH2F*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH2FmUcOallocatorlETH2FmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETH2FmUcOallocatorlETH2FmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH2FmUcOallocatorlETH2FmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETH2FmUcOallocatorlETH2FmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH2FmUcOallocatorlETH2FmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::DecisionTree*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLDecisionTreemUcOallocatorlETMVAcLcLDecisionTreemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLDecisionTreemUcOallocatorlETMVAcLcLDecisionTreemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLDecisionTreemUcOallocatorlETMVAcLcLDecisionTreemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLDecisionTreemUcOallocatorlETMVAcLcLDecisionTreemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLDecisionTreemUcOallocatorlETMVAcLcLDecisionTreemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<DecisionTree*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLDecisionTreemUcOallocatorlETMVAcLcLDecisionTreemUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodRuleFit));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<EFitParameters>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLMethodCutscLcLEFitParameterscOallocatorlETMVAcLcLMethodCutscLcLEFitParametersgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLMethodCutscLcLEFitParameterscOallocatorlETMVAcLcLMethodCutscLcLEFitParametersgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLMethodCutscLcLEFitParameterscOallocatorlETMVAcLcLMethodCutscLcLEFitParametersgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLMethodCutscLcLEFitParameterscOallocatorlETMVAcLcLMethodCutscLcLEFitParametersgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLMethodCutscLcLEFitParameterscOallocatorlETMVAcLcLMethodCutscLcLEFitParametersgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::MethodCuts::EFitParameters>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLMethodCutscLcLEFitParameterscOallocatorlETMVAcLcLMethodCutscLcLEFitParametersgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Interval*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::Interval*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<PDF*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::PDF*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("VarType",102,-1,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLkNN));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<VarType>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLkNN));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("VarVec",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLkNN));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::kNN::Event>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLkNNcLcLEventcOallocatorlETMVAcLcLkNNcLcLEventgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLkNNcLcLEventcOallocatorlETMVAcLcLkNNcLcLEventgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLkNNcLcLEventcOallocatorlETMVAcLcLkNNcLcLEventgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLkNNcLcLEventcOallocatorlETMVAcLcLkNNcLcLEventgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLkNNcLcLEventcOallocatorlETMVAcLcLkNNcLcLEventgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Node<Event>",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLkNNcLcLNodelETMVAcLcLkNNcLcLEventgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLkNN));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<const Node<Event>*,VarType>",117,G__get_linked_tagnum(&G__G__TMVA1LN_pairlEconstsPTMVAcLcLkNNcLcLNodelETMVAcLcLkNNcLcLEventgRmUcOfloatgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLkNN));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<Elem>",117,G__get_linked_tagnum(&G__G__TMVA1LN_listlEpairlEconstsPTMVAcLcLkNNcLcLNodelETMVAcLcLkNNcLcLEventgRmUcOfloatgRcOallocatorlEpairlEconstsPTMVAcLcLkNNcLcLNodelETMVAcLcLkNNcLcLEventgRmUcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("list<pair<const TMVA::kNN::Node<TMVA::kNN::Event>*,float> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_listlEpairlEconstsPTMVAcLcLkNNcLcLNodelETMVAcLcLkNNcLcLEventgRmUcOfloatgRcOallocatorlEpairlEconstsPTMVAcLcLkNNcLcLNodelETMVAcLcLkNNcLcLEventgRmUcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,std::vector<Double_t> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEintcOvectorlEdoublecOallocatorlEdoublegRsPgRcOlesslEintgRcOallocatorlEpairlEconstsPintcOvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,vector<double,allocator<double> > >",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEintcOvectorlEdoublecOallocatorlEdoublegRsPgRcOlesslEintgRcOallocatorlEpairlEconstsPintcOvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,vector<double,allocator<double> >,less<int> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEintcOvectorlEdoublecOallocatorlEdoublegRsPgRcOlesslEintgRcOallocatorlEpairlEconstsPintcOvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<Int_t,Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,double>",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,double,less<int> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<Short_t,UInt_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEshortcOunsignedsPintcOlesslEshortgRcOallocatorlEpairlEconstsPshortcOunsignedsPintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<short,unsigned int>",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEshortcOunsignedsPintcOlesslEshortgRcOallocatorlEpairlEconstsPshortcOunsignedsPintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<short,unsigned int,less<short> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEshortcOunsignedsPintcOlesslEshortgRcOallocatorlEpairlEconstsPshortcOunsignedsPintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<Int_t,std::vector<Float_t> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEintcOvectorlEfloatcOallocatorlEfloatgRsPgRcOlesslEintgRcOallocatorlEpairlEconstsPintcOvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,vector<float,allocator<float> > >",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEintcOvectorlEfloatcOallocatorlEfloatgRsPgRcOlesslEintgRcOallocatorlEpairlEconstsPintcOvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,vector<float,allocator<float> >,less<int> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEintcOvectorlEfloatcOallocatorlEfloatgRsPgRcOlesslEintgRcOallocatorlEpairlEconstsPintcOvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<Int_t,Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEintcOfloatcOlesslEintgRcOallocatorlEpairlEconstsPintcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,float>",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEintcOfloatcOlesslEintgRcOallocatorlEpairlEconstsPintcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<int,float,less<int> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEintcOfloatcOlesslEintgRcOallocatorlEpairlEconstsPintcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const BinarySearchTreeNode*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERS));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Double_t,Double_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_pairlEdoublecOdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::pair<Double_t,Double_t> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<Double_t,Double_t> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<double,double> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<DecisionTree*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLDecisionTreemUcOallocatorlETMVAcLcLDecisionTreemUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBDT));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<const TMVA::Event*,std::pair<Double_t,Double_t> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEconstsPTMVAcLcLEventmUcOpairlEdoublecOdoublegRcOlesslEconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEconstsPTMVAcLcLEventmUsPconstcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<const TMVA::Event*,pair<double,double> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEconstsPTMVAcLcLEventmUcOpairlEdoublecOdoublegRcOlesslEconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEconstsPTMVAcLcLEventmUsPconstcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<const TMVA::Event*,pair<double,double>,less<const TMVA::Event*> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEconstsPTMVAcLcLEventmUcOpairlEdoublecOdoublegRcOlesslEconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEconstsPTMVAcLcLEventmUsPconstcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<const TMVA::Event*,std::vector<double> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEconstsPTMVAcLcLEventmUcOvectorlEdoublecOallocatorlEdoublegRsPgRcOlesslEconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEconstsPTMVAcLcLEventmUsPconstcOvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<const TMVA::Event*,vector<double,allocator<double> > >",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEconstsPTMVAcLcLEventmUcOvectorlEdoublecOallocatorlEdoublegRsPgRcOlesslEconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEconstsPTMVAcLcLEventmUsPconstcOvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<const TMVA::Event*,vector<double,allocator<double> >,less<const TMVA::Event*> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_maplEconstsPTMVAcLcLEventmUcOvectorlEdoublecOallocatorlEdoublegRsPgRcOlesslEconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEconstsPTMVAcLcLEventmUsPconstcOvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Bool_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEboolcOallocatorlEboolgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::SVEvent*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLSVEventmUcOallocatorlETMVAcLcLSVEventmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLSVEventmUcOallocatorlETMVAcLcLSVEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLSVEventmUcOallocatorlETMVAcLcLSVEventmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLSVEventmUcOallocatorlETMVAcLcLSVEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLSVEventmUcOallocatorlETMVAcLcLSVEventmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("deque<Short_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_dequelEshortcOallocatorlEshortgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("deque<short>",117,G__get_linked_tagnum(&G__G__TMVA1LN_dequelEshortcOallocatorlEshortgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Float_t,Float_t>",117,G__get_linked_tagnum(&G__G__TMVA1LN_pairlEfloatcOfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::pair<Float_t,Float_t> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<Float_t,Float_t> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<float,float> >",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::PDEFoamCell*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TH1D*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1DmUcOallocatorlETH1DmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETH1DmUcOallocatorlETH1DmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1DmUcOallocatorlETH1DmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETH1DmUcOallocatorlETH1DmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1DmUcOallocatorlETH1DmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("EKernel",117,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDEFoamcLcLEKernel),0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDEFoam));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<PDEFoam*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLPDEFoammUcOallocatorlETMVAcLcLPDEFoammUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLPDEFoammUcOallocatorlETMVAcLcLPDEFoammUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLPDEFoammUcOallocatorlETMVAcLcLPDEFoammUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLPDEFoammUcOallocatorlETMVAcLcLPDEFoammUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLPDEFoammUcOallocatorlETMVAcLcLPDEFoammUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::PDEFoam*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLPDEFoammUcOallocatorlETMVAcLcLPDEFoammUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<Double_t>*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<Double_t>*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<double,allocator<double> >*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TCut>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETCutcOallocatorlETCutgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETCutcOallocatorlETCutgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETCutcOallocatorlETCutgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETCutcOallocatorlETCutgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETCutcOallocatorlETCutgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TTreeFormula*>",117,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETTreeFormulamUcOallocatorlETTreeFormulamUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETTreeFormulamUcOallocatorlETTreeFormulamUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETTreeFormulamUcOallocatorlETTreeFormulamUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA1LN_reverse_iteratorlEvectorlETTreeFormulamUcOallocatorlETTreeFormulamUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETTreeFormulamUcOallocatorlETTreeFormulamUgRsPgR));
   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__TMVA1LN_TMVA));
   {
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1LN_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__TMVA1LN_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__TMVA1LN_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__TMVA1LN_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__TMVA1LN_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__TMVA1LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kSILENT=%lldLL",(long long)TMVA::kSILENT).data(),0,(char*)NULL);
   G__memvar_setup((void*)(&TMVA::max_Events_),105,0,1,-1,-1,-1,1,"max_Events_=",0,(char*)NULL);
   G__memvar_setup((void*)(&TMVA::max_nLayers_),105,0,1,-1,-1,-1,1,"max_nLayers_=",0,(char*)NULL);
   G__memvar_setup((void*)(&TMVA::max_nNodes_),105,0,1,-1,-1,-1,1,"max_nNodes_=",0,(char*)NULL);
   G__memvar_setup((void*)(&TMVA::max_nVar_),105,0,1,-1,-1,-1,1,"max_nVar_=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEDTSeparation),-1,-2,1,G__FastAllocString(2048).Format("kFoam=%lldLL",(long long)TMVA::kFoam).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEDTSeparation),-1,-2,1,G__FastAllocString(2048).Format("kGiniIndex=%lldLL",(long long)TMVA::kGiniIndex).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEDTSeparation),-1,-2,1,G__FastAllocString(2048).Format("kMisClassificationError=%lldLL",(long long)TMVA::kMisClassificationError).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEDTSeparation),-1,-2,1,G__FastAllocString(2048).Format("kCrossEntropy=%lldLL",(long long)TMVA::kCrossEntropy).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEDTSeparation),-1,-2,1,G__FastAllocString(2048).Format("kGiniIndexWithLaplace=%lldLL",(long long)TMVA::kGiniIndexWithLaplace).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEDTSeparation),-1,-2,1,G__FastAllocString(2048).Format("kSdivSqrtSplusB=%lldLL",(long long)TMVA::kSdivSqrtSplusB).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEFoamType),-1,-2,1,G__FastAllocString(2048).Format("kSeparate=%lldLL",(long long)TMVA::kSeparate).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEFoamType),-1,-2,1,G__FastAllocString(2048).Format("kDiscr=%lldLL",(long long)TMVA::kDiscr).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEFoamType),-1,-2,1,G__FastAllocString(2048).Format("kMonoTarget=%lldLL",(long long)TMVA::kMonoTarget).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEFoamType),-1,-2,1,G__FastAllocString(2048).Format("kMultiTarget=%lldLL",(long long)TMVA::kMultiTarget).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEFoamType),-1,-2,1,G__FastAllocString(2048).Format("kMultiClass=%lldLL",(long long)TMVA::kMultiClass).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kValue=%lldLL",(long long)TMVA::kValue).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kValueError=%lldLL",(long long)TMVA::kValueError).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kValueDensity=%lldLL",(long long)TMVA::kValueDensity).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kMeanValue=%lldLL",(long long)TMVA::kMeanValue).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kRms=%lldLL",(long long)TMVA::kRms).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kRmsOvMean=%lldLL",(long long)TMVA::kRmsOvMean).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kCellVolume=%lldLL",(long long)TMVA::kCellVolume).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLETargetSelection),-1,-2,1,G__FastAllocString(2048).Format("kMean=%lldLL",(long long)TMVA::kMean).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLETargetSelection),-1,-2,1,G__FastAllocString(2048).Format("kMpv=%lldLL",(long long)TMVA::kMpv).data(),0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::Configurable */
static void G__setup_memvarTMVAcLcLConfigurable(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable));
   { TMVA::Configurable *p; p=(TMVA::Configurable*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fOptions=",0,"! options string");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fLooseOptionCheckingEnabled=",0,"! checker for option string");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLOptionBase),-1,-1,4,"fLastDeclaredOption=",0,"! last declared option");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TList),-1,-1,4,"fListOfOptions=",0,"! option list");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fConfigName=",0,"the name of this configurable");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fConfigDescription=",0,"description of this configurable");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fReferenceFile=",0,"reference file for options writing");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"! message logger");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::Event */
static void G__setup_memvarTMVAcLcLEvent(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEvent));
   { TMVA::Event *p; p=(TMVA::Event*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgIsTraining=",0,"mark if we are in an actual training or \"evaluation/testing\" phase --> ignoreNegWeights only in actual training !");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgIgnoreNegWeightsInTraining=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fValues=",0,"the event values ; mutable, to be able to copy the dynamic values in there");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fValuesRearranged=",0,"the event values ; mutable, to be able to copy the dynamic values in there");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR),G__defined_typename("vector<Float_t*>"),-1,4,"fValuesDynamic=",0,"the event values");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fTargets=",0,"target values for regression");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fSpectators=",0,"\"visisting\" variables not used in MVAs ; mutable, to be able to copy the dynamic values in there");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),G__defined_typename("vector<UInt_t>"),-1,4,"fVariableArrangement=",0,"needed for MethodCategories, where we can train on other than the main variables");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fClass=",0,"class number");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fWeight=",0,"event weight (product of global and individual weights)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fBoostWeight=",0,"internal weight to be set by boosting algorithm");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDynamic=",0,"is set when the dynamic values are taken");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDoNotBoost=",0,"mark event as not to be boosted (used to compensate for events with negative event weights");
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodBase */
static void G__setup_memvarTMVAcLcLMethodBase(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase));
   { TMVA::MethodBase *p; p=(TMVA::MethodBase*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBasecLcLEWeightFileType),-1,-2,1,G__FastAllocString(2048).Format("kROOT=%lldLL",(long long)TMVA::MethodBase::kROOT).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBasecLcLEWeightFileType),-1,-2,1,G__FastAllocString(2048).Format("kTEXT=%lldLL",(long long)TMVA::MethodBase::kTEXT).data(),0,(char*)NULL);
   G__memvar_setup((void*)((long)(&p->fTmpEvent)-(long)(p)),85,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEvent),-1,-1,1,"fTmpEvent=",0,"! temporary event when testing on a different DataSet than the own one");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBasecLcLECutOrientation),-1,-2,4,"kNegative=-1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBasecLcLECutOrientation),-1,-2,4,"kPositive=1LL",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking),-1,-1,2,"fRanking=",0,"pointer to ranking object (created by derived classifiers)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETStringcOallocatorlETStringgRsPgR),G__defined_typename("vector<TString>"),-1,2,"fInputVars=",0,"vector of input variables used in MVA");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNbins=",0,"number of bins in input variable histograms");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNbinsMVAoutput=",0,"number of bins in MVA output histograms");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNbinsH=",0,"number of bins in evaluation histograms");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLTypescLcLEAnalysisType),-1,-1,2,"fAnalysisType=",0,"method-mode : true --> regression, false --> classification");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,2,"fRegressionReturnVal=",0,"holds the return-values for the regression");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,2,"fMulticlassReturnVal=",0,"holds the return-values for the multiclass classification");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDisableWriting=",0,"! set to true in order to suppress writing to XML");
   G__memvar_setup((void*)0,117,1,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLDataSetInfo),-1,-1,4,"fDataSetInfo=",0,"! the data set information (sometimes needed)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSignalReferenceCut=",0,"minimum requirement on the MVA output to declare an event signal-like");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSignalReferenceCutOrientation=",0,"minimum requirement on the MVA output to declare an event signal-like");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLTypescLcLESBType),-1,-1,4,"fVariableTransformType=",0,"this is the event type (sig or bgd) assumed for variable transform");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fJobName=",0,"name of job -> user defined, appears in weight files");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fMethodName=",0,"name of the method (set in derived class)");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLTypescLcLEMVA),-1,-1,4,"fMethodType=",0,"type of method (set in derived class)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fTestvar=",0,"variable used in evaluation, etc (mostly the MVA)");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fTMVATrainingVersion=",0,"TMVA version used for training");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fROOTTrainingVersion=",0,"ROOT version used for training");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fConstructedFromWeightFile=",0,"is it obtained from weight file?");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TDirectory),-1,-1,4,"fBaseDir=",0,"base directory for the instance, needed to know where to jump back from localDir");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TDirectory),-1,-1,4,"fMethodBaseDir=",0,"base directory for the method");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fParentDir=",0,"method parent name, like booster name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fFileDir=",0,"unix sub-directory for weight files (default: \"weights\")");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fWeightFile=",0,"weight file name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TH1),-1,-1,4,"fEffS=",0,"efficiency histogram for rootfinder");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLPDF),-1,-1,4,"fDefaultPDF=",0,"default PDF definitions");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLPDF),-1,-1,4,"fMVAPdfS=",0,"signal MVA PDF");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLPDF),-1,-1,4,"fMVAPdfB=",0,"background MVA PDF");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLPDF),-1,-1,4,"fSplS=",0,"PDFs of MVA distribution (signal)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLPDF),-1,-1,4,"fSplB=",0,"PDFs of MVA distribution (background)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TSpline),-1,-1,4,"fSpleffBvsS=",0,"splines for signal eff. versus background eff.");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLPDF),-1,-1,4,"fSplTrainS=",0,"PDFs of training MVA distribution (signal)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLPDF),-1,-1,4,"fSplTrainB=",0,"PDFs of training MVA distribution (background)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TSpline),-1,-1,4,"fSplTrainEffBvsS=",0,"splines for training signal eff. versus background eff.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMeanS=",0,"mean (signal)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMeanB=",0,"mean (background)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRmsS=",0,"RMS (signal)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRmsB=",0,"RMS (background)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fXmin=",0,"minimum (signal and background)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fXmax=",0,"maximum (signal and background)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fVarTransformString=",0,"labels variable transform method");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLTransformationHandler),-1,-1,4,"fTransformationPointer=",0,"pointer to the rest of transformations");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLTransformationHandler),-1,-1,4,"fTransformation=",0,"the list of transformations");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fVerbose=",0,"verbose flag");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fVerbosityLevelString=",0,"verbosity level (user input string)");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEMsgType),-1,-1,4,"fVerbosityLevel=",0,"verbosity level");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fHelp=",0,"help flag");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fHasMVAPdfs=",0,"MVA Pdfs are created for this classifier");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fIgnoreNegWeightsInTraining=",0,"If true, events with negative weights are not used in training");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fSignalClass=",0,"index of the Signal-class");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fBackgroundClass=",0,"index of the Background-class");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTrainTime=",0,"for timing measurements");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTestTime=",0,"for timing measurements");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBasecLcLECutOrientation),-1,-1,4,"fCutOrientation=",0,"+1 if Sig>Bkg, -1 otherwise");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLTSpline1),-1,-1,4,"fSplRefS=",0,"helper splines for RootFinder (signal)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLTSpline1),-1,-1,4,"fSplRefB=",0,"helper splines for RootFinder (background)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLTSpline1),-1,-1,4,"fSplTrainRefS=",0,"helper splines for RootFinder (signal)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLTSpline1),-1,-1,4,"fSplTrainRefB=",0,"helper splines for RootFinder (background)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR),G__defined_typename("vector<const std::vector<TMVA::Event*>*>"),-1,4,"fEventCollections=",0,"if the method needs the complete event-collection, the transformed event coll. ist stored here.");
   G__memvar_setup((void*)((long)(&p->fSetupCompleted)-(long)(p)),103,0,0,-1,G__defined_typename("Bool_t"),-1,1,"fSetupCompleted=",0,"is method setup");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),-1,-2,4,"fgThisBase=",0,"this pointer");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNormalise=",0,"normalise input variables");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseDecorr=",0,"synonymous for decorrelation");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fVariableTransformTypeString=",0,"labels variable transform type");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTxtWeightsOnly=",0,"if TRUE, write weights only to text files ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNbinsMVAPdf=",0,"number of bins used in histogram that creates PDF");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNsmoothMVAPdf=",0,"number of times a histogram is smoothed before creating the PDF");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::Factory */
static void G__setup_memvarTMVAcLcLFactory(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLFactory));
   { TMVA::Factory *p; p=(TMVA::Factory*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLDataSetManager),-1,-1,4,"fDataSetManager=",0,"DSMTEST");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TFile),-1,-2,4,"fgTargetFile=",0,"! ROOT output file");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLDataInputHandler),-1,-1,4,"fDataInputHandler=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLVariableTransformBasemUcOallocatorlETMVAcLcLVariableTransformBasemUgRsPgR),G__defined_typename("vector<TMVA::VariableTransformBase*>"),-1,4,"fDefaultTrfs=",0,"! list of transformations on default DataSet");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fOptions=",0,"! option string given by construction (presently only \"V\")");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fTransformations=",0,"! List of transformations to test");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fVerbose=",0,"! verbose mode");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLIMethodmUcOallocatorlETMVAcLcLIMethodmUgRsPgR),G__defined_typename("MVector"),-1,4,"fMethods=",0,"! all MVA methods");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fJobName=",0,"! jobname, used as extension in weight file names");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLFactorycLcLDataAssignType),-1,-2,4,"kUndefined=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLFactorycLcLDataAssignType),-1,-2,4,"kAssignTrees=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLFactorycLcLDataAssignType),-1,-2,4,"kAssignEvents=2LL",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLFactorycLcLDataAssignType),-1,-1,4,"fDataAssignType=",0,"! flags for data assigning");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETTreemUcOallocatorlETTreemUgRsPgR),G__defined_typename("vector<TTree*>"),-1,4,"fTrainAssignTree=",0,"! for each class: tmp tree if user wants to assign the events directly");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETTreemUcOallocatorlETTreemUgRsPgR),G__defined_typename("vector<TTree*>"),-1,4,"fTestAssignTree=",0,"! for each class: tmp tree if user wants to assign the events directly");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fATreeType=",0,"type of event (=classIndex)");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fATreeWeight=",0,"weight of the event");
   G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,4,"fATreeEvent=",0,"event variables");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLTypescLcLEAnalysisType),-1,-1,4,"fAnalysisType=",0,"! the training type");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodBoost */
static void G__setup_memvarTMVAcLcLMethodBoost(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBoost));
   { TMVA::MethodBoost *p; p=(TMVA::MethodBoost*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fBoostNum=",0,"Number of times the classifier is boosted");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fBoostType=",0,"string specifying the boost type      ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fTransformString=",0,"min and max values for the classifier response      ");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDetailedMonitoring=",0,"produce detailed monitoring histograms (boost-wise)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAdaBoostBeta=",0,"ADA boost parameter, default is 1      ");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fRandomSeed=",0,"seed for random number generator used for bagging");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fBaggedSampleFraction=",0,"rel.Size of bagged sample");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fBoostedMethodName=",0,"details of the boosted classifier");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fBoostedMethodTitle=",0,"title ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fBoostedMethodOptions=",0,"options");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMonitorBoostedMethod=",0,"monitor the MVA response of every classifier");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR),G__defined_typename("vector<TH1*>"),-1,4,"fTrainSigMVAHist=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR),G__defined_typename("vector<TH1*>"),-1,4,"fTrainBgdMVAHist=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR),G__defined_typename("vector<TH1*>"),-1,4,"fBTrainSigMVAHist=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR),G__defined_typename("vector<TH1*>"),-1,4,"fBTrainBgdMVAHist=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR),G__defined_typename("vector<TH1*>"),-1,4,"fTestSigMVAHist=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR),G__defined_typename("vector<TH1*>"),-1,4,"fTestBgdMVAHist=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TTree),-1,-1,4,"fMonitorTree=",0,"tree  to monitor values during the boosting      ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fBoostWeight=",0,"the weight used to boost the next classifier      ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMethodError=",0,"estimation of the level error of the classifier ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fROC_training=",0,"roc integral of last trained method (on training sample)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fOverlap_integral=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fMVAvalues=",0,"mva values for the last trained method");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLDataSetManager),-1,-1,4,"fDataSetManager=",0,"DSMTEST");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fHistoricOption=",0,"historic variable, only needed for \"CompatibilityOptions\" ");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fHistoricBoolOption=",0,"historic variable, only needed for \"CompatibilityOptions\" ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodCuts */
static void G__setup_memvarTMVAcLcLMethodCuts(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCuts));
   { TMVA::MethodCuts *p; p=(TMVA::MethodCuts*)0x1000; if (p) { }
   G__memvar_setup((void*)(&TMVA::MethodCuts::fgMaxAbsCutVal),100,0,1,-1,G__defined_typename("Double_t"),-2,1,"fgMaxAbsCutVal=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEFitMethodType),-1,-2,4,"kUseMonteCarlo=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEFitMethodType),-1,-2,4,"kUseGeneticAlgorithm=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEFitMethodType),-1,-2,4,"kUseSimulatedAnnealing=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEFitMethodType),-1,-2,4,"kUseMinuit=3LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEFitMethodType),-1,-2,4,"kUseEventScan=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEFitMethodType),-1,-2,4,"kUseMonteCarloEvents=5LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEEffMethod),-1,-2,4,"kUseEventSelection=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEEffMethod),-1,-2,4,"kUsePDFs=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEFitParameters),-1,-2,4,"kNotEnforced=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEFitParameters),-1,-2,4,"kForceMin=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEFitParameters),-1,-2,4,"kForceMax=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEFitParameters),-1,-2,4,"kForceSmart=3LL",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fFitMethodS=",0,"chosen fit method (string)");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEFitMethodType),-1,-1,4,"fFitMethod=",0,"chosen fit method");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fEffMethodS=",0,"chosen efficiency calculation method (string)");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEEffMethod),-1,-1,4,"fEffMethod=",0,"chosen efficiency calculation method");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLMethodCutscLcLEFitParameterscOallocatorlETMVAcLcLMethodCutscLcLEFitParametersgRsPgR),G__defined_typename("vector<EFitParameters>"),-1,4,"fFitParams=",0,"vector for series of fit methods");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTestSignalEff=",0,"used to test optimized signal efficiency");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEffSMin=",0,"used to test optimized signal efficiency");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEffSMax=",0,"used to test optimized signal efficiency");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCutRangeMin=",0,"minimum of allowed cut range");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCutRangeMax=",0,"maximum of allowed cut range");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR),G__defined_typename("vector<Interval*>"),-1,4,"fCutRange=",0,"allowed ranges for cut optimisation");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLBinarySearchTree),-1,-1,4,"fBinaryTreeS=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLBinarySearchTree),-1,-1,4,"fBinaryTreeB=",0,(char*)NULL);
   G__memvar_setup((void*)0,68,2,0,-1,G__defined_typename("Double_t"),-1,4,"fCutMin=",0,"minimum requirement");
   G__memvar_setup((void*)0,68,2,0,-1,G__defined_typename("Double_t"),-1,4,"fCutMax=",0,"maximum requirement");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTmpCutMin=",0,"temporary minimum requirement");
   G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTmpCutMax=",0,"temporary maximum requirement");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fAllVarsI=",0,"what to do with variables");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNpar=",0,"number of parameters in fit (default: 2*Nvar)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEffRef=",0,"reference efficiency");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"fRangeSign=",0,"used to match cuts to fit parameters (and vice versa)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TRandom),-1,-1,4,"fRandom=",0,"random generator for MC optimisation method");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fMeanS=",0,"means of variables (signal)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fMeanB=",0,"means of variables (background)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fRmsS=",0,"RMSs of variables (signal)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fRmsB=",0,"RMSs of variables (background)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TH1),-1,-1,4,"fEffBvsSLocal=",0,"intermediate eff. background versus eff signal histo");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR),G__defined_typename("vector<TH1*>"),-1,4,"fVarHistS=",0,"reference histograms (signal)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR),G__defined_typename("vector<TH1*>"),-1,4,"fVarHistB=",0,"reference histograms (background)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR),G__defined_typename("vector<TH1*>"),-1,4,"fVarHistS_smooth=",0,"smoothed reference histograms (signal)        ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR),G__defined_typename("vector<TH1*>"),-1,4,"fVarHistB_smooth=",0,"smoothed reference histograms (background)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR),G__defined_typename("vector<PDF*>"),-1,4,"fVarPdfS=",0,"reference PDFs (signal)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR),G__defined_typename("vector<PDF*>"),-1,4,"fVarPdfB=",0,"reference PDFs (background)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNegEffWarning=",0,"flag risen in case of negative efficiency warning");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodCompositeBase */
static void G__setup_memvarTMVAcLcLMethodCompositeBase(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCompositeBase));
   { TMVA::MethodCompositeBase *p; p=(TMVA::MethodCompositeBase*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fCurrentMethodIdx=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase),-1,-1,2,"fCurrentMethod=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLIMethodmUcOallocatorlETMVAcLcLIMethodmUgRsPgR),G__defined_typename("vector<IMethod*>"),-1,2,"fMethods=",0,"vector of all classifiers");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,2,"fMethodWeight=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodANNBase */
static void G__setup_memvarTMVAcLcLMethodANNBase(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodANNBase));
   { TMVA::MethodANNBase *p; p=(TMVA::MethodANNBase*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodANNBasecLcLEEstimator),-1,-2,1,G__FastAllocString(2048).Format("kMSE=%lldLL",(long long)TMVA::MethodANNBase::kMSE).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodANNBasecLcLEEstimator),-1,-2,1,G__FastAllocString(2048).Format("kCE=%lldLL",(long long)TMVA::MethodANNBase::kCE).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TObjArray),-1,-1,2,"fNetwork=",0,"TObjArray of TObjArrays representing network");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TObjArray),-1,-1,2,"fSynapses=",0,"array of pointers to synapses, no structural data");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLTActivation),-1,-1,2,"fActivation=",0,"activation function to be used for hidden layers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLTActivation),-1,-1,2,"fOutput=",0,"activation function to be used for output layers, depending on estimator");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLTActivation),-1,-1,2,"fIdentity=",0,"activation for input and output layers");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TRandom3),-1,-1,2,"frgen=",0,"random number generator for various uses");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLTNeuronInput),-1,-1,2,"fInputCalculator=",0,"input calculator for all neurons");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,2,"fRegulatorIdx=",0,"index to different priors from every synapses");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,2,"fRegulators=",0,"the priors as regulator");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodANNBasecLcLEEstimator),-1,-1,2,"fEstimator=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,2,"fEstimatorS=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TH1F),-1,-1,2,"fEstimatorHistTrain=",0,"monitors convergence of training sample");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TH1F),-1,-1,2,"fEstimatorHistTest=",0,"monitors convergence of independent test sample");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR),G__defined_typename("vector<TH1*>"),-1,2,"fEpochMonHistS=",0,"epoch monitoring hitograms for signal");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR),G__defined_typename("vector<TH1*>"),-1,2,"fEpochMonHistB=",0,"epoch monitoring hitograms for background");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR),G__defined_typename("vector<TH1*>"),-1,2,"fEpochMonHistW=",0,"epoch monitoring hitograms for weights");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,2,"fInvHessian=",0,"zjh");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fUseRegulator=",0,"zjh");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fRandomSeed=",0,"random seed for initial synapse weights");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNcycles=",0,"number of epochs to train");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,2,"fNeuronType=",0,"name of neuron activation function class");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,2,"fNeuronInputType=",0,"name of neuron input calculator class");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TObjArray),-1,-1,4,"fInputLayer=",0,"cache this for fast access");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLTNeuronmUcOallocatorlETMVAcLcLTNeuronmUgRsPgR),G__defined_typename("vector<TNeuron*>"),-1,4,"fOutputNeurons=",0,"cache this for fast access");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fLayerSpec=",0,"layout specification option");
   G__memvar_setup((void*)G__PVOID,103,0,1,-1,G__defined_typename("Bool_t"),-2,4,"fgDEBUG=1ULL",0,"debug flag");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodTMlpANN */
static void G__setup_memvarTMVAcLcLMethodTMlpANN(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodTMlpANN));
   { TMVA::MethodTMlpANN *p; p=(TMVA::MethodTMlpANN*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fLayerSpec=",0,"Layer specification option");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMultiLayerPerceptron),-1,-1,4,"fMLP=",0,"the TMLP");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TTree),-1,-1,4,"fLocalTrainingTree=",0,"local copy of training tree");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fHiddenLayer=",0,"string containig the hidden layer structure");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNcycles=",0,"number of training cylcles");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fValidationFraction=",0,"fraction of events in training tree used for cross validation");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fMLPBuildOptions=",0,"option string to build the mlp");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fLearningMethod=",0,"the learning method (given via option string)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodRuleFit */
static void G__setup_memvarTMVAcLcLMethodRuleFit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodRuleFit));
   { TMVA::MethodRuleFit *p; p=(TMVA::MethodRuleFit*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRuleFit),-1,-1,4,"fRuleFit=",0,"RuleFit instance");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),G__defined_typename("vector<TMVA::Event*>"),-1,4,"fEventSample=",0,"the complete training sample");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSignalFraction=",0,"scalefactor for bkg events to modify initial s/b fraction in training data");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TTree),-1,-1,4,"fMonitorNtuple=",0,"pointer to monitor rule ntuple");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNTImportance=",0,"ntuple: rule importance");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNTCoefficient=",0,"ntuple: rule coefficient");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNTSupport=",0,"ntuple: rule support");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNTNcuts=",0,"ntuple: rule number of cuts");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNTNvars=",0,"ntuple: rule number of vars");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNTPtag=",0,"ntuple: rule P(tag)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNTPss=",0,"ntuple: rule P(tag s, true s)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNTPsb=",0,"ntuple: rule P(tag s, true b)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNTPbs=",0,"ntuple: rule P(tag b, true s)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNTPbb=",0,"ntuple: rule P(tag b, true b)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNTSSB=",0,"ntuple: rule S/(S+B)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNTType=",0,"ntuple: rule type (+1->signal, -1->bkg)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fRuleFitModuleS=",0,"which rulefit module to use");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseRuleFitJF=",0,"if true interface with J.Friedmans RuleFit module");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fRFWorkDir=",0,"working directory from Friedmans module");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fRFNrules=",0,"max number of rules (only Friedmans module)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fRFNendnodes=",0,"max number of rules (only Friedmans module)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLDecisionTreemUcOallocatorlETMVAcLcLDecisionTreemUgRsPgR),-1,-1,4,"fForest=",0,"the forest");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNTrees=",0,"number of trees in forest");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTreeEveFrac=",0,"fraction of events used for traing each tree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLSeparationBase),-1,-1,4,"fSepType=",0,"the separation used in node splitting");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMinFracNEve=",0,"min fraction of number events");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMaxFracNEve=",0,"ditto max");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNCuts=",0,"grid used in cut applied in node splitting");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fSepTypeS=",0,"forest generation: separation type - see DecisionTree");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fPruneMethodS=",0,"forest generation: prune method - see DecisionTree");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLDecisionTreecLcLEPruneMethod),-1,-1,4,"fPruneMethod=",0,"forest generation: method used for pruning - see DecisionTree ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPruneStrength=",0,"forest generation: prune strength - see DecisionTree");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fForestTypeS=",0,"forest generation: how the trees are generated");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseBoost=",0,"use boosted events for forest generation");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fGDPathEveFrac=",0,"GD path: fraction of subsamples used for the fitting");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fGDValidEveFrac=",0,"GD path: fraction of subsamples used for the fitting");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fGDTau=",0,"GD path: def threshhold fraction [0..1]");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fGDTauPrec=",0,"GD path: precision of estimated tau");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fGDTauMin=",0,"GD path: min threshhold fraction [0..1]");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fGDTauMax=",0,"GD path: max threshhold fraction [0..1]");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fGDTauScan=",0,"GD path: number of points to scan");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fGDPathStep=",0,"GD path: step size in path");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fGDNPathSteps=",0,"GD path: number of steps");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fGDErrScale=",0,"GD path: stop ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMinimp=",0,"rule/linear: minimum importance");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fModelTypeS=",0,"rule ensemble: which model (rule,linear or both)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fRuleMinDist=",0,"rule min distance - see RuleEnsemble");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLinQuantile=",0,"quantile cut to remove outliers - see RuleEnsemble");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodFisher */
static void G__setup_memvarTMVAcLcLMethodFisher(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFisher));
   { TMVA::MethodFisher *p; p=(TMVA::MethodFisher*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFishercLcLEFisherMethod),-1,-2,1,G__FastAllocString(2048).Format("kFisher=%lldLL",(long long)TMVA::MethodFisher::kFisher).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFishercLcLEFisherMethod),-1,-2,1,G__FastAllocString(2048).Format("kMahalanobis=%lldLL",(long long)TMVA::MethodFisher::kMahalanobis).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,4,"fMeanMatx=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fTheMethod=",0,"Fisher or Mahalanobis");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFishercLcLEFisherMethod),-1,-1,4,"fFisherMethod=",0,"Fisher or Mahalanobis ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,4,"fBetw=",0,"between-class matrix");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,4,"fWith=",0,"within-class matrix");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,4,"fCov=",0,"full covariance matrix");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSumOfWeightsS=",0,"sum-of-weights for signal training events");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSumOfWeightsB=",0,"sum-of-weights for background training events");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fDiscrimPow=",0,"discriminating power");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fFisherCoeff=",0,"Fisher coefficients");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fF0=",0,"offset");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::kNN::Event */
static void G__setup_memvarTMVAcLcLkNNcLcLEvent(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLkNNcLcLEvent));
   { TMVA::kNN::Event *p; p=(TMVA::kNN::Event*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("VarVec"),-1,4,"fVar=",0,"coordinates (variables) for knn search");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("VarVec"),-1,4,"fTgt=",0,"targets for regression analysis");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fWeight=",0,"event weight");
   G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,4,"fType=",0,"event type ==0 or == 1, expand it to arbitrary class types? ");
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodKNN */
static void G__setup_memvarTMVAcLcLMethodKNN(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodKNN));
   { TMVA::MethodKNN *p; p=(TMVA::MethodKNN*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSumOfWeightsS=",0,"sum-of-weights for signal training events");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSumOfWeightsB=",0,"sum-of-weights for background training events      ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLkNNcLcLModulekNN),-1,-1,4,"fModule=",0,"! module where all work is done");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fnkNN=",0,"number of k-nearest neighbors ");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fBalanceDepth=",0,"number of binary tree levels used for balancing tree");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fScaleFrac=",0,"fraction of events used to compute variable width");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fSigmaFact=",0,"scale factor for Gaussian sigma in Gaus. kernel");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fKernel=",0,"=\"Gaus\",\"Poln\" - kernel type for smoothing");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTrim=",0,"set equal number of signal and background events");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseKernel=",0,"use polynomial kernel weight function");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseWeight=",0,"use weights to count kNN");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseLDA=",0,"use local linear discriminat analysis to compute MVA");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLkNNcLcLEventcOallocatorlETMVAcLcLkNNcLcLEventgRsPgR),G__defined_typename("EventVec"),-1,4,"fEvent=",0,"! (untouched) events used for learning");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLLDA),-1,-1,4,"fLDA=",0,"! Experimental feature for local knn analysis");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTreeOptDepth=",0,"number of binary tree levels used for optimization");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodCFMlpANN_Utils */
static void G__setup_memvarTMVAcLcLMethodCFMlpANN_Utils(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_Utils));
   { TMVA::MethodCFMlpANN_Utils *p; p=(TMVA::MethodCFMlpANN_Utils*)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,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fg_100=",0,"constant");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fg_0=",0,"constant");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fg_max_nVar_=",0,"static maximum number of input variables");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fg_max_nNodes_=",0,"maximum number of nodes per variable");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,2,"fg_999=",0,"constant");
   G__memvar_setup((void*)0,67,0,1,-1,-1,-2,2,"fg_MethodName=",0,"method name for print");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcL693),-1,-1,2,"fParam_1=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcL694),-1,-1,2,"fVarn_1=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcLVARn2),-1,-1,2,"fVarn2_1=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcLVARn2),-1,-1,2,"fVarn3_1=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcL696),-1,-1,2,"fNeur_1=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcL697),-1,-1,2,"fDel_1=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcL698),-1,-1,2,"fCost_1=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodCFMlpANN */
static void G__setup_memvarTMVAcLcLMethodCFMlpANN(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN));
   { TMVA::MethodCFMlpANN *p; p=(TMVA::MethodCFMlpANN*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN),-1,-2,4,"fgThis=",0,"this carrier");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTlEfloatgR),G__defined_typename("TMatrixF"),-1,4,"fData=",0,"the (data,var) string");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"fClass=",0,"the event class (1=signal, 2=background)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNlayers=",0,"number of layers (including input and output layers)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNcycles=",0,"number of training cycles");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNodes=",0,"number of nodes per layer");
   G__memvar_setup((void*)0,68,2,0,-1,G__defined_typename("Double_t"),-1,4,"fYNN=",0,"weights");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fLayerSpec=",0,"the hidden layer specification string");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodLikelihood */
static void G__setup_memvarTMVAcLcLMethodLikelihood(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodLikelihood));
   { TMVA::MethodLikelihood *p; p=(TMVA::MethodLikelihood*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEpsilon=",0,"minimum number of likelihood (to avoid zero)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTransformLikelihoodOutput=",0,"likelihood output is sigmoid-transformed");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDropVariable=",0,"for ranking test");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR),G__defined_typename("vector<TH1*>"),-1,4,"fHistSig=",0,"signal PDFs (histograms)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR),G__defined_typename("vector<TH1*>"),-1,4,"fHistBgd=",0,"background PDFs (histograms)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR),G__defined_typename("vector<TH1*>"),-1,4,"fHistSig_smooth=",0,"signal PDFs (smoothed histograms)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR),G__defined_typename("vector<TH1*>"),-1,4,"fHistBgd_smooth=",0,"background PDFs (smoothed histograms)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLPDF),-1,-1,4,"fDefaultPDFLik=",0,"pdf that contains default definitions");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR),G__defined_typename("vector<PDF*>"),-1,4,"fPDFSig=",0,"list of PDFs (signal)    ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR),G__defined_typename("vector<PDF*>"),-1,4,"fPDFBgd=",0,"list of PDFs (background)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNsmooth=",0,"number of smooth passes");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNsmoothVarS=",0,"number of smooth passes");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNsmoothVarB=",0,"number of smooth passes");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fAverageEvtPerBin=",0,"average events per bin; used to calculate fNbins");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fAverageEvtPerBinVarS=",0,"average events per bin; used to calculate fNbins");
   G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,4,"fAverageEvtPerBinVarB=",0,"average events per bin; used to calculate fNbins");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fBorderMethodString=",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,"fKDEfineFactor=",0,"fine tuning factor for Adaptive KDE");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fKDEiterString=",0,"Number of iterations (string)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fKDEtypeString=",0,"Kernel type to use for KDE (string)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fInterpolateString=",0,"which interpolation method used for reference histograms (individual for each variable)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodHMatrix */
static void G__setup_memvarTMVAcLcLMethodHMatrix(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodHMatrix));
   { TMVA::MethodHMatrix *p; p=(TMVA::MethodHMatrix*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,4,"fInvHMatrixS=",0,"inverse H-matrix (signal)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,4,"fInvHMatrixB=",0,"inverse H-matrix (background)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,4,"fVecMeanS=",0,"vector of mean values (signal)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,4,"fVecMeanB=",0,"vector of mean values (background)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodPDERS */
static void G__setup_memvarTMVAcLcLMethodPDERS(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERS));
   { TMVA::MethodPDERS *p; p=(TMVA::MethodPDERS*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLVolume),-1,-1,2,"fHelpVolume=",0,"auxiliary variable");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fFcnCall=",0,"number of external function calls (RootFinder)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fVolumeRange=",0,"option volume range");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fKernelString=",0,"option kernel estimator");
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEVolumeRangeMode),-1,-2,4,"kUnsupported=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEVolumeRangeMode),-1,-2,4,"kMinMax=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEVolumeRangeMode),-1,-2,4,"kRMS=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEVolumeRangeMode),-1,-2,4,"kAdaptive=3LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEVolumeRangeMode),-1,-2,4,"kUnscaled=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEVolumeRangeMode),-1,-2,4,"kkNN=5LL",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEVolumeRangeMode),-1,-1,4,"fVRangeMode=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEKernelEstimator),-1,-2,4,"kBox=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEKernelEstimator),-1,-2,4,"kSphere=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEKernelEstimator),-1,-2,4,"kTeepee=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEKernelEstimator),-1,-2,4,"kGauss=3LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEKernelEstimator),-1,-2,4,"kSinc3=4LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEKernelEstimator),-1,-2,4,"kSinc5=5LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEKernelEstimator),-1,-2,4,"kSinc7=6LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEKernelEstimator),-1,-2,4,"kSinc9=7LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEKernelEstimator),-1,-2,4,"kSinc11=8LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEKernelEstimator),-1,-2,4,"kLanczos2=9LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEKernelEstimator),-1,-2,4,"kLanczos3=10LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEKernelEstimator),-1,-2,4,"kLanczos5=11LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEKernelEstimator),-1,-2,4,"kLanczos8=12LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEKernelEstimator),-1,-2,4,"kTrim=13LL",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEKernelEstimator),-1,-1,4,"fKernelEstimator=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLBinarySearchTree),-1,-1,4,"fBinaryTree=",0,"binary tree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fDelta=",0,"size of volume");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fShift=",0,"volume center");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fAverageRMS=",0,"average RMS of signal and background");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fScaleS=",0,"weight for signal events");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fScaleB=",0,"weight for background events");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fDeltaFrac=",0,"fraction of RMS");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fGaussSigma=",0,"size of Gauss in adaptive volume ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fGaussSigmaNorm=",0,"size of Gauss in adaptive volume (normalised to dimensions)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNRegOut=",0,"number of output dimensions for regression");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fNEventsMin=",0,"minimum number of events in adaptive volume");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fNEventsMax=",0,"maximum number of events in adaptive volume");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fMaxVIterations=",0,"maximum number of iterations to adapt volume size");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fInitialScale=",0,"initial scale for adaptive volume");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fInitializedVolumeEle=",0,"is volume element initialized ?");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fkNNMin=",0,"min number of events in kNN tree");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fkNNMax=",0,"max number of events in kNN tree");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMax_distance=",0,"maximum distance");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fPrinted=",0,"print");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNormTree=",0,"binary-search tree is normalised");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERS),-1,-2,4,"fgThisPDERS=",0,"this pointer (required by root finder)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodBDT */
static void G__setup_memvarTMVAcLcLMethodBDT(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBDT));
   { TMVA::MethodBDT *p; p=(TMVA::MethodBDT*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR),G__defined_typename("vector<const TMVA::Event*>"),-1,4,"fEventSample=",0,"the training events");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR),G__defined_typename("vector<const TMVA::Event*>"),-1,4,"fValidationSample=",0,"the Validation events");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR),G__defined_typename("vector<const TMVA::Event*>"),-1,4,"fSubSample=",0,"subsample for bagged grad boost");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR),G__defined_typename("vector<const TMVA::Event*>"),-1,4,"fTrainSample=",0,"pointer to sample actually used in training (fEventSample or fSubSample) for example");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNTrees=",0,"number of decision trees requested");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLDecisionTreemUcOallocatorlETMVAcLcLDecisionTreemUgRsPgR),-1,-1,4,"fForest=",0,"the collection of decision trees");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fBoostWeights=",0,"the weights applied in the individual boosts");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSigToBkgFraction=",0,"Signal to Background fraction assumed during training");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fBoostType=",0,"string specifying the boost type");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAdaBoostBeta=",0,"beta parameter for AdaBoost algorithm");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fAdaBoostR2Loss=",0,"loss type used in AdaBoostR2 (Linear,Quadratic or Exponential)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTransitionPoint=",0,"break-down point for gradient regression");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fShrinkage=",0,"learning rate for gradient boost;");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fBaggedBoost=",0,"turn bagging in combination with boost on/off");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fBaggedGradBoost=",0,"turn bagging in combination with grad boost on/off");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSumOfWeights=",0,"sum of all event weights");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_maplEconstsPTMVAcLcLEventmUcOpairlEdoublecOdoublegRcOlesslEconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEconstsPTMVAcLcLEventmUsPconstcOpairlEdoublecOdoublegRsPgRsPgRsPgR),G__defined_typename("map<const TMVA::Event*,std::pair<Double_t,Double_t> >"),-1,4,"fWeightedResiduals=",0,"weighted regression residuals");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_maplEconstsPTMVAcLcLEventmUcOvectorlEdoublecOallocatorlEdoublegRsPgRcOlesslEconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEconstsPTMVAcLcLEventmUsPconstcOvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRsPgR),G__defined_typename("map<const TMVA::Event*,std::vector<double> >"),-1,4,"fResiduals=",0,"individual event residuals for gradient boost");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLSeparationBase),-1,-1,4,"fSepType=",0,"the separation used in node splitting");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fSepTypeS=",0,"the separation (option string) used in node splitting");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMinNodeEvents=",0,"min number of events in node");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fMinNodeSize=",0,"min percentage of training events in node");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fMinNodeSizeS=",0,"string containing min percentage of training events in node");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNCuts=",0,"grid used in cut applied in node splitting");
   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,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseYesNoLeaf=",0,"use sig or bkg classification in leave nodes or sig/bkg");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNodePurityLimit=",0,"purity limit for sig/bkg nodes");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNNodesMax=",0,"max # of nodes");
   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,105,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLDecisionTreecLcLEPruneMethod),-1,-1,4,"fPruneMethod=",0,"method used for prunig");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fPruneMethodS=",0,"prune method option String");
   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,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fFValidationEvents=",0,"fraction of events to use for pruning");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fAutomatic=",0,"use user given prune strength or automatically determined one using a validation sample");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fRandomisedTrees=",0,"choose a random subset of possible cut variables at each node during training");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fUseNvars=",0,"the number of variables used in the randomised tree splitting");
   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,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fUseNTrainEvents=",0,"number of randomly picked training events used in randomised (and bagged) trees");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fBaggedSampleFraction=",0,"relative size of bagged event sample to original sample size");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fNegWeightTreatment=",0,"variable that holds the option of how to treat negative event weights in training");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNoNegWeightsInTraining=",0,"ignore negative event weights in the training");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fInverseBoostNegWeights=",0,"boost ev. with neg. weights with 1/boostweight rathre than boostweight");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fPairNegWeightsGlobal=",0,"pair ev. with neg. and pos. weights in traning sample and \"annihilate\" them ");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTrainWithNegWeights=",0,"yes there are negative event weights and we don't ignore them");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDoBoostMonitor=",0,"create control plot with ROC integral vs tree number");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TTree),-1,-1,4,"fMonitorNtuple=",0,"monitoring ntuple");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fITree=",0,"ntuple var: ith tree");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fBoostWeight=",0,"ntuple var: boost weight");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fErrorFraction=",0,"ntuple var: misclassification error fraction");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCss=",0,"Cost factor");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCts_sb=",0,"Cost factor");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCtb_ss=",0,"Cost factor");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCbb=",0,"Cost factor");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDoPreselection=",0,"do or do not perform automatic pre-selection of 100% eff. cuts");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fVariableImportance=",0,"the relative importance of the different variables");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fLowSigCut=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fLowBkgCut=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fHighSigCut=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fHighBkgCut=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEboolcOallocatorlEboolgRsPgR),G__defined_typename("vector<Bool_t>"),-1,4,"fIsLowSigCut=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEboolcOallocatorlEboolgRsPgR),G__defined_typename("vector<Bool_t>"),-1,4,"fIsLowBkgCut=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEboolcOallocatorlEboolgRsPgR),G__defined_typename("vector<Bool_t>"),-1,4,"fIsHighSigCut=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEboolcOallocatorlEboolgRsPgR),G__defined_typename("vector<Bool_t>"),-1,4,"fIsHighBkgCut=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fHistoricBool=",0,"historic variable, only needed for \"CompatibilityOptions\" ");
   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,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodDT */
static void G__setup_memvarTMVAcLcLMethodDT(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodDT));
   { TMVA::MethodDT *p; p=(TMVA::MethodDT*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),G__defined_typename("vector<Event*>"),-1,4,"fEventSample=",0,"the training events");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLDecisionTree),-1,-1,4,"fTree=",0,"the decision tree");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLSeparationBase),-1,-1,4,"fSepType=",0,"the separation used in node splitting");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fSepTypeS=",0,"the separation (option string) used in node splitting");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMinNodeEvents=",0,"min number of events in node");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fMinNodeSize=",0,"min percentage of training events in node");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fMinNodeSizeS=",0,"string containing min percentage of training events in node");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNCuts=",0,"grid used in cut applied in node splitting");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseYesNoLeaf=",0,"use sig or bkg classification in leave nodes or sig/bkg");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNodePurityLimit=",0,"purity limit for sig/bkg nodes");
   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,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fErrorFraction=",0,"ntuple var: misclassification error fraction ");
   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__TMVA1LN_TMVAcLcLDecisionTreecLcLEPruneMethod),-1,-1,4,"fPruneMethod=",0,"method used for prunig ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fPruneMethodS=",0,"prune method option String");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fAutomatic=",0,"use user given prune strength or automatically determined one using a validation sample ");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fRandomisedTrees=",0,"choose a random subset of possible cut variables at each node during training");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fUseNvars=",0,"the number of variables used in the randomised tree splitting");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUsePoissonNvars=",0,"fUseNvars is used as a poisson mean, and the actual value of useNvars is at each step drawn form that distribution");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fVariableImportance=",0,"the relative importance of the different variables ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDeltaPruneStrength=",0,"step size in pruning, is adjusted according to experience of previous trees        ");
   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,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fPruneBeforeBoost=",0,"aincient variable, only needed for \"CompatibilityOptions\" ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodSVM */
static void G__setup_memvarTMVAcLcLMethodSVM(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodSVM));
   { TMVA::MethodSVM *p; p=(TMVA::MethodSVM*)0x1000; if (p) { }
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fCost=",0,"cost value");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fTolerance=",0,"tolerance parameter");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fMaxIter=",0,"max number of iteration");
   G__memvar_setup((void*)0,114,0,0,-1,G__defined_typename("UShort_t"),-1,4,"fNSubSets=",0,"nr of subsets, default 1");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fBparm=",0,"free plane coefficient ");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fGamma=",0,"RBF Kernel parameter");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLSVWorkingSet),-1,-1,4,"fWgSet=",0,"svm working set ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLSVEventmUcOallocatorlETMVAcLcLSVEventmUgRsPgR),G__defined_typename("vector<TMVA::SVEvent*>"),-1,4,"fInputData=",0,"vector of training data in SVM format");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLSVEventmUcOallocatorlETMVAcLcLSVEventmUgRsPgR),G__defined_typename("vector<TMVA::SVEvent*>"),-1,4,"fSupportVectors=",0,"contains support vectors");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLSVKernelFunction),-1,-1,4,"fSVKernelFunction=",0,"kernel function");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,4,"fMinVars=",0,"for normalization //is it still needed?? ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TVectorTlEdoublegR),G__defined_typename("TVectorD"),-1,4,"fMaxVars=",0,"for normalization //is it still needed?? ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fTheKernel=",0,"kernel name");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fDoubleSigmaSquared=",0,"for RBF Kernel");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOrder=",0,"for Polynomial Kernel ( polynomial order )");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fTheta=",0,"for Sigmoidal Kernel");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fKappa=",0,"for Sigmoidal Kernel");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodBayesClassifier */
static void G__setup_memvarTMVAcLcLMethodBayesClassifier(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBayesClassifier));
   { TMVA::MethodBayesClassifier *p; p=(TMVA::MethodBayesClassifier*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodFDA */
static void G__setup_memvarTMVAcLcLMethodFDA(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFDA));
   { TMVA::MethodFDA *p; p=(TMVA::MethodFDA*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fFormulaStringP=",0,"string with function");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fParRangeStringP=",0,"string with ranges of parameters");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fFormulaStringT=",0,"string with function");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fParRangeStringT=",0,"string with ranges of parameters");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TFormula),-1,-1,4,"fFormula=",0,"the discrimination function");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNPars=",0,"number of parameters");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR),G__defined_typename("vector<Interval*>"),-1,4,"fParRange=",0,"ranges of parameters");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fBestPars=",0,"the pars that optimise (minimise) the estimator");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fFitMethod=",0,"estimator optimisation method");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fConverger=",0,"fitmethod uses fConverger as intermediate step to converge into local minimas");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLFitterBase),-1,-1,4,"fFitter=",0,"the fitter used in the training");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIFitterTarget),-1,-1,4,"fConvergerFitter=",0,"intermediate fitter");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSumOfWeightsSig=",0,"sum of weights (signal)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSumOfWeightsBkg=",0,"sum of weights (background)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSumOfWeights=",0,"sum of weights");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOutputDimensions=",0,"number of output values");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodMLP */
static void G__setup_memvarTMVAcLcLMethodMLP(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodMLP));
   { TMVA::MethodMLP *p; p=(TMVA::MethodMLP*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodMLPcLcLETrainingMethod),-1,-2,1,G__FastAllocString(2048).Format("kBP=%lldLL",(long long)TMVA::MethodMLP::kBP).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodMLPcLcLETrainingMethod),-1,-2,1,G__FastAllocString(2048).Format("kBFGS=%lldLL",(long long)TMVA::MethodMLP::kBFGS).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodMLPcLcLETrainingMethod),-1,-2,1,G__FastAllocString(2048).Format("kGA=%lldLL",(long long)TMVA::MethodMLP::kGA).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodMLPcLcLEBPTrainingMode),-1,-2,1,G__FastAllocString(2048).Format("kSequential=%lldLL",(long long)TMVA::MethodMLP::kSequential).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodMLPcLcLEBPTrainingMode),-1,-2,1,G__FastAllocString(2048).Format("kBatch=%lldLL",(long long)TMVA::MethodMLP::kBatch).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fUseRegulator=",0,"zjh");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fCalculateErrors=",0,"compute inverse hessian matrix at the end of the training");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fPrior=",0,"zjh");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fPriorDev=",0,"zjh");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fUpdateLimit=",0,"zjh");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodMLPcLcLETrainingMethod),-1,-1,4,"fTrainingMethod=",0,"method of training, BP or GA");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fTrainMethodS=",0,"training method option param");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fSamplingFraction=",0,"fraction of events which is sampled for training");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fSamplingEpoch=",0,"fraction of epochs where sampling is used");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fSamplingWeight=",0,"changing factor for event weights when sampling is turned on");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSamplingTraining=",0,"The training sample is sampled");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSamplingTesting=",0,"The testing sample is sampled");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLastAlpha=",0,"line search variable");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTau=",0,"line search variable");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fResetStep=",0,"reset time (how often we clear hessian matrix)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLearnRate=",0,"learning rate for synapse weight adjustments");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDecayRate=",0,"decay rate for above learning rate");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodMLPcLcLEBPTrainingMode),-1,-1,4,"fBPMode=",0,"backprop learning mode (sequential or batch)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fBpModeS=",0,"backprop learning mode option string (sequential or batch)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fBatchSize=",0,"batch size, only matters if in batch learning mode");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fTestRate=",0,"test for overtraining performed at each #th epochs");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fEpochMon=",0,"create and fill epoch-wise monitoring histograms (makes outputfile big!)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fGA_nsteps=",0,"GA settings: number of steps");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fGA_preCalc=",0,"GA settings: number of pre-calc steps");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fGA_SC_steps=",0,"GA settings: SC_steps");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fGA_SC_rate=",0,"GA settings: SC_rate");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fGA_SC_factor=",0,"GA settings: SC_factor");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR),G__defined_typename("vector<std::pair<Float_t,Float_t> >"),-1,4,"fDeviationsFromTargets=",0,"deviation from the targets, event weight");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fWeightRange=",0,"suppress outliers for the estimator calculation");
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"fgPRINT_ESTIMATOR_INC=10LL",0,"debug flags");
   G__memvar_setup((void*)G__PVOID,103,0,1,-1,G__defined_typename("Bool_t"),-2,4,"fgPRINT_SEQ=0ULL",0,"debug flags");
   G__memvar_setup((void*)G__PVOID,103,0,1,-1,G__defined_typename("Bool_t"),-2,4,"fgPRINT_BATCH=0ULL",0,"debug flags");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodPDEFoam */
static void G__setup_memvarTMVAcLcLMethodPDEFoam(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDEFoam));
   { TMVA::MethodPDEFoam *p; p=(TMVA::MethodPDEFoam*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDEFoamcLcLEKernel),-1,-2,1,G__FastAllocString(2048).Format("kNone=%lldLL",(long long)TMVA::MethodPDEFoam::kNone).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDEFoamcLcLEKernel),-1,-2,1,G__FastAllocString(2048).Format("kGaus=%lldLL",(long long)TMVA::MethodPDEFoam::kGaus).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDEFoamcLcLEKernel),-1,-2,1,G__FastAllocString(2048).Format("kLinN=%lldLL",(long long)TMVA::MethodPDEFoam::kLinN).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSigBgSeparated=",0,"Separate Sig and Bg, or not");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fFrac=",0,"Fraction used for calc of Xmin, Xmax");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fDiscrErrCut=",0,"cut on discrimant error");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fVolFrac=",0,"volume fraction (used for density calculation during buildup)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fnCells=",0,"Number of Cells  (1000)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fnActiveCells=",0,"Number of active cells");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fnSampl=",0,"Number of MC events per cell in build-up (1000)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fnBin=",0,"Number of bins in build-up (100)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fEvPerBin=",0,"Maximum events (equiv.) per bin in buid-up (1000)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fCompress=",0,"compress foam output file");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fMultiTargetRegression=",0,"do regression on multible targets");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNmin=",0,"minimal number of events in cell necessary to split cell\"");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fCutNmin=",0,"Keep for bw compatibility: Grabbing cell with maximal RMS to split next (TFoam default)");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fMaxDepth=",0,"maximum depth of cell tree");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fKernelStr=",0,"Kernel for GetMvaValue() (option string)");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDEFoamcLcLEKernel),G__defined_typename("EKernel"),-1,4,"fKernel=",0,"Kernel for GetMvaValue()");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLPDEFoamKernelBase),-1,-1,4,"fKernelEstimator=",0,"Kernel estimator");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fTargetSelectionStr=",0,"method of selecting the target (only mulit target regr.)");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLETargetSelection),-1,-1,4,"fTargetSelection=",0,"method of selecting the target (only mulit target regr.)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fFillFoamWithOrigWeights=",0,"fill the foam with boost weights");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseYesNoCell=",0,"return -1 or 1 for bg or signal like event");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TString),-1,-1,4,"fDTLogic=",0,"use DT algorithm to split cells");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEDTSeparation),-1,-1,4,"fDTSeparation=",0,"enum which specifies the separation to use for the DT logic");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fPeekMax=",0,"BACKWARDS COMPATIBILITY: peek up cell with max. driver integral for split");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fXmin=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fXmax=",0,"range for histograms and foams");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLPDEFoammUcOallocatorlETMVAcLcLPDEFoammUgRsPgR),G__defined_typename("vector<PDEFoam*>"),-1,4,"fFoam=",0,"grown PDEFoams");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodLD */
static void G__setup_memvarTMVAcLcLMethodLD(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodLD));
   { TMVA::MethodLD *p; p=(TMVA::MethodLD*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNRegOut=",0,"size of the output");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,4,"fSumMatx=",0,"Sum of coordinates product matrix ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,4,"fSumValMatx=",0,"Sum of values multiplied by coordinates");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMatrixTlEdoublegR),G__defined_typename("TMatrixD"),-1,4,"fCoeffMatx=",0,"Matrix of coefficients");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgR),G__defined_typename("vector<std::vector<Double_t>*>"),-1,4,"fLDCoeff=",0,"LD coefficients");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MethodCategory */
static void G__setup_memvarTMVAcLcLMethodCategory(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCategory));
   { TMVA::MethodCategory *p; p=(TMVA::MethodCategory*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLIMethodmUcOallocatorlETMVAcLcLIMethodmUgRsPgR),G__defined_typename("vector<IMethod*>"),-1,2,"fMethods=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETCutcOallocatorlETCutgRsPgR),G__defined_typename("vector<TCut>"),-1,2,"fCategoryCuts=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),G__defined_typename("vector<UInt_t>"),-1,2,"fCategorySpecIdx=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETStringcOallocatorlETStringgRsPgR),G__defined_typename("vector<TString>"),-1,2,"fVars=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR),G__defined_typename("vector<std::vector<UInt_t> >"),-1,2,"fVarMaps=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TTree),-1,-1,4,"fCatTree=",0,"! needed in conjunction with TTreeFormulas for evaluation category expressions");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETTreeFormulamUcOallocatorlETTreeFormulamUgRsPgR),G__defined_typename("vector<TTreeFormula*>"),-1,4,"fCatFormulas=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLDataSetManager),-1,-1,4,"fDataSetManager=",0,"DSMTEST");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA1LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__TMVA1() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTMVA(void) {
   /* TMVA */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVA));
   G__memfunc_setup("Endl",387,G__G__TMVA1_136_0_1, 117, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_136_0_2, 117, G__get_linked_tagnum(&G__G__TMVA1LN_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("operator<<",996,G__G__TMVA1_136_0_3, 117, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_136_0_4, 117, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_136_0_5, 117, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_136_0_6, 117, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_136_0_7, 117, G__get_linked_tagnum(&G__G__TMVA1LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os u 'TMVA::Rule' - 11 - rule", (char*)NULL, (void*) G__func2void( (ostream& (*)(ostream&, const TMVA::Rule&))(&TMVA::operator<<) ), 0);
   G__memfunc_setup("operator<<",996,G__G__TMVA1_136_0_8, 117, G__get_linked_tagnum(&G__G__TMVA1LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os u 'TMVA::RuleEnsemble' - 11 - event", (char*)NULL, (void*) G__func2void( (ostream& (*)(ostream&, const TMVA::RuleEnsemble&))(&TMVA::operator<<) ), 0);
   G__memfunc_setup("operator<<",996,G__G__TMVA1_136_0_9, 117, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_136_0_10, 117, G__get_linked_tagnum(&G__G__TMVA1LN_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__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLConfigurable(void) {
   /* TMVA::Configurable */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable));
   G__memfunc_setup("Configurable",1233,G__G__TMVA1_164_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLConfigurable), -1, 0, 1, 1, 1, 0, "u 'TString' - 11 '\"\"' theOption", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ParseOptions",1255,G__G__TMVA1_164_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintOptions",1273,G__G__TMVA1_164_0_3, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetConfigName",1271,G__G__TMVA1_164_0_5, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetConfigDescription",2042,G__G__TMVA1_164_0_6, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetConfigName",1283,G__G__TMVA1_164_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetConfigDescription",2054,G__G__TMVA1_164_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckForUnusedOptions",2149,G__G__TMVA1_164_0_9, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOptions",1036,G__G__TMVA1_164_0_10, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TString), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOptions",1048,G__G__TMVA1_164_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteOptionsToStream",2086,G__G__TMVA1_164_0_12, 121, -1, -1, 0, 2, 1, 1, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - o u 'TString' - 11 - prefix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadOptionsFromStream",2152,G__G__TMVA1_164_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddOptionsXMLTo",1449,G__G__TMVA1_164_0_14, 121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadOptionsFromXML",1773,G__G__TMVA1_164_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - node", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LooseOptionCheckingEnabled",2626,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EnableLooseOptions",1845,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteOptionsReferenceToFile",2761,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetSetFlag",1193,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReferenceFile",1583,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TString), -1, 1, 0, 1, 2, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SplitOptions",1272,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8, 
"u 'TString' - 11 - theOpt u 'TList' - 1 - loo", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMsgType",1013,G__G__TMVA1_164_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TMVA::EMsgType' - 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA1_164_0_24, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::Configurable::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_164_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Configurable::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_164_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::Configurable::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_164_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::Configurable::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_164_0_31, 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__TMVA1_164_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Configurable::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_164_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Configurable::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_164_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Configurable::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_164_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Configurable::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~Configurable", 1359, G__G__TMVA1_164_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLEvent(void) {
   /* TMVA::Event */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEvent));
   G__memfunc_setup("Event",514,G__G__TMVA1_185_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Event",514,G__G__TMVA1_185_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEvent), -1, 0, 1, 1, 1, 0, "u 'TMVA::Event' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Event",514,G__G__TMVA1_185_0_3, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEvent), -1, 0, 6, 5, 1, 0, 
"u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - values u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - targetValues "
"u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - spectatorValues h - 'UInt_t' 0 '0' theClass "
"d - 'Double_t' 0 '1.0' weight d - 'Double_t' 0 '1.0' boostweight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Event",514,G__G__TMVA1_185_0_4, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEvent), -1, 0, 5, 5, 1, 0, 
"u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - values u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - targetValues "
"h - 'UInt_t' 0 '0' theClass d - 'Double_t' 0 '1.0' weight "
"d - 'Double_t' 0 '1.0' boostweight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Event",514,G__G__TMVA1_185_0_5, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEvent), -1, 0, 4, 5, 1, 0, 
"u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - - h - 'UInt_t' 0 - theClass "
"d - 'Double_t' 0 '1.0' weight d - 'Double_t' 0 '1.0' boostweight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Event",514,G__G__TMVA1_185_0_6, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEvent), -1, 0, 2, 5, 1, 0, 
"U 'vector<float*,allocator<float*> >' 'vector<Float_t*>' 11 - - h - 'UInt_t' 0 - nvar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsDynamic",897,G__G__TMVA1_185_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWeight",904,G__G__TMVA1_185_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOriginalWeight",1725,G__G__TMVA1_185_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBoostWeight",1423,G__G__TMVA1_185_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClass",790,G__G__TMVA1_185_0_11, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNVariables",1287,G__G__TMVA1_185_0_12, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNTargets",1096,G__G__TMVA1_185_0_13, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNSpectators",1430,G__G__TMVA1_185_0_14, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValue",797,G__G__TMVA1_185_0_15, 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("GetValues",912,G__G__TMVA1_185_0_16, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValues",912,G__G__TMVA1_185_0_17, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTarget",903,G__G__TMVA1_185_0_18, 102, -1, G__defined_typename("Float_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - itgt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTargets",1018,G__G__TMVA1_185_0_19, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTargets",1018,G__G__TMVA1_185_0_20, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSpectator",1237,G__G__TMVA1_185_0_21, 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("GetSpectators",1352,G__G__TMVA1_185_0_22, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSpectators",1352,G__G__TMVA1_185_0_23, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWeight",916,G__G__TMVA1_185_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBoostWeight",1435,G__G__TMVA1_185_0_25, 121, -1, -1, 0, 1, 1, 1, 8, "d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ScaleBoostWeight",1623,G__G__TMVA1_185_0_26, 121, -1, -1, 0, 1, 1, 1, 8, "d - 'Double_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetClass",802,G__G__TMVA1_185_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVal",591,G__G__TMVA1_185_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - ivar f - 'Float_t' 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTarget",915,G__G__TMVA1_185_0_29, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - itgt f - 'Float_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSpectator",1249,G__G__TMVA1_185_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - 'UInt_t' 0 - ivar f - 'Float_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVariableArrangement",2246,G__G__TMVA1_185_0_31, 121, -1, -1, 0, 1, 1, 1, 8, "U 'vector<unsigned int,allocator<unsigned int> >' 'vector<UInt_t>' 40 - m", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDoNotBoost",1303,G__G__TMVA1_185_0_32, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearDynamicVariables",2117,G__G__TMVA1_185_0_33, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::Event::ClearDynamicVariables) ), 0);
   G__memfunc_setup("CopyVarValues",1332,G__G__TMVA1_185_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMVA::Event' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,G__G__TMVA1_185_0_35, 121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - o", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetIsTraining",1316,G__G__TMVA1_185_0_36, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TMVA::Event::SetIsTraining) ), 0);
   G__memfunc_setup("SetIgnoreNegWeightsInTraining",2936,G__G__TMVA1_185_0_37, 121, -1, -1, 0, 1, 3, 1, 0, "g - 'Bool_t' 0 - -", (char*)NULL, (void*) G__func2void( (void (*)(Bool_t))(&TMVA::Event::SetIgnoreNegWeightsInTraining) ), 0);
   // automatic destructor
   G__memfunc_setup("~Event", 640, G__G__TMVA1_185_0_38, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA1_185_0_39, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEvent), -1, 1, 1, 1, 1, 0, "u 'TMVA::Event' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodBase(void) {
   /* TMVA::MethodBase */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase));
   G__memfunc_setup("SetupMethod",1138,G__G__TMVA1_319_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessSetup",1264,G__G__TMVA1_319_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckSetup",1007,G__G__TMVA1_319_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", "may be overwritten by derived classes", (void*) NULL, 1);
   G__memfunc_setup("AddOutput",922,G__G__TMVA1_319_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"i 'TMVA::Types::ETreeType' - 0 - type i 'TMVA::Types::EAnalysisType' - 0 - analysisType", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrainMethod",1119,G__G__TMVA1_319_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OptimizeTuningParameters",2522,G__G__TMVA1_319_0_8, 117, G__get_linked_tagnum(&G__G__TMVA1LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR), G__defined_typename("map<TString,Double_t>"), 0, 2, 1, 1, 0, 
"u 'TString' - 0 '\"ROCIntegral\"' fomType u 'TString' - 0 '\"FitGA\"' fitType", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTuneParameters",1756,G__G__TMVA1_319_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'map<TString,double,less<TString>,allocator<pair<const TString,double> > >' 'map<TString,Double_t>' 0 - tuneParameters", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetTrainTime",1209,G__G__TMVA1_319_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - trainTime", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrainTime",1197,G__G__TMVA1_319_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTestTime",1115,G__G__TMVA1_319_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - testTime", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTestTime",1103,G__G__TMVA1_319_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TestClassification",1868,G__G__TMVA1_319_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetKSTrainingVsTest",1891,G__G__TMVA1_319_0_16, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"c - 'Char_t' 0 - SorB u 'TString' - 0 '\"X\"' opt", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TestMulticlass",1473,G__G__TMVA1_319_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TestRegression",1473,G__G__TMVA1_319_0_18, 121, -1, -1, 0, 10, 1, 1, 0, 
"d - 'Double_t' 1 - bias d - 'Double_t' 1 - biasT "
"d - 'Double_t' 1 - dev d - 'Double_t' 1 - devT "
"d - 'Double_t' 1 - rms d - 'Double_t' 1 - rmsT "
"d - 'Double_t' 1 - mInf d - 'Double_t' 1 - mInfT "
"d - 'Double_t' 1 - corr i 'TMVA::Types::ETreeType' - 0 - type", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DeclareCompatibilityOptions",2806,G__G__TMVA1_319_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", "declaration of past options", (void*) NULL, 1);
   G__memfunc_setup("Reset",515,G__G__TMVA1_319_0_23, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' errLower D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMvaValue",1089,G__G__TMVA1_319_0_25, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"U 'TMVA::Event' - 50 - ev D - 'Double_t' 0 '0' err "
"D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NoErrorCalc",1082,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"D - 'Double_t' 40 - err D - 'Double_t' 40 - errUpper", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRegressionValues",1969,G__G__TMVA1_319_0_27, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 1, 1, 1, 1, "U 'TMVA::Event' - 50 - ev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRegressionValues",1969,G__G__TMVA1_319_0_28, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMulticlassValues",1969,G__G__TMVA1_319_0_29, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetProba",788,G__G__TMVA1_319_0_30, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "U 'TMVA::Event' - 10 - ev", "the simple one, automatically calcualtes the mvaVal and uses the SAME sig/bkg ratio as given in the training sample (typically 50/50 .. (NormMode=EqualNumEvents) but can be different) ", (void*) NULL, 1);
   G__memfunc_setup("GetProba",788,G__G__TMVA1_319_0_31, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - mvaVal d - 'Double_t' 0 - ap_sig", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRarity",923,G__G__TMVA1_319_0_32, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 - mvaVal i 'TMVA::Types::ESBType' - 0 'Types::kBackground' reftype", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("MakeClass",884,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TString' - 11 'TString(\"\")' classFileName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintHelpMessage",1627,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteStateToFile",1615,G__G__TMVA1_319_0_36, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadStateFromFile",1681,G__G__TMVA1_319_0_37, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddWeightsXMLTo",1432,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadWeightsFromXML",1756,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "Y - - 0 - wghtnode", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - -", "backward compatibility", (void*) NULL, 3);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TFile' - 1 - -", "backward compatibility", (void*) NULL, 1);
   G__memfunc_setup("WriteStateToXML",1472,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadStateFromXML",1538,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteStateToStream",1851,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - tf", "needed for MakeClass", (void*) NULL, 0);
   G__memfunc_setup("WriteVarsToStream",1750,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - tf u 'TString' - 11 '\"\"' prefix", "needed for MakeClass", (void*) NULL, 0);
   G__memfunc_setup("ReadStateFromStream",1917,G__G__TMVA1_319_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - tf", "backward compatibility", (void*) NULL, 0);
   G__memfunc_setup("ReadStateFromStream",1917,G__G__TMVA1_319_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TFile' - 1 - rf", "backward compatibility", (void*) NULL, 0);
   G__memfunc_setup("ReadStateFromXMLString",2169,G__G__TMVA1_319_0_48, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - xmlstr", "for reading from memory", (void*) NULL, 0);
   G__memfunc_setup("AddVarsXMLTo",1113,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddSpectatorsXMLTo",1765,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTargetsXMLTo",1431,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddClassesXMLTo",1419,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadVariablesFromXML",1946,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "Y - - 0 - varnode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadSpectatorsFromXML",2089,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "Y - - 0 - specnode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTargetsFromXML",1755,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "Y - - 0 - tarnode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadClassesFromXML",1743,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "Y - - 0 - clsnode", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadVarsFromStream",1816,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr", "backward compatibility", (void*) NULL, 0);
   G__memfunc_setup("WriteEvaluationHistosToFile",2784,G__G__TMVA1_319_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TMVA::Types::ETreeType' - 0 - treetype", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteMonitoringHistosToFile",2798,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetEfficiency",1301,G__G__TMVA1_319_0_60, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"u 'TString' - 11 - - i 'TMVA::Types::ETreeType' - 0 - - "
"d - 'Double_t' 1 - err", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTrainingEfficiency",2129,G__G__TMVA1_319_0_61, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMulticlassEfficiency",2358,G__G__TMVA1_319_0_62, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 0, 1, 1, 1, 0, "u 'vector<vector<float,allocator<float> >,allocator<vector<float,allocator<float> > > >' 'vector<std::vector<Float_t> >' 1 - purity", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMulticlassTrainingEfficiency",3186,G__G__TMVA1_319_0_63, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 0, 1, 1, 1, 0, "u 'vector<vector<float,allocator<float> >,allocator<vector<float,allocator<float> > > >' 'vector<std::vector<Float_t> >' 1 - purity", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSignificance",1507,G__G__TMVA1_319_0_64, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetROCIntegral",1338,G__G__TMVA1_319_0_65, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"U 'TH1D' - 0 - histS U 'TH1D' - 0 - histB", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetROCIntegral",1338,G__G__TMVA1_319_0_66, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"U 'TMVA::PDF' - 0 '0' pdfS U 'TMVA::PDF' - 0 '0' pdfB", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMaximumSignificance",2241,G__G__TMVA1_319_0_67, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"d - 'Double_t' 0 - SignalEvents d - 'Double_t' 0 - BackgroundEvents "
"d - 'Double_t' 1 - optimal_significance_value", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSeparation",1334,G__G__TMVA1_319_0_68, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"U 'TH1' - 0 - - U 'TH1' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSeparation",1334,G__G__TMVA1_319_0_69, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"U 'TMVA::PDF' - 0 '0' pdfS U 'TMVA::PDF' - 0 '0' pdfB", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRegressionDeviation",2276,G__G__TMVA1_319_0_70, 121, -1, -1, 0, 4, 1, 1, 8, 
"h - 'UInt_t' 0 - tgtNum i 'TMVA::Types::ETreeType' - 0 - type "
"d - 'Double_t' 1 - stddev d - 'Double_t' 1 - stddev90Percent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetJobName",956,G__G__TMVA1_319_0_71, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TString), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethodName",1282,G__G__TMVA1_319_0_72, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TString), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethodTypeName",1700,G__G__TMVA1_319_0_73, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethodType",1315,G__G__TMVA1_319_0_74, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLTypescLcLEMVA), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTestvarName",1418,G__G__TMVA1_319_0_76, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TString), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetProbaName",1173,G__G__TMVA1_319_0_77, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TString), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWeightFileName",1673,G__G__TMVA1_319_0_78, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTestvarName",1430,G__G__TMVA1_319_0_79, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 '\"\"' v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNvar",695,G__G__TMVA1_319_0_80, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNVariables",1287,G__G__TMVA1_319_0_81, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNTargets",1096,G__G__TMVA1_319_0_82, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInputVar",1113,G__G__TMVA1_319_0_83, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TString), -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInputLabel",1296,G__G__TMVA1_319_0_84, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TString), -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInputTitle",1330,G__G__TMVA1_319_0_85, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TString), -1, 1, 1, 1, 1, 9, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMean",673,G__G__TMVA1_319_0_86, 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("GetRMS",530,G__G__TMVA1_319_0_87, 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("GetXmin",700,G__G__TMVA1_319_0_88, 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("GetXmax",702,G__G__TMVA1_319_0_89, 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("GetSignalReferenceCut",2105,G__G__TMVA1_319_0_90, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSignalReferenceCutOrientation",3269,G__G__TMVA1_319_0_91, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSignalReferenceCut",2117,G__G__TMVA1_319_0_92, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cut", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSignalReferenceCutOrientation",3281,G__G__TMVA1_319_0_93, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - cutOrientation", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BaseDir",666,G__G__TMVA1_319_0_94, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TDirectory), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MethodBaseDir",1275,G__G__TMVA1_319_0_95, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TDirectory), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMethodDir",1196,G__G__TMVA1_319_0_96, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - methodDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBaseDir",966,G__G__TMVA1_319_0_97, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - methodDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMethodBaseDir",1575,G__G__TMVA1_319_0_98, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TDirectory' - 0 - methodDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrainingTMVAVersionCode",2549,G__G__TMVA1_319_0_99, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrainingROOTVersionCode",2561,G__G__TMVA1_319_0_100, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrainingTMVAVersionString",2801,G__G__TMVA1_319_0_101, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrainingROOTVersionString",2813,G__G__TMVA1_319_0_102, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTransformationHandler",2485,G__G__TMVA1_319_0_103, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLTransformationHandler), -1, 1, 1, 1, 1, 0, "g - 'Bool_t' 0 'true' takeReroutedIfAvailable", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTransformationHandler",2485,G__G__TMVA1_319_0_104, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLTransformationHandler), -1, 1, 1, 1, 1, 9, "g - 'Bool_t' 0 'true' takeReroutedIfAvailable", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RerouteTransformationHandler",2939,G__G__TMVA1_319_0_105, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::TransformationHandler' - 0 - fTargetTransformation", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Data",378,G__G__TMVA1_319_0_106, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLDataSet), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DataInfo",774,G__G__TMVA1_319_0_107, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLDataSetInfo), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNEvents",995,G__G__TMVA1_319_0_108, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEvent",802,G__G__TMVA1_319_0_109, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEvent), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEvent",802,G__G__TMVA1_319_0_110, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEvent), -1, 0, 1, 1, 1, 9, "U 'TMVA::Event' - 10 - ev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEvent",802,G__G__TMVA1_319_0_111, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEvent), -1, 0, 1, 1, 1, 9, "n - 'Long64_t' 0 - ievt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEvent",802,G__G__TMVA1_319_0_112, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9, 
"n - 'Long64_t' 0 - ievt i 'TMVA::Types::ETreeType' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrainingEvent",1630,G__G__TMVA1_319_0_113, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEvent), -1, 0, 1, 1, 1, 9, "n - 'Long64_t' 0 - ievt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTestingEvent",1536,G__G__TMVA1_319_0_114, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLEvent), -1, 0, 1, 1, 1, 9, "n - 'Long64_t' 0 - ievt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEventCollection",1838,G__G__TMVA1_319_0_115, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR), G__defined_typename("vector<TMVA::Event*>"), 1, 1, 1, 1, 1, "i 'TMVA::Types::ETreeType' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsSignalLike",1183,G__G__TMVA1_319_0_116, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsSignalLike",1183,G__G__TMVA1_319_0_117, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - mvaVal", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("HasMVAPdfs",909,G__G__TMVA1_319_0_118, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAnalysisType",1554,G__G__TMVA1_319_0_119, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TMVA::Types::EAnalysisType' - 0 - type", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetAnalysisType",1542,G__G__TMVA1_319_0_120, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLTypescLcLEAnalysisType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoRegression",1236,G__G__TMVA1_319_0_121, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DoMulticlass",1236,G__G__TMVA1_319_0_122, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DisableWriting",1432,G__G__TMVA1_319_0_123, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - setter", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWeightFileName",1685,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TString' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWeightFileDir",1575,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TString), -1, 1, 0, 1, 2, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWeightFileDir",1587,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TString' - 0 - fileDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsNormalised",1226,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNormalised",1338,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 - norm", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Verbose",726,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Help",393,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInternalVarName",1799,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TString), -1, 1, 1, 1, 2, 9, "i - 'Int_t' 0 - ivar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOriginalVarName",1791,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TString), -1, 1, 1, 1, 2, 9, "i - 'Int_t' 0 - ivar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasTrainingTree",1512,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeClassSpecific",1690,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClassSpecificHeader",2275,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetThisBase",1075,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase), -1, 0, 0, 3, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Statistics",1067,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 8, 1, 2, 0, 
"i 'TMVA::Types::ETreeType' - 0 - treeType u 'TString' - 11 - theVarName "
"d - 'Double_t' 1 - - d - 'Double_t' 1 - - "
"d - 'Double_t' 1 - - d - 'Double_t' 1 - - "
"d - 'Double_t' 1 - - d - 'Double_t' 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TxtWeightsOnly",1469,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsConstructedFromWeightFile",2758,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitBase",783,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclareBaseOptions",1815,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ProcessBaseOptions",1862,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCutOrientation",1752,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBasecLcLECutOrientation), -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetThisBase",1302,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateMVAPdfs",1221,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IGetEffForRoot",1349,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 3, 4, 0, "d - 'Double_t' 0 - -", "interface", (void*) NULL, 0);
   G__memfunc_setup("GetEffForRoot",1276,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 0 - -", "implementation", (void*) NULL, 0);
   G__memfunc_setup("GetLine",680,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - fin C - - 0 - buf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddClassifierOutput",1951,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i 'TMVA::Types::ETreeType' - 0 - type", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddClassifierOutputProb",2354,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i 'TMVA::Types::ETreeType' - 0 - type", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddRegressionOutput",1979,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i 'TMVA::Types::ETreeType' - 0 - type", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddMulticlassOutput",1979,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i 'TMVA::Types::ETreeType' - 0 - type", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddInfoItem",1060,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"Y - - 0 - gi u 'TString' - 11 - name "
"u 'TString' - 11 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateVariableTransforms",2473,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 3, 4, 0, 
"u 'TString' - 11 - trafoDefinition u 'TMVA::DataSetInfo' - 1 - dataInfo "
"u 'TMVA::TransformationHandler' - 1 - transformationHandler u 'TMVA::MsgLogger' - 1 - log", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IgnoreEventsWithNegWeightsInTraining",3677,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA1_319_0_156, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodBase::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_319_0_157, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodBase::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_319_0_158, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodBase::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_319_0_159, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodBase::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_319_0_163, 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__TMVA1_319_0_164, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodBase::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_319_0_165, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodBase::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_319_0_166, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodBase::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_319_0_167, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodBase::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodBase", 1114, G__G__TMVA1_319_0_168, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLFactory(void) {
   /* TMVA::Factory */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLFactory));
   G__memfunc_setup("Factory",728,G__G__TMVA1_323_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLFactory), -1, 0, 3, 1, 1, 0, 
"u 'TString' - 0 - theJobName U 'TFile' - 0 - theTargetFile "
"u 'TString' - 0 '\"\"' theOption", (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("AddSignalTrainingEvent",2213,G__G__TMVA1_323_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - event d - 'Double_t' 0 '1.0' weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBackgroundTrainingEvent",2631,G__G__TMVA1_323_0_4, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - event d - 'Double_t' 0 '1.0' weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddSignalTestEvent",1801,G__G__TMVA1_323_0_5, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - event d - 'Double_t' 0 '1.0' weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBackgroundTestEvent",2219,G__G__TMVA1_323_0_6, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - event d - 'Double_t' 0 '1.0' weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTrainingEvent",1607,G__G__TMVA1_323_0_7, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TString' - 11 - className u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - event "
"d - 'Double_t' 0 - weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTestEvent",1195,G__G__TMVA1_323_0_8, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TString' - 11 - className u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - event "
"d - 'Double_t' 0 - weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddEvent",779,G__G__TMVA1_323_0_9, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'TString' - 11 - className i 'TMVA::Types::ETreeType' - 0 - tt "
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - event d - 'Double_t' 0 - weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UserAssignEvents",1657,G__G__TMVA1_323_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - clIndex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateEventAssignTrees",2238,G__G__TMVA1_323_0_11, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TTree), -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddDataSet",943,G__G__TMVA1_323_0_12, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLDataSetInfo), -1, 1, 1, 1, 1, 0, "u 'TMVA::DataSetInfo' - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddDataSet",943,G__G__TMVA1_323_0_13, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLDataSetInfo), -1, 1, 1, 1, 1, 0, "u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInputTrees",1343,G__G__TMVA1_323_0_14, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'TString' - 11 - signalFileName u 'TString' - 11 - backgroundFileName "
"d - 'Double_t' 0 '1.0' signalWeight d - 'Double_t' 0 '1.0' backgroundWeight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInputTrees",1343,G__G__TMVA1_323_0_15, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TTree' - 0 - inputTree u 'TCut' - 11 - SigCut "
"u 'TCut' - 11 - BgCut", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInputTrees",1343,G__G__TMVA1_323_0_16, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TTree' - 0 - signal U 'TTree' - 0 - background "
"d - 'Double_t' 0 '1.0' signalWeight d - 'Double_t' 0 '1.0' backgroundWeight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddSignalTree",1271,G__G__TMVA1_323_0_17, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TTree' - 0 - signal d - 'Double_t' 0 '1.0' weight "
"i 'TMVA::Types::ETreeType' - 0 'Types::kMaxTreeType' treetype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddSignalTree",1271,G__G__TMVA1_323_0_18, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TString' - 0 - datFileS d - 'Double_t' 0 '1.0' weight "
"i 'TMVA::Types::ETreeType' - 0 'Types::kMaxTreeType' treetype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddSignalTree",1271,G__G__TMVA1_323_0_19, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TTree' - 0 - signal d - 'Double_t' 0 - weight "
"u 'TString' - 11 - treetype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSignalTree",1306,G__G__TMVA1_323_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TTree' - 0 - signal d - 'Double_t' 0 '1.0' weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBackgroundTree",1689,G__G__TMVA1_323_0_21, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TTree' - 0 - background d - 'Double_t' 0 '1.0' weight "
"i 'TMVA::Types::ETreeType' - 0 'Types::kMaxTreeType' treetype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBackgroundTree",1689,G__G__TMVA1_323_0_22, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TString' - 0 - datFileB d - 'Double_t' 0 '1.0' weight "
"i 'TMVA::Types::ETreeType' - 0 'Types::kMaxTreeType' treetype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddBackgroundTree",1689,G__G__TMVA1_323_0_23, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TTree' - 0 - background d - 'Double_t' 0 - weight "
"u 'TString' - 11 - treetype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBackgroundTree",1724,G__G__TMVA1_323_0_24, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TTree' - 0 - background d - 'Double_t' 0 '1.0' weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSignalWeightExpression",2594,G__G__TMVA1_323_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - variable", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBackgroundWeightExpression",3012,G__G__TMVA1_323_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - variable", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddRegressionTree",1722,G__G__TMVA1_323_0_27, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TTree' - 0 - tree d - 'Double_t' 0 '1.0' weight "
"i 'TMVA::Types::ETreeType' - 0 'Types::kMaxTreeType' treetype", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTree",700,G__G__TMVA1_323_0_28, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TTree' - 0 - tree u 'TString' - 11 - className "
"d - 'Double_t' 0 - weight", "depreciated", (void*) NULL, 0);
   G__memfunc_setup("AddTree",665,G__G__TMVA1_323_0_29, 121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TTree' - 0 - tree u 'TString' - 11 - className "
"d - 'Double_t' 0 '1.0' weight u 'TCut' - 11 '\"\"' cut "
"i 'TMVA::Types::ETreeType' - 0 'Types::kMaxTreeType' tt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTree",665,G__G__TMVA1_323_0_30, 121, -1, -1, 0, 5, 1, 1, 0, 
"U 'TTree' - 0 - tree u 'TString' - 11 - className "
"d - 'Double_t' 0 - weight u 'TCut' - 11 - cut "
"u 'TString' - 11 - treeType", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInputVariables",1749,G__G__TMVA1_323_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "U 'vector<TString,allocator<TString> >' 'vector<TString>' 0 - theVariables", "depreciated", (void*) NULL, 0);
   G__memfunc_setup("AddVariable",1071,G__G__TMVA1_323_0_32, 121, -1, -1, 0, 6, 1, 1, 0, 
"u 'TString' - 11 - expression u 'TString' - 11 - title "
"u 'TString' - 11 - unit c - - 0 ''F'' type "
"d - 'Double_t' 0 '0' min d - 'Double_t' 0 '0' max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddVariable",1071,G__G__TMVA1_323_0_33, 121, -1, -1, 0, 4, 1, 1, 0, 
"u 'TString' - 11 - expression c - - 0 ''F'' type "
"d - 'Double_t' 0 '0' min d - 'Double_t' 0 '0' max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTarget",880,G__G__TMVA1_323_0_34, 121, -1, -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - expression u 'TString' - 11 '\"\"' title "
"u 'TString' - 11 '\"\"' unit d - 'Double_t' 0 '0' min "
"d - 'Double_t' 0 '0' max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddRegressionTarget",1937,G__G__TMVA1_323_0_35, 121, -1, -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - expression u 'TString' - 11 '\"\"' title "
"u 'TString' - 11 '\"\"' unit d - 'Double_t' 0 '0' min "
"d - 'Double_t' 0 '0' max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddSpectator",1214,G__G__TMVA1_323_0_36, 121, -1, -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - expression u 'TString' - 11 '\"\"' title "
"u 'TString' - 11 '\"\"' unit d - 'Double_t' 0 '0' min "
"d - 'Double_t' 0 '0' max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWeightExpression",1988,G__G__TMVA1_323_0_37, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - variable u 'TString' - 11 '\"\"' className", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCut",600,G__G__TMVA1_323_0_38, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - cut u 'TString' - 11 '\"\"' className", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCut",600,G__G__TMVA1_323_0_39, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TCut' - 11 - cut u 'TString' - 11 '\"\"' className", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddCut",565,G__G__TMVA1_323_0_40, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - cut u 'TString' - 11 '\"\"' className", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddCut",565,G__G__TMVA1_323_0_41, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TCut' - 11 - cut u 'TString' - 11 '\"\"' className", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrepareTrainingAndTestTree",2638,G__G__TMVA1_323_0_42, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TCut' - 11 - cut u 'TString' - 11 - splitOpt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrepareTrainingAndTestTree",2638,G__G__TMVA1_323_0_43, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TCut' - 0 - sigcut u 'TCut' - 0 - bkgcut "
"u 'TString' - 11 - splitOpt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrepareTrainingAndTestTree",2638,G__G__TMVA1_323_0_44, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'TCut' - 11 - cut i - 'Int_t' 0 - Ntrain "
"i - 'Int_t' 0 '-1' Ntest", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrepareTrainingAndTestTree",2638,G__G__TMVA1_323_0_45, 121, -1, -1, 0, 6, 1, 1, 0, 
"u 'TCut' - 11 - cut i - 'Int_t' 0 - NsigTrain "
"i - 'Int_t' 0 - NbkgTrain i - 'Int_t' 0 - NsigTest "
"i - 'Int_t' 0 - NbkgTest u 'TString' - 11 '\"SplitMode=Random:!V\"' otherOpt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BookMethod",1004,G__G__TMVA1_323_0_46, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase), -1, 0, 3, 1, 1, 0, 
"u 'TString' - 0 - theMethodName u 'TString' - 0 - methodTitle "
"u 'TString' - 0 '\"\"' theOption", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BookMethod",1004,G__G__TMVA1_323_0_47, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase), -1, 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EMVA' - 0 - theMethod u 'TString' - 0 - methodTitle "
"u 'TString' - 0 '\"\"' theOption", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BookMethod",1004,G__G__TMVA1_323_0_48, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase), -1, 0, 5, 1, 1, 0, 
"i 'TMVA::Types::EMVA' - 0 - - u 'TString' - 0 - - "
"u 'TString' - 0 - - i 'TMVA::Types::EMVA' - 0 - - "
"u 'TString' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OptimizeAllMethods",1854,G__G__TMVA1_323_0_49, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TString' - 0 '\"ROCIntegral\"' fomType u 'TString' - 0 '\"FitGA\"' fitType", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OptimizeAllMethodsForClassification",3601,G__G__TMVA1_323_0_50, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TString' - 0 '\"ROCIntegral\"' fomType u 'TString' - 0 '\"FitGA\"' fitType", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OptimizeAllMethodsForRegression",3206,G__G__TMVA1_323_0_51, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TString' - 0 '\"ROCIntegral\"' fomType u 'TString' - 0 '\"FitGA\"' fitType", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrainAllMethods",1515,G__G__TMVA1_323_0_52, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrainAllMethodsForClassification",3262,G__G__TMVA1_323_0_53, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrainAllMethodsForRegression",2867,G__G__TMVA1_323_0_54, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TestAllMethods",1421,G__G__TMVA1_323_0_55, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvaluateAllMethods",1828,G__G__TMVA1_323_0_56, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvaluateAllVariables",2025,G__G__TMVA1_323_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 0 '\"\"' options", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteAllMethods",1600,G__G__TMVA1_323_0_58, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethod",897,G__G__TMVA1_323_0_59, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod), -1, 0, 1, 1, 1, 8, "u 'TString' - 11 - title", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Verbose",726,G__G__TMVA1_323_0_60, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVerbose",1026,G__G__TMVA1_323_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeClass",884,G__G__TMVA1_323_0_62, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TString' - 11 '\"\"' methodTitle", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintHelpMessage",1627,G__G__TMVA1_323_0_63, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TString' - 11 '\"\"' methodTitle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RootBaseDir",1086,G__G__TMVA1_323_0_64, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TDirectory), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TDirectory* (*)())(&TMVA::Factory::RootBaseDir) ), 0);
   G__memfunc_setup("Greetings",936,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteDataInformation",2059,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DataInput",906,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLDataInputHandler), -1, 1, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DefaultDataSetInfo",1783,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLDataSetInfo), -1, 1, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInputTreesFromEventAssignTrees",3389,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA1_323_0_70, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::Factory::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_323_0_71, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Factory::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_323_0_72, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::Factory::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_323_0_73, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::Factory::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_323_0_77, 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__TMVA1_323_0_78, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Factory::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_323_0_79, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Factory::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_323_0_80, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Factory::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_323_0_81, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Factory::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~Factory", 854, G__G__TMVA1_323_0_82, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodBoost(void) {
   /* TMVA::MethodBoost */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBoost));
   G__memfunc_setup("MethodBoost",1128,G__G__TMVA1_342_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBoost), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - jobName u 'TString' - 11 - methodTitle "
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 '\"\"' theOption "
"U 'TDirectory' - 0 'NULL' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MethodBoost",1128,G__G__TMVA1_342_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBoost), -1, 0, 3, 1, 1, 0, 
"u 'TMVA::DataSetInfo' - 1 - dsi u 'TString' - 11 - theWeightFile "
"U 'TDirectory' - 0 'NULL' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAnalysisType",1538,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EAnalysisType' - 0 - type h - 'UInt_t' 0 - numberClasses "
"h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BookMethod",1004,G__G__TMVA1_342_0_6, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EMVA' - 0 - theMethod u 'TString' - 0 - methodTitle "
"u 'TString' - 0 - theOption", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBoostedMethodName",2014,G__G__TMVA1_342_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 0 - methodName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBoostNum",1111,G__G__TMVA1_342_0_8, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CleanBoostOptions",1750,G__G__TMVA1_342_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ClearAll",768,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintResults",1279,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"u 'TString' - 11 - - u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - - "
"d - 'Double_t' 10 - -", (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, 1);
   G__memfunc_setup("InitHistos",1038,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckSetup",1007,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MonitorBoost",1263,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"i 'TMVA::Types::EBoostStage' - 0 - stage h - 'UInt_t' 0 '0' methodIdx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareCompatibilityOptions",2806,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CurrentMethod",1348,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CurrentMethodIdx",1641,(G__InterfaceMethod) NULL, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SingleTrain",1120,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SingleBoost",1129,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "U 'TMVA::MethodBase' - 0 - method", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdaBoost",781,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 0, 
"U 'TMVA::MethodBase' - 0 - method g - 'Bool_t' 0 - useYesNoLeaf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Bagging",687,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcMethodWeight",1596,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBoostROCIntegral",1857,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 4, 0, 
"g - 'Bool_t' 0 - - i 'TMVA::Types::ETreeType' - 0 - - "
"g - 'Bool_t' 0 'kFALSE' CalcOverlapIntergral", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteMonitoringHistosToFile",2798,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteEvaluationHistosToFile",2784,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i 'TMVA::Types::ETreeType' - 0 - treetype", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TestClassification",1868,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FindMVACut",913,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TMVA::MethodBase' - 0 - method", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ResetBoostWeights",1765,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateMVAHistorgrams",1995,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcMVAValues",1223,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA1_342_0_36, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodBoost::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_342_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodBoost::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_342_0_38, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodBoost::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_342_0_39, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodBoost::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_342_0_43, 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__TMVA1_342_0_44, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodBoost::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_342_0_45, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodBoost::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_342_0_46, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodBoost::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_342_0_47, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodBoost::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodBoost", 1254, G__G__TMVA1_342_0_48, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodCuts(void) {
   /* TMVA::MethodCuts */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCuts));
   G__memfunc_setup("MethodCuts",1024,G__G__TMVA1_420_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCuts), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - jobName u 'TString' - 11 - methodTitle "
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 '\"MC:150:10000:\"' theOption "
"U 'TDirectory' - 0 '0' theTargetFile", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MethodCuts",1024,G__G__TMVA1_420_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCuts), -1, 0, 3, 1, 1, 0, 
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 - theWeightFile "
"U 'TDirectory' - 0 'NULL' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DynamicCast",1104,G__G__TMVA1_420_0_3, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCuts), -1, 0, 1, 3, 1, 0, "U 'TMVA::IMethod' - 0 - method", (char*)NULL, (void*) G__func2void( (TMVA::MethodCuts* (*)(TMVA::IMethod*))(&TMVA::MethodCuts::DynamicCast) ), 0);
   G__memfunc_setup("HasAnalysisType",1538,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EAnalysisType' - 0 - type h - 'UInt_t' 0 - numberClasses "
"h - 'UInt_t' 0 - numberTargets", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddWeightsXMLTo",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromXML",1756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - wghtnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteMonitoringHistosToFile",2798,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TestClassification",1868,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSeparation",1334,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"U 'TH1' - 0 - - U 'TH1' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSeparation",1334,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"U 'TMVA::PDF' - 0 '0' - U 'TMVA::PDF' - 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSignificance",1507,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetmuTransform",1470,G__G__TMVA1_420_0_15, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "U 'TTree' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEfficiency",1301,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"u 'TString' - 11 - - i 'TMVA::Types::ETreeType' - 0 - - "
"d - 'Double_t' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTrainingEfficiency",2129,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRarity",923,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"d - 'Double_t' 0 - - i 'TMVA::Types::ESBType' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ComputeEstimator",1685,G__G__TMVA1_420_0_19, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EstimatorFunction",1790,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EstimatorFunction",1790,G__G__TMVA1_420_0_21, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - ievt1 i - 'Int_t' 0 - ievt2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTestSignalEfficiency",2335,G__G__TMVA1_420_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - effS", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintCuts",940,G__G__TMVA1_420_0_23, 121, -1, -1, 0, 1, 1, 1, 8, "d - 'Double_t' 0 - effS", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCuts",703,G__G__TMVA1_420_0_24, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"d - 'Double_t' 0 - effS u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - cutMin "
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - cutMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCuts",703,G__G__TMVA1_420_0_25, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 8, 
"d - 'Double_t' 0 - effS D - 'Double_t' 0 - cutMin "
"D - 'Double_t' 0 - cutMax", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckSetup",1007,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClassSpecific",1690,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MatchParsToCuts",1509,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - - D - 'Double_t' 0 - - "
"D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MatchParsToCuts",1509,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"D - 'Double_t' 0 - - D - 'Double_t' 0 - - "
"D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MatchCutsToPars",1509,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - - D - 'Double_t' 0 - - "
"D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MatchCutsToPars",1509,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - - D - 'Double_t' 2 - - "
"D - 'Double_t' 2 - - i - 'Int_t' 0 - ibin", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateVariablePDFs",1735,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEffsfromSelection",2046,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
"D - 'Double_t' 0 - cutMin D - 'Double_t' 0 - cutMax "
"d - 'Double_t' 1 - effS d - 'Double_t' 1 - effB", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEffsfromPDFs",1445,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 4, 0, 
"D - 'Double_t' 0 - cutMin D - 'Double_t' 0 - cutMax "
"d - 'Double_t' 1 - effS d - 'Double_t' 1 - effB", (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, 1);
   G__memfunc_setup("Class",502,G__G__TMVA1_420_0_40, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodCuts::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_420_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodCuts::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_420_0_42, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodCuts::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_420_0_43, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodCuts::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_420_0_47, 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__TMVA1_420_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodCuts::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_420_0_49, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodCuts::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_420_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodCuts::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_420_0_51, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodCuts::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodCuts", 1150, G__G__TMVA1_420_0_52, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodCompositeBase(void) {
   /* TMVA::MethodCompositeBase */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCompositeBase));
   G__memfunc_setup("AddWeightsXMLTo",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromXML",1756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - wghtnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMethod",897,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod), -1, 0, 1, 1, 2, 8, "u 'TString' - 11 - title", "accessor by name", (void*) NULL, 0);
   G__memfunc_setup("GetMethod",897,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod), -1, 0, 1, 1, 2, 8, "i - 'Int_t' 10 - index", "accessor by index in vector", (void*) NULL, 0);
   G__memfunc_setup("GetCurrentMethodIndex",2140,(G__InterfaceMethod) NULL, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLastMethod",1301,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPreviousMethod",1758,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentMethod",1636,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCurrentMethod",1636,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBase), -1, 0, 1, 1, 2, 0, "h - 'UInt_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA1_433_0_18, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodCompositeBase::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_433_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodCompositeBase::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_433_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodCompositeBase::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_433_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodCompositeBase::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_433_0_25, 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__TMVA1_433_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodCompositeBase::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_433_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodCompositeBase::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_433_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodCompositeBase::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_433_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodCompositeBase::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodCompositeBase", 2061, G__G__TMVA1_433_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodANNBase(void) {
   /* TMVA::MethodANNBase */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodANNBase));
   G__memfunc_setup("InitANNBase",1004,G__G__TMVA1_487_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetActivation",1342,G__G__TMVA1_487_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::TActivation' - 0 - activation", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNeuronInputCalculator",2493,G__G__TMVA1_487_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::TNeuronInput' - 0 - inputCalculator", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PrintNetwork",1271,G__G__TMVA1_487_0_7, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddWeightsXMLTo",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromXML",1756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - wghtnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRegressionValues",1969,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMulticlassValues",1969,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteMonitoringHistosToFile",2798,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Debug",487,G__G__TMVA1_487_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeClassSpecific",1690,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ParseLayoutString",1776,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEintcOallocatorlEintgRsPgR), G__defined_typename("vector<Int_t>"), 0, 1, 1, 2, 0, "u 'TString' - 0 - layerSpec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildNetwork",1242,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"U 'vector<int,allocator<int> >' 'vector<Int_t>' 0 - layout U 'vector<double,allocator<double> >' 'vector<Double_t>' 0 'NULL' weights "
"g - 'Bool_t' 0 'kFALSE' fromFile", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ForceNetworkInputs",1884,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"U 'TMVA::Event' - 10 - ev i - 'Int_t' 0 '-1' ignoreIndex", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNetworkOutput",1691,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintMessage",1234,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'TString' - 0 - message g - 'Bool_t' 0 'kFALSE' force", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ForceNetworkCalculations",2491,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WaitForKeyboard",1517,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NumCycles",915,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInputNeuron",1447,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLTNeuron), -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOutputNeuron",1576,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLTNeuron), -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 '0' index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateWeightMonitoringHists",2797,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'TString' - 11 - bulkname U 'vector<TH1*,allocator<TH1*> >' 'vector<TH1*>' 0 '0' hv", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildLayers",1120,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"U 'vector<int,allocator<int> >' 'vector<Int_t>' 0 - layout g - 'Bool_t' 0 'false' from_file", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildLayer",1005,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 6, 1, 4, 0, 
"i - 'Int_t' 0 - numNeurons U 'TObjArray' - 0 - curLayer "
"U 'TObjArray' - 0 - prevLayer i - 'Int_t' 0 - layerIndex "
"i - 'Int_t' 0 - numLayers g - 'Bool_t' 0 'false' from_file", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPreLinks",1073,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"U 'TMVA::TNeuron' - 0 - neuron U 'TObjArray' - 0 - prevLayer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitWeights",1135,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ForceWeights",1226,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'vector<double,allocator<double> >' 'vector<Double_t>' 0 - weights", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteNetwork",1341,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteNetworkLayer",1850,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TObjArray' - 1 - layer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintLayer",1034,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "U 'TObjArray' - 0 - layer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintNeuron",1156,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "U 'TMVA::TNeuron' - 0 - neuron", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA1_487_0_40, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodANNBase::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_487_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodANNBase::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_487_0_42, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodANNBase::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_487_0_43, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodANNBase::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_487_0_47, 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__TMVA1_487_0_48, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodANNBase::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_487_0_49, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodANNBase::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_487_0_50, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodANNBase::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_487_0_51, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodANNBase::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodANNBase", 1335, G__G__TMVA1_487_0_52, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodTMlpANN(void) {
   /* TMVA::MethodTMlpANN */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodTMlpANN));
   G__memfunc_setup("MethodTMlpANN",1211,G__G__TMVA1_498_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodTMlpANN), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - jobName u 'TString' - 11 - methodTitle "
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 '\"3000:N-1:N-2\"' theOption "
"U 'TDirectory' - 0 '0' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MethodTMlpANN",1211,G__G__TMVA1_498_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodTMlpANN), -1, 0, 3, 1, 1, 0, 
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 - theWeightFile "
"U 'TDirectory' - 0 'NULL' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAnalysisType",1538,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EAnalysisType' - 0 - type h - 'UInt_t' 0 - numberClasses "
"h - 'UInt_t' 0 - numberTargets", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddWeightsXMLTo",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromXML",1756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - wghtnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetHiddenLayer",1397,G__G__TMVA1_498_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 0 '\"\"' hiddenlayer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClass",884,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TString' - 11 'TString(\"\")' classFileName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClassSpecific",1690,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateMLPOptions",1577,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TString' - 0 - -", (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, 1);
   G__memfunc_setup("Class",502,G__G__TMVA1_498_0_18, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodTMlpANN::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_498_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodTMlpANN::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_498_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodTMlpANN::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_498_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodTMlpANN::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_498_0_25, 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__TMVA1_498_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodTMlpANN::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_498_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodTMlpANN::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_498_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodTMlpANN::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_498_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodTMlpANN::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodTMlpANN", 1337, G__G__TMVA1_498_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodRuleFit(void) {
   /* TMVA::MethodRuleFit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodRuleFit));
   G__memfunc_setup("MethodRuleFit",1308,G__G__TMVA1_584_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodRuleFit), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - jobName u 'TString' - 11 - methodTitle "
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 '\"\"' theOption "
"U 'TDirectory' - 0 '0' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MethodRuleFit",1308,G__G__TMVA1_584_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodRuleFit), -1, 0, 3, 1, 1, 0, 
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 - theWeightFile "
"U 'TDirectory' - 0 'NULL' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAnalysisType",1538,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EAnalysisType' - 0 - type h - 'UInt_t' 0 - numberClasses "
"h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddWeightsXMLTo",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromXML",1756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - wghtnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteMonitoringHistosToFile",2798,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("UseBoost",820,G__G__TMVA1_584_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRuleFitPtr",1297,G__G__TMVA1_584_0_12, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRuleFit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRuleFitConstPtr",1816,G__G__TMVA1_584_0_13, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRuleFit), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethodBaseDir",1563,G__G__TMVA1_584_0_14, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TDirectory), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrainingEvents",1745,G__G__TMVA1_584_0_15, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR), G__defined_typename("vector<TMVA::Event*>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetForest",915,G__G__TMVA1_584_0_16, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLDecisionTreemUcOallocatorlETMVAcLcLDecisionTreemUgRsPgR), G__defined_typename("vector<TMVA::DecisionTree*>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNTrees",881,G__G__TMVA1_584_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTreeEveFrac",1356,G__G__TMVA1_584_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSeparationBaseConst",2232,G__G__TMVA1_584_0_19, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLSeparationBase), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSeparationBase",1713,G__G__TMVA1_584_0_20, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLSeparationBase), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPruneMethod",1419,G__G__TMVA1_584_0_21, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLDecisionTreecLcLEPruneMethod), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPruneStrength",1657,G__G__TMVA1_584_0_22, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinFracNEve",1326,G__G__TMVA1_584_0_23, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxFracNEve",1328,G__G__TMVA1_584_0_24, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNCuts",781,G__G__TMVA1_584_0_25, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGDNPathSteps",1429,G__G__TMVA1_584_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGDPathStep",1236,G__G__TMVA1_584_0_27, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGDErrScale",1212,G__G__TMVA1_584_0_28, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGDPathEveFrac",1492,G__G__TMVA1_584_0_29, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGDValidEveFrac",1591,G__G__TMVA1_584_0_30, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLinQuantile",1414,G__G__TMVA1_584_0_31, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRFWorkDir",1146,G__G__TMVA1_584_0_32, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TString), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRFNrules",1073,G__G__TMVA1_584_0_33, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRFNendnodes",1366,G__G__TMVA1_584_0_34, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeClassSpecific",1690,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClassRuleCuts",1707,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeClassLinear",1487,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitEventSample",1528,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitMonitorNtuple",1780,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrainTMVARuleFit",1521,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrainJFRuleFit",1353,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA1_584_0_46, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodRuleFit::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_584_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodRuleFit::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_584_0_48, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodRuleFit::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_584_0_49, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodRuleFit::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_584_0_53, 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__TMVA1_584_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodRuleFit::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_584_0_55, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodRuleFit::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_584_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodRuleFit::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_584_0_57, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodRuleFit::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodRuleFit", 1434, G__G__TMVA1_584_0_58, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodFisher(void) {
   /* TMVA::MethodFisher */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFisher));
   G__memfunc_setup("MethodFisher",1218,G__G__TMVA1_636_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFisher), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - jobName u 'TString' - 11 - methodTitle "
"u 'TMVA::DataSetInfo' - 1 - dsi u 'TString' - 11 '\"Fisher\"' theOption "
"U 'TDirectory' - 0 '0' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MethodFisher",1218,G__G__TMVA1_636_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFisher), -1, 0, 3, 1, 1, 0, 
"u 'TMVA::DataSetInfo' - 1 - dsi u 'TString' - 11 - theWeightFile "
"U 'TDirectory' - 0 'NULL' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAnalysisType",1538,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EAnalysisType' - 0 - type h - 'UInt_t' 0 - numberClasses "
"h - 'UInt_t' 0 - numberTargets", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddWeightsXMLTo",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromXML",1756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - wghtnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetFisherMethod",1506,G__G__TMVA1_636_0_9, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFishercLcLEFisherMethod), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintCoefficients",1759,G__G__TMVA1_636_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeClassSpecific",1690,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitMatrices",1228,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMean",673,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCov_WithinClass",1808,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCov_BetweenClass",1895,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCov_Full",1082,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDiscrimPower",1528,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFisherCoeff",1380,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (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, 1);
   G__memfunc_setup("Class",502,G__G__TMVA1_636_0_24, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodFisher::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_636_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodFisher::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_636_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodFisher::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_636_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodFisher::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_636_0_31, 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__TMVA1_636_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodFisher::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_636_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodFisher::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_636_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodFisher::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_636_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodFisher::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodFisher", 1344, G__G__TMVA1_636_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLkNNcLcLEvent(void) {
   /* TMVA::kNN::Event */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLkNNcLcLEvent));
   G__memfunc_setup("Event",514,G__G__TMVA1_639_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLkNNcLcLEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Event",514,G__G__TMVA1_639_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLkNNcLcLEvent), -1, 0, 3, 1, 1, 0, 
"u 'vector<float,allocator<float> >' 'TMVA::kNN::VarVec' 11 - vec d - 'Double_t' 0 - weight "
"s - 'Short_t' 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Event",514,G__G__TMVA1_639_0_3, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLkNNcLcLEvent), -1, 0, 4, 1, 1, 0, 
"u 'vector<float,allocator<float> >' 'TMVA::kNN::VarVec' 11 - vec d - 'Double_t' 0 - weight "
"s - 'Short_t' 0 - type u 'vector<float,allocator<float> >' 'TMVA::kNN::VarVec' 11 - tvec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWeight",904,G__G__TMVA1_639_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVar",585,G__G__TMVA1_639_0_5, 102, -1, G__defined_typename("TMVA::kNN::VarType"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTgt",591,G__G__TMVA1_639_0_6, 102, -1, G__defined_typename("TMVA::kNN::VarType"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNVar",663,G__G__TMVA1_639_0_7, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNTgt",669,G__G__TMVA1_639_0_8, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetType",706,G__G__TMVA1_639_0_9, 115, -1, G__defined_typename("Short_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDist",692,G__G__TMVA1_639_0_10, 102, -1, G__defined_typename("TMVA::kNN::VarType"), 0, 2, 1, 1, 8, 
"f - 'TMVA::kNN::VarType' 0 - var h - 'UInt_t' 0 - ivar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDist",692,G__G__TMVA1_639_0_11, 102, -1, G__defined_typename("TMVA::kNN::VarType"), 0, 1, 1, 1, 8, "u 'TMVA::kNN::Event' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTargets",1030,G__G__TMVA1_639_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<float,allocator<float> >' 'TMVA::kNN::VarVec' 11 - tvec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTargets",1018,G__G__TMVA1_639_0_13, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("TMVA::kNN::VarVec"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVars",700,G__G__TMVA1_639_0_14, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("TMVA::kNN::VarVec"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,G__G__TMVA1_639_0_15, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,G__G__TMVA1_639_0_16, 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("GetDist",692,G__G__TMVA1_639_0_17, 102, -1, G__defined_typename("TMVA::kNN::VarType"), 0, 2, 1, 1, 8, 
"f - 'TMVA::kNN::VarType' 10 - var1 h - 'UInt_t' 10 - ivar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVar",585,G__G__TMVA1_639_0_18, 102, -1, G__defined_typename("TMVA::kNN::VarType"), 0, 1, 1, 1, 8, "h - 'UInt_t' 10 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTgt",591,G__G__TMVA1_639_0_19, 102, -1, G__defined_typename("TMVA::kNN::VarType"), 0, 1, 1, 1, 8, "h - 'UInt_t' 10 - i", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("Event", 514, G__G__TMVA1_639_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLkNNcLcLEvent), -1, 0, 1, 1, 1, 0, "u 'TMVA::kNN::Event' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~Event", 640, G__G__TMVA1_639_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA1_639_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLkNNcLcLEvent), -1, 1, 1, 1, 1, 0, "u 'TMVA::kNN::Event' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodKNN(void) {
   /* TMVA::MethodKNN */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodKNN));
   G__memfunc_setup("MethodKNN",840,G__G__TMVA1_691_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodKNN), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - jobName u 'TString' - 11 - methodTitle "
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 '\"KNN\"' theOption "
"U 'TDirectory' - 0 'NULL' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MethodKNN",840,G__G__TMVA1_691_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodKNN), -1, 0, 3, 1, 1, 0, 
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 - theWeightFile "
"U 'TDirectory' - 0 'NULL' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAnalysisType",1538,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EAnalysisType' - 0 - type h - 'UInt_t' 0 - numberClasses "
"h - 'UInt_t' 0 - numberTargets", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRegressionValues",1969,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteWeightsToStream",2069,G__G__TMVA1_691_0_7, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TFile' - 1 - rf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddWeightsXMLTo",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromXML",1756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - wghtnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TFile' - 1 - rf", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClassSpecific",1690,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareCompatibilityOptions",2806,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeKNN",613,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PolnKernel",1018,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 8, "d - 'Double_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GausKernel",1009,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 4, 8, 
"u 'TMVA::kNN::Event' - 11 - event_knn u 'TMVA::kNN::Event' - 11 - event "
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 11 - svec", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getKernelRadius",1545,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 8, "u 'list<pair<const TMVA::kNN::Node<TMVA::kNN::Event>*,float>,allocator<pair<const TMVA::kNN::Node<TMVA::kNN::Event>*,float> > >' 'TMVA::kNN::List' 11 - rlist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getRMS",562,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<Double_t>"), 0, 2, 1, 4, 9, 
"u 'list<pair<const TMVA::kNN::Node<TMVA::kNN::Event>*,float>,allocator<pair<const TMVA::kNN::Node<TMVA::kNN::Event>*,float> > >' 'TMVA::kNN::List' 11 - rlist u 'TMVA::kNN::Event' - 11 - event_knn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("getLDAValue",1038,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 2, 1, 4, 0, 
"u 'list<pair<const TMVA::kNN::Node<TMVA::kNN::Event>*,float>,allocator<pair<const TMVA::kNN::Node<TMVA::kNN::Event>*,float> > >' 'TMVA::kNN::List' 11 - rlist u 'TMVA::kNN::Event' - 11 - event_knn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA1_691_0_25, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodKNN::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_691_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodKNN::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_691_0_27, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodKNN::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_691_0_28, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodKNN::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_691_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__TMVA1_691_0_33, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodKNN::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_691_0_34, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodKNN::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_691_0_35, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodKNN::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_691_0_36, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodKNN::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodKNN", 966, G__G__TMVA1_691_0_37, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodCFMlpANN_Utils(void) {
   /* TMVA::MethodCFMlpANN_Utils */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_Utils));
   G__memfunc_setup("Train_nn",825,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 8, 1, 2, 0, 
"D - 'Double_t' 0 - tin2 D - 'Double_t' 0 - tout2 "
"I - 'Int_t' 0 - ntrain I - 'Int_t' 0 - ntest "
"I - 'Int_t' 0 - nvar2 I - 'Int_t' 0 - nlayer "
"I - 'Int_t' 0 - nodes I - 'Int_t' 0 - ncycle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Entree_new",1036,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 8, 1, 2, 0, 
"I - 'Int_t' 0 - - C - - 0 - - "
"I - 'Int_t' 0 - ntrain I - 'Int_t' 0 - ntest "
"I - 'Int_t' 0 - numlayer I - 'Int_t' 0 - nodes "
"I - 'Int_t' 0 - numcycle i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DataInterface",1291,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 9, 1, 2, 0, 
"D - 'Double_t' 0 - - D - 'Double_t' 0 - - "
"I - 'Int_t' 0 - - I - 'Int_t' 0 - - "
"I - 'Int_t' 0 - - I - 'Int_t' 0 - - "
"D - 'Double_t' 0 - - I - 'Int_t' 0 - - "
"I - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Fdecroi",700,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 2, 0, "I - 'Int_t' 0 - i__", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sen3a",442,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Wini",407,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("En_avant",812,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "I - 'Int_t' 0 - ievent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("En_avant2",862,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "I - 'Int_t' 0 - ievent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("En_arriere",1020,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "I - 'Int_t' 0 - ievent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Leclearn",806,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"I - 'Int_t' 0 - ktest D - 'Double_t' 0 - tout2 "
"D - 'Double_t' 0 - tin2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Out",312,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"I - 'Int_t' 0 - iii I - 'Int_t' 0 - maxcycle", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Cout",411,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"I - 'Int_t' 0 - - D - 'Double_t' 0 - xxx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Innit",514,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"C - - 0 - det D - 'Double_t' 0 - tout2 "
"D - 'Double_t' 0 - tin2 i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TestNN",572,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Inl",291,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GraphNN",654,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 1, 2, 0, 
"I - 'Int_t' 0 - ilearn D - 'Double_t' 0 - - "
"D - 'Double_t' 0 - - C - - 0 - - "
"i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Foncf",492,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"I - 'Int_t' 0 - i__ D - 'Double_t' 0 - u "
"D - 'Double_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Cout2",461,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"I - 'Int_t' 0 - - D - 'Double_t' 0 - yyy", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Lecev2",545,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"I - 'Int_t' 0 - ktest D - 'Double_t' 0 - tout2 "
"D - 'Double_t' 0 - tin2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Arret",510,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "C - - 10 - mot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CollectVar",1007,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"I - 'Int_t' 0 - nvar I - 'Int_t' 0 - class__ "
"D - 'Double_t' 0 - xpg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("W_ref",499,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 4, 1, 2, 8, 
"D - 'Double_t' 10 - wNN i - 'Int_t' 0 - a_1 "
"i - 'Int_t' 0 - a_2 i - 'Int_t' 0 - a_3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("W_ref",499,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 1, 4, 1, 2, 0, 
"D - 'Double_t' 0 - wNN i - 'Int_t' 0 - a_1 "
"i - 'Int_t' 0 - a_2 i - 'Int_t' 0 - a_3", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Ww_ref",618,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 2, 8, 
"D - 'Double_t' 10 - wwNN i - 'Int_t' 0 - a_1 "
"i - 'Int_t' 0 - a_2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Ww_ref",618,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 1, 3, 1, 2, 0, 
"D - 'Double_t' 0 - wwNN i - 'Int_t' 0 - a_1 "
"i - 'Int_t' 0 - a_2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLogger",908,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TMVA::MsgLogger' - 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ULog",375,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 0, "", "avoiding control reaches end of non-void function warning", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA1_692_0_29, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodCFMlpANN_Utils::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_692_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodCFMlpANN_Utils::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_692_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodCFMlpANN_Utils::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_692_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodCFMlpANN_Utils::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA1_692_0_33, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA1_692_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__TMVA1_692_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA1_692_0_36, 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__TMVA1_692_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodCFMlpANN_Utils::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_692_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodCFMlpANN_Utils::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_692_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodCFMlpANN_Utils::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_692_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodCFMlpANN_Utils::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodCFMlpANN_Utils", 2014, G__G__TMVA1_692_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA1_692_0_42, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_Utils), -1, 1, 1, 1, 1, 0, "u 'TMVA::MethodCFMlpANN_Utils' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodCFMlpANN(void) {
   /* TMVA::MethodCFMlpANN */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN));
   G__memfunc_setup("MethodCFMlpANN",1264,G__G__TMVA1_699_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - jobName u 'TString' - 11 - methodTitle "
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 '\"3000:N-1:N-2\"' theOption "
"U 'TDirectory' - 0 '0' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MethodCFMlpANN",1264,G__G__TMVA1_699_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN), -1, 0, 3, 1, 1, 0, 
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 - theWeightFile "
"U 'TDirectory' - 0 'NULL' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAnalysisType",1538,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EAnalysisType' - 0 - type h - 'UInt_t' 0 - numberClasses "
"h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddWeightsXMLTo",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromXML",1756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - wghtnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetData",666,G__G__TMVA1_699_0_9, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - isel i - 'Int_t' 0 - ivar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetClass",790,G__G__TMVA1_699_0_10, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - ivar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("This",408,G__G__TMVA1_699_0_11, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TMVA::MethodCFMlpANN* (*)())(&TMVA::MethodCFMlpANN::This) ), 0);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClassSpecific",1690,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClassSpecificHeader",2275,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DataInterface",1291,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 9, 1, 2, 0, 
"D - 'Double_t' 0 - - D - 'Double_t' 0 - - "
"I - 'Int_t' 0 - - I - 'Int_t' 0 - - "
"I - 'Int_t' 0 - - I - 'Int_t' 0 - - "
"D - 'Double_t' 0 - - I - 'Int_t' 0 - - "
"I - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintWeights",1256,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - o", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EvalANN",613,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - - g - 'Bool_t' 1 - isOK", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NN_ava",563,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NN_fonc",673,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 8, 
"i - 'Int_t' 0 - - d - 'Double_t' 0 - -", (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, 1);
   G__memfunc_setup("Class",502,G__G__TMVA1_699_0_24, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodCFMlpANN::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_699_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodCFMlpANN::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_699_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodCFMlpANN::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_699_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodCFMlpANN::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_699_0_31, 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__TMVA1_699_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodCFMlpANN::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_699_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodCFMlpANN::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_699_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodCFMlpANN::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_699_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodCFMlpANN::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodCFMlpANN", 1390, G__G__TMVA1_699_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodLikelihood(void) {
   /* TMVA::MethodLikelihood */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodLikelihood));
   G__memfunc_setup("MethodLikelihood",1637,G__G__TMVA1_700_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodLikelihood), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - jobName u 'TString' - 11 - methodTitle "
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 '\"\"' theOption "
"U 'TDirectory' - 0 '0' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MethodLikelihood",1637,G__G__TMVA1_700_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodLikelihood), -1, 0, 3, 1, 1, 0, 
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 - theWeightFile "
"U 'TDirectory' - 0 'NULL' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAnalysisType",1538,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EAnalysisType' - 0 - type h - 'UInt_t' 0 - numberClasses "
"h - 'UInt_t' 0 - numberTargets", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteWeightsToStream",2069,G__G__TMVA1_700_0_5, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TFile' - 1 - rf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddWeightsXMLTo",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TFile' - 1 - istr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromXML",1756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - wghtnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteMonitoringHistosToFile",2798,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteOptionsToStream",2086,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - o u 'TString' - 11 - prefix", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareCompatibilityOptions",2806,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClassSpecific",1690,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClassSpecificHeader",2275,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TransformLikelihoodOutput",2641,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 8, 
"d - 'Double_t' 0 - ps d - 'Double_t' 0 - pb", (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, 1);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA1_700_0_22, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodLikelihood::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_700_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodLikelihood::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_700_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodLikelihood::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_700_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodLikelihood::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_700_0_29, 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__TMVA1_700_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodLikelihood::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_700_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodLikelihood::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_700_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodLikelihood::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_700_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodLikelihood::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodLikelihood", 1763, G__G__TMVA1_700_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodHMatrix(void) {
   /* TMVA::MethodHMatrix */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodHMatrix));
   G__memfunc_setup("MethodHMatrix",1310,G__G__TMVA1_701_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodHMatrix), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - jobName u 'TString' - 11 - methodTitle "
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 '\"\"' theOption "
"U 'TDirectory' - 0 '0' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MethodHMatrix",1310,G__G__TMVA1_701_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodHMatrix), -1, 0, 3, 1, 1, 0, 
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 - theWeightFile "
"U 'TDirectory' - 0 'NULL' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAnalysisType",1538,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EAnalysisType' - 0 - type h - 'UInt_t' 0 - numberClasses "
"h - 'UInt_t' 0 - numberTargets", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddWeightsXMLTo",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromXML",1756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - wghtnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClassSpecific",1690,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetChi2",614,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "i 'TMVA::Types::ESBType' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeCovariance",1752,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"g - 'Bool_t' 0 - - U 'TMatrixT<double>' 'TMatrixD' 0 - -", (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, 1);
   G__memfunc_setup("Class",502,G__G__TMVA1_701_0_17, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodHMatrix::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_701_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodHMatrix::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_701_0_19, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodHMatrix::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_701_0_20, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodHMatrix::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_701_0_24, 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__TMVA1_701_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodHMatrix::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_701_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodHMatrix::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_701_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodHMatrix::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_701_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodHMatrix::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodHMatrix", 1436, G__G__TMVA1_701_0_29, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodPDERS(void) {
   /* TMVA::MethodPDERS */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERS));
   G__memfunc_setup("MethodPDERS",991,G__G__TMVA1_702_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERS), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - jobName u 'TString' - 11 - methodTitle "
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 - theOption "
"U 'TDirectory' - 0 '0' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MethodPDERS",991,G__G__TMVA1_702_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERS), -1, 0, 3, 1, 1, 0, 
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 - theWeightFile "
"U 'TDirectory' - 0 'NULL' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAnalysisType",1538,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EAnalysisType' - 0 - type h - 'UInt_t' 0 - numberClasses "
"h - 'UInt_t' 0 - numberTargets", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteWeightsToStream",2069,G__G__TMVA1_702_0_5, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TFile' - 1 - rf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddWeightsXMLTo",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TFile' - 1 - istr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromXML",1756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - wghtnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRegressionValues",1969,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IGetVolumeContentForRoot",2439,G__G__TMVA1_702_0_12, 100, -1, G__defined_typename("Double_t"), 0, 1, 3, 1, 0, "d - 'Double_t' 0 - -", (char*)NULL, (void*) G__func2void( (Double_t (*)(Double_t))(&TMVA::MethodPDERS::IGetVolumeContentForRoot) ), 0);
   G__memfunc_setup("GetVolumeContentForRoot",2366,G__G__TMVA1_702_0_13, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ThisPDERS",790,G__G__TMVA1_702_0_14, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDERS), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TMVA::MethodPDERS* (*)())(&TMVA::MethodPDERS::ThisPDERS) ), 0);
   G__memfunc_setup("MakeClassSpecific",1690,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetBinaryTree",1301,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLBinarySearchTree), -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CKernelEstimate",1504,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 2, 0, 
"u 'TMVA::Event' - 11 - - u 'vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >' - 1 - - "
"u 'TMVA::Volume' - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RKernelEstimate",1519,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
"u 'TMVA::Event' - 11 - - u 'vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >' - 1 - - "
"u 'TMVA::Volume' - 1 - - U 'vector<float,allocator<float> >' 'vector<Float_t>' 0 - pdfSum", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ApplyKernelFunction",1965,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 2, 0, "d - 'Double_t' 0 - normalized_distance", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("KernelNormalization",1992,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 2, 0, "d - 'Double_t' 0 - pdf", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNormalizedDistance",2144,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 2, 0, 
"u 'TMVA::Event' - 11 - base_event u 'TMVA::BinarySearchTreeNode' - 11 - sample_event "
"D - 'Double_t' 0 - dim_normalization", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NormSinc",809,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 2, 0, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LanczosFilter",1344,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 2, 0, 
"i - 'Int_t' 0 - level d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 2, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CalcAverages",1185,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateBinarySearchTree",2207,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i 'TMVA::Types::ETreeType' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSample",898,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"u 'TMVA::Event' - 11 - e u 'vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >' - 1 - events "
"U 'TMVA::Volume' - 0 - volume", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVolumeElement",1646,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CRScalc",635,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "u 'TMVA::Event' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RRScalc",650,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"u 'TMVA::Event' - 11 - - U 'vector<float,allocator<float> >' 'vector<Float_t>' 0 - count", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetError",810,(G__InterfaceMethod) NULL, 102, -1, G__defined_typename("Float_t"), 0, 4, 1, 4, 8, 
"f - 'Float_t' 0 - countS f - 'Float_t' 0 - countB "
"f - 'Float_t' 0 - sumW2S f - 'Float_t' 0 - sumW2B", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateThis",1019,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (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, 1);
   G__memfunc_setup("Class",502,G__G__TMVA1_702_0_37, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodPDERS::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_702_0_38, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodPDERS::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_702_0_39, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodPDERS::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_702_0_40, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodPDERS::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_702_0_44, 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__TMVA1_702_0_45, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodPDERS::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_702_0_46, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodPDERS::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_702_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodPDERS::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_702_0_48, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodPDERS::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodPDERS", 1117, G__G__TMVA1_702_0_49, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodBDT(void) {
   /* TMVA::MethodBDT */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBDT));
   G__memfunc_setup("MethodBDT",827,G__G__TMVA1_705_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBDT), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - jobName u 'TString' - 11 - methodTitle "
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 '\"\"' theOption "
"U 'TDirectory' - 0 '0' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MethodBDT",827,G__G__TMVA1_705_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBDT), -1, 0, 3, 1, 1, 0, 
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 - theWeightFile "
"U 'TDirectory' - 0 'NULL' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAnalysisType",1538,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EAnalysisType' - 0 - type h - 'UInt_t' 0 - numberClasses "
"h - 'UInt_t' 0 - numberTargets", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitEventSample",1528,G__G__TMVA1_705_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OptimizeTuningParameters",2522,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA1LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR), G__defined_typename("map<TString,Double_t>"), 0, 2, 1, 1, 0, 
"u 'TString' - 0 '\"ROCIntegral\"' fomType u 'TString' - 0 '\"FitGA\"' fitType", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetTuneParameters",1756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'map<TString,double,less<TString>,allocator<pair<const TString,double> > >' 'map<TString,Double_t>' 0 - tuneParameters", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddWeightsXMLTo",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromXML",1756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteMonitoringHistosToFile",2798,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNTrees",881,G__G__TMVA1_705_0_14, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 4, 0, 
"D - 'Double_t' 0 - err D - 'Double_t' 0 - errUpper "
"h - 'UInt_t' 0 - useNTrees", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrivateGetMvaValue",1820,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 4, 1, 4, 0, 
"U 'TMVA::Event' - 10 - ev D - 'Double_t' 0 '0' err "
"D - 'Double_t' 0 '0' errUpper h - 'UInt_t' 0 '0' useNTrees", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BoostMonitor",1263,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - iTree", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMulticlassValues",1969,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRegressionValues",1969,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Boost",519,G__G__TMVA1_705_0_20, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 1, 0, 
"u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'vector<const TMVA::Event*>' 1 - - U 'TMVA::DecisionTree' - 0 - dt "
"h - 'UInt_t' 0 '0' cls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMaxDepth",1095,G__G__TMVA1_705_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinNodeSize",1393,G__G__TMVA1_705_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - sizeInPercent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinNodeSize",1393,G__G__TMVA1_705_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 0 - sizeInPercent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNTrees",893,G__G__TMVA1_705_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetAdaBoostBeta",1461,G__G__TMVA1_705_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNodePurityLimit",1854,G__G__TMVA1_705_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - l", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetShrinkage",1224,G__G__TMVA1_705_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUseNvars",1123,G__G__TMVA1_705_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBaggedSampleFraction",2302,G__G__TMVA1_705_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetForest",915,G__G__TMVA1_705_0_33, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlETMVAcLcLDecisionTreemUcOallocatorlETMVAcLcLDecisionTreemUgRsPgR), G__defined_typename("vector<TMVA::DecisionTree*>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrainingEvents",1745,G__G__TMVA1_705_0_34, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR), G__defined_typename("vector<const TMVA::Event*>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBoostWeights",1538,G__G__TMVA1_705_0_35, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVariableImportance",2136,G__G__TMVA1_705_0_36, 117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<Double_t>"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetVariableImportance",2136,G__G__TMVA1_705_0_37, 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("TestTreeQuality",1561,G__G__TMVA1_705_0_38, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "U 'TMVA::DecisionTree' - 0 - dt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeClassSpecific",1690,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClassSpecificHeader",2275,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClassInstantiateNode",2430,G__G__TMVA1_705_0_41, 121, -1, -1, 0, 3, 1, 1, 8, 
"U 'TMVA::DecisionTreeNode' - 0 - n u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout "
"u 'TString' - 11 - className", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareCompatibilityOptions",2806,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PreProcessNegativeEventWeights",3094,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdaBoost",781,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 0, 
"u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'vector<const TMVA::Event*>' 1 - - U 'TMVA::DecisionTree' - 0 - dt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdaCost",671,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 0, 
"u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'vector<const TMVA::Event*>' 1 - - U 'TMVA::DecisionTree' - 0 - dt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Bagging",687,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RegBoost",805,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 0, 
"u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'vector<const TMVA::Event*>' 1 - - U 'TMVA::DecisionTree' - 0 - dt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdaBoostR2",913,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 0, 
"u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'vector<const TMVA::Event*>' 1 - - U 'TMVA::DecisionTree' - 0 - dt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GradBoost",901,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 4, 0, 
"u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'vector<const TMVA::Event*>' 1 - - U 'TMVA::DecisionTree' - 0 - dt "
"h - 'UInt_t' 0 '0' cls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GradBoostRegression",1958,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 0, 
"u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'vector<const TMVA::Event*>' 1 - - U 'TMVA::DecisionTree' - 0 - dt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitGradBoost",1305,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'vector<const TMVA::Event*>' 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateTargets",1341,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'vector<const TMVA::Event*>' 1 - - h - 'UInt_t' 0 '0' cls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateTargetsRegression",2398,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'vector<const TMVA::Event*>' 1 - - g - 'Bool_t' 0 'kFALSE' first", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetGradBoostMVA",1417,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 0, 
"U 'TMVA::Event' - 10 - e h - 'UInt_t' 0 - nTrees", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBaggedSubSample",1766,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'vector<const TMVA::Event*>' 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWeightedQuantile",1940,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 4, 0, 
"u 'vector<pair<double,double>,allocator<pair<double,double> > >' 'vector<std::pair<Double_t,Double_t> >' 0 - vec d - 'Double_t' 10 - quantile "
"d - 'Double_t' 10 '0.0' SumOfWeights", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeterminePreselectionCuts",2601,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'vector<const TMVA::Event*>' 11 - eventSample", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ApplyPreselectionCuts",2194,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "U 'TMVA::Event' - 10 - ev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA1_705_0_61, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodBDT::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_705_0_62, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodBDT::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_705_0_63, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodBDT::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_705_0_64, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodBDT::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_705_0_68, 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__TMVA1_705_0_69, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodBDT::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_705_0_70, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodBDT::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_705_0_71, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodBDT::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_705_0_72, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodBDT::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodBDT", 953, G__G__TMVA1_705_0_73, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodDT(void) {
   /* TMVA::MethodDT */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodDT));
   G__memfunc_setup("MethodDT",761,G__G__TMVA1_727_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodDT), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - jobName u 'TString' - 11 - methodTitle "
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 '\"\"' theOption "
"U 'TDirectory' - 0 '0' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MethodDT",761,G__G__TMVA1_727_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodDT), -1, 0, 3, 1, 1, 0, 
"u 'TMVA::DataSetInfo' - 1 - dsi u 'TString' - 11 - theWeightFile "
"U 'TDirectory' - 0 'NULL' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAnalysisType",1538,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EAnalysisType' - 0 - type h - 'UInt_t' 0 - numberClasses "
"h - 'UInt_t' 0 - numberTargets", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddWeightsXMLTo",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromXML",1756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - wghtnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareCompatibilityOptions",2806,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PruneTree",922,G__G__TMVA1_727_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TestTreeQuality",1561,G__G__TMVA1_727_0_15, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "U 'TMVA::DecisionTree' - 0 - dt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPruneStrength",1657,G__G__TMVA1_727_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinNodeSize",1393,G__G__TMVA1_727_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - sizeInPercent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinNodeSize",1393,G__G__TMVA1_727_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 0 - sizeInPercent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNNodesBeforePruning",2205,G__G__TMVA1_727_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNNodes",871,G__G__TMVA1_727_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 0, "", (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, 1);
   G__memfunc_setup("Class",502,G__G__TMVA1_727_0_22, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodDT::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_727_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodDT::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_727_0_24, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodDT::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_727_0_25, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodDT::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_727_0_29, 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__TMVA1_727_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodDT::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_727_0_31, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodDT::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_727_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodDT::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_727_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodDT::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodDT", 887, G__G__TMVA1_727_0_34, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodSVM(void) {
   /* TMVA::MethodSVM */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodSVM));
   G__memfunc_setup("MethodSVM",855,G__G__TMVA1_731_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodSVM), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - jobName u 'TString' - 11 - methodTitle "
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 '\"\"' theOption "
"U 'TDirectory' - 0 '0' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MethodSVM",855,G__G__TMVA1_731_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodSVM), -1, 0, 3, 1, 1, 0, 
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 - theWeightFile "
"U 'TDirectory' - 0 'NULL' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAnalysisType",1538,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EAnalysisType' - 0 - type h - 'UInt_t' 0 - numberClasses "
"h - 'UInt_t' 0 - numberTargets", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteWeightsToStream",2069,G__G__TMVA1_731_0_5, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TFile' - 1 - fout", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddWeightsXMLTo",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TFile' - 1 - fFin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromXML",1756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - wghtnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRegressionValues",1969,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClassSpecific",1690,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareCompatibilityOptions",2806,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA1_731_0_19, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodSVM::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_731_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodSVM::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_731_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodSVM::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_731_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodSVM::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_731_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__TMVA1_731_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodSVM::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_731_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodSVM::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_731_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodSVM::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_731_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodSVM::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodSVM", 981, G__G__TMVA1_731_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodBayesClassifier(void) {
   /* TMVA::MethodBayesClassifier */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBayesClassifier));
   G__memfunc_setup("MethodBayesClassifier",2138,G__G__TMVA1_736_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBayesClassifier), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - jobName u 'TString' - 11 - methodTitle "
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 '\"\"' theOption "
"U 'TDirectory' - 0 '0' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MethodBayesClassifier",2138,G__G__TMVA1_736_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodBayesClassifier), -1, 0, 3, 1, 1, 0, 
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 - theWeightFile "
"U 'TDirectory' - 0 'NULL' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAnalysisType",1538,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EAnalysisType' - 0 - type h - 'UInt_t' 0 - numberClasses "
"h - 'UInt_t' 0 - numberTargets", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddWeightsXMLTo",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromXML",1756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClassSpecific",1690,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA1_736_0_15, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodBayesClassifier::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_736_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodBayesClassifier::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_736_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodBayesClassifier::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_736_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodBayesClassifier::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_736_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA1_736_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodBayesClassifier::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_736_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodBayesClassifier::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_736_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodBayesClassifier::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_736_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodBayesClassifier::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodBayesClassifier", 2264, G__G__TMVA1_736_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodFDA(void) {
   /* TMVA::MethodFDA */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFDA));
   G__memfunc_setup("MethodFDA",812,G__G__TMVA1_738_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFDA), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - jobName u 'TString' - 11 - methodTitle "
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 '\"\"' theOption "
"U 'TDirectory' - 0 '0' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MethodFDA",812,G__G__TMVA1_738_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodFDA), -1, 0, 3, 1, 1, 0, 
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 - theWeightFile "
"U 'TDirectory' - 0 'NULL' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAnalysisType",1538,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EAnalysisType' - 0 - type h - 'UInt_t' 0 - numberClasses "
"h - 'UInt_t' 0 - numberTargets", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddWeightsXMLTo",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromXML",1756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - wghtnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRegressionValues",1969,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMulticlassValues",1969,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EstimatorFunction",1790,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CheckSetup",1007,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClassSpecific",1690,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CalculateMulticlassValues",2591,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"U 'TMVA::Event' - 11 - evt u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - parameters "
"u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - values", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateFormula",1322,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InterpretFormula",1683,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 3, 1, 4, 0, 
"U 'TMVA::Event' - 10 - - u 'vector<double,allocator<double> >::iterator' - 0 - begin "
"u 'vector<double,allocator<double> >::iterator' - 0 - end", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ClearAll",768,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintResults",1279,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"u 'TString' - 11 - - u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - - "
"d - 'Double_t' 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA1_738_0_24, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodFDA::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_738_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodFDA::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_738_0_26, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodFDA::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_738_0_27, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodFDA::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_738_0_31, 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__TMVA1_738_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodFDA::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_738_0_33, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodFDA::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_738_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodFDA::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_738_0_35, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodFDA::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodFDA", 938, G__G__TMVA1_738_0_36, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodMLP(void) {
   /* TMVA::MethodMLP */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodMLP));
   G__memfunc_setup("MethodMLP",842,G__G__TMVA1_744_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodMLP), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - jobName u 'TString' - 11 - methodTitle "
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 - theOption "
"U 'TDirectory' - 0 '0' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MethodMLP",842,G__G__TMVA1_744_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodMLP), -1, 0, 3, 1, 1, 0, 
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 - theWeightFile "
"U 'TDirectory' - 0 '0' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAnalysisType",1538,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EAnalysisType' - 0 - type h - 'UInt_t' 0 - numberClasses "
"h - 'UInt_t' 0 - numberTargets", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ComputeEstimator",1685,G__G__TMVA1_744_0_5, 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("EstimatorFunction",1790,(G__InterfaceMethod) NULL,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, 1);
   G__memfunc_setup("HasInverseHessian",1731,G__G__TMVA1_744_0_7, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClassSpecific",1690,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - nEpochs", (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, 1);
   G__memfunc_setup("InitializeLearningRates",2369,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", "although this is only needed by backprop", (void*) NULL, 0);
   G__memfunc_setup("CalculateEstimator",1862,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 0, 
"i 'TMVA::Types::ETreeType' - 0 'Types::kTraining' treeType i - 'Int_t' 0 '-1' iEpoch", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BFGSMinimize",1124,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - nEpochs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGammaDelta",1273,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - Gamma u 'TMatrixT<double>' 'TMatrixD' 1 - Delta "
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - Buffer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SteepestDir",1132,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TMatrixT<double>' 'TMatrixD' 1 - Dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHessian",1003,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 4, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - Hessian u 'TMatrixT<double>' 'TMatrixD' 1 - Gamma "
"u 'TMatrixT<double>' 'TMatrixD' 1 - Delta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDir",587,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - Hessian u 'TMatrixT<double>' 'TMatrixD' 1 - Dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DerivDir",793,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "u 'TMatrixT<double>' 'TMatrixD' 1 - Dir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LineSearch",990,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 4, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - Dir u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - Buffer "
"D - 'Double_t' 0 '0' dError", "zjh", (void*) NULL, 0);
   G__memfunc_setup("ComputeDEDw",1057,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SimulateEvent",1350,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TMVA::Event' - 10 - ev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDirWeights",1318,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - Origin u 'TMatrixT<double>' 'TMatrixD' 1 - Dir "
"d - 'Double_t' 0 - alpha", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetError",810,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMSEErr",814,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 0, 
"U 'TMVA::Event' - 10 - ev h - 'UInt_t' 0 '0' index", "zjh", (void*) NULL, 0);
   G__memfunc_setup("GetCEErr",721,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 0, 
"U 'TMVA::Event' - 10 - ev h - 'UInt_t' 0 '0' index", "zjh", (void*) NULL, 0);
   G__memfunc_setup("BackPropagationMinimize",2359,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - nEpochs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrainOneEpoch",1295,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Shuffle",717,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"I - 'Int_t' 0 - index i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DecaySynapseWeights",1956,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "g - 'Bool_t' 0 - lateEpoch", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrainOneEvent",1314,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "i - 'Int_t' 0 - ievt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDesiredOutput",1649,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "U 'TMVA::Event' - 10 - ev", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateNetwork",1357,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"d - 'Double_t' 0 - desired d - 'Double_t' 0 '1.0' eventWeight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateNetwork",1357,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - desired d - 'Double_t' 0 '1.0' eventWeight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculateNeuronDeltas",2146,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateSynapses",1465,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdjustSynapseWeights",2089,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrainOneEventFast",1712,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"i - 'Int_t' 0 - ievt F - 'Float_t' 1 - branchVar "
"i - 'Int_t' 1 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GeneticMinimize",1537,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetApproxInvHessian",1938,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - InvHessian g - - 0 'true' regulate", "rank-1 approximation, neglect 2nd derivatives. //zjh", (void*) NULL, 0);
   G__memfunc_setup("UpdateRegulators",1675,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", "zjh", (void*) NULL, 0);
   G__memfunc_setup("UpdatePriors",1250,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", "zjh", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA1_744_0_46, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodMLP::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_744_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodMLP::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_744_0_48, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodMLP::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_744_0_49, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodMLP::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_744_0_53, 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__TMVA1_744_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodMLP::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_744_0_55, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodMLP::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_744_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodMLP::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_744_0_57, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodMLP::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodMLP", 968, G__G__TMVA1_744_0_58, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodPDEFoam(void) {
   /* TMVA::MethodPDEFoam */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDEFoam));
   G__memfunc_setup("MethodPDEFoam",1213,G__G__TMVA1_791_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDEFoam), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - jobName u 'TString' - 11 - methodTitle "
"u 'TMVA::DataSetInfo' - 1 - dsi u 'TString' - 11 '\"PDEFoam\"' theOption "
"U 'TDirectory' - 0 '0' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MethodPDEFoam",1213,G__G__TMVA1_791_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDEFoam), -1, 0, 3, 1, 1, 0, 
"u 'TMVA::DataSetInfo' - 1 - dsi u 'TString' - 11 - theWeightFile "
"U 'TDirectory' - 0 'NULL' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAnalysisType",1538,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EAnalysisType' - 0 - type h - 'UInt_t' 0 - numberClasses "
"h - 'UInt_t' 0 - numberTargets", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("TrainMonoTargetRegression",2591,G__G__TMVA1_791_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", "Regression output: one value", (void*) NULL, 0);
   G__memfunc_setup("TrainMultiTargetRegression",2705,G__G__TMVA1_791_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", "Regression output: any number of values", (void*) NULL, 0);
   G__memfunc_setup("TrainSeparatedClassification",2883,G__G__TMVA1_791_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", "Classification: one foam for Sig, one for Bg", (void*) NULL, 0);
   G__memfunc_setup("TrainUnifiedClassification",2670,G__G__TMVA1_791_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", "Classification: one foam for Signal and Bg", (void*) NULL, 0);
   G__memfunc_setup("TrainMultiClassification",2485,G__G__TMVA1_791_0_9, 121, -1, -1, 0, 0, 1, 1, 0, "", "Classification: one foam for every class", (void*) NULL, 0);
   G__memfunc_setup("AddWeightsXMLTo",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromXML",1756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - wghtnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteFoamsToFile",1604,G__G__TMVA1_791_0_13, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadFoamsFromFile",1670,G__G__TMVA1_791_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadClonedFoamFromFile",2152,G__G__TMVA1_791_0_15, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLPDEFoam), -1, 0, 2, 1, 1, 0, 
"U 'TFile' - 0 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMulticlassValues",1969,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRegressionValues",1969,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Reset",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNCuts",781,G__G__TMVA1_791_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TMVA::PDEFoamCell' - 0 - cell u 'vector<unsigned int,allocator<unsigned int> >' 'vector<UInt_t>' 1 - nCuts", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetKernel",897,G__G__TMVA1_791_0_22, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDEFoamcLcLEKernel), G__defined_typename("TMVA::MethodPDEFoam::EKernel"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("KernelToUInt",1188,G__G__TMVA1_791_0_23, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "u 'TMVA::MethodPDEFoam::EKernel' 'TMVA::MethodPDEFoam::EKernel' 0 - ker", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UIntToKernel",1188,G__G__TMVA1_791_0_24, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodPDEFoamcLcLEKernel), G__defined_typename("TMVA::MethodPDEFoam::EKernel"), 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - iker", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TargetSelectionToUInt",2128,G__G__TMVA1_791_0_25, 104, -1, G__defined_typename("UInt_t"), 0, 1, 1, 1, 8, "i 'TMVA::ETargetSelection' - 0 - ts", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UIntToTargetSelection",2128,G__G__TMVA1_791_0_26, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLETargetSelection), -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - its", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeClassSpecific",1690,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CalculateMVAError",1660,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcXminXmax",1197,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetXminXmax",1126,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TMVA::PDEFoam' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitFoam",791,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLPDEFoam), -1, 0, 3, 1, 2, 0, 
"u 'TString' - 0 - - i 'TMVA::EFoamType' - 0 - - "
"h - 'UInt_t' 0 '0' cls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreatePDEFoamKernel",1809,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLPDEFoamKernelBase), -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteFoams",1097,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillVariableNamesToFoam",2279,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareCompatibilityOptions",2806,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintCoefficients",1759,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (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, 1);
   G__memfunc_setup("Class",502,G__G__TMVA1_791_0_41, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodPDEFoam::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_791_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodPDEFoam::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_791_0_43, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodPDEFoam::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_791_0_44, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodPDEFoam::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_791_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__TMVA1_791_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodPDEFoam::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_791_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodPDEFoam::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_791_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodPDEFoam::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_791_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodPDEFoam::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodPDEFoam", 1339, G__G__TMVA1_791_0_53, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodLD(void) {
   /* TMVA::MethodLD */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodLD));
   G__memfunc_setup("MethodLD",753,G__G__TMVA1_797_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodLD), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - jobName u 'TString' - 11 - methodTitle "
"u 'TMVA::DataSetInfo' - 1 - dsi u 'TString' - 11 '\"LD\"' theOption "
"U 'TDirectory' - 0 '0' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MethodLD",753,G__G__TMVA1_797_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodLD), -1, 0, 3, 1, 1, 0, 
"u 'TMVA::DataSetInfo' - 1 - dsi u 'TString' - 11 - theWeightFile "
"U 'TDirectory' - 0 '0' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAnalysisType",1538,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EAnalysisType' - 0 - type h - 'UInt_t' 0 - numberClasses "
"h - 'UInt_t' 0 - numberTargets", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRegressionValues",1969,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddWeightsXMLTo",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromStream",2135,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromXML",1756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - wghtnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClassSpecific",1690,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 8, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitMatrices",1228,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSum",597,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSumVal",888,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLDCoeff",915,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintCoefficients",1759,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA1_797_0_21, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodLD::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_797_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodLD::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_797_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodLD::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_797_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodLD::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_797_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__TMVA1_797_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodLD::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_797_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodLD::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_797_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodLD::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_797_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodLD::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodLD", 879, G__G__TMVA1_797_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMethodCategory(void) {
   /* TMVA::MethodCategory */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCategory));
   G__memfunc_setup("MethodCategory",1439,G__G__TMVA1_802_0_1, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCategory), -1, 0, 5, 1, 1, 0, 
"u 'TString' - 11 - jobName u 'TString' - 11 - methodTitle "
"u 'TMVA::DataSetInfo' - 1 - theData u 'TString' - 11 '\"\"' theOption "
"U 'TDirectory' - 0 'NULL' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MethodCategory",1439,G__G__TMVA1_802_0_2, 105, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLMethodCategory), -1, 0, 3, 1, 1, 0, 
"u 'TMVA::DataSetInfo' - 1 - dsi u 'TString' - 11 - theWeightFile "
"U 'TDirectory' - 0 'NULL' theTargetDir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAnalysisType",1538,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"i 'TMVA::Types::EAnalysisType' - 0 - type h - 'UInt_t' 0 - numberClasses "
"h - 'UInt_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Train",510,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateRanking",1310,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AddMethod",874,G__G__TMVA1_802_0_6, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLIMethod), -1, 0, 5, 1, 1, 0, 
"u 'TCut' - 11 - - u 'TString' - 11 - theVariables "
"i 'TMVA::Types::EMVA' - 0 - theMethod u 'TString' - 11 - theTitle "
"u 'TString' - 11 - theOptions", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddWeightsXMLTo",1432,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadWeightsFromXML",1756,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - wghtnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMvaValue",1089,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"D - 'Double_t' 0 '0' err D - 'Double_t' 0 '0' errUpper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetRegressionValues",1969,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 1, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeClass",884,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'TString' - 11 'TString(\"\")' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Init",404,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProcessOptions",1483,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PassesCut",923,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 4, 0, 
"U 'TMVA::Event' - 10 - ev h - 'UInt_t' 0 - methodIdx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateCategoryDSI",1650,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA1LN_TMVAcLcLDataSetInfo), -1, 1, 3, 1, 2, 0, 
"u 'TCut' - 11 - - u 'TString' - 11 - - "
"u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitCircularTree",1625,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TMVA::DataSetInfo' - 11 - dsi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA1_802_0_19, 85, G__get_linked_tagnum(&G__G__TMVA1LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MethodCategory::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA1_802_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodCategory::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA1_802_0_21, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MethodCategory::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA1_802_0_22, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MethodCategory::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA1LN_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__TMVA1_802_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__TMVA1_802_0_27, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodCategory::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA1_802_0_28, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodCategory::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA1_802_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MethodCategory::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA1_802_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MethodCategory::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MethodCategory", 1565, G__G__TMVA1_802_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncG__TMVA1() {
}

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();

}

static void G__cpp_setup_global1() {
}

static void G__cpp_setup_global2() {
}

static void G__cpp_setup_global3() {
}

static void G__cpp_setup_global4() {
}

static void G__cpp_setup_global5() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__TMVA1() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
  G__cpp_setup_global3();
  G__cpp_setup_global4();
  G__cpp_setup_global5();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {
}

static void G__cpp_setup_func5() {
}

static void G__cpp_setup_func6() {
}

static void G__cpp_setup_func7() {
}

static void G__cpp_setup_func8() {
}

static void G__cpp_setup_func9() {
}

static void G__cpp_setup_func10() {
}

static void G__cpp_setup_func11() {
}

static void G__cpp_setup_func12() {
}

static void G__cpp_setup_func13() {
}

static void G__cpp_setup_func14() {
}

static void G__cpp_setup_func15() {
}

static void G__cpp_setup_func16() {
}

static void G__cpp_setup_func17() {
}

static void G__cpp_setup_func18() {
}

static void G__cpp_setup_func19() {
}

static void G__cpp_setup_func20() {
}

static void G__cpp_setup_func21() {
}

static void G__cpp_setup_func22() {
}

static void G__cpp_setup_func23() {
}

static void G__cpp_setup_func24() {
}

static void G__cpp_setup_func25() {
}

static void G__cpp_setup_func26() {
}

static void G__cpp_setup_func27() {
}

static void G__cpp_setup_func28() {
}

static void G__cpp_setup_func29() {
}

static void G__cpp_setup_func30() {
}

static void G__cpp_setup_func31() {
}

static void G__cpp_setup_func32() {
}

static void G__cpp_setup_func33() {
}

static void G__cpp_setup_func34() {
}

static void G__cpp_setup_func35() {
}

static void G__cpp_setup_func36() {
}

static void G__cpp_setup_func37() {
}

static void G__cpp_setup_func38() {
}

static void G__cpp_setup_func39() {
}

static void G__cpp_setup_func40() {
}

static void G__cpp_setup_func41() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__TMVA1() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
  G__cpp_setup_func6();
  G__cpp_setup_func7();
  G__cpp_setup_func8();
  G__cpp_setup_func9();
  G__cpp_setup_func10();
  G__cpp_setup_func11();
  G__cpp_setup_func12();
  G__cpp_setup_func13();
  G__cpp_setup_func14();
  G__cpp_setup_func15();
  G__cpp_setup_func16();
  G__cpp_setup_func17();
  G__cpp_setup_func18();
  G__cpp_setup_func19();
  G__cpp_setup_func20();
  G__cpp_setup_func21();
  G__cpp_setup_func22();
  G__cpp_setup_func23();
  G__cpp_setup_func24();
  G__cpp_setup_func25();
  G__cpp_setup_func26();
  G__cpp_setup_func27();
  G__cpp_setup_func28();
  G__cpp_setup_func29();
  G__cpp_setup_func30();
  G__cpp_setup_func31();
  G__cpp_setup_func32();
  G__cpp_setup_func33();
  G__cpp_setup_func34();
  G__cpp_setup_func35();
  G__cpp_setup_func36();
  G__cpp_setup_func37();
  G__cpp_setup_func38();
  G__cpp_setup_func39();
  G__cpp_setup_func40();
  G__cpp_setup_func41();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__TMVA1LN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TDirectory = { "TDirectory" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_basic_istreamlEcharcOchar_traitslEchargRsPgR = { "basic_istream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TList = { "TList" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TObjArray = { "TObjArray" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVA = { "TMVA" , 110 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMsgLogger = { "TMVA::MsgLogger" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLEMsgType = { "TMVA::EMsgType" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLTypes = { "TMVA::Types" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLTypescLcLEMVA = { "TMVA::Types::EMVA" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLTypescLcLEAnalysisType = { "TMVA::Types::EAnalysisType" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLTypescLcLESBType = { "TMVA::Types::ESBType" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLTypescLcLETreeType = { "TMVA::Types::ETreeType" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLTypescLcLEBoostStage = { "TMVA::Types::EBoostStage" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR = { "map<TString,TMVA::Types::EMVA,less<TString>,allocator<pair<const TString,TMVA::Types::EMVA> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR = { "map<TMVA::EMsgType,string,less<TMVA::EMsgType>,allocator<pair<const TMVA::EMsgType,string> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLConfigurable = { "TMVA::Configurable" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLOptionBase = { "TMVA::OptionBase" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLOptionlEboolgR = { "TMVA::Option<bool>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEboolcOallocatorlEboolgRsPgR = { "vector<bool,allocator<bool> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<bool,allocator<bool> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLOptionlEboolmUgR = { "TMVA::Option<bool*>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLOptionlEfloatgR = { "TMVA::Option<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR = { "vector<float,allocator<float> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<float,allocator<float> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TCut = { "TCut" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLEvent = { "TMVA::Event" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR = { "vector<float*,allocator<float*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<float*,allocator<float*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TTree = { "TTree" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TFile = { "TFile" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR = { "map<string,TObjArray*,less<string>,allocator<pair<const string,TObjArray*> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TH1 = { "TH1" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TRandom = { "TRandom" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TRandom3 = { "TRandom3" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLDataSetInfo = { "TMVA::DataSetInfo" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLDataSet = { "TMVA::DataSet" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR = { "vector<TMVA::Event*,allocator<TMVA::Event*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::Event*,allocator<TMVA::Event*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR = { "vector<vector<TMVA::Event*,allocator<TMVA::Event*> >*,allocator<vector<TMVA::Event*,allocator<TMVA::Event*> >*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<TMVA::Event*,allocator<TMVA::Event*> >*,allocator<vector<TMVA::Event*,allocator<TMVA::Event*> >*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_maplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgR = { "map<TString,TMVA::Results*,less<TString>,allocator<pair<const TString,TMVA::Results*> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR = { "vector<map<TString,TMVA::Results*,less<TString>,allocator<pair<const TString,TMVA::Results*> > >,allocator<map<TString,TMVA::Results*,less<TString>,allocator<pair<const TString,TMVA::Results*> > > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<map<TString,TMVA::Results*,less<TString>,allocator<pair<const TString,TMVA::Results*> > >,allocator<map<TString,TMVA::Results*,less<TString>,allocator<pair<const TString,TMVA::Results*> > > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEcharcOallocatorlEchargRsPgR = { "vector<char,allocator<char> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR = { "reverse_iterator<vector<char,allocator<char> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_pairlEfloatcOlongsPlonggR = { "pair<float,long long>" , 115 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR = { "vector<pair<float,long long>*,allocator<pair<float,long long>*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<float,long long>*,allocator<pair<float,long long>*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR = { "vector<vector<pair<float,long long>*,allocator<pair<float,long long>*> >,allocator<vector<pair<float,long long>*,allocator<pair<float,long long>*> > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<pair<float,long long>*,allocator<pair<float,long long>*> >,allocator<vector<pair<float,long long>*,allocator<pair<float,long long>*> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR = { "vector<long long,allocator<long long> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcLcLiteratorgR = { "reverse_iterator<vector<long long,allocator<long long> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR = { "vector<vector<long long,allocator<long long> >,allocator<vector<long long,allocator<long long> > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<long long,allocator<long long> >,allocator<vector<long long,allocator<long long> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLIMethod = { "TMVA::IMethod" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodBase = { "TMVA::MethodBase" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLDataInputHandler = { "TMVA::DataInputHandler" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLDataSetManager = { "TMVA::DataSetManager" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLFactory = { "TMVA::Factory" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETMVAcLcLIMethodmUcOallocatorlETMVAcLcLIMethodmUgRsPgR = { "vector<TMVA::IMethod*,allocator<TMVA::IMethod*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLIMethodmUcOallocatorlETMVAcLcLIMethodmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::IMethod*,allocator<TMVA::IMethod*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgRcLcLiterator = { "vector<double,allocator<double> >::iterator" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<double,allocator<double> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETMVAcLcLVariableTransformBasemUcOallocatorlETMVAcLcLVariableTransformBasemUgRsPgR = { "vector<TMVA::VariableTransformBase*,allocator<TMVA::VariableTransformBase*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLVariableTransformBasemUcOallocatorlETMVAcLcLVariableTransformBasemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::VariableTransformBase*,allocator<TMVA::VariableTransformBase*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLFactorycLcLDataAssignType = { "TMVA::Factory::DataAssignType" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETTreemUcOallocatorlETTreemUgRsPgR = { "vector<TTree*,allocator<TTree*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETTreemUcOallocatorlETTreemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TTree*,allocator<TTree*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLRanking = { "TMVA::Ranking" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodBoost = { "TMVA::MethodBoost" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTlEdoublegR = { "TMatrixT<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR = { "vector<TMVA::VariableInfo,allocator<TMVA::VariableInfo> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::VariableInfo,allocator<TMVA::VariableInfo> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR = { "vector<TMVA::ClassInfo*,allocator<TMVA::ClassInfo*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::ClassInfo*,allocator<TMVA::ClassInfo*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLTransformationHandler = { "TMVA::TransformationHandler" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgR = { "vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR = { "vector<vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> >,allocator<vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> >,allocator<vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR = { "vector<TMVA::Ranking*,allocator<TMVA::Ranking*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::Ranking*,allocator<TMVA::Ranking*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLIFitterTarget = { "TMVA::IFitterTarget" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TH1D = { "TH1D" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TH1F = { "TH1F" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_maplETStringcOTMVAcLcLIntervalmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIntervalmUgRsPgRsPgR = { "map<TString,TMVA::Interval*,less<TString>,allocator<pair<const TString,TMVA::Interval*> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR = { "map<TString,double,less<TString>,allocator<pair<const TString,double> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR = { "map<vector<double,allocator<double> >,double,less<vector<double,allocator<double> > >,allocator<pair<const vector<double,allocator<double> >,double> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TSpline = { "TSpline" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLPDF = { "TMVA::PDF" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLTSpline1 = { "TMVA::TSpline1" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodCuts = { "TMVA::MethodCuts" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodBasecLcLEWeightFileType = { "TMVA::MethodBase::EWeightFileType" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR = { "vector<vector<float,allocator<float> >,allocator<vector<float,allocator<float> > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<float,allocator<float> >,allocator<vector<float,allocator<float> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodBasecLcLECutOrientation = { "TMVA::MethodBase::ECutOrientation" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR = { "vector<const vector<TMVA::Event*,allocator<TMVA::Event*> >*,allocator<const vector<TMVA::Event*,allocator<TMVA::Event*> >*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const vector<TMVA::Event*,allocator<TMVA::Event*> >*,allocator<const vector<TMVA::Event*,allocator<TMVA::Event*> >*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodCompositeBase = { "TMVA::MethodCompositeBase" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TElementActionTlEfloatgR = { "TElementActionT<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TElementPosActionTlEfloatgR = { "TElementPosActionT<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TElementActionTlEdoublegR = { "TElementActionT<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TElementPosActionTlEdoublegR = { "TElementPosActionT<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTSymlEdoublegR = { "TMatrixTSym<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTSparselEdoublegR = { "TMatrixTSparse<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTRow_constlEdoublegR = { "TMatrixTRow_const<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTRowlEdoublegR = { "TMatrixTRow<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTDiag_constlEdoublegR = { "TMatrixTDiag_const<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTColumn_constlEdoublegR = { "TMatrixTColumn_const<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTlEfloatgR = { "TMatrixT<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTRow_constlEfloatgR = { "TMatrixTRow_const<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTRowlEfloatgR = { "TMatrixTRow<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTDiag_constlEfloatgR = { "TMatrixTDiag_const<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTColumn_constlEfloatgR = { "TMatrixTColumn_const<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTFlat_constlEfloatgR = { "TMatrixTFlat_const<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTSub_constlEfloatgR = { "TMatrixTSub_const<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTSparseRow_constlEfloatgR = { "TMatrixTSparseRow_const<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTSparseDiag_constlEfloatgR = { "TMatrixTSparseDiag_const<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTColumnlEfloatgR = { "TMatrixTColumn<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTDiaglEfloatgR = { "TMatrixTDiag<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTFlatlEfloatgR = { "TMatrixTFlat<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTSublEfloatgR = { "TMatrixTSub<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTSparseRowlEfloatgR = { "TMatrixTSparseRow<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTSparseDiaglEfloatgR = { "TMatrixTSparseDiag<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLTActivation = { "TMVA::TActivation" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TFormula = { "TFormula" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLTNeuron = { "TMVA::TNeuron" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLTNeuronInput = { "TMVA::TNeuronInput" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodANNBase = { "TMVA::MethodANNBase" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodANNBasecLcLEEstimator = { "TMVA::MethodANNBase::EEstimator" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR = { "vector<TH1*,allocator<TH1*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETH1mUcOallocatorlETH1mUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TH1*,allocator<TH1*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETMVAcLcLTNeuronmUcOallocatorlETMVAcLcLTNeuronmUgRsPgR = { "vector<TMVA::TNeuron*,allocator<TMVA::TNeuron*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLTNeuronmUcOallocatorlETMVAcLcLTNeuronmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::TNeuron*,allocator<TMVA::TNeuron*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMultiLayerPerceptron = { "TMultiLayerPerceptron" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodTMlpANN = { "TMVA::MethodTMlpANN" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTSparseRow_constlEdoublegR = { "TMatrixTSparseRow_const<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTSparseRowlEdoublegR = { "TMatrixTSparseRow<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTSparseDiag_constlEdoublegR = { "TMatrixTSparseDiag_const<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTFlat_constlEdoublegR = { "TMatrixTFlat_const<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTSub_constlEdoublegR = { "TMatrixTSub_const<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTColumnlEdoublegR = { "TMatrixTColumn<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTDiaglEdoublegR = { "TMatrixTDiag<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTFlatlEdoublegR = { "TMatrixTFlat<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTSublEdoublegR = { "TMatrixTSub<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMatrixTSparseDiaglEdoublegR = { "TMatrixTSparseDiag<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLNode = { "TMVA::Node" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLBinaryTree = { "TMVA::BinaryTree" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLDecisionTreeNode = { "TMVA::DecisionTreeNode" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLVolume = { "TMVA::Volume" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLBinarySearchTreeNode = { "TMVA::BinarySearchTreeNode" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLBinarySearchTree = { "TMVA::BinarySearchTree" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR = { "vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR = { "pair<double,const TMVA::Event*>" , 115 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR = { "vector<pair<double,const TMVA::Event*>,allocator<pair<double,const TMVA::Event*> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<double,const TMVA::Event*>,allocator<pair<double,const TMVA::Event*> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLSeparationBase = { "TMVA::SeparationBase" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLDecisionTree = { "TMVA::DecisionTree" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR = { "vector<const TMVA::Event*,allocator<const TMVA::Event*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const TMVA::Event*,allocator<const TMVA::Event*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLDecisionTreecLcLEPruneMethod = { "TMVA::DecisionTree::EPruneMethod" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgR = { "vector<const TMVA::Node*,allocator<const TMVA::Node*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const TMVA::Node*,allocator<const TMVA::Node*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLRuleEnsemble = { "TMVA::RuleEnsemble" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLRule = { "TMVA::Rule" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLRuleFit = { "TMVA::RuleFit" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodRuleFit = { "TMVA::MethodRuleFit" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR = { "vector<const TMVA::DecisionTree*,allocator<const TMVA::DecisionTree*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const TMVA::DecisionTree*,allocator<const TMVA::DecisionTree*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgR = { "vector<TMVA::Rule*,allocator<TMVA::Rule*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::Rule*,allocator<TMVA::Rule*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR = { "vector<TH1F*,allocator<TH1F*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TH1F*,allocator<TH1F*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR = { "vector<vector<unsigned int,allocator<unsigned int> >,allocator<vector<unsigned int,allocator<unsigned int> > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<unsigned int,allocator<unsigned int> >,allocator<vector<unsigned int,allocator<unsigned int> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR = { "vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETH2FmUcOallocatorlETH2FmUgRsPgR = { "vector<TH2F*,allocator<TH2F*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETH2FmUcOallocatorlETH2FmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TH2F*,allocator<TH2F*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETMVAcLcLDecisionTreemUcOallocatorlETMVAcLcLDecisionTreemUgRsPgR = { "vector<TMVA::DecisionTree*,allocator<TMVA::DecisionTree*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLDecisionTreemUcOallocatorlETMVAcLcLDecisionTreemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::DecisionTree*,allocator<TMVA::DecisionTree*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEFitMethodType = { "TMVA::MethodCuts::EFitMethodType" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEEffMethod = { "TMVA::MethodCuts::EEffMethod" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEFitParameters = { "TMVA::MethodCuts::EFitParameters" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETMVAcLcLMethodCutscLcLEFitParameterscOallocatorlETMVAcLcLMethodCutscLcLEFitParametersgRsPgR = { "vector<TMVA::MethodCuts::EFitParameters,allocator<TMVA::MethodCuts::EFitParameters> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLMethodCutscLcLEFitParameterscOallocatorlETMVAcLcLMethodCutscLcLEFitParametersgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::MethodCuts::EFitParameters,allocator<TMVA::MethodCuts::EFitParameters> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR = { "vector<TMVA::Interval*,allocator<TMVA::Interval*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::Interval*,allocator<TMVA::Interval*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR = { "vector<TMVA::PDF*,allocator<TMVA::PDF*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::PDF*,allocator<TMVA::PDF*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodFisher = { "TMVA::MethodFisher" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodFishercLcLEFisherMethod = { "TMVA::MethodFisher::EFisherMethod" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLkNN = { "TMVA::kNN" , 110 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLkNNcLcLEvent = { "TMVA::kNN::Event" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETMVAcLcLkNNcLcLEventcOallocatorlETMVAcLcLkNNcLcLEventgRsPgR = { "vector<TMVA::kNN::Event,allocator<TMVA::kNN::Event> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLkNNcLcLEventcOallocatorlETMVAcLcLkNNcLcLEventgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::kNN::Event,allocator<TMVA::kNN::Event> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLkNNcLcLNodelETMVAcLcLkNNcLcLEventgR = { "TMVA::kNN::Node<TMVA::kNN::Event>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_pairlEconstsPTMVAcLcLkNNcLcLNodelETMVAcLcLkNNcLcLEventgRmUcOfloatgR = { "pair<const TMVA::kNN::Node<TMVA::kNN::Event>*,float>" , 115 , -1 };
G__linked_taginfo G__G__TMVA1LN_listlEpairlEconstsPTMVAcLcLkNNcLcLNodelETMVAcLcLkNNcLcLEventgRmUcOfloatgRcOallocatorlEpairlEconstsPTMVAcLcLkNNcLcLNodelETMVAcLcLkNNcLcLEventgRmUcOfloatgRsPgRsPgR = { "list<pair<const TMVA::kNN::Node<TMVA::kNN::Event>*,float>,allocator<pair<const TMVA::kNN::Node<TMVA::kNN::Event>*,float> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLkNNcLcLModulekNN = { "TMVA::kNN::ModulekNN" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_maplEintcOvectorlEdoublecOallocatorlEdoublegRsPgRcOlesslEintgRcOallocatorlEpairlEconstsPintcOvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRsPgR = { "map<int,vector<double,allocator<double> >,less<int>,allocator<pair<const int,vector<double,allocator<double> > > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR = { "map<int,double,less<int>,allocator<pair<const int,double> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_maplEshortcOunsignedsPintcOlesslEshortgRcOallocatorlEpairlEconstsPshortcOunsignedsPintgRsPgRsPgR = { "map<short,unsigned int,less<short>,allocator<pair<const short,unsigned int> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLLDA = { "TMVA::LDA" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_maplEintcOvectorlEfloatcOallocatorlEfloatgRsPgRcOlesslEintgRcOallocatorlEpairlEconstsPintcOvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRsPgR = { "map<int,vector<float,allocator<float> >,less<int>,allocator<pair<const int,vector<float,allocator<float> > > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_maplEintcOfloatcOlesslEintgRcOallocatorlEpairlEconstsPintcOfloatgRsPgRsPgR = { "map<int,float,less<int>,allocator<pair<const int,float> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodKNN = { "TMVA::MethodKNN" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_Utils = { "TMVA::MethodCFMlpANN_Utils" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcL693 = { "TMVA::MethodCFMlpANN_Utils::" , 115 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcL694 = { "TMVA::MethodCFMlpANN_Utils::" , 115 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcLVARn2 = { "TMVA::MethodCFMlpANN_Utils::VARn2" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcL696 = { "TMVA::MethodCFMlpANN_Utils::" , 115 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcL697 = { "TMVA::MethodCFMlpANN_Utils::" , 115 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcL698 = { "TMVA::MethodCFMlpANN_Utils::" , 115 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN = { "TMVA::MethodCFMlpANN" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodLikelihood = { "TMVA::MethodLikelihood" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodHMatrix = { "TMVA::MethodHMatrix" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodPDERS = { "TMVA::MethodPDERS" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEVolumeRangeMode = { "TMVA::MethodPDERS::EVolumeRangeMode" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEKernelEstimator = { "TMVA::MethodPDERS::EKernelEstimator" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodBDT = { "TMVA::MethodBDT" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_pairlEdoublecOdoublegR = { "pair<double,double>" , 115 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR = { "vector<pair<double,double>,allocator<pair<double,double> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<double,double>,allocator<pair<double,double> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_maplEconstsPTMVAcLcLEventmUcOpairlEdoublecOdoublegRcOlesslEconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEconstsPTMVAcLcLEventmUsPconstcOpairlEdoublecOdoublegRsPgRsPgRsPgR = { "map<const TMVA::Event*,pair<double,double>,less<const TMVA::Event*>,allocator<pair<const TMVA::Event* const,pair<double,double> > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_maplEconstsPTMVAcLcLEventmUcOvectorlEdoublecOallocatorlEdoublegRsPgRcOlesslEconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEconstsPTMVAcLcLEventmUsPconstcOvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRsPgR = { "map<const TMVA::Event*,vector<double,allocator<double> >,less<const TMVA::Event*>,allocator<pair<const TMVA::Event* const,vector<double,allocator<double> > > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodDT = { "TMVA::MethodDT" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLSVWorkingSet = { "TMVA::SVWorkingSet" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLSVKernelFunction = { "TMVA::SVKernelFunction" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodSVM = { "TMVA::MethodSVM" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETMVAcLcLSVEventmUcOallocatorlETMVAcLcLSVEventmUgRsPgR = { "vector<TMVA::SVEvent*,allocator<TMVA::SVEvent*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLSVEventmUcOallocatorlETMVAcLcLSVEventmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::SVEvent*,allocator<TMVA::SVEvent*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodBayesClassifier = { "TMVA::MethodBayesClassifier" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLFitterBase = { "TMVA::FitterBase" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodFDA = { "TMVA::MethodFDA" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLConvergenceTest = { "TMVA::ConvergenceTest" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_dequelEshortcOallocatorlEshortgRsPgR = { "deque<short,allocator<short> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodMLP = { "TMVA::MethodMLP" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodMLPcLcLETrainingMethod = { "TMVA::MethodMLP::ETrainingMethod" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodMLPcLcLEBPTrainingMode = { "TMVA::MethodMLP::EBPTrainingMode" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_pairlEfloatcOfloatgR = { "pair<float,float>" , 115 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR = { "vector<pair<float,float>,allocator<pair<float,float> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<float,float>,allocator<pair<float,float> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLPDEFoamCell = { "TMVA::PDEFoamCell" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLPDEFoamKernelBase = { "TMVA::PDEFoamKernelBase" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLPDEFoam = { "TMVA::PDEFoam" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLEDTSeparation = { "TMVA::EDTSeparation" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLEFoamType = { "TMVA::EFoamType" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLECellValue = { "TMVA::ECellValue" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR = { "vector<TMVA::PDEFoamCell*,allocator<TMVA::PDEFoamCell*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::PDEFoamCell*,allocator<TMVA::PDEFoamCell*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLETargetSelection = { "TMVA::ETargetSelection" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETH1DmUcOallocatorlETH1DmUgRsPgR = { "vector<TH1D*,allocator<TH1D*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETH1DmUcOallocatorlETH1DmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TH1D*,allocator<TH1D*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodPDEFoam = { "TMVA::MethodPDEFoam" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodPDEFoamcLcLEKernel = { "TMVA::MethodPDEFoam::EKernel" , 101 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETMVAcLcLPDEFoammUcOallocatorlETMVAcLcLPDEFoammUgRsPgR = { "vector<TMVA::PDEFoam*,allocator<TMVA::PDEFoam*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLPDEFoammUcOallocatorlETMVAcLcLPDEFoammUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::PDEFoam*,allocator<TMVA::PDEFoam*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodLD = { "TMVA::MethodLD" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgR = { "vector<vector<double,allocator<double> >*,allocator<vector<double,allocator<double> >*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<double,allocator<double> >*,allocator<vector<double,allocator<double> >*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_TMVAcLcLMethodCategory = { "TMVA::MethodCategory" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETCutcOallocatorlETCutgRsPgR = { "vector<TCut,allocator<TCut> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETCutcOallocatorlETCutgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TCut,allocator<TCut> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_vectorlETTreeFormulamUcOallocatorlETTreeFormulamUgRsPgR = { "vector<TTreeFormula*,allocator<TTreeFormula*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA1LN_reverse_iteratorlEvectorlETTreeFormulamUcOallocatorlETTreeFormulamUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TTreeFormula*,allocator<TTreeFormula*> >::iterator>" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__TMVA1() {
  G__G__TMVA1LN_TClass.tagnum = -1 ;
  G__G__TMVA1LN_TBuffer.tagnum = -1 ;
  G__G__TMVA1LN_TDirectory.tagnum = -1 ;
  G__G__TMVA1LN_TMemberInspector.tagnum = -1 ;
  G__G__TMVA1LN_TObject.tagnum = -1 ;
  G__G__TMVA1LN_TString.tagnum = -1 ;
  G__G__TMVA1LN_basic_istreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TList.tagnum = -1 ;
  G__G__TMVA1LN_TObjArray.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVA.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMsgLogger.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLEMsgType.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLTypes.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLTypescLcLEMVA.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLTypescLcLEAnalysisType.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLTypescLcLESBType.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLTypescLcLETreeType.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLTypescLcLEBoostStage.tagnum = -1 ;
  G__G__TMVA1LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLConfigurable.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLOptionBase.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLOptionlEboolgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEboolcOallocatorlEboolgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLOptionlEboolmUgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLOptionlEfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TCut.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLEvent.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TTree.tagnum = -1 ;
  G__G__TMVA1LN_TFile.tagnum = -1 ;
  G__G__TMVA1LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_TH1.tagnum = -1 ;
  G__G__TMVA1LN_TRandom.tagnum = -1 ;
  G__G__TMVA1LN_TRandom3.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLDataSetInfo.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLDataSet.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_maplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEcharcOallocatorlEchargRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_pairlEfloatcOlongsPlonggR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLIMethod.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodBase.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLDataInputHandler.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLDataSetManager.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLFactory.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETMVAcLcLIMethodmUcOallocatorlETMVAcLcLIMethodmUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLIMethodmUcOallocatorlETMVAcLcLIMethodmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgRcLcLiterator.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETMVAcLcLVariableTransformBasemUcOallocatorlETMVAcLcLVariableTransformBasemUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLVariableTransformBasemUcOallocatorlETMVAcLcLVariableTransformBasemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLFactorycLcLDataAssignType.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETTreemUcOallocatorlETTreemUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETTreemUcOallocatorlETTreemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLRanking.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodBoost.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTlEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLTransformationHandler.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLIFitterTarget.tagnum = -1 ;
  G__G__TMVA1LN_TVectorTlEfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_TVectorTlEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_TH1D.tagnum = -1 ;
  G__G__TMVA1LN_TH1F.tagnum = -1 ;
  G__G__TMVA1LN_maplETStringcOTMVAcLcLIntervalmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIntervalmUgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_TSpline.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLPDF.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLTSpline1.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodCuts.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodBasecLcLEWeightFileType.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodBasecLcLECutOrientation.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodCompositeBase.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTBaselEfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTBaselEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_TElementActionTlEfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_TElementPosActionTlEfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_TElementActionTlEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_TElementPosActionTlEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTSymlEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTSparselEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTRow_constlEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTRowlEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTDiag_constlEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTColumn_constlEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTlEfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTRow_constlEfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTRowlEfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTDiag_constlEfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTColumn_constlEfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTFlat_constlEfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTSub_constlEfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTSparseRow_constlEfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTSparseDiag_constlEfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTColumnlEfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTDiaglEfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTFlatlEfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTSublEfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTSparseRowlEfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTSparseDiaglEfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLTActivation.tagnum = -1 ;
  G__G__TMVA1LN_TFormula.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLTNeuron.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLTNeuronInput.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodANNBase.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodANNBasecLcLEEstimator.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETH1mUcOallocatorlETH1mUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETMVAcLcLTNeuronmUcOallocatorlETMVAcLcLTNeuronmUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLTNeuronmUcOallocatorlETMVAcLcLTNeuronmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMultiLayerPerceptron.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodTMlpANN.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTSparseRow_constlEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTSparseRowlEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTSparseDiag_constlEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTFlat_constlEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTSub_constlEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTColumnlEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTDiaglEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTFlatlEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTSublEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_TMatrixTSparseDiaglEdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLNode.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLBinaryTree.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLDecisionTreeNode.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLVolume.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLBinarySearchTreeNode.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLBinarySearchTree.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLSeparationBase.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLDecisionTree.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLDecisionTreecLcLEPruneMethod.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLRuleEnsemble.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLRule.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLRuleFit.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodRuleFit.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETH2FmUcOallocatorlETH2FmUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETH2FmUcOallocatorlETH2FmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETMVAcLcLDecisionTreemUcOallocatorlETMVAcLcLDecisionTreemUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLDecisionTreemUcOallocatorlETMVAcLcLDecisionTreemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEFitMethodType.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEEffMethod.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEFitParameters.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETMVAcLcLMethodCutscLcLEFitParameterscOallocatorlETMVAcLcLMethodCutscLcLEFitParametersgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLMethodCutscLcLEFitParameterscOallocatorlETMVAcLcLMethodCutscLcLEFitParametersgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodFisher.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodFishercLcLEFisherMethod.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLkNN.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLkNNcLcLEvent.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETMVAcLcLkNNcLcLEventcOallocatorlETMVAcLcLkNNcLcLEventgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLkNNcLcLEventcOallocatorlETMVAcLcLkNNcLcLEventgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLkNNcLcLNodelETMVAcLcLkNNcLcLEventgR.tagnum = -1 ;
  G__G__TMVA1LN_pairlEconstsPTMVAcLcLkNNcLcLNodelETMVAcLcLkNNcLcLEventgRmUcOfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_listlEpairlEconstsPTMVAcLcLkNNcLcLNodelETMVAcLcLkNNcLcLEventgRmUcOfloatgRcOallocatorlEpairlEconstsPTMVAcLcLkNNcLcLNodelETMVAcLcLkNNcLcLEventgRmUcOfloatgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLkNNcLcLModulekNN.tagnum = -1 ;
  G__G__TMVA1LN_maplEintcOvectorlEdoublecOallocatorlEdoublegRsPgRcOlesslEintgRcOallocatorlEpairlEconstsPintcOvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_maplEshortcOunsignedsPintcOlesslEshortgRcOallocatorlEpairlEconstsPshortcOunsignedsPintgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLLDA.tagnum = -1 ;
  G__G__TMVA1LN_maplEintcOvectorlEfloatcOallocatorlEfloatgRsPgRcOlesslEintgRcOallocatorlEpairlEconstsPintcOvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_maplEintcOfloatcOlesslEintgRcOallocatorlEpairlEconstsPintcOfloatgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodKNN.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_Utils.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcL693.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcL694.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcLVARn2.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcL696.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcL697.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcL698.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodLikelihood.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodHMatrix.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodPDERS.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEVolumeRangeMode.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEKernelEstimator.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodBDT.tagnum = -1 ;
  G__G__TMVA1LN_pairlEdoublecOdoublegR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_maplEconstsPTMVAcLcLEventmUcOpairlEdoublecOdoublegRcOlesslEconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEconstsPTMVAcLcLEventmUsPconstcOpairlEdoublecOdoublegRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_maplEconstsPTMVAcLcLEventmUcOvectorlEdoublecOallocatorlEdoublegRsPgRcOlesslEconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEconstsPTMVAcLcLEventmUsPconstcOvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodDT.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLSVWorkingSet.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLSVKernelFunction.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodSVM.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETMVAcLcLSVEventmUcOallocatorlETMVAcLcLSVEventmUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLSVEventmUcOallocatorlETMVAcLcLSVEventmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodBayesClassifier.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLFitterBase.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodFDA.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLConvergenceTest.tagnum = -1 ;
  G__G__TMVA1LN_dequelEshortcOallocatorlEshortgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodMLP.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodMLPcLcLETrainingMethod.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodMLPcLcLEBPTrainingMode.tagnum = -1 ;
  G__G__TMVA1LN_pairlEfloatcOfloatgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLPDEFoamCell.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLPDEFoamKernelBase.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLPDEFoam.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLEDTSeparation.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLEFoamType.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLECellValue.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLETargetSelection.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETH1DmUcOallocatorlETH1DmUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETH1DmUcOallocatorlETH1DmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodPDEFoam.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodPDEFoamcLcLEKernel.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETMVAcLcLPDEFoammUcOallocatorlETMVAcLcLPDEFoammUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLPDEFoammUcOallocatorlETMVAcLcLPDEFoammUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodLD.tagnum = -1 ;
  G__G__TMVA1LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_TMVAcLcLMethodCategory.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETCutcOallocatorlETCutgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETCutcOallocatorlETCutgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA1LN_vectorlETTreeFormulamUcOallocatorlETTreeFormulamUgRsPgR.tagnum = -1 ;
  G__G__TMVA1LN_reverse_iteratorlEvectorlETTreeFormulamUcOallocatorlETTreeFormulamUgRsPgRcLcLiteratorgR.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__TMVA1() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TClass);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TDirectory);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TObject);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TString);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_basic_istreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TList);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TObjArray);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVA),0,-1,0,(char*)NULL,G__setup_memvarTMVA,G__setup_memfuncTMVA);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMsgLogger);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLEMsgType);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLTypes);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLTypescLcLEMVA);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLTypescLcLEAnalysisType);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLTypescLcLESBType);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLTypescLcLETreeType);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLTypescLcLEBoostStage);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLConfigurable),sizeof(TMVA::Configurable),-1,292096,"Virtual base class for all TMVA method",G__setup_memvarTMVAcLcLConfigurable,G__setup_memfuncTMVAcLcLConfigurable);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLOptionBase);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLOptionlEboolgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEboolcOallocatorlEboolgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLOptionlEboolmUgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETStringcOallocatorlETStringgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLOptionlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEfloatcOallocatorlEfloatgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TCut);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLEvent),sizeof(TMVA::Event),-1,296704,(char*)NULL,G__setup_memvarTMVAcLcLEvent,G__setup_memfuncTMVAcLcLEvent);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TTree);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TFile);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TH1);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TRandom);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TRandom3);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLDataSetInfo);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLDataSet);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_maplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEcharcOallocatorlEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEintcOallocatorlEintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_pairlEfloatcOlongsPlonggR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLIMethod);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodBase),sizeof(TMVA::MethodBase),-1,324619,"Virtual base class for all TMVA method",G__setup_memvarTMVAcLcLMethodBase,G__setup_memfuncTMVAcLcLMethodBase);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLDataInputHandler);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLDataSetManager);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLFactory),sizeof(TMVA::Factory),-1,324608,"The factory creates all MVA methods, and performs their training and testing",G__setup_memvarTMVAcLcLFactory,G__setup_memfuncTMVAcLcLFactory);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETMVAcLcLIMethodmUcOallocatorlETMVAcLcLIMethodmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLIMethodmUcOallocatorlETMVAcLcLIMethodmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEdoublecOallocatorlEdoublegRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETMVAcLcLVariableTransformBasemUcOallocatorlETMVAcLcLVariableTransformBasemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLVariableTransformBasemUcOallocatorlETMVAcLcLVariableTransformBasemUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLFactorycLcLDataAssignType);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETTreemUcOallocatorlETTreemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETTreemUcOallocatorlETTreemUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLRanking);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodBoost),sizeof(TMVA::MethodBoost),-1,324608,(char*)NULL,G__setup_memvarTMVAcLcLMethodBoost,G__setup_memfuncTMVAcLcLMethodBoost);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLTransformationHandler);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLIFitterTarget);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TVectorTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TVectorTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TH1D);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TH1F);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_maplETStringcOTMVAcLcLIntervalmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIntervalmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TSpline);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLPDF);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLTSpline1);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodCuts),sizeof(TMVA::MethodCuts),-1,324608,"Multivariate optimisation of signal efficiency",G__setup_memvarTMVAcLcLMethodCuts,G__setup_memfuncTMVAcLcLMethodCuts);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodBasecLcLEWeightFileType);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodBasecLcLECutOrientation);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodCompositeBase),sizeof(TMVA::MethodCompositeBase),-1,324615,(char*)NULL,G__setup_memvarTMVAcLcLMethodCompositeBase,G__setup_memfuncTMVAcLcLMethodCompositeBase);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTBaselEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTBaselEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TElementActionTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TElementPosActionTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TElementActionTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TElementPosActionTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTSymlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTSparselEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTRow_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTRowlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTDiag_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTColumn_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTRow_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTRowlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTDiag_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTColumn_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTFlat_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTSub_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTSparseRow_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTSparseDiag_constlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTColumnlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTDiaglEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTFlatlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTSublEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTSparseRowlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTSparseDiaglEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLTActivation);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TFormula);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLTNeuron);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLTNeuronInput);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodANNBase),sizeof(TMVA::MethodANNBase),-1,324612,"Base class for TMVA ANNs",G__setup_memvarTMVAcLcLMethodANNBase,G__setup_memfuncTMVAcLcLMethodANNBase);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodANNBasecLcLEEstimator);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETH1mUcOallocatorlETH1mUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETH1mUcOallocatorlETH1mUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETMVAcLcLTNeuronmUcOallocatorlETMVAcLcLTNeuronmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLTNeuronmUcOallocatorlETMVAcLcLTNeuronmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMultiLayerPerceptron);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodTMlpANN),sizeof(TMVA::MethodTMlpANN),-1,324608,"Implementation of interface for TMultiLayerPerceptron",G__setup_memvarTMVAcLcLMethodTMlpANN,G__setup_memfuncTMVAcLcLMethodTMlpANN);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTSparseRow_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTSparseRowlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTSparseDiag_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTFlat_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTSub_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTColumnlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTDiaglEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTFlatlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTSublEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMatrixTSparseDiaglEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLNode);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLBinaryTree);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLDecisionTreeNode);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLVolume);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLBinarySearchTreeNode);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLBinarySearchTree);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLSeparationBase);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLDecisionTree);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLDecisionTreecLcLEPruneMethod);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLRuleEnsemble);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLRule);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLRuleFit);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodRuleFit),sizeof(TMVA::MethodRuleFit),-1,324608,"Friedman's RuleFit method",G__setup_memvarTMVAcLcLMethodRuleFit,G__setup_memfuncTMVAcLcLMethodRuleFit);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETH2FmUcOallocatorlETH2FmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETH2FmUcOallocatorlETH2FmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETMVAcLcLDecisionTreemUcOallocatorlETMVAcLcLDecisionTreemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLDecisionTreemUcOallocatorlETMVAcLcLDecisionTreemUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEFitMethodType);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEEffMethod);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodCutscLcLEFitParameters);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETMVAcLcLMethodCutscLcLEFitParameterscOallocatorlETMVAcLcLMethodCutscLcLEFitParametersgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLMethodCutscLcLEFitParameterscOallocatorlETMVAcLcLMethodCutscLcLEFitParametersgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodFisher),sizeof(TMVA::MethodFisher),-1,324608,"Analysis of Fisher discriminant (Fisher or Mahalanobis approach) ",G__setup_memvarTMVAcLcLMethodFisher,G__setup_memfuncTMVAcLcLMethodFisher);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodFishercLcLEFisherMethod);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLkNN);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLkNNcLcLEvent),sizeof(TMVA::kNN::Event),-1,296192,(char*)NULL,G__setup_memvarTMVAcLcLkNNcLcLEvent,G__setup_memfuncTMVAcLcLkNNcLcLEvent);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETMVAcLcLkNNcLcLEventcOallocatorlETMVAcLcLkNNcLcLEventgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLkNNcLcLEventcOallocatorlETMVAcLcLkNNcLcLEventgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLkNNcLcLNodelETMVAcLcLkNNcLcLEventgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_pairlEconstsPTMVAcLcLkNNcLcLNodelETMVAcLcLkNNcLcLEventgRmUcOfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_listlEpairlEconstsPTMVAcLcLkNNcLcLNodelETMVAcLcLkNNcLcLEventgRmUcOfloatgRcOallocatorlEpairlEconstsPTMVAcLcLkNNcLcLNodelETMVAcLcLkNNcLcLEventgRmUcOfloatgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLkNNcLcLModulekNN);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_maplEintcOvectorlEdoublecOallocatorlEdoublegRsPgRcOlesslEintgRcOallocatorlEpairlEconstsPintcOvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_maplEintcOdoublecOlesslEintgRcOallocatorlEpairlEconstsPintcOdoublegRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_maplEshortcOunsignedsPintcOlesslEshortgRcOallocatorlEpairlEconstsPshortcOunsignedsPintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLLDA);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_maplEintcOvectorlEfloatcOallocatorlEfloatgRsPgRcOlesslEintgRcOallocatorlEpairlEconstsPintcOvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_maplEintcOfloatcOlesslEintgRcOallocatorlEpairlEconstsPintcOfloatgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodKNN),sizeof(TMVA::MethodKNN),-1,324608,"k Nearest Neighbour classifier",G__setup_memvarTMVAcLcLMethodKNN,G__setup_memfuncTMVAcLcLMethodKNN);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_Utils),sizeof(TMVA::MethodCFMlpANN_Utils),-1,263425,"Implementation of Clermond-Ferrand artificial neural network",G__setup_memvarTMVAcLcLMethodCFMlpANN_Utils,G__setup_memfuncTMVAcLcLMethodCFMlpANN_Utils);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcL693);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcL694);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcLVARn2);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcL696);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcL697);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN_UtilscLcL698);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodCFMlpANN),sizeof(TMVA::MethodCFMlpANN),-1,324608,"Interface for Clermond-Ferrand artificial neural network",G__setup_memvarTMVAcLcLMethodCFMlpANN,G__setup_memfuncTMVAcLcLMethodCFMlpANN);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodLikelihood),sizeof(TMVA::MethodLikelihood),-1,324608,"Likelihood analysis (\"non-parametric approach\") ",G__setup_memvarTMVAcLcLMethodLikelihood,G__setup_memfuncTMVAcLcLMethodLikelihood);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodHMatrix),sizeof(TMVA::MethodHMatrix),-1,324608,"H-Matrix method, a simple comparison of chi-squared estimators for signal and background",G__setup_memvarTMVAcLcLMethodHMatrix,G__setup_memfuncTMVAcLcLMethodHMatrix);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodPDERS),sizeof(TMVA::MethodPDERS),-1,324608,"Multi-dimensional probability density estimator range search (PDERS) method",G__setup_memvarTMVAcLcLMethodPDERS,G__setup_memfuncTMVAcLcLMethodPDERS);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEVolumeRangeMode);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodPDERScLcLEKernelEstimator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodBDT),sizeof(TMVA::MethodBDT),-1,324608,"Analysis of Boosted Decision Trees",G__setup_memvarTMVAcLcLMethodBDT,G__setup_memfuncTMVAcLcLMethodBDT);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_pairlEdoublecOdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_maplEconstsPTMVAcLcLEventmUcOpairlEdoublecOdoublegRcOlesslEconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEconstsPTMVAcLcLEventmUsPconstcOpairlEdoublecOdoublegRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_maplEconstsPTMVAcLcLEventmUcOvectorlEdoublecOallocatorlEdoublegRsPgRcOlesslEconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEconstsPTMVAcLcLEventmUsPconstcOvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodDT),sizeof(TMVA::MethodDT),-1,324608,"Analysis of Decision Trees ",G__setup_memvarTMVAcLcLMethodDT,G__setup_memfuncTMVAcLcLMethodDT);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLSVWorkingSet);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLSVKernelFunction);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodSVM),sizeof(TMVA::MethodSVM),-1,324608,"Support Vector Machine",G__setup_memvarTMVAcLcLMethodSVM,G__setup_memfuncTMVAcLcLMethodSVM);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETMVAcLcLSVEventmUcOallocatorlETMVAcLcLSVEventmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLSVEventmUcOallocatorlETMVAcLcLSVEventmUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodBayesClassifier),sizeof(TMVA::MethodBayesClassifier),-1,324608,"Friedman's BayesClassifier method ",G__setup_memvarTMVAcLcLMethodBayesClassifier,G__setup_memfuncTMVAcLcLMethodBayesClassifier);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLFitterBase);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodFDA),sizeof(TMVA::MethodFDA),-1,324608,"Function Discriminant Analysis",G__setup_memvarTMVAcLcLMethodFDA,G__setup_memfuncTMVAcLcLMethodFDA);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLConvergenceTest);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_dequelEshortcOallocatorlEshortgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodMLP),sizeof(TMVA::MethodMLP),-1,324608,"Multi-layer perceptron implemented specifically for TMVA",G__setup_memvarTMVAcLcLMethodMLP,G__setup_memfuncTMVAcLcLMethodMLP);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodMLPcLcLETrainingMethod);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodMLPcLcLEBPTrainingMode);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_pairlEfloatcOfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEpairlEfloatcOfloatgRcOallocatorlEpairlEfloatcOfloatgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLPDEFoamCell);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLPDEFoamKernelBase);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLPDEFoam);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLEDTSeparation);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLEFoamType);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLECellValue);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLETargetSelection);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETH1DmUcOallocatorlETH1DmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETH1DmUcOallocatorlETH1DmUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodPDEFoam),sizeof(TMVA::MethodPDEFoam),-1,324608,"Multi-dimensional probability density estimator using TFoam (PDE-Foam)",G__setup_memvarTMVAcLcLMethodPDEFoam,G__setup_memfuncTMVAcLcLMethodPDEFoam);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodPDEFoamcLcLEKernel);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETMVAcLcLPDEFoammUcOallocatorlETMVAcLcLPDEFoammUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETMVAcLcLPDEFoammUcOallocatorlETMVAcLcLPDEFoammUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodLD),sizeof(TMVA::MethodLD),-1,324608,"Linear discriminant analysis",G__setup_memvarTMVAcLcLMethodLD,G__setup_memfuncTMVAcLcLMethodLD);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRmUgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA1LN_TMVAcLcLMethodCategory),sizeof(TMVA::MethodCategory),-1,324608,(char*)NULL,G__setup_memvarTMVAcLcLMethodCategory,G__setup_memfuncTMVAcLcLMethodCategory);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETCutcOallocatorlETCutgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETCutcOallocatorlETCutgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_vectorlETTreeFormulamUcOallocatorlETTreeFormulamUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA1LN_reverse_iteratorlEvectorlETTreeFormulamUcOallocatorlETTreeFormulamUgRsPgRcLcLiteratorgR);
}
extern "C" void G__cpp_setupG__TMVA1(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__TMVA1()");
  G__set_cpp_environmentG__TMVA1();
  G__cpp_setup_tagtableG__TMVA1();

  G__cpp_setup_inheritanceG__TMVA1();

  G__cpp_setup_typetableG__TMVA1();

  G__cpp_setup_memvarG__TMVA1();

  G__cpp_setup_memfuncG__TMVA1();
  G__cpp_setup_globalG__TMVA1();
  G__cpp_setup_funcG__TMVA1();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__TMVA1();
  return;
}
class G__cpp_setup_initG__TMVA1 {
  public:
    G__cpp_setup_initG__TMVA1() { G__add_setup_func("G__TMVA1",(G__incsetup)(&G__cpp_setupG__TMVA1)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__TMVA1() { G__remove_setup_func("G__TMVA1"); }
};
G__cpp_setup_initG__TMVA1 G__cpp_setup_initializerG__TMVA1;