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

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

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

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

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

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

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

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

         map< ::TString, ::TMVA::Types::EMVA > fStr2type; //types-to-text map
         ::TMVA::MsgLogger* fLogger; //message logger
      };
      #endif
      } 
      namespace TMVA {

      #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
      typedef ::TMVA::ROCCalc ROCCalc;
      #else
      class ROCCalc  {
         public:
         //friend XX;
         int fMaxIter; //maximum number of iterations
         double fAbsTol; //absolute tolerance deviation
         unsigned int fNbins; //
         bool fUseSplines; //
         ::TH1* fmvaS; //
         ::TH1* fmvaB; //the input mva distributions
         ::TH1* fmvaSpdf; //
         ::TH1* fmvaBpdf; //the normalized (and rebinned) input mva distributions
         float fXmin; //
         float fXmax; //min and max of the mva distribution  
         double fNevtS; //number of signal events (used in error calculation)
         int fCutOrientation; //+1 if larger mva value means more signal like, -1 otherwise
         ::TSpline* fSplS; //
         ::TSpline* fSplB; //
         ::TSpline* fSplmvaCumS; //
         ::TSpline* fSplmvaCumB; //spline of cumulated mva distributions
         ::TSpline* fSpleffBvsS; //
         ::TH1* fmvaScumul; //
         ::TH1* fmvaBcumul; //
         int fnStot; //
         int fnBtot; //
         ::TH1* fSignificance; //
         ::TH1* fPurity; //
         double fSignalCut; //MVA cut value for last demanded background rejection or signal efficiency
         ::TString fSuffix; //
         ::TMVA::MsgLogger* fLogger; //! message logger
      };
      #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/ROCCalc.h", 17,
                     ::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 TMVAcLcLTNeuron_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLTNeuron(void *p = 0);
   static void *newArray_TMVAcLcLTNeuron(Long_t size, void *p);
   static void delete_TMVAcLcLTNeuron(void *p);
   static void deleteArray_TMVAcLcLTNeuron(void *p);
   static void destruct_TMVAcLcLTNeuron(void *p);

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

namespace ROOTDict {
   void TMVAcLcLMsgLogger_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLMsgLogger(void *p = 0);
   static void *newArray_TMVAcLcLMsgLogger(Long_t size, void *p);
   static void delete_TMVAcLcLMsgLogger(void *p);
   static void deleteArray_TMVAcLcLMsgLogger(void *p);
   static void destruct_TMVAcLcLMsgLogger(void *p);

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

namespace ROOTDict {
   void TMVAcLcLTSynapse_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLTSynapse(void *p = 0);
   static void *newArray_TMVAcLcLTSynapse(Long_t size, void *p);
   static void delete_TMVAcLcLTSynapse(void *p);
   static void deleteArray_TMVAcLcLTSynapse(void *p);
   static void destruct_TMVAcLcLTSynapse(void *p);

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

namespace ROOTDict {
   void TMVAcLcLTActivation_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLTActivation(void *p);
   static void deleteArray_TMVAcLcLTActivation(void *p);
   static void destruct_TMVAcLcLTActivation(void *p);

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

namespace ROOTDict {
   void TMVAcLcLTypes_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMVAcLcLTypes_Dictionary();
   static void delete_TMVAcLcLTypes(void *p);
   static void deleteArray_TMVAcLcLTypes(void *p);
   static void destruct_TMVAcLcLTypes(void *p);

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

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

} // end of namespace ROOTDict

namespace ROOTDict {
   void TMVAcLcLTNeuronInput_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLTNeuronInput(void *p);
   static void deleteArray_TMVAcLcLTNeuronInput(void *p);
   static void destruct_TMVAcLcLTNeuronInput(void *p);

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

namespace ROOTDict {
   void TMVAcLcLTActivationChooser_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLTActivationChooser(void *p = 0);
   static void *newArray_TMVAcLcLTActivationChooser(Long_t size, void *p);
   static void delete_TMVAcLcLTActivationChooser(void *p);
   static void deleteArray_TMVAcLcLTActivationChooser(void *p);
   static void destruct_TMVAcLcLTActivationChooser(void *p);

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

namespace ROOTDict {
   void TMVAcLcLTActivationSigmoid_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLTActivationSigmoid(void *p = 0);
   static void *newArray_TMVAcLcLTActivationSigmoid(Long_t size, void *p);
   static void delete_TMVAcLcLTActivationSigmoid(void *p);
   static void deleteArray_TMVAcLcLTActivationSigmoid(void *p);
   static void destruct_TMVAcLcLTActivationSigmoid(void *p);

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

namespace ROOTDict {
   void TMVAcLcLTActivationIdentity_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLTActivationIdentity(void *p = 0);
   static void *newArray_TMVAcLcLTActivationIdentity(Long_t size, void *p);
   static void delete_TMVAcLcLTActivationIdentity(void *p);
   static void deleteArray_TMVAcLcLTActivationIdentity(void *p);
   static void destruct_TMVAcLcLTActivationIdentity(void *p);

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

namespace ROOTDict {
   void TMVAcLcLTActivationTanh_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLTActivationTanh(void *p = 0);
   static void *newArray_TMVAcLcLTActivationTanh(Long_t size, void *p);
   static void delete_TMVAcLcLTActivationTanh(void *p);
   static void deleteArray_TMVAcLcLTActivationTanh(void *p);
   static void destruct_TMVAcLcLTActivationTanh(void *p);

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

namespace ROOTDict {
   void TMVAcLcLTActivationRadial_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLTActivationRadial(void *p = 0);
   static void *newArray_TMVAcLcLTActivationRadial(Long_t size, void *p);
   static void delete_TMVAcLcLTActivationRadial(void *p);
   static void deleteArray_TMVAcLcLTActivationRadial(void *p);
   static void destruct_TMVAcLcLTActivationRadial(void *p);

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

namespace ROOTDict {
   void TMVAcLcLTNeuronInputSum_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLTNeuronInputSum(void *p = 0);
   static void *newArray_TMVAcLcLTNeuronInputSum(Long_t size, void *p);
   static void delete_TMVAcLcLTNeuronInputSum(void *p);
   static void deleteArray_TMVAcLcLTNeuronInputSum(void *p);
   static void destruct_TMVAcLcLTNeuronInputSum(void *p);

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

namespace ROOTDict {
   void TMVAcLcLTNeuronInputSqSum_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLTNeuronInputSqSum(void *p = 0);
   static void *newArray_TMVAcLcLTNeuronInputSqSum(Long_t size, void *p);
   static void delete_TMVAcLcLTNeuronInputSqSum(void *p);
   static void deleteArray_TMVAcLcLTNeuronInputSqSum(void *p);
   static void destruct_TMVAcLcLTNeuronInputSqSum(void *p);

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

namespace ROOTDict {
   void TMVAcLcLTNeuronInputAbs_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLTNeuronInputAbs(void *p = 0);
   static void *newArray_TMVAcLcLTNeuronInputAbs(Long_t size, void *p);
   static void delete_TMVAcLcLTNeuronInputAbs(void *p);
   static void deleteArray_TMVAcLcLTNeuronInputAbs(void *p);
   static void destruct_TMVAcLcLTNeuronInputAbs(void *p);

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

namespace ROOTDict {
   void TMVAcLcLTNeuronInputChooser_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLTNeuronInputChooser(void *p = 0);
   static void *newArray_TMVAcLcLTNeuronInputChooser(Long_t size, void *p);
   static void delete_TMVAcLcLTNeuronInputChooser(void *p);
   static void deleteArray_TMVAcLcLTNeuronInputChooser(void *p);
   static void destruct_TMVAcLcLTNeuronInputChooser(void *p);

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

namespace ROOTDict {
   void TMVAcLcLRanking_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLRanking(void *p = 0);
   static void *newArray_TMVAcLcLRanking(Long_t size, void *p);
   static void delete_TMVAcLcLRanking(void *p);
   static void deleteArray_TMVAcLcLRanking(void *p);
   static void destruct_TMVAcLcLRanking(void *p);

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

namespace ROOTDict {
   void TMVAcLcLVariableTransformBase_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLVariableTransformBase(void *p);
   static void deleteArray_TMVAcLcLVariableTransformBase(void *p);
   static void destruct_TMVAcLcLVariableTransformBase(void *p);

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

namespace ROOTDict {
   void TMVAcLcLRuleFit_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMVAcLcLRuleFit(void *p = 0);
   static void *newArray_TMVAcLcLRuleFit(Long_t size, void *p);
   static void delete_TMVAcLcLRuleFit(void *p);
   static void deleteArray_TMVAcLcLRuleFit(void *p);
   static void destruct_TMVAcLcLRuleFit(void *p);

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

namespace ROOTDict {
   void TMVAcLcLRuleFitAPI_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLRuleFitAPI(void *p);
   static void deleteArray_TMVAcLcLRuleFitAPI(void *p);
   static void destruct_TMVAcLcLRuleFitAPI(void *p);

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

namespace ROOTDict {
   void TMVAcLcLIMethod_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLIMethod(void *p);
   static void deleteArray_TMVAcLcLIMethod(void *p);
   static void destruct_TMVAcLcLIMethod(void *p);

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

namespace ROOTDict {
   void TMVAcLcLVariableIdentityTransform_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLVariableIdentityTransform(void *p);
   static void deleteArray_TMVAcLcLVariableIdentityTransform(void *p);
   static void destruct_TMVAcLcLVariableIdentityTransform(void *p);

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

namespace ROOTDict {
   void TMVAcLcLVariableDecorrTransform_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLVariableDecorrTransform(void *p);
   static void deleteArray_TMVAcLcLVariableDecorrTransform(void *p);
   static void destruct_TMVAcLcLVariableDecorrTransform(void *p);

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

namespace ROOTDict {
   void TMVAcLcLVariablePCATransform_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLVariablePCATransform(void *p);
   static void deleteArray_TMVAcLcLVariablePCATransform(void *p);
   static void destruct_TMVAcLcLVariablePCATransform(void *p);

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

namespace ROOTDict {
   void TMVAcLcLVariableGaussTransform_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLVariableGaussTransform(void *p);
   static void deleteArray_TMVAcLcLVariableGaussTransform(void *p);
   static void destruct_TMVAcLcLVariableGaussTransform(void *p);

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

namespace ROOTDict {
   void TMVAcLcLVariableNormalizeTransform_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLVariableNormalizeTransform(void *p);
   static void deleteArray_TMVAcLcLVariableNormalizeTransform(void *p);
   static void destruct_TMVAcLcLVariableNormalizeTransform(void *p);

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

namespace ROOTDict {
   void TMVAcLcLVariableRearrangeTransform_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMVAcLcLVariableRearrangeTransform(void *p);
   static void deleteArray_TMVAcLcLVariableRearrangeTransform(void *p);
   static void destruct_TMVAcLcLVariableRearrangeTransform(void *p);

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

namespace ROOTDict {
   void TMVAcLcLROCCalc_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void TMVAcLcLROCCalc_Dictionary();
   static void delete_TMVAcLcLROCCalc(void *p);
   static void deleteArray_TMVAcLcLROCCalc(void *p);
   static void destruct_TMVAcLcLROCCalc(void *p);

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

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

} // end of namespace ROOTDict

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void TNeuron::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::TNeuron.
      TClass *R__cl = ::TMVA::TNeuron::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLinksIn", &fLinksIn);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLinksOut", &fLinksOut);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValue", &fValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActivationValue", &fActivationValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDelta", &fDelta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDEDw", &fDEDw);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fError", &fError);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fForcedValue", &fForcedValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fActivation", &fActivation);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInputCalculator", &fInputCalculator);
      TObject::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLTNeuron(void *p) {
      return  p ? new(p) ::TMVA::TNeuron : new ::TMVA::TNeuron;
   }
   static void *newArray_TMVAcLcLTNeuron(Long_t nElements, void *p) {
      return p ? new(p) ::TMVA::TNeuron[nElements] : new ::TMVA::TNeuron[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLTNeuron(void *p) {
      delete ((::TMVA::TNeuron*)p);
   }
   static void deleteArray_TMVAcLcLTNeuron(void *p) {
      delete [] ((::TMVA::TNeuron*)p);
   }
   static void destruct_TMVAcLcLTNeuron(void *p) {
      typedef ::TMVA::TNeuron current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::TNeuron

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void TSynapse::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::TSynapse.
      TClass *R__cl = ::TMVA::TSynapse::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWeight", &fWeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLearnRate", &fLearnRate);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDelta", &fDelta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDEDw", &fDEDw);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCount", &fCount);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPreNeuron", &fPreNeuron);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPostNeuron", &fPostNeuron);
      TObject::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLTSynapse(void *p) {
      return  p ? new(p) ::TMVA::TSynapse : new ::TMVA::TSynapse;
   }
   static void *newArray_TMVAcLcLTSynapse(Long_t nElements, void *p) {
      return p ? new(p) ::TMVA::TSynapse[nElements] : new ::TMVA::TSynapse[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLTSynapse(void *p) {
      delete ((::TMVA::TSynapse*)p);
   }
   static void deleteArray_TMVAcLcLTSynapse(void *p) {
      delete [] ((::TMVA::TSynapse*)p);
   }
   static void destruct_TMVAcLcLTSynapse(void *p) {
      typedef ::TMVA::TSynapse current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::TSynapse

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLTActivationChooser(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TActivationChooser : new ::TMVA::TActivationChooser;
   }
   static void *newArray_TMVAcLcLTActivationChooser(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TActivationChooser[nElements] : new ::TMVA::TActivationChooser[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLTActivationChooser(void *p) {
      delete ((::TMVA::TActivationChooser*)p);
   }
   static void deleteArray_TMVAcLcLTActivationChooser(void *p) {
      delete [] ((::TMVA::TActivationChooser*)p);
   }
   static void destruct_TMVAcLcLTActivationChooser(void *p) {
      typedef ::TMVA::TActivationChooser current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::TActivationChooser

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLTActivation(void *p) {
      delete ((::TMVA::TActivation*)p);
   }
   static void deleteArray_TMVAcLcLTActivation(void *p) {
      delete [] ((::TMVA::TActivation*)p);
   }
   static void destruct_TMVAcLcLTActivation(void *p) {
      typedef ::TMVA::TActivation current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::TActivation

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLTActivationSigmoid(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TActivationSigmoid : new ::TMVA::TActivationSigmoid;
   }
   static void *newArray_TMVAcLcLTActivationSigmoid(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TActivationSigmoid[nElements] : new ::TMVA::TActivationSigmoid[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLTActivationSigmoid(void *p) {
      delete ((::TMVA::TActivationSigmoid*)p);
   }
   static void deleteArray_TMVAcLcLTActivationSigmoid(void *p) {
      delete [] ((::TMVA::TActivationSigmoid*)p);
   }
   static void destruct_TMVAcLcLTActivationSigmoid(void *p) {
      typedef ::TMVA::TActivationSigmoid current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::TActivationSigmoid

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLTActivationIdentity(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TActivationIdentity : new ::TMVA::TActivationIdentity;
   }
   static void *newArray_TMVAcLcLTActivationIdentity(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TActivationIdentity[nElements] : new ::TMVA::TActivationIdentity[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLTActivationIdentity(void *p) {
      delete ((::TMVA::TActivationIdentity*)p);
   }
   static void deleteArray_TMVAcLcLTActivationIdentity(void *p) {
      delete [] ((::TMVA::TActivationIdentity*)p);
   }
   static void destruct_TMVAcLcLTActivationIdentity(void *p) {
      typedef ::TMVA::TActivationIdentity current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::TActivationIdentity

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLTActivationTanh(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TActivationTanh : new ::TMVA::TActivationTanh;
   }
   static void *newArray_TMVAcLcLTActivationTanh(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TActivationTanh[nElements] : new ::TMVA::TActivationTanh[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLTActivationTanh(void *p) {
      delete ((::TMVA::TActivationTanh*)p);
   }
   static void deleteArray_TMVAcLcLTActivationTanh(void *p) {
      delete [] ((::TMVA::TActivationTanh*)p);
   }
   static void destruct_TMVAcLcLTActivationTanh(void *p) {
      typedef ::TMVA::TActivationTanh current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::TActivationTanh

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLTActivationRadial(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TActivationRadial : new ::TMVA::TActivationRadial;
   }
   static void *newArray_TMVAcLcLTActivationRadial(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TActivationRadial[nElements] : new ::TMVA::TActivationRadial[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLTActivationRadial(void *p) {
      delete ((::TMVA::TActivationRadial*)p);
   }
   static void deleteArray_TMVAcLcLTActivationRadial(void *p) {
      delete [] ((::TMVA::TActivationRadial*)p);
   }
   static void destruct_TMVAcLcLTActivationRadial(void *p) {
      typedef ::TMVA::TActivationRadial current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::TActivationRadial

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLTNeuronInputChooser(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TNeuronInputChooser : new ::TMVA::TNeuronInputChooser;
   }
   static void *newArray_TMVAcLcLTNeuronInputChooser(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TNeuronInputChooser[nElements] : new ::TMVA::TNeuronInputChooser[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLTNeuronInputChooser(void *p) {
      delete ((::TMVA::TNeuronInputChooser*)p);
   }
   static void deleteArray_TMVAcLcLTNeuronInputChooser(void *p) {
      delete [] ((::TMVA::TNeuronInputChooser*)p);
   }
   static void destruct_TMVAcLcLTNeuronInputChooser(void *p) {
      typedef ::TMVA::TNeuronInputChooser current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::TNeuronInputChooser

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLTNeuronInput(void *p) {
      delete ((::TMVA::TNeuronInput*)p);
   }
   static void deleteArray_TMVAcLcLTNeuronInput(void *p) {
      delete [] ((::TMVA::TNeuronInput*)p);
   }
   static void destruct_TMVAcLcLTNeuronInput(void *p) {
      typedef ::TMVA::TNeuronInput current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::TNeuronInput

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLTNeuronInputSum(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TNeuronInputSum : new ::TMVA::TNeuronInputSum;
   }
   static void *newArray_TMVAcLcLTNeuronInputSum(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TNeuronInputSum[nElements] : new ::TMVA::TNeuronInputSum[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLTNeuronInputSum(void *p) {
      delete ((::TMVA::TNeuronInputSum*)p);
   }
   static void deleteArray_TMVAcLcLTNeuronInputSum(void *p) {
      delete [] ((::TMVA::TNeuronInputSum*)p);
   }
   static void destruct_TMVAcLcLTNeuronInputSum(void *p) {
      typedef ::TMVA::TNeuronInputSum current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::TNeuronInputSum

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLTNeuronInputSqSum(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TNeuronInputSqSum : new ::TMVA::TNeuronInputSqSum;
   }
   static void *newArray_TMVAcLcLTNeuronInputSqSum(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TNeuronInputSqSum[nElements] : new ::TMVA::TNeuronInputSqSum[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLTNeuronInputSqSum(void *p) {
      delete ((::TMVA::TNeuronInputSqSum*)p);
   }
   static void deleteArray_TMVAcLcLTNeuronInputSqSum(void *p) {
      delete [] ((::TMVA::TNeuronInputSqSum*)p);
   }
   static void destruct_TMVAcLcLTNeuronInputSqSum(void *p) {
      typedef ::TMVA::TNeuronInputSqSum current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::TNeuronInputSqSum

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLTNeuronInputAbs(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TNeuronInputAbs : new ::TMVA::TNeuronInputAbs;
   }
   static void *newArray_TMVAcLcLTNeuronInputAbs(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::TNeuronInputAbs[nElements] : new ::TMVA::TNeuronInputAbs[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLTNeuronInputAbs(void *p) {
      delete ((::TMVA::TNeuronInputAbs*)p);
   }
   static void deleteArray_TMVAcLcLTNeuronInputAbs(void *p) {
      delete [] ((::TMVA::TNeuronInputAbs*)p);
   }
   static void destruct_TMVAcLcLTNeuronInputAbs(void *p) {
      typedef ::TMVA::TNeuronInputAbs current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::TNeuronInputAbs

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

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::Types*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStr2type", (void*)&sobj->fStr2type);
      R__insp.InspectMember("map<TString,TMVA::Types::EMVA>", (void*)&sobj->fStr2type, "fStr2type.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &sobj->fLogger);
   }

}

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLTypes(void *p) {
      delete ((::TMVA::Types*)p);
   }
   static void deleteArray_TMVAcLcLTypes(void *p) {
      delete [] ((::TMVA::Types*)p);
   }
   static void destruct_TMVAcLcLTypes(void *p) {
      typedef ::TMVA::Types current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::Types

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void Ranking::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::Ranking.
      TClass *R__cl = ::TMVA::Ranking::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRanking", (void*)&fRanking);
      R__insp.InspectMember("vector<TMVA::Rank>", (void*)&fRanking, "fRanking.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fContext", &fContext);
      R__insp.InspectMember(fContext, "fContext.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRankingDiscriminatorName", &fRankingDiscriminatorName);
      R__insp.InspectMember(fRankingDiscriminatorName, "fRankingDiscriminatorName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLRanking(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::Ranking : new ::TMVA::Ranking;
   }
   static void *newArray_TMVAcLcLRanking(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::Ranking[nElements] : new ::TMVA::Ranking[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLRanking(void *p) {
      delete ((::TMVA::Ranking*)p);
   }
   static void deleteArray_TMVAcLcLRanking(void *p) {
      delete [] ((::TMVA::Ranking*)p);
   }
   static void destruct_TMVAcLcLRanking(void *p) {
      typedef ::TMVA::Ranking current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::Ranking

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void RuleFit::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::RuleFit.
      TClass *R__cl = ::TMVA::RuleFit::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrainingEvents", (void*)&fTrainingEvents);
      R__insp.InspectMember("vector<const TMVA::Event*>", (void*)&fTrainingEvents, "fTrainingEvents.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrainingEventsRndm", (void*)&fTrainingEventsRndm);
      R__insp.InspectMember("vector<const TMVA::Event*>", (void*)&fTrainingEventsRndm, "fTrainingEventsRndm.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEventWeights", (void*)&fEventWeights);
      R__insp.InspectMember("vector<Double_t>", (void*)&fEventWeights, "fEventWeights.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTreeSample", &fNTreeSample);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNEveEffTrain", &fNEveEffTrain);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fForest", (void*)&fForest);
      R__insp.InspectMember("vector<const TMVA::DecisionTree*>", (void*)&fForest, "fForest.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRuleEnsemble", (void*)&fRuleEnsemble);
      R__insp.InspectMember("TMVA::RuleEnsemble", (void*)&fRuleEnsemble, "fRuleEnsemble.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRuleFitParams", (void*)&fRuleFitParams);
      R__insp.InspectMember("TMVA::RuleFitParams", (void*)&fRuleFitParams, "fRuleFitParams.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMethodRuleFit", &fMethodRuleFit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMethodBase", &fMethodBase);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVisHistsUseImp", &fVisHistsUseImp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLRuleFit(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::RuleFit : new ::TMVA::RuleFit;
   }
   static void *newArray_TMVAcLcLRuleFit(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::RuleFit[nElements] : new ::TMVA::RuleFit[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLRuleFit(void *p) {
      delete ((::TMVA::RuleFit*)p);
   }
   static void deleteArray_TMVAcLcLRuleFit(void *p) {
      delete [] ((::TMVA::RuleFit*)p);
   }
   static void destruct_TMVAcLcLRuleFit(void *p) {
      typedef ::TMVA::RuleFit current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::RuleFit

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void RuleFitAPI::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::RuleFitAPI.
      TClass *R__cl = ::TMVA::RuleFitAPI::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMethodRuleFit", &fMethodRuleFit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRuleFit", &fRuleFit);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRFYhat", (void*)&fRFYhat);
      R__insp.InspectMember("vector<Float_t>", (void*)&fRFYhat, "fRFYhat.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRFVarImp", (void*)&fRFVarImp);
      R__insp.InspectMember("vector<Float_t>", (void*)&fRFVarImp, "fRFVarImp.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRFVarImpInd", (void*)&fRFVarImpInd);
      R__insp.InspectMember("vector<Int_t>", (void*)&fRFVarImpInd, "fRFVarImpInd.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRFWorkDir", &fRFWorkDir);
      R__insp.InspectMember(fRFWorkDir, "fRFWorkDir.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRFIntParms", (void*)&fRFIntParms);
      R__insp.InspectMember("TMVA::RuleFitAPI::IntParms", (void*)&fRFIntParms, "fRFIntParms.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRFRealParms", (void*)&fRFRealParms);
      R__insp.InspectMember("TMVA::RuleFitAPI::RealParms", (void*)&fRFRealParms, "fRFRealParms.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRFLx", (void*)&fRFLx);
      R__insp.InspectMember("vector<int>", (void*)&fRFLx, "fRFLx.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fRFProgram", &fRFProgram);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fModelType", &fModelType);
      R__insp.InspectMember(fModelType, "fModelType.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLogger", &fLogger);
      R__insp.InspectMember(fLogger, "fLogger.");
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLRuleFitAPI(void *p) {
      delete ((::TMVA::RuleFitAPI*)p);
   }
   static void deleteArray_TMVAcLcLRuleFitAPI(void *p) {
      delete [] ((::TMVA::RuleFitAPI*)p);
   }
   static void destruct_TMVAcLcLRuleFitAPI(void *p) {
      typedef ::TMVA::RuleFitAPI current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::RuleFitAPI

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLIMethod(void *p) {
      delete ((::TMVA::IMethod*)p);
   }
   static void deleteArray_TMVAcLcLIMethod(void *p) {
      delete [] ((::TMVA::IMethod*)p);
   }
   static void destruct_TMVAcLcLIMethod(void *p) {
      typedef ::TMVA::IMethod current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::IMethod

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void MsgLogger::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::MsgLogger.
      TClass *R__cl = ::TMVA::MsgLogger::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fObjSource", &fObjSource);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStrSource", (void*)&fStrSource);
      R__insp.InspectMember("string", (void*)&fStrSource, "fStrSource.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fActiveType", &fActiveType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinType", &fMinType);
      R__insp.GenericShowMembers("basic_ostringstream<char,char_traits<char>,allocator<char> >", ( ::basic_ostringstream<char,char_traits<char>,allocator<char> > *) (this ), false);
      TObject::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrappers around operator new
   static void *new_TMVAcLcLMsgLogger(void *p) {
      return  p ? new(p) ::TMVA::MsgLogger : new ::TMVA::MsgLogger;
   }
   static void *newArray_TMVAcLcLMsgLogger(Long_t nElements, void *p) {
      return p ? new(p) ::TMVA::MsgLogger[nElements] : new ::TMVA::MsgLogger[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMVAcLcLMsgLogger(void *p) {
      delete ((::TMVA::MsgLogger*)p);
   }
   static void deleteArray_TMVAcLcLMsgLogger(void *p) {
      delete [] ((::TMVA::MsgLogger*)p);
   }
   static void destruct_TMVAcLcLMsgLogger(void *p) {
      typedef ::TMVA::MsgLogger current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::MsgLogger

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void VariableTransformBase::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::VariableTransformBase.
      TClass *R__cl = ::TMVA::VariableTransformBase::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDsiOutput", &fDsiOutput);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTransformedEvent", &fTransformedEvent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBackTransformedEvent", &fBackTransformedEvent);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGet", (void*)&fGet);
      R__insp.InspectMember("TMVA::VariableTransformBase::VectorOfCharAndInt", (void*)&fGet, "fGet.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPut", (void*)&fPut);
      R__insp.InspectMember("TMVA::VariableTransformBase::VectorOfCharAndInt", (void*)&fPut, "fPut.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVariableTransform", &fVariableTransform);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseSignalTransform", &fUseSignalTransform);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEnabled", &fEnabled);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCreated", &fCreated);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormalise", &fNormalise);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNVars", &fNVars);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTransformName", &fTransformName);
      R__insp.InspectMember(fTransformName, "fTransformName.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVariables", (void*)&fVariables);
      R__insp.InspectMember("vector<TMVA::VariableInfo>", (void*)&fVariables, "fVariables.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTargets", (void*)&fTargets);
      R__insp.InspectMember("vector<TMVA::VariableInfo>", (void*)&fTargets, "fTargets.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSpectators", (void*)&fSpectators);
      R__insp.InspectMember("vector<TMVA::VariableInfo>", (void*)&fSpectators, "fSpectators.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fVariableTypesAreCounted", &fVariableTypesAreCounted);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNVariables", &fNVariables);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNTargets", &fNTargets);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNSpectators", &fNSpectators);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSortGet", &fSortGet);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTMVAVersion", &fTMVAVersion);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
      TObject::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLVariableTransformBase(void *p) {
      delete ((::TMVA::VariableTransformBase*)p);
   }
   static void deleteArray_TMVAcLcLVariableTransformBase(void *p) {
      delete [] ((::TMVA::VariableTransformBase*)p);
   }
   static void destruct_TMVAcLcLVariableTransformBase(void *p) {
      typedef ::TMVA::VariableTransformBase current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::VariableTransformBase

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLVariableIdentityTransform(void *p) {
      delete ((::TMVA::VariableIdentityTransform*)p);
   }
   static void deleteArray_TMVAcLcLVariableIdentityTransform(void *p) {
      delete [] ((::TMVA::VariableIdentityTransform*)p);
   }
   static void destruct_TMVAcLcLVariableIdentityTransform(void *p) {
      typedef ::TMVA::VariableIdentityTransform current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::VariableIdentityTransform

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLVariableDecorrTransform(void *p) {
      delete ((::TMVA::VariableDecorrTransform*)p);
   }
   static void deleteArray_TMVAcLcLVariableDecorrTransform(void *p) {
      delete [] ((::TMVA::VariableDecorrTransform*)p);
   }
   static void destruct_TMVAcLcLVariableDecorrTransform(void *p) {
      typedef ::TMVA::VariableDecorrTransform current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::VariableDecorrTransform

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void VariablePCATransform::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::VariablePCATransform.
      TClass *R__cl = ::TMVA::VariablePCATransform::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMeanValues", (void*)&fMeanValues);
      R__insp.InspectMember("vector<TVectorD*>", (void*)&fMeanValues, "fMeanValues.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEigenVectors", (void*)&fEigenVectors);
      R__insp.InspectMember("vector<TMatrixD*>", (void*)&fEigenVectors, "fEigenVectors.", false);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::VariableTransformBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLVariablePCATransform(void *p) {
      delete ((::TMVA::VariablePCATransform*)p);
   }
   static void deleteArray_TMVAcLcLVariablePCATransform(void *p) {
      delete [] ((::TMVA::VariablePCATransform*)p);
   }
   static void destruct_TMVAcLcLVariablePCATransform(void *p) {
      typedef ::TMVA::VariablePCATransform current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::VariablePCATransform

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

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

} // namespace TMVA
//______________________________________________________________________________
      namespace TMVA {
void VariableGaussTransform::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMVA::VariableGaussTransform.
      TClass *R__cl = ::TMVA::VariableGaussTransform::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFlatNotGauss", &fFlatNotGauss);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPdfMinSmooth", &fPdfMinSmooth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fPdfMaxSmooth", &fPdfMaxSmooth);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCumulativeDist", (void*)&fCumulativeDist);
      R__insp.InspectMember("vector<std::vector<TH1F*> >", (void*)&fCumulativeDist, "fCumulativeDist.", true);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCumulativePDF", (void*)&fCumulativePDF);
      R__insp.InspectMember("vector<std::vector<PDF*> >", (void*)&fCumulativePDF, "fCumulativePDF.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fElementsperbin", &fElementsperbin);
      //This works around a msvc bug and should be harmless on other platforms
      typedef TMVA::VariableTransformBase baseClass1;
      baseClass1::ShowMembers(R__insp);
}

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLVariableGaussTransform(void *p) {
      delete ((::TMVA::VariableGaussTransform*)p);
   }
   static void deleteArray_TMVAcLcLVariableGaussTransform(void *p) {
      delete [] ((::TMVA::VariableGaussTransform*)p);
   }
   static void destruct_TMVAcLcLVariableGaussTransform(void *p) {
      typedef ::TMVA::VariableGaussTransform current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::VariableGaussTransform

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLVariableNormalizeTransform(void *p) {
      delete ((::TMVA::VariableNormalizeTransform*)p);
   }
   static void deleteArray_TMVAcLcLVariableNormalizeTransform(void *p) {
      delete [] ((::TMVA::VariableNormalizeTransform*)p);
   }
   static void destruct_TMVAcLcLVariableNormalizeTransform(void *p) {
      typedef ::TMVA::VariableNormalizeTransform current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::VariableNormalizeTransform

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

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

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

} // namespace TMVA
namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLVariableRearrangeTransform(void *p) {
      delete ((::TMVA::VariableRearrangeTransform*)p);
   }
   static void deleteArray_TMVAcLcLVariableRearrangeTransform(void *p) {
      delete [] ((::TMVA::VariableRearrangeTransform*)p);
   }
   static void destruct_TMVAcLcLVariableRearrangeTransform(void *p) {
      typedef ::TMVA::VariableRearrangeTransform current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::VariableRearrangeTransform

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

      TClass *R__cl  = ::ROOTDict::GenerateInitInstanceLocal((const ::TMVA::ROCCalc*)0x0)->GetClass();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxIter", &sobj->fMaxIter);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fAbsTol", &sobj->fAbsTol);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbins", &sobj->fNbins);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseSplines", &sobj->fUseSplines);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fmvaS", &sobj->fmvaS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fmvaB", &sobj->fmvaB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fmvaSpdf", &sobj->fmvaSpdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fmvaBpdf", &sobj->fmvaBpdf);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmin", &sobj->fXmin);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fXmax", &sobj->fXmax);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNevtS", &sobj->fNevtS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCutOrientation", &sobj->fCutOrientation);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSplS", &sobj->fSplS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSplB", &sobj->fSplB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSplmvaCumS", &sobj->fSplmvaCumS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSplmvaCumB", &sobj->fSplmvaCumB);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSpleffBvsS", &sobj->fSpleffBvsS);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fmvaScumul", &sobj->fmvaScumul);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fmvaBcumul", &sobj->fmvaBcumul);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fnStot", &sobj->fnStot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fnBtot", &sobj->fnBtot);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSignificance", &sobj->fSignificance);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPurity", &sobj->fPurity);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSignalCut", &sobj->fSignalCut);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSuffix", &sobj->fSuffix);
      R__insp.InspectMember(sobj->fSuffix, "fSuffix.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &sobj->fLogger);
   }

}

namespace ROOTDict {
   // Wrapper around operator delete
   static void delete_TMVAcLcLROCCalc(void *p) {
      delete ((::TMVA::ROCCalc*)p);
   }
   static void deleteArray_TMVAcLcLROCCalc(void *p) {
      delete [] ((::TMVA::ROCCalc*)p);
   }
   static void destruct_TMVAcLcLROCCalc(void *p) {
      typedef ::TMVA::ROCCalc current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class ::TMVA::ROCCalc

namespace ROOTDict {
   void maplETStringcOTMVAcLcLTypescLcLEMVAgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void maplETStringcOTMVAcLcLTypescLcLEMVAgR_Dictionary();
   static void *new_maplETStringcOTMVAcLcLTypescLcLEMVAgR(void *p = 0);
   static void *newArray_maplETStringcOTMVAcLcLTypescLcLEMVAgR(Long_t size, void *p);
   static void delete_maplETStringcOTMVAcLcLTypescLcLEMVAgR(void *p);
   static void deleteArray_maplETStringcOTMVAcLcLTypescLcLEMVAgR(void *p);
   static void destruct_maplETStringcOTMVAcLcLTypescLcLEMVAgR(void *p);

   // Function generating the singleton type initializer
   static ROOT::TGenericClassInfo *GenerateInitInstanceLocal(const map<TString,TMVA::Types::EMVA>*)
   {
      map<TString,TMVA::Types::EMVA> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<TString,TMVA::Types::EMVA>),0);
      static ::ROOT::TGenericClassInfo 
         instance("map<TString,TMVA::Types::EMVA>", -2, "/home/mice/Grid/MAUS-v3.2.1/third_party/source/root_v5.34.36/cint/cint/lib/prec_stl/map", 63,
                  typeid(map<TString,TMVA::Types::EMVA>), ::ROOT::DefineBehavior(ptr, ptr),
                  0, &maplETStringcOTMVAcLcLTypescLcLEMVAgR_Dictionary, isa_proxy, 0,
                  sizeof(map<TString,TMVA::Types::EMVA>) );
      instance.SetNew(&new_maplETStringcOTMVAcLcLTypescLcLEMVAgR);
      instance.SetNewArray(&newArray_maplETStringcOTMVAcLcLTypescLcLEMVAgR);
      instance.SetDelete(&delete_maplETStringcOTMVAcLcLTypescLcLEMVAgR);
      instance.SetDeleteArray(&deleteArray_maplETStringcOTMVAcLcLTypescLcLEMVAgR);
      instance.SetDestructor(&destruct_maplETStringcOTMVAcLcLTypescLcLEMVAgR);
      instance.AdoptCollectionProxyInfo( ::ROOT::TCollectionProxyInfo::Generate( ::ROOT::TCollectionProxyInfo::MapInsert< map<TString,TMVA::Types::EMVA> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<TString,TMVA::Types::EMVA>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void maplETStringcOTMVAcLcLTypescLcLEMVAgR_Dictionary() {
      ::ROOTDict::GenerateInitInstanceLocal((const map<TString,TMVA::Types::EMVA>*)0x0)->GetClass();
   }

} // end of namespace ROOTDict

namespace ROOTDict {
   // Wrappers around operator new
   static void *new_maplETStringcOTMVAcLcLTypescLcLEMVAgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<TString,TMVA::Types::EMVA> : new map<TString,TMVA::Types::EMVA>;
   }
   static void *newArray_maplETStringcOTMVAcLcLTypescLcLEMVAgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<TString,TMVA::Types::EMVA>[nElements] : new map<TString,TMVA::Types::EMVA>[nElements];
   }
   // Wrapper around operator delete
   static void delete_maplETStringcOTMVAcLcLTypescLcLEMVAgR(void *p) {
      delete ((map<TString,TMVA::Types::EMVA>*)p);
   }
   static void deleteArray_maplETStringcOTMVAcLcLTypescLcLEMVAgR(void *p) {
      delete [] ((map<TString,TMVA::Types::EMVA>*)p);
   }
   static void destruct_maplETStringcOTMVAcLcLTypescLcLEMVAgR(void *p) {
      typedef map<TString,TMVA::Types::EMVA> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOTDict for class map<TString,TMVA::Types::EMVA>

/********************************************************
* G__TMVA4.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__TMVA4();

extern "C" void G__set_cpp_environmentG__TMVA4() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TMVA/TNeuron.h");
  G__add_compiledheader("TMVA/TSynapse.h");
  G__add_compiledheader("TMVA/TActivationChooser.h");
  G__add_compiledheader("TMVA/TActivation.h");
  G__add_compiledheader("TMVA/TActivationSigmoid.h");
  G__add_compiledheader("TMVA/TActivationIdentity.h");
  G__add_compiledheader("TMVA/TActivationTanh.h");
  G__add_compiledheader("TMVA/TActivationRadial.h");
  G__add_compiledheader("TMVA/TNeuronInputChooser.h");
  G__add_compiledheader("TMVA/TNeuronInput.h");
  G__add_compiledheader("TMVA/TNeuronInputSum.h");
  G__add_compiledheader("TMVA/TNeuronInputSqSum.h");
  G__add_compiledheader("TMVA/TNeuronInputAbs.h");
  G__add_compiledheader("TMVA/Types.h");
  G__add_compiledheader("TMVA/Ranking.h");
  G__add_compiledheader("TMVA/RuleFit.h");
  G__add_compiledheader("TMVA/RuleFitAPI.h");
  G__add_compiledheader("TMVA/IMethod.h");
  G__add_compiledheader("TMVA/MsgLogger.h");
  G__add_compiledheader("TMVA/VariableTransformBase.h");
  G__add_compiledheader("TMVA/VariableIdentityTransform.h");
  G__add_compiledheader("TMVA/VariableDecorrTransform.h");
  G__add_compiledheader("TMVA/VariablePCATransform.h");
  G__add_compiledheader("TMVA/VariableGaussTransform.h");
  G__add_compiledheader("TMVA/VariableNormalizeTransform.h");
  G__add_compiledheader("TMVA/VariableRearrangeTransform.h");
  G__add_compiledheader("TMVA/ROCCalc.h");
  G__cpp_reset_tagtableG__TMVA4();
}
#include <new>
extern "C" int G__cpp_dllrevG__TMVA4() { return(30051515); }

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

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

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

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

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

static int G__G__TMVA4_141_0_8(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__TMVA4_141_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__TMVA4_141_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::TNeuron */
static int G__G__TMVA4_142_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMVA::TNeuron* p = NULL;
   char* gvp = (char*) G__getgvp();
   int n = G__getaryconstruct();
   if (n) {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::TNeuron[n];
     } else {
       p = new((void*) gvp) TMVA::TNeuron[n];
     }
   } else {
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMVA::TNeuron;
     } else {
       p = new((void*) gvp) TMVA::TNeuron;
     }
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

static int G__G__TMVA4_143_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const TMVA::MsgLogger*) G__getstructoffset())->GetSource();
         pobj = new string(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__TMVA4_143_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const TMVA::MsgLogger*) G__getstructoffset())->GetPrintedSource();
         pobj = new string(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__TMVA4_143_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string* pobj;
         const string xobj = ((const TMVA::MsgLogger*) G__getstructoffset())->GetFormattedSource();
         pobj = new string(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__TMVA4_143_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) TMVA::MsgLogger::GetMaxSourceSize());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA4_143_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::MsgLogger& obj = ((TMVA::MsgLogger*) G__getstructoffset())->operator=(*(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__TMVA4_143_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::MsgLogger& obj = TMVA::MsgLogger::Endmsg(*(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__TMVA4_143_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TMVA::MsgLogger& obj = ((TMVA::MsgLogger*) G__getstructoffset())->operator<<((std::ios& (*)(std::ios&) ) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

static int G__G__TMVA4_145_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         TString* pobj;
         TString xobj = ((TMVA::TActivation*) G__getstructoffset())->GetExpression();
         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__TMVA4_145_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::TActivation*) G__getstructoffset())->MakeFunction(*(ostream*) libp->para[0].ref, *(TString*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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


/* TMVA::TNeuronInput */
static int G__G__TMVA4_163_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMVA::TNeuronInput*) G__getstructoffset())->GetInput((TMVA::TNeuron*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__TMVA4_359_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TMVA::VariableTransformBase*) G__getstructoffset())->PrepareTransformation(*(vector<TMVA::Event*,allocator<TMVA::Event*> >*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

static int G__G__TMVA4_359_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      G__letint(result7, 103, (long) ((const TMVA::VariableTransformBase*) G__getstructoffset())->GetInput((TMVA::Event*) G__int(libp->para[0]), *(vector<Float_t>*) libp->para[1].ref
, *(vector<Char_t>*) libp->para[2].ref, (Bool_t) G__int(libp->para[3])));
      break;
   case 3:
      G__letint(result7, 103, (long) ((const TMVA::VariableTransformBase*) G__getstructoffset())->GetInput((TMVA::Event*) G__int(libp->para[0]), *(vector<Float_t>*) libp->para[1].ref
, *(vector<Char_t>*) libp->para[2].ref));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA4_359_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      ((const TMVA::VariableTransformBase*) G__getstructoffset())->SetOutput((TMVA::Event*) G__int(libp->para[0]), *(vector<Float_t>*) libp->para[1].ref
, *(vector<Char_t>*) libp->para[2].ref, (TMVA::Event*) G__int(libp->para[3])
, (Bool_t) G__int(libp->para[4]));
      G__setnull(result7);
      break;
   case 4:
      ((const TMVA::VariableTransformBase*) G__getstructoffset())->SetOutput((TMVA::Event*) G__int(libp->para[0]), *(vector<Float_t>*) libp->para[1].ref
, *(vector<Char_t>*) libp->para[2].ref, (TMVA::Event*) G__int(libp->para[3]));
      G__setnull(result7);
      break;
   case 3:
      ((const TMVA::VariableTransformBase*) G__getstructoffset())->SetOutput((TMVA::Event*) G__int(libp->para[0]), *(vector<Float_t>*) libp->para[1].ref
, *(vector<Char_t>*) libp->para[2].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA4_359_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TMVA::VariableTransformBase*) G__getstructoffset())->CountVariableTypes(*(UInt_t*) G__UIntref(&libp->para[0]), *(UInt_t*) G__UIntref(&libp->para[1])
, *(UInt_t*) G__UIntref(&libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__TMVA4_359_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TMVA::VariableTransformBase*) G__getstructoffset())->GetShortName();
         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__TMVA4_359_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TMVA::VariableTransformBase*) G__getstructoffset())->WriteTransformationToStream(*(ostream*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

static int G__G__TMVA4_359_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::VariableTransformBase*) G__getstructoffset())->MakeFunction(*(ostream*) libp->para[0].ref, *(TString*) libp->para[1].ref
, (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3])
, (Int_t) G__int(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__TMVA4_390_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::RuleFit*) G__getstructoffset())->FillVisHistCut((TMVA::Rule*) G__int(libp->para[0]), *(vector<TH2F*>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA4_390_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::RuleFit*) G__getstructoffset())->FillVisHistCorr((TMVA::Rule*) G__int(libp->para[0]), *(vector<TH2F*>*) libp->para[1].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__TMVA4_390_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::RuleFit*) G__getstructoffset())->FillCut((TH2F*) G__int(libp->para[0]), (TMVA::Rule*) G__int(libp->para[1])
, (Int_t) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

static int G__G__TMVA4_390_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMVA::RuleFit*) G__getstructoffset())->GetRndmSampleEvents(*(vector<const TMVA::Event*>*) libp->para[0].ref, (UInt_t) G__int(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

static int G__G__TMVA4_435_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((TMVA::IMethod*) G__getstructoffset())->HasAnalysisType((TMVA::Types::EAnalysisType) G__int(libp->para[0]), (UInt_t) G__int(libp->para[1])
, (UInt_t) G__int(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* TMVA */

/* TMVA::TNeuron */

/* TMVA::MsgLogger */

/* TMVA::TSynapse */

/* TMVA::TActivation */

/* TMVA::Types */

/* TMVA::TNeuronInput */

/* TMVA::TActivationChooser */

/* TMVA::TActivationSigmoid */

/* TMVA::TActivationIdentity */

/* TMVA::TActivationTanh */

/* TMVA::TActivationRadial */

/* TMVA::TNeuronInputSum */

/* TMVA::TNeuronInputSqSum */

/* TMVA::TNeuronInputAbs */

/* TMVA::TNeuronInputChooser */

/* TMVA::Ranking */

/* TMVA::VariableTransformBase */

/* TMVA::RuleFit */

/* TMVA::RuleFitAPI */

/* TMVA::IMethod */

/* TMVA::VariableIdentityTransform */

/* TMVA::VariableDecorrTransform */

/* TMVA::VariablePCATransform */

/* TMVA::VariableGaussTransform */

/* TMVA::VariableNormalizeTransform */

/* TMVA::VariableRearrangeTransform */

/* TMVA::ROCCalc */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__TMVA4 {
 public:
  G__Sizep2memfuncG__TMVA4(): p(&G__Sizep2memfuncG__TMVA4::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__TMVA4::*p)();
};

size_t G__get_sizep2memfuncG__TMVA4()
{
  G__Sizep2memfuncG__TMVA4 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_TMVAcLcLMsgLogger_basic_ioslEcharcOchar_traitslEchargRsPgR_2(long pobject) {
  TMVA::MsgLogger *G__Lderived=(TMVA::MsgLogger*)pobject;
  basic_ios<char,char_traits<char> > *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}

static long G__2vbo_TMVAcLcLMsgLogger_ios_base_3(long pobject) {
  TMVA::MsgLogger *G__Lderived=(TMVA::MsgLogger*)pobject;
  ios_base *G__Lbase=G__Lderived;
  return((long)G__Lbase-(long)G__Lderived);
}


/*********************************************************
* Inheritance information setup/
*********************************************************/
extern "C" void G__cpp_setup_inheritanceG__TMVA4() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron))) {
     TMVA::TNeuron *G__Lderived;
     G__Lderived=(TMVA::TNeuron*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron),G__get_linked_tagnum(&G__G__TMVA4LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger))) {
     TMVA::MsgLogger *G__Lderived;
     G__Lderived=(TMVA::MsgLogger*)0x1000;
     {
       basic_ostringstream<char,char_traits<char>,allocator<char> > *G__Lpbase=(basic_ostringstream<char,char_traits<char>,allocator<char> >*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),G__get_linked_tagnum(&G__G__TMVA4LN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       basic_ostream<char,char_traits<char> > *G__Lpbase=(basic_ostream<char,char_traits<char> >*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),G__get_linked_tagnum(&G__G__TMVA4LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),G__get_linked_tagnum(&G__G__TMVA4LN_basic_ioslEcharcOchar_traitslEchargRsPgR),(long)G__2vbo_TMVAcLcLMsgLogger_basic_ioslEcharcOchar_traitslEchargRsPgR_2,1,2);
     }
     {
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),G__get_linked_tagnum(&G__G__TMVA4LN_ios_base),(long)G__2vbo_TMVAcLcLMsgLogger_ios_base_3,1,6);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),G__get_linked_tagnum(&G__G__TMVA4LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTSynapse))) {
     TMVA::TSynapse *G__Lderived;
     G__Lderived=(TMVA::TSynapse*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTSynapse),G__get_linked_tagnum(&G__G__TMVA4LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationSigmoid))) {
     TMVA::TActivationSigmoid *G__Lderived;
     G__Lderived=(TMVA::TActivationSigmoid*)0x1000;
     {
       TMVA::TActivation *G__Lpbase=(TMVA::TActivation*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationSigmoid),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivation),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationIdentity))) {
     TMVA::TActivationIdentity *G__Lderived;
     G__Lderived=(TMVA::TActivationIdentity*)0x1000;
     {
       TMVA::TActivation *G__Lpbase=(TMVA::TActivation*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationIdentity),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivation),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationTanh))) {
     TMVA::TActivationTanh *G__Lderived;
     G__Lderived=(TMVA::TActivationTanh*)0x1000;
     {
       TMVA::TActivation *G__Lpbase=(TMVA::TActivation*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationTanh),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivation),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationRadial))) {
     TMVA::TActivationRadial *G__Lderived;
     G__Lderived=(TMVA::TActivationRadial*)0x1000;
     {
       TMVA::TActivation *G__Lpbase=(TMVA::TActivation*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationRadial),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivation),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSum))) {
     TMVA::TNeuronInputSum *G__Lderived;
     G__Lderived=(TMVA::TNeuronInputSum*)0x1000;
     {
       TMVA::TNeuronInput *G__Lpbase=(TMVA::TNeuronInput*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSum),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInput),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum))) {
     TMVA::TNeuronInputSqSum *G__Lderived;
     G__Lderived=(TMVA::TNeuronInputSqSum*)0x1000;
     {
       TMVA::TNeuronInput *G__Lpbase=(TMVA::TNeuronInput*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInput),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs))) {
     TMVA::TNeuronInputAbs *G__Lderived;
     G__Lderived=(TMVA::TNeuronInputAbs*)0x1000;
     {
       TMVA::TNeuronInput *G__Lpbase=(TMVA::TNeuronInput*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInput),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase))) {
     TMVA::VariableTransformBase *G__Lderived;
     G__Lderived=(TMVA::VariableTransformBase*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase),G__get_linked_tagnum(&G__G__TMVA4LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform))) {
     TMVA::VariableIdentityTransform *G__Lderived;
     G__Lderived=(TMVA::VariableIdentityTransform*)0x1000;
     {
       TMVA::VariableTransformBase *G__Lpbase=(TMVA::VariableTransformBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform),G__get_linked_tagnum(&G__G__TMVA4LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform))) {
     TMVA::VariableDecorrTransform *G__Lderived;
     G__Lderived=(TMVA::VariableDecorrTransform*)0x1000;
     {
       TMVA::VariableTransformBase *G__Lpbase=(TMVA::VariableTransformBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform),G__get_linked_tagnum(&G__G__TMVA4LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariablePCATransform))) {
     TMVA::VariablePCATransform *G__Lderived;
     G__Lderived=(TMVA::VariablePCATransform*)0x1000;
     {
       TMVA::VariableTransformBase *G__Lpbase=(TMVA::VariableTransformBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariablePCATransform),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariablePCATransform),G__get_linked_tagnum(&G__G__TMVA4LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableGaussTransform))) {
     TMVA::VariableGaussTransform *G__Lderived;
     G__Lderived=(TMVA::VariableGaussTransform*)0x1000;
     {
       TMVA::VariableTransformBase *G__Lpbase=(TMVA::VariableTransformBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableGaussTransform),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableGaussTransform),G__get_linked_tagnum(&G__G__TMVA4LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform))) {
     TMVA::VariableNormalizeTransform *G__Lderived;
     G__Lderived=(TMVA::VariableNormalizeTransform*)0x1000;
     {
       TMVA::VariableTransformBase *G__Lpbase=(TMVA::VariableTransformBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform),G__get_linked_tagnum(&G__G__TMVA4LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableRearrangeTransform))) {
     TMVA::VariableRearrangeTransform *G__Lderived;
     G__Lderived=(TMVA::VariableRearrangeTransform*)0x1000;
     {
       TMVA::VariableTransformBase *G__Lpbase=(TMVA::VariableTransformBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableRearrangeTransform),G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableRearrangeTransform),G__get_linked_tagnum(&G__G__TMVA4LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__TMVA4() {

   /* Setting up typedef entry */
   G__search_typename2("Int_t",105,-1,0,-1);
   G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
   G__search_typename2("UInt_t",104,-1,0,-1);
   G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
   G__search_typename2("Double_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes",0);
   G__search_typename2("Bool_t",103,-1,0,-1);
   G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4LN_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__TMVA4LN_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__TMVA4LN_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__TMVA4LN_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__TMVA4LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMVAVersion_t",104,-1,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVA));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TString,TMVA::Types::EMVA>",117,G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::Rank>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTBaselEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTBaselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<float>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEdoublecOallocatorlEdoublegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEdoublecOallocatorlEdoublegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<double>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const TMVA::BinarySearchTreeNode*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::Event*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Int_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEintcOallocatorlEintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Double_t,const TMVA::Event*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4LN_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__TMVA4LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<double,const TMVA::Event*> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<std::string,TObjArray*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<string,TObjArray*,less<string> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Float_t*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<float*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<VariableInfo>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::VariableInfo>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<ClassInfo*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::ClassInfo*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const TMVA::Event*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const TMVA::Node*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Char_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEcharcOallocatorlEchargRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEcharcOallocatorlEchargRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEcharcOallocatorlEchargRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<char>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEcharcOallocatorlEchargRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const TMVA::DecisionTree*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::Rule*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TH1F*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<UInt_t> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<UInt_t> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<unsigned int,allocator<unsigned int> > >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<Double_t> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<Double_t> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<double,allocator<double> > >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TH2F*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETH2FmUcOallocatorlETH2FmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETH2FmUcOallocatorlETH2FmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETH2FmUcOallocatorlETH2FmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETH2FmUcOallocatorlETH2FmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETH2FmUcOallocatorlETH2FmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("std::ios& (*)(std::ios&) ",49,-1,0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<EMsgType,std::string>",117,G__get_linked_tagnum(&G__G__TMVA4LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("map<TMVA::EMsgType,string>",117,G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("IntParms",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLIntParms),0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPI));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("RealParms",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLRealParms),0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPI));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("pair<Char_t,UInt_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_pairlEcharcOunsignedsPintgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::pair<Char_t,UInt_t> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<Char_t,UInt_t> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<char,unsigned int> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("VectorOfCharAndInt",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ItVarTypeIdx",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ItVarTypeIdxConst",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgRcLcLiterator),0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<Event*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<const Event*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSym<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTSymlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMatrixD*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMatrixT<double>*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMatrixDSym*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMatrixTSym<double>*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTRow_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTColumn_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTDiag_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTFlat_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTSub_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTSparseRow_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTSparseDiag_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTRowlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTColumnlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTDiaglEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTFlatlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTSublEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTSparseRowlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTSparseDiaglEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementActionT<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TElementActionTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementPosActionT<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TElementPosActionTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparse<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMatrixTSparselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVectorD*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVectorT<double>*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Option<Bool_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLOptionlEboolgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVA));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<bool>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEboolcOallocatorlEboolgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEboolcOallocatorlEboolgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Option<Bool_t*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLOptionlEboolmUgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVA));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("Option<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLOptionlEfloatgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVA));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<TH1F*> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<TH1F*> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<TH1F*,allocator<TH1F*> > >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<PDF*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TMVA::PDF*>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<PDF*> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<PDF*> >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<TMVA::PDF*,allocator<TMVA::PDF*> > >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("FloatVector",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<FloatVector>",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<float,allocator<float> > >",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("VectorOfFloatVectors",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("FloatVector",117,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableRearrangeTransform));
   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__TMVA4LN_TMVA));
   {
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4LN_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__TMVA4LN_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__TMVA4LN_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__TMVA4LN_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__TMVA4LN_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__TMVA4LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kSILENT=%lldLL",(long long)TMVA::kSILENT).data(),0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::TNeuron */
static void G__setup_memvarTMVAcLcLTNeuron(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron));
   { TMVA::TNeuron *p; p=(TMVA::TNeuron*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TObjArray),-1,-1,4,"fLinksIn=",0,"array of input synapses");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TObjArray),-1,-1,4,"fLinksOut=",0,"array of output synapses");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fValue=",0,"input value");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fActivationValue=",0,"activation/output value");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDelta=",0,"error field of neuron");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDEDw=",0,"sum of all deltas");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fError=",0,"error, only set for output neurons");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fForcedValue=",0,"flag for forced input value");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivation),-1,-1,4,"fActivation=",0,"activation equation");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInput),-1,-1,4,"fInputCalculator=",0,"input calculator");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),-1,-2,4,"fgLogger=",0,"! message logger, static to save resources");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::MsgLogger */
static void G__setup_memvarTMVAcLcLMsgLogger(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger));
   { TMVA::MsgLogger *p; p=(TMVA::MsgLogger*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TObject),-1,-1,4,"fObjSource=",0,"the source TObject (used for name)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_string),-1,-1,4,"fStrSource=",0,"alternative string source");
   G__memvar_setup((void*)0,117,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_string),-1,-2,4,"fgPrefix=",0,"the prefix of the source name");
   G__memvar_setup((void*)0,117,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_string),-1,-2,4,"fgSuffix=",0,"suffix following source name");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEMsgType),-1,-1,4,"fActiveType=",0,"active type");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-2,4,"fgMaxSourceSize=",0,"maximum length of source name");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgOutputSupressed=",0,"disable the output globaly (used by generic booster)");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-2,4,"fgInhibitOutput=",0,"flag to suppress all output");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fgInstanceCounter=",0,"counts open MsgLogger instances");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR),G__defined_typename("map<EMsgType,std::string>"),-2,4,"fgTypeMap=",0,"matches output types with strings");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR),G__defined_typename("map<EMsgType,std::string>"),-2,4,"fgColorMap=",0,"matches output types with terminal colors");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEMsgType),-1,-1,4,"fMinType=",0,"minimum type for output");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::TSynapse */
static void G__setup_memvarTMVAcLcLTSynapse(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTSynapse));
   { TMVA::TSynapse *p; p=(TMVA::TSynapse*)0x1000; if (p) { }
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fWeight=",0,"weight of the synapse");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLearnRate=",0,"learning rate parameter");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDelta=",0,"local error field");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDEDw=",0,"sum of deltas");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCount=",0,"number of updates contributing to error field");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron),-1,-1,4,"fPreNeuron=",0,"pointer to pre-neuron");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron),-1,-1,4,"fPostNeuron=",0,"pointer to post-neuron");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),-1,-2,4,"fgLogger=",0,"! message logger, static to save resources");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::TActivation */
static void G__setup_memvarTMVAcLcLTActivation(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivation));
   { TMVA::TActivation *p; p=(TMVA::TActivation*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::Types */
static void G__setup_memvarTMVAcLcLTypes(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypes));
   { TMVA::Types *p; p=(TMVA::Types*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kVariable=%lldLL",(long long)TMVA::Types::kVariable).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kCuts=%lldLL",(long long)TMVA::Types::kCuts).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kLikelihood=%lldLL",(long long)TMVA::Types::kLikelihood).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kPDERS=%lldLL",(long long)TMVA::Types::kPDERS).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kHMatrix=%lldLL",(long long)TMVA::Types::kHMatrix).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kFisher=%lldLL",(long long)TMVA::Types::kFisher).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kKNN=%lldLL",(long long)TMVA::Types::kKNN).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kCFMlpANN=%lldLL",(long long)TMVA::Types::kCFMlpANN).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kTMlpANN=%lldLL",(long long)TMVA::Types::kTMlpANN).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kBDT=%lldLL",(long long)TMVA::Types::kBDT).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kDT=%lldLL",(long long)TMVA::Types::kDT).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kRuleFit=%lldLL",(long long)TMVA::Types::kRuleFit).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kSVM=%lldLL",(long long)TMVA::Types::kSVM).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kMLP=%lldLL",(long long)TMVA::Types::kMLP).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kBayesClassifier=%lldLL",(long long)TMVA::Types::kBayesClassifier).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kFDA=%lldLL",(long long)TMVA::Types::kFDA).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kBoost=%lldLL",(long long)TMVA::Types::kBoost).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kPDEFoam=%lldLL",(long long)TMVA::Types::kPDEFoam).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kLD=%lldLL",(long long)TMVA::Types::kLD).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kPlugins=%lldLL",(long long)TMVA::Types::kPlugins).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kCategory=%lldLL",(long long)TMVA::Types::kCategory).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA),-1,-2,1,G__FastAllocString(2048).Format("kMaxMethod=%lldLL",(long long)TMVA::Types::kMaxMethod).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform),-1,-2,1,G__FastAllocString(2048).Format("kIdentity=%lldLL",(long long)TMVA::Types::kIdentity).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform),-1,-2,1,G__FastAllocString(2048).Format("kDecorrelated=%lldLL",(long long)TMVA::Types::kDecorrelated).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform),-1,-2,1,G__FastAllocString(2048).Format("kNormalized=%lldLL",(long long)TMVA::Types::kNormalized).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform),-1,-2,1,G__FastAllocString(2048).Format("kPCA=%lldLL",(long long)TMVA::Types::kPCA).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform),-1,-2,1,G__FastAllocString(2048).Format("kRearranged=%lldLL",(long long)TMVA::Types::kRearranged).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform),-1,-2,1,G__FastAllocString(2048).Format("kGauss=%lldLL",(long long)TMVA::Types::kGauss).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform),-1,-2,1,G__FastAllocString(2048).Format("kUniform=%lldLL",(long long)TMVA::Types::kUniform).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform),-1,-2,1,G__FastAllocString(2048).Format("kMaxVariableTransform=%lldLL",(long long)TMVA::Types::kMaxVariableTransform).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEAnalysisType),-1,-2,1,G__FastAllocString(2048).Format("kClassification=%lldLL",(long long)TMVA::Types::kClassification).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEAnalysisType),-1,-2,1,G__FastAllocString(2048).Format("kRegression=%lldLL",(long long)TMVA::Types::kRegression).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEAnalysisType),-1,-2,1,G__FastAllocString(2048).Format("kMulticlass=%lldLL",(long long)TMVA::Types::kMulticlass).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEAnalysisType),-1,-2,1,G__FastAllocString(2048).Format("kNoAnalysisType=%lldLL",(long long)TMVA::Types::kNoAnalysisType).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEAnalysisType),-1,-2,1,G__FastAllocString(2048).Format("kMaxAnalysisType=%lldLL",(long long)TMVA::Types::kMaxAnalysisType).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLESBType),-1,-2,1,G__FastAllocString(2048).Format("kSignal=%lldLL",(long long)TMVA::Types::kSignal).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLESBType),-1,-2,1,G__FastAllocString(2048).Format("kBackground=%lldLL",(long long)TMVA::Types::kBackground).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLESBType),-1,-2,1,G__FastAllocString(2048).Format("kSBBoth=%lldLL",(long long)TMVA::Types::kSBBoth).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLESBType),-1,-2,1,G__FastAllocString(2048).Format("kMaxSBType=%lldLL",(long long)TMVA::Types::kMaxSBType).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLESBType),-1,-2,1,G__FastAllocString(2048).Format("kTrueType=%lldLL",(long long)TMVA::Types::kTrueType).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLETreeType),-1,-2,1,G__FastAllocString(2048).Format("kTraining=%lldLL",(long long)TMVA::Types::kTraining).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLETreeType),-1,-2,1,G__FastAllocString(2048).Format("kTesting=%lldLL",(long long)TMVA::Types::kTesting).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLETreeType),-1,-2,1,G__FastAllocString(2048).Format("kMaxTreeType=%lldLL",(long long)TMVA::Types::kMaxTreeType).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLETreeType),-1,-2,1,G__FastAllocString(2048).Format("kValidation=%lldLL",(long long)TMVA::Types::kValidation).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLETreeType),-1,-2,1,G__FastAllocString(2048).Format("kTrainingOriginal=%lldLL",(long long)TMVA::Types::kTrainingOriginal).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEBoostStage),-1,-2,1,G__FastAllocString(2048).Format("kBoostProcBegin=%lldLL",(long long)TMVA::Types::kBoostProcBegin).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEBoostStage),-1,-2,1,G__FastAllocString(2048).Format("kBeforeTraining=%lldLL",(long long)TMVA::Types::kBeforeTraining).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEBoostStage),-1,-2,1,G__FastAllocString(2048).Format("kBeforeBoosting=%lldLL",(long long)TMVA::Types::kBeforeBoosting).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEBoostStage),-1,-2,1,G__FastAllocString(2048).Format("kAfterBoosting=%lldLL",(long long)TMVA::Types::kAfterBoosting).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEBoostStage),-1,-2,1,G__FastAllocString(2048).Format("kBoostProcEnd=%lldLL",(long long)TMVA::Types::kBoostProcEnd).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypes),-1,-2,4,"fgTypesPtr=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR),G__defined_typename("map<TString,TMVA::Types::EMVA>"),-1,4,"fStr2type=",0,"types-to-text map");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"message logger");
   }
   G__tag_memvar_reset();
}


   /* TMVA::TNeuronInput */
static void G__setup_memvarTMVAcLcLTNeuronInput(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInput));
   { TMVA::TNeuronInput *p; p=(TMVA::TNeuronInput*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::TActivationChooser */
static void G__setup_memvarTMVAcLcLTActivationChooser(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationChooser));
   { TMVA::TActivationChooser *p; p=(TMVA::TActivationChooser*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationChoosercLcLEActivationType),-1,-2,1,G__FastAllocString(2048).Format("kLinear=%lldLL",(long long)TMVA::TActivationChooser::kLinear).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationChoosercLcLEActivationType),-1,-2,1,G__FastAllocString(2048).Format("kSigmoid=%lldLL",(long long)TMVA::TActivationChooser::kSigmoid).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationChoosercLcLEActivationType),-1,-2,1,G__FastAllocString(2048).Format("kTanh=%lldLL",(long long)TMVA::TActivationChooser::kTanh).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationChoosercLcLEActivationType),-1,-2,1,G__FastAllocString(2048).Format("kRadial=%lldLL",(long long)TMVA::TActivationChooser::kRadial).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fLINEAR=",0,"activation function name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fSIGMOID=",0,"activation function name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fTANH=",0,"activation function name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fRADIAL=",0,"activation function name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"! message logger");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::TActivationSigmoid */
static void G__setup_memvarTMVAcLcLTActivationSigmoid(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationSigmoid));
   { TMVA::TActivationSigmoid *p; p=(TMVA::TActivationSigmoid*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TFormula),-1,-1,4,"fEqn=",0,"equation of sigmoid");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TFormula),-1,-1,4,"fEqnDerivative=",0,"equation of sigmoid derivative");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::TActivationIdentity */
static void G__setup_memvarTMVAcLcLTActivationIdentity(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationIdentity));
   { TMVA::TActivationIdentity *p; p=(TMVA::TActivationIdentity*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::TActivationTanh */
static void G__setup_memvarTMVAcLcLTActivationTanh(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationTanh));
   { TMVA::TActivationTanh *p; p=(TMVA::TActivationTanh*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TFormula),-1,-1,4,"fEqn=",0,"equation of tanh sigmoid");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TFormula),-1,-1,4,"fEqnDerivative=",0,"equation of tanh sigmoid derivative");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::TActivationRadial */
static void G__setup_memvarTMVAcLcLTActivationRadial(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationRadial));
   { TMVA::TActivationRadial *p; p=(TMVA::TActivationRadial*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TFormula),-1,-1,4,"fEqn=",0,"equation of radial basis function");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TFormula),-1,-1,4,"fEqnDerivative=",0,"equation of derivative");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::TNeuronInputSum */
static void G__setup_memvarTMVAcLcLTNeuronInputSum(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSum));
   { TMVA::TNeuronInputSum *p; p=(TMVA::TNeuronInputSum*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::TNeuronInputSqSum */
static void G__setup_memvarTMVAcLcLTNeuronInputSqSum(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum));
   { TMVA::TNeuronInputSqSum *p; p=(TMVA::TNeuronInputSqSum*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::TNeuronInputAbs */
static void G__setup_memvarTMVAcLcLTNeuronInputAbs(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs));
   { TMVA::TNeuronInputAbs *p; p=(TMVA::TNeuronInputAbs*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::TNeuronInputChooser */
static void G__setup_memvarTMVAcLcLTNeuronInputChooser(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChooser));
   { TMVA::TNeuronInputChooser *p; p=(TMVA::TNeuronInputChooser*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChoosercLcLENeuronInputType),-1,-2,1,G__FastAllocString(2048).Format("kSum=%lldLL",(long long)TMVA::TNeuronInputChooser::kSum).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChoosercLcLENeuronInputType),-1,-2,1,G__FastAllocString(2048).Format("kSqSum=%lldLL",(long long)TMVA::TNeuronInputChooser::kSqSum).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChoosercLcLENeuronInputType),-1,-2,1,G__FastAllocString(2048).Format("kAbsSum=%lldLL",(long long)TMVA::TNeuronInputChooser::kAbsSum).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fSUM=",0,"neuron input type name ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fSQSUM=",0,"neuron input type name ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fABSSUM=",0,"neuron input type name ");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::Ranking */
static void G__setup_memvarTMVAcLcLRanking(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRanking));
   { TMVA::Ranking *p; p=(TMVA::Ranking*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgR),G__defined_typename("vector<TMVA::Rank>"),-1,4,"fRanking=",0,"vector of ranks");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fContext=",0,"the ranking context");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fRankingDiscriminatorName=",0,"the name of the ranking discriminator");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"! message logger");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::VariableTransformBase */
static void G__setup_memvarTMVAcLcLVariableTransformBase(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase));
   { TMVA::VariableTransformBase *p; p=(TMVA::VariableTransformBase*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,1,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLDataSetInfo),-1,-1,2,"fDsi=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLDataSetInfo),-1,-1,2,"fDsiOutput=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent),-1,-1,2,"fTransformedEvent=",0,"holds the current transformed event");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent),-1,-1,2,"fBackTransformedEvent=",0,"holds the current back-transformed event");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgR),G__defined_typename("VectorOfCharAndInt"),-1,2,"fGet=",0,"get variables/targets/spectators");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgR),G__defined_typename("VectorOfCharAndInt"),-1,2,"fPut=",0,"put variables/targets/spectators");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform),-1,-1,4,"fVariableTransform=",0,"Decorrelation, PCA, etc.");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseSignalTransform=",0,"true if transformation bases on signal data");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fEnabled=",0,"has been enabled");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fCreated=",0,"has been created");
   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,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNVars=",0,"number of variables");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fTransformName=",0,"name of transformation");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR),G__defined_typename("vector<TMVA::VariableInfo>"),-1,4,"fVariables=",0,"event variables [saved to weight file]");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR),G__defined_typename("vector<TMVA::VariableInfo>"),-1,4,"fTargets=",0,"event targets [saved to weight file --> TODO ]");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR),G__defined_typename("vector<TMVA::VariableInfo>"),-1,4,"fSpectators=",0,"event spectators [saved to weight file --> TODO ]");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fVariableTypesAreCounted=",0,"true if variable types have been counted already");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNVariables=",0,"number of variables to be transformed");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNTargets=",0,"number of targets to be transformed");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNSpectators=",0,"number of spectators to be transformed");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSortGet=",0,"if true, sort the variables into the order as defined by the user at the var definition");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("TMVAVersion_t"),-1,2,"fTMVAVersion=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),-1,-1,2,"fLogger=",0,"! message logger");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::RuleFit */
static void G__setup_memvarTMVAcLcLRuleFit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFit));
   { TMVA::RuleFit *p; p=(TMVA::RuleFit*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR),G__defined_typename("vector<const TMVA::Event*>"),-1,4,"fTrainingEvents=",0,"all training events");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR),G__defined_typename("vector<const TMVA::Event*>"),-1,4,"fTrainingEventsRndm=",0,"idem, but randomly shuffled");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fEventWeights=",0,"original weights of the events - follows fTrainingEvents");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNTreeSample=",0,"number of events in sub sample = frac*neve");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNEveEffTrain=",0,"reweighted number of events = sum(wi)");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR),G__defined_typename("vector<const TMVA::DecisionTree*>"),-1,4,"fForest=",0,"the input forest of decision trees");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleEnsemble),-1,-1,4,"fRuleEnsemble=",0,"the ensemble of rules");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitParams),-1,-1,4,"fRuleFitParams=",0,"fit rule parameters");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMethodRuleFit),-1,-1,4,"fMethodRuleFit=",0,"pointer the method which initialized this RuleFit instance");
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMethodBase),-1,-1,4,"fMethodBase=",0,"pointer the method base which initialized this RuleFit instance");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fVisHistsUseImp=",0,"if true, use importance as weight; else coef in vis hists");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"message logger");
   G__memvar_setup((void*)G__PVOID,105,0,1,-1,G__defined_typename("Int_t"),-2,4,"randSEED=0LL",0,"set to 1 for debugging purposes or to zero for random seeds");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::RuleFitAPI */
static void G__setup_memvarTMVAcLcLRuleFitAPI(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPI));
   { TMVA::RuleFitAPI *p; p=(TMVA::RuleFitAPI*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFMode),-1,-2,2,"kRfRegress=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFMode),-1,-2,2,"kRfClass=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLEModel),-1,-2,2,"kRfLinear=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLEModel),-1,-2,2,"kRfRules=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLEModel),-1,-2,2,"kRfBoth=2LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFProgram),-1,-2,2,"kRfTrain=0LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFProgram),-1,-2,2,"kRfPredict=1LL",0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFProgram),-1,-2,2,"kRfVarimp=2LL",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMethodRuleFit),-1,-1,4,"fMethodRuleFit=",0,"parent method - set in constructor");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFit),-1,-1,4,"fRuleFit=",0,"non const ptr to RuleFit class in MethodRuleFit");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fRFYhat=",0,"score results from test sample");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fRFVarImp=",0,"variable importances");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<Int_t>"),-1,4,"fRFVarImpInd=",0,"variable index");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fRFWorkDir=",0,"working directory");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLIntParms),G__defined_typename("IntParms"),-1,4,"fRFIntParms=",0,"integer parameters");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLRealParms),G__defined_typename("RealParms"),-1,4,"fRFRealParms=",0,"real parameters");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEintcOallocatorlEintgRsPgR),G__defined_typename("vector<int>"),-1,4,"fRFLx=",0,"variable selector");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFProgram),-1,-1,4,"fRFProgram=",0,"what to run");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fModelType=",0,"model type string");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"message logger");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::IMethod */
static void G__setup_memvarTMVAcLcLIMethod(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLIMethod));
   { TMVA::IMethod *p; p=(TMVA::IMethod*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::VariableIdentityTransform */
static void G__setup_memvarTMVAcLcLVariableIdentityTransform(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform));
   { TMVA::VariableIdentityTransform *p; p=(TMVA::VariableIdentityTransform*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::VariableDecorrTransform */
static void G__setup_memvarTMVAcLcLVariableDecorrTransform(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform));
   { TMVA::VariableDecorrTransform *p; p=(TMVA::VariableDecorrTransform*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgR),G__defined_typename("vector<TMatrixD*>"),-1,4,"fDecorrMatrices=",0,"! Decorrelation matrix [class0/class1/.../all classes]");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::VariablePCATransform */
static void G__setup_memvarTMVAcLcLVariablePCATransform(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariablePCATransform));
   { TMVA::VariablePCATransform *p; p=(TMVA::VariablePCATransform*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgR),G__defined_typename("vector<TVectorD*>"),-1,4,"fMeanValues=",0,"mean values");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgR),G__defined_typename("vector<TMatrixD*>"),-1,4,"fEigenVectors=",0,"eigenvectors");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::VariableGaussTransform */
static void G__setup_memvarTMVAcLcLVariableGaussTransform(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableGaussTransform));
   { TMVA::VariableGaussTransform *p; p=(TMVA::VariableGaussTransform*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fFlatNotGauss=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPdfMinSmooth=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPdfMaxSmooth=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgR),G__defined_typename("vector<std::vector<TH1F*> >"),-1,4,"fCumulativeDist=",0,"! The Cummulative distributions ");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgR),G__defined_typename("vector<std::vector<PDF*> >"),-1,4,"fCumulativePDF=",0,"The cumulative PDF");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fElementsperbin=",0,"av number of events stored per bin in cum dist");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::VariableNormalizeTransform */
static void G__setup_memvarTMVAcLcLVariableNormalizeTransform(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform));
   { TMVA::VariableNormalizeTransform *p; p=(TMVA::VariableNormalizeTransform*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),G__defined_typename("VectorOfFloatVectors"),-1,4,"fMin=",0,"! Min of source range");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),G__defined_typename("VectorOfFloatVectors"),-1,4,"fMax=",0,"! Max of source range");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::VariableRearrangeTransform */
static void G__setup_memvarTMVAcLcLVariableRearrangeTransform(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableRearrangeTransform));
   { TMVA::VariableRearrangeTransform *p; p=(TMVA::VariableRearrangeTransform*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TClass),G__defined_typename("atomic_TClass_ptr"),-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMVA::ROCCalc */
static void G__setup_memvarTMVAcLcLROCCalc(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLROCCalc));
   { TMVA::ROCCalc *p; p=(TMVA::ROCCalc*)0x1000; if (p) { }
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMaxIter=",0,"maximum number of iterations");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAbsTol=",0,"absolute tolerance deviation");
   G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNbins=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseSplines=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TH1),-1,-1,4,"fmvaS=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TH1),-1,-1,4,"fmvaB=",0,"the input mva distributions");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TH1),-1,-1,4,"fmvaSpdf=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TH1),-1,-1,4,"fmvaBpdf=",0,"the normalized (and rebinned) input mva distributions");
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fXmin=",0,(char*)NULL);
   G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fXmax=",0,"min and max of the mva distribution  ");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNevtS=",0,"number of signal events (used in error calculation)");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCutOrientation=",0,"+1 if larger mva value means more signal like, -1 otherwise");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TSpline),-1,-1,4,"fSplS=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TSpline),-1,-1,4,"fSplB=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TSpline),-1,-1,4,"fSplmvaCumS=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TSpline),-1,-1,4,"fSplmvaCumB=",0,"spline of cumulated mva distributions");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TSpline),-1,-1,4,"fSpleffBvsS=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TH1),-1,-1,4,"fmvaScumul=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TH1),-1,-1,4,"fmvaBcumul=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fnStot=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fnBtot=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TH1),-1,-1,4,"fSignificance=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TH1),-1,-1,4,"fPurity=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSignalCut=",0,"MVA cut value for last demanded background rejection or signal efficiency");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TString),-1,-1,4,"fSuffix=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"! message logger");
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__TMVA4() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTMVA(void) {
   /* TMVA */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVA));
   G__memfunc_setup("operator<<",996,G__G__TMVA4_141_0_1, 117, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_141_0_2, 117, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_141_0_3, 117, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_141_0_4, 117, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_141_0_5, 117, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_141_0_6, 117, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_141_0_7, 117, G__get_linked_tagnum(&G__G__TMVA4LN_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("Endl",387,G__G__TMVA4_141_0_8, 117, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_141_0_9, 117, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_141_0_10, 117, G__get_linked_tagnum(&G__G__TMVA4LN_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_memfuncTMVAcLcLTNeuron(void) {
   /* TMVA::TNeuron */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron));
   G__memfunc_setup("TNeuron",715,G__G__TMVA4_142_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ForceValue",1004,G__G__TMVA4_142_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculateValue",1419,G__G__TMVA4_142_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculateActivationValue",2461,G__G__TMVA4_142_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculateDelta",1400,G__G__TMVA4_142_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetActivationEqn",1634,G__G__TMVA4_142_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::TActivation' - 0 - activation", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInputCalculator",1862,G__G__TMVA4_142_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::TNeuronInput' - 0 - calculator", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPreLink",958,G__G__TMVA4_142_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::TSynapse' - 0 - pre", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPostLink",1085,G__G__TMVA4_142_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::TSynapse' - 0 - post", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeletePreLinks",1403,G__G__TMVA4_142_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetError",822,G__G__TMVA4_142_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - error", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateSynapsesBatch",1947,G__G__TMVA4_142_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateSynapsesSequential",2516,G__G__TMVA4_142_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdjustSynapseWeights",2089,G__G__TMVA4_142_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitSynapseDeltas",1748,G__G__TMVA4_142_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintActivationEqn",1859,G__G__TMVA4_142_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValue",797,G__G__TMVA4_142_0_17, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetActivationValue",1839,G__G__TMVA4_142_0_18, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDelta",778,G__G__TMVA4_142_0_19, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDEDw",612,G__G__TMVA4_142_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NumPreLinks",1112,G__G__TMVA4_142_0_21, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NumPostLinks",1239,G__G__TMVA4_142_0_22, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PreLinkAt",874,G__G__TMVA4_142_0_23, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTSynapse), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PostLinkAt",1001,G__G__TMVA4_142_0_24, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTSynapse), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetInputNeuron",1459,G__G__TMVA4_142_0_25, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOutputNeuron",1588,G__G__TMVA4_142_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetBiasNeuron",1314,G__G__TMVA4_142_0_27, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDEDw",624,G__G__TMVA4_142_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - DEDw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsInputNeuron",1347,G__G__TMVA4_142_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsOutputNeuron",1476,G__G__TMVA4_142_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintPreLinks",1333,G__G__TMVA4_142_0_31, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintPostLinks",1460,G__G__TMVA4_142_0_32, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"\"' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitNeuron",1035,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeleteLinksArray",1619,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TObjArray' - 1 - links", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintLinks",1038,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 8, "U 'TObjArray' - 0 - links", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintMessage",1234,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"i 'TMVA::EMsgType' - 0 - - u 'TString' - 0 - message", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NumLinks",817,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 4, 8, "U 'TObjArray' - 0 - links", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NullifyLinks",1252,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TObjArray' - 1 - links", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA4_142_0_41, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TNeuron::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_142_0_42, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuron::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_142_0_43, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TNeuron::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_142_0_44, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TNeuron::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_142_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__TMVA4_142_0_49, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuron::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_142_0_50, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuron::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_142_0_51, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuron::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_142_0_52, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuron::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TNeuron", 715, G__G__TMVA4_142_0_53, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron), -1, 0, 1, 1, 1, 0, "u 'TMVA::TNeuron' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TNeuron", 841, G__G__TMVA4_142_0_54, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA4_142_0_55, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuron), -1, 1, 1, 1, 1, 0, "u 'TMVA::TNeuron' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLMsgLogger(void) {
   /* TMVA::MsgLogger */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger));
   G__memfunc_setup("MsgLogger",903,G__G__TMVA4_143_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 0, 2, 1, 1, 0, 
"U 'TObject' - 10 - source i 'TMVA::EMsgType' - 0 'kINFO' minType", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MsgLogger",903,G__G__TMVA4_143_0_2, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - source i 'TMVA::EMsgType' - 0 'kINFO' minType", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MsgLogger",903,G__G__TMVA4_143_0_3, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 0, 1, 1, 1, 0, "i 'TMVA::EMsgType' - 0 'kINFO' minType", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MsgLogger",903,G__G__TMVA4_143_0_4, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 0, 1, 1, 1, 0, "u 'TMVA::MsgLogger' - 11 - parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetSource",925,G__G__TMVA4_143_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - source", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMinType",998,G__G__TMVA4_143_0_6, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEMsgType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinType",1010,G__G__TMVA4_143_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TMVA::EMsgType' - 0 - minType", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSource",913,G__G__TMVA4_143_0_8, 117, G__get_linked_tagnum(&G__G__TMVA4LN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPrintedSource",1639,G__G__TMVA4_143_0_9, 117, G__get_linked_tagnum(&G__G__TMVA4LN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFormattedSource",1847,G__G__TMVA4_143_0_10, 117, G__get_linked_tagnum(&G__G__TMVA4LN_string), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMaxSourceSize",1618,G__G__TMVA4_143_0_11, 104, -1, G__defined_typename("UInt_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (UInt_t (*)())(&TMVA::MsgLogger::GetMaxSourceSize) ), 0);
   G__memfunc_setup("operator=",937,G__G__TMVA4_143_0_12, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 1, 1, 1, 0, "u 'TMVA::MsgLogger' - 11 - parent", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Endmsg",606,G__G__TMVA4_143_0_13, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 1, 3, 1, 0, "u 'TMVA::MsgLogger' - 1 - logger", (char*)NULL, (void*) G__func2void( (TMVA::MsgLogger& (*)(TMVA::MsgLogger&))(&TMVA::MsgLogger::Endmsg) ), 0);
   G__memfunc_setup("operator<<",996,G__G__TMVA4_143_0_14, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 1, 1, 1, 0, "1 - 'std::ios& (*)(std::ios&) ' 0 - _f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator<<",996,G__G__TMVA4_143_0_15, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 1, 1, 1, 0, "i 'TMVA::EMsgType' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InhibitOutput",1368,G__G__TMVA4_143_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MsgLogger::InhibitOutput) ), 0);
   G__memfunc_setup("EnableOutput",1240,G__G__TMVA4_143_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MsgLogger::EnableOutput) ), 0);
   G__memfunc_setup("Send",394,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitMaps",805,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteMsg",818,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8, 
"i 'TMVA::EMsgType' - 0 - type u 'string' - 11 - line", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA4_143_0_21, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MsgLogger::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_143_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MsgLogger::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_143_0_23, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MsgLogger::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_143_0_24, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MsgLogger::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_143_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__TMVA4_143_0_29, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MsgLogger::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_143_0_30, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MsgLogger::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_143_0_31, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MsgLogger::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_143_0_32, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MsgLogger::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~MsgLogger", 1029, G__G__TMVA4_143_0_33, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLTSynapse(void) {
   /* TMVA::TSynapse */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTSynapse));
   G__memfunc_setup("TSynapse",823,G__G__TMVA4_144_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTSynapse), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWeight",916,G__G__TMVA4_144_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - weight", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWeight",904,G__G__TMVA4_144_0_3, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLearningRate",1512,G__G__TMVA4_144_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - rate", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetLearningRate",1500,G__G__TMVA4_144_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DecayLearningRate",1698,G__G__TMVA4_144_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - rate", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPreNeuron",1226,G__G__TMVA4_144_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::TNeuron' - 0 - pre", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPostNeuron",1353,G__G__TMVA4_144_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::TNeuron' - 0 - post", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWeightedValue",1614,G__G__TMVA4_144_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWeightedDelta",1595,G__G__TMVA4_144_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AdjustWeight",1235,G__G__TMVA4_144_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalculateDelta",1400,G__G__TMVA4_144_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitDelta",894,G__G__TMVA4_144_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDEDw",624,G__G__TMVA4_144_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - DEDw", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDEDw",612,G__G__TMVA4_144_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDelta",778,G__G__TMVA4_144_0_16, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA4_144_0_18, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TSynapse::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_144_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TSynapse::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_144_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TSynapse::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_144_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TSynapse::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_144_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__TMVA4_144_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TSynapse::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_144_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TSynapse::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_144_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TSynapse::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_144_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TSynapse::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TSynapse", 823, G__G__TMVA4_144_0_30, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTSynapse), -1, 0, 1, 1, 1, 0, "u 'TMVA::TSynapse' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSynapse", 949, G__G__TMVA4_144_0_31, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA4_144_0_32, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTSynapse), -1, 1, 1, 1, 1, 0, "u 'TMVA::TSynapse' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLTActivation(void) {
   /* TMVA::TActivation */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivation));
   G__memfunc_setup("Eval",392,G__G__TMVA4_145_0_2, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - arg", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("EvalDerivative",1435,G__G__TMVA4_145_0_3, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - arg", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMin",580,G__G__TMVA4_145_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMax",582,G__G__TMVA4_145_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetExpression",1360,G__G__TMVA4_145_0_6, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("MakeFunction",1220,G__G__TMVA4_145_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__TMVA4_145_0_8, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TActivation::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_145_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivation::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_145_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TActivation::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_145_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TActivation::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA4_145_0_12, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA4_145_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__TMVA4_145_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_145_0_15, 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__TMVA4_145_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivation::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_145_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivation::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_145_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivation::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_145_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivation::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TActivation", 1252, G__G__TMVA4_145_0_20, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA4_145_0_21, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivation), -1, 1, 1, 1, 1, 0, "u 'TMVA::TActivation' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLTypes(void) {
   /* TMVA::Types */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypes));
   G__memfunc_setup("Instance",821,G__G__TMVA4_147_0_1, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypes), -1, 1, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TMVA::Types& (*)())(&TMVA::Types::Instance) ), 0);
   G__memfunc_setup("DestroyInstance",1567,G__G__TMVA4_147_0_2, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::Types::DestroyInstance) ), 0);
   G__memfunc_setup("GetMethodType",1315,G__G__TMVA4_147_0_3, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA), -1, 0, 1, 1, 1, 8, "u 'TString' - 11 - method", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethodName",1282,G__G__TMVA4_147_0_4, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 1, 1, 1, 8, "i 'TMVA::Types::EMVA' - 0 - method", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddTypeMapping",1399,G__G__TMVA4_147_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 1, 0, 
"i 'TMVA::Types::EMVA' - 0 - method u 'TString' - 11 - methodname", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Types",533,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypes), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("Types", 533, G__G__TMVA4_147_0_8, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypes), -1, 0, 1, 1, 1, 0, "u 'TMVA::Types' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~Types", 659, G__G__TMVA4_147_0_9, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA4_147_0_10, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypes), -1, 1, 1, 1, 1, 0, "u 'TMVA::Types' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLTNeuronInput(void) {
   /* TMVA::TNeuronInput */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInput));
   G__memfunc_setup("GetInput",816,G__G__TMVA4_163_0_2, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "U 'TMVA::TNeuron' - 10 - neuron", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetName",673,G__G__TMVA4_163_0_3, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__TMVA4_163_0_4, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TNeuronInput::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_163_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInput::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_163_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TNeuronInput::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_163_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TNeuronInput::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA4_163_0_8, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA4_163_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__TMVA4_163_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_163_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_163_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInput::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_163_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuronInput::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_163_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInput::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_163_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuronInput::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TNeuronInput", 1369, G__G__TMVA4_163_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA4_163_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInput), -1, 1, 1, 1, 1, 0, "u 'TMVA::TNeuronInput' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLTActivationChooser(void) {
   /* TMVA::TActivationChooser */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationChooser));
   G__memfunc_setup("TActivationChooser",1849,G__G__TMVA4_164_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationChooser), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateActivation",1638,G__G__TMVA4_164_0_2, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivation), -1, 0, 1, 1, 1, 8, "i 'TMVA::TActivationChooser::EActivationType' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateActivation",1638,G__G__TMVA4_164_0_3, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivation), -1, 0, 1, 1, 1, 8, "u 'TString' - 11 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAllActivationNames",2111,G__G__TMVA4_164_0_4, 85, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR), G__defined_typename("vector<TString>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA4_164_0_6, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TActivationChooser::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_164_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationChooser::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_164_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TActivationChooser::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_164_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TActivationChooser::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA4_164_0_10, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA4_164_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__TMVA4_164_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_164_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_164_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationChooser::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_164_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivationChooser::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_164_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationChooser::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_164_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivationChooser::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TActivationChooser", 1849, G__G__TMVA4_164_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationChooser), -1, 0, 1, 1, 1, 0, "u 'TMVA::TActivationChooser' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TActivationChooser", 1975, G__G__TMVA4_164_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA4_164_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationChooser), -1, 1, 1, 1, 1, 0, "u 'TMVA::TActivationChooser' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLTActivationSigmoid(void) {
   /* TMVA::TActivationSigmoid */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationSigmoid));
   G__memfunc_setup("TActivationSigmoid",1842,G__G__TMVA4_170_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationSigmoid), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - arg", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EvalDerivative",1435,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - arg", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMin",580,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMax",582,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetExpression",1360,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeFunction",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA4_170_0_8, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TActivationSigmoid::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_170_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationSigmoid::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_170_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TActivationSigmoid::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_170_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TActivationSigmoid::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_170_0_15, 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__TMVA4_170_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationSigmoid::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_170_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivationSigmoid::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_170_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationSigmoid::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_170_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivationSigmoid::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TActivationSigmoid", 1842, G__G__TMVA4_170_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationSigmoid), -1, 0, 1, 1, 1, 0, "u 'TMVA::TActivationSigmoid' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TActivationSigmoid", 1968, G__G__TMVA4_170_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA4_170_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationSigmoid), -1, 1, 1, 1, 1, 0, "u 'TMVA::TActivationSigmoid' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLTActivationIdentity(void) {
   /* TMVA::TActivationIdentity */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationIdentity));
   G__memfunc_setup("TActivationIdentity",1968,G__G__TMVA4_171_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationIdentity), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - arg", "f(x) = x", (void*) NULL, 1);
   G__memfunc_setup("EvalDerivative",1435,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMin",580,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", "these should never be called", (void*) NULL, 1);
   G__memfunc_setup("GetMax",582,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", "these should never be called", (void*) NULL, 1);
   G__memfunc_setup("GetExpression",1360,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeFunction",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA4_171_0_8, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TActivationIdentity::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_171_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationIdentity::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_171_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TActivationIdentity::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_171_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TActivationIdentity::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_171_0_15, 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__TMVA4_171_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationIdentity::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_171_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivationIdentity::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_171_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationIdentity::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_171_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivationIdentity::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TActivationIdentity", 1968, G__G__TMVA4_171_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationIdentity), -1, 0, 1, 1, 1, 0, "u 'TMVA::TActivationIdentity' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TActivationIdentity", 2094, G__G__TMVA4_171_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA4_171_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationIdentity), -1, 1, 1, 1, 1, 0, "u 'TMVA::TActivationIdentity' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLTActivationTanh(void) {
   /* TMVA::TActivationTanh */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationTanh));
   G__memfunc_setup("TActivationTanh",1521,G__G__TMVA4_172_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationTanh), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - arg", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EvalDerivative",1435,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - arg", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMin",580,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMax",582,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetExpression",1360,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeFunction",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA4_172_0_8, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TActivationTanh::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_172_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationTanh::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_172_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TActivationTanh::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_172_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TActivationTanh::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_172_0_15, 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__TMVA4_172_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationTanh::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_172_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivationTanh::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_172_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationTanh::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_172_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivationTanh::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TActivationTanh", 1521, G__G__TMVA4_172_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationTanh), -1, 0, 1, 1, 1, 0, "u 'TMVA::TActivationTanh' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TActivationTanh", 1647, G__G__TMVA4_172_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA4_172_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationTanh), -1, 1, 1, 1, 1, 0, "u 'TMVA::TActivationTanh' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLTActivationRadial(void) {
   /* TMVA::TActivationRadial */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationRadial));
   G__memfunc_setup("TActivationRadial",1715,G__G__TMVA4_173_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationRadial), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - arg", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("EvalDerivative",1435,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "d - 'Double_t' 0 - arg", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMin",580,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMax",582,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetExpression",1360,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeFunction",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA4_173_0_8, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TActivationRadial::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_173_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationRadial::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_173_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TActivationRadial::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_173_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TActivationRadial::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_173_0_15, 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__TMVA4_173_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationRadial::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_173_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivationRadial::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_173_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TActivationRadial::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_173_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TActivationRadial::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TActivationRadial", 1715, G__G__TMVA4_173_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationRadial), -1, 0, 1, 1, 1, 0, "u 'TMVA::TActivationRadial' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TActivationRadial", 1841, G__G__TMVA4_173_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA4_173_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTActivationRadial), -1, 1, 1, 1, 1, 0, "u 'TMVA::TActivationRadial' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLTNeuronInputSum(void) {
   /* TMVA::TNeuronInputSum */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSum));
   G__memfunc_setup("TNeuronInputSum",1552,G__G__TMVA4_174_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSum), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInput",816,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "U 'TMVA::TNeuron' - 10 - neuron", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA4_174_0_4, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TNeuronInputSum::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_174_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputSum::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_174_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TNeuronInputSum::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_174_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TNeuronInputSum::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_174_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_174_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputSum::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_174_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuronInputSum::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_174_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputSum::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_174_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuronInputSum::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TNeuronInputSum", 1552, G__G__TMVA4_174_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSum), -1, 0, 1, 1, 1, 0, "u 'TMVA::TNeuronInputSum' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TNeuronInputSum", 1678, G__G__TMVA4_174_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA4_174_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSum), -1, 1, 1, 1, 1, 0, "u 'TMVA::TNeuronInputSum' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLTNeuronInputSqSum(void) {
   /* TMVA::TNeuronInputSqSum */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum));
   G__memfunc_setup("TNeuronInputSqSum",1748,G__G__TMVA4_175_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInput",816,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "U 'TMVA::TNeuron' - 10 - neuron", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA4_175_0_4, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TNeuronInputSqSum::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_175_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputSqSum::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_175_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TNeuronInputSqSum::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_175_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TNeuronInputSqSum::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_175_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_175_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputSqSum::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_175_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuronInputSqSum::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_175_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputSqSum::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_175_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuronInputSqSum::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TNeuronInputSqSum", 1748, G__G__TMVA4_175_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum), -1, 0, 1, 1, 1, 0, "u 'TMVA::TNeuronInputSqSum' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TNeuronInputSqSum", 1874, G__G__TMVA4_175_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA4_175_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum), -1, 1, 1, 1, 1, 0, "u 'TMVA::TNeuronInputSqSum' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLTNeuronInputAbs(void) {
   /* TMVA::TNeuronInputAbs */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs));
   G__memfunc_setup("TNeuronInputAbs",1521,G__G__TMVA4_176_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInput",816,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "U 'TMVA::TNeuron' - 10 - neuron", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA4_176_0_4, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TNeuronInputAbs::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_176_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputAbs::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_176_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TNeuronInputAbs::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_176_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TNeuronInputAbs::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_176_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_176_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputAbs::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_176_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuronInputAbs::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_176_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputAbs::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_176_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuronInputAbs::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TNeuronInputAbs", 1521, G__G__TMVA4_176_0_16, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs), -1, 0, 1, 1, 1, 0, "u 'TMVA::TNeuronInputAbs' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TNeuronInputAbs", 1647, G__G__TMVA4_176_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA4_176_0_18, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs), -1, 1, 1, 1, 1, 0, "u 'TMVA::TNeuronInputAbs' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLTNeuronInputChooser(void) {
   /* TMVA::TNeuronInputChooser */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChooser));
   G__memfunc_setup("TNeuronInputChooser",1966,G__G__TMVA4_177_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChooser), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateNeuronInput",1755,G__G__TMVA4_177_0_2, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInput), -1, 0, 1, 1, 1, 8, "i 'TMVA::TNeuronInputChooser::ENeuronInputType' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateNeuronInput",1755,G__G__TMVA4_177_0_3, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInput), -1, 0, 1, 1, 1, 8, "u 'TString' - 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetAllNeuronInputNames",2228,G__G__TMVA4_177_0_4, 85, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR), G__defined_typename("vector<TString>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA4_177_0_5, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::TNeuronInputChooser::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_177_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputChooser::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_177_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::TNeuronInputChooser::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_177_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::TNeuronInputChooser::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA4_177_0_9, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA4_177_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__TMVA4_177_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_177_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_177_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputChooser::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_177_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuronInputChooser::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_177_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::TNeuronInputChooser::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_177_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::TNeuronInputChooser::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TNeuronInputChooser", 1966, G__G__TMVA4_177_0_17, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChooser), -1, 0, 1, 1, 1, 0, "u 'TMVA::TNeuronInputChooser' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TNeuronInputChooser", 2092, G__G__TMVA4_177_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA4_177_0_19, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChooser), -1, 1, 1, 1, 1, 0, "u 'TMVA::TNeuronInputChooser' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLRanking(void) {
   /* TMVA::Ranking */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRanking));
   G__memfunc_setup("Ranking",714,G__G__TMVA4_180_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Ranking",714,G__G__TMVA4_180_0_2, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRanking), -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - context u 'TString' - 11 - rankingDiscriminatorName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddRank",661,G__G__TMVA4_180_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMVA::Rank' - 11 - rank", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Print",525,G__G__TMVA4_180_0_4, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetContext",1041,G__G__TMVA4_180_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - context", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDiscrName",1186,G__G__TMVA4_180_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - discrName", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA4_180_0_8, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::Ranking::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_180_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Ranking::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_180_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::Ranking::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_180_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::Ranking::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA4_180_0_12, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA4_180_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__TMVA4_180_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_180_0_15, 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__TMVA4_180_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Ranking::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_180_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Ranking::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_180_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Ranking::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_180_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Ranking::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("Ranking", 714, G__G__TMVA4_180_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRanking), -1, 0, 1, 1, 1, 0, "u 'TMVA::Ranking' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~Ranking", 840, G__G__TMVA4_180_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA4_180_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRanking), -1, 1, 1, 1, 1, 0, "u 'TMVA::Ranking' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLVariableTransformBase(void) {
   /* TMVA::VariableTransformBase */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase));
   G__memfunc_setup("Initialize",1042,G__G__TMVA4_359_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PrepareTransformation",2214,G__G__TMVA4_359_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Transform",956,G__G__TMVA4_359_0_4, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9, 
"U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("InverseTransform",1688,G__G__TMVA4_359_0_5, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9, 
"U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetEnabled",983,G__G__TMVA4_359_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNormalise",1238,G__G__TMVA4_359_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsEnabled",871,G__G__TMVA4_359_0_8, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsCreated",884,G__G__TMVA4_359_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsNormalised",1226,G__G__TMVA4_359_0_10, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SelectInput",1136,G__G__TMVA4_359_0_11, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'TString' - 11 - inputVariables g - 'Bool_t' 0 'kFALSE' putIntoVariables", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetInput",816,G__G__TMVA4_359_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 4, 1, 1, 8, 
"U 'TMVA::Event' - 10 - event u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - input "
"u 'vector<char,allocator<char> >' 'vector<Char_t>' 1 - mask g - 'Bool_t' 0 'kFALSE' backTransform", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetOutput",957,G__G__TMVA4_359_0_13, 121, -1, -1, 0, 5, 1, 1, 8, 
"U 'TMVA::Event' - 0 - event u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - output "
"u 'vector<char,allocator<char> >' 'vector<Char_t>' 1 - mask U 'TMVA::Event' - 10 '0' oldEvent "
"g - 'Bool_t' 0 'kFALSE' backTransform", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CountVariableTypes",1860,G__G__TMVA4_359_0_14, 121, -1, -1, 0, 3, 1, 1, 8, 
"h - 'UInt_t' 1 - nvars h - 'UInt_t' 1 - ntgts "
"h - 'UInt_t' 1 - nspcts", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ToggleInputSortOrder",2070,G__G__TMVA4_359_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - sortOrder", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetOutputDataSetInfo",2031,G__G__TMVA4_359_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::DataSetInfo' - 0 - outputDsi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUseSignalTransform",2163,G__G__TMVA4_359_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'kTRUE' e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseSignalTransform",1863,G__G__TMVA4_359_0_18, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetShortName",1201,G__G__TMVA4_359_0_20, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteTransformationToStream",2833,G__G__TMVA4_359_0_21, 121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - o", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadTransformationFromStream",2899,G__G__TMVA4_359_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr u 'TString' - 11 '\"\"' classname", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("AttachXMLTo",1033,G__G__TMVA4_359_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadFromXML",1025,G__G__TMVA4_359_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - trfnode", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetVariableTransform",2050,G__G__TMVA4_359_0_25, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeFunction",1220,G__G__TMVA4_359_0_26, 121, -1, -1, 0, 5, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName "
"i - 'Int_t' 0 - part h - 'UInt_t' 0 - trCounter "
"i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetTransformationStrings",2529,G__G__TMVA4_359_0_27, 85, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR), G__defined_typename("vector<TString>"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintTransformation",2020,G__G__TMVA4_359_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Variables",921,G__G__TMVA4_359_0_29, 117, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR), G__defined_typename("vector<TMVA::VariableInfo>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Targets",730,G__G__TMVA4_359_0_30, 117, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR), G__defined_typename("vector<TMVA::VariableInfo>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Spectators",1064,G__G__TMVA4_359_0_31, 117, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR), G__defined_typename("vector<TMVA::VariableInfo>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,G__G__TMVA4_359_0_32, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTMVAVersion",1354,G__G__TMVA4_359_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'TMVA::TMVAVersion_t' 0 - v", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcNorm",783,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetCreated",996,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'kTRUE' c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNVariables",1299,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "h - 'UInt_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetName",685,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "u 'TString' - 11 - c", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNVariables",1287,(G__InterfaceMethod) NULL, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNTargets",1096,(G__InterfaceMethod) NULL, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNSpectators",1430,(G__InterfaceMethod) NULL, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Variables",921,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR), G__defined_typename("vector<TMVA::VariableInfo>"), 1, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Targets",730,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR), G__defined_typename("vector<TMVA::VariableInfo>"), 1, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Spectators",1064,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR), G__defined_typename("vector<TMVA::VariableInfo>"), 1, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNClasses",1084,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpdateNorm",1023,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"i - 'Int_t' 0 - ivar d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA4_359_0_46, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::VariableTransformBase::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_359_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableTransformBase::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_359_0_48, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::VariableTransformBase::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_359_0_49, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::VariableTransformBase::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_359_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__TMVA4_359_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableTransformBase::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_359_0_55, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableTransformBase::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_359_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableTransformBase::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_359_0_57, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableTransformBase::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~VariableTransformBase", 2267, G__G__TMVA4_359_0_58, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLRuleFit(void) {
   /* TMVA::RuleFit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFit));
   G__memfunc_setup("RuleFit",699,G__G__TMVA4_390_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFit), -1, 0, 1, 1, 1, 0, "U 'TMVA::MethodBase' - 10 - rfbase", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RuleFit",699,G__G__TMVA4_390_0_2, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitNEveEff",1043,G__G__TMVA4_390_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitPtrs",829,G__G__TMVA4_390_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::MethodBase' - 10 - rfbase", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Initialize",1042,G__G__TMVA4_390_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::MethodBase' - 10 - rfbase", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMsgType",1013,G__G__TMVA4_390_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TMVA::EMsgType' - 0 - t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrainingEvents",1757,G__G__TMVA4_390_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'vector<const TMVA::Event*>' 11 - el", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReshuffleEvents",1561,G__G__TMVA4_390_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMethodBase",1288,G__G__TMVA4_390_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::MethodBase' - 10 - rfbase", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeForest",1009,G__G__TMVA4_390_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildTree",896,G__G__TMVA4_390_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::DecisionTree' - 0 - dt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SaveEventWeights",1644,G__G__TMVA4_390_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RestoreEventWeights",1985,G__G__TMVA4_390_0_13, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Boost",519,G__G__TMVA4_390_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::DecisionTree' - 0 - dt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ForestStatistics",1694,G__G__TMVA4_390_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("EvalEvent",906,G__G__TMVA4_390_0_16, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'TMVA::Event' - 11 - e", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcWeightSum",1296,G__G__TMVA4_390_0_17, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"U 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'vector<const TMVA::Event*>' 10 - events h - 'UInt_t' 0 '0' neve", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FitCoefficients",1525,G__G__TMVA4_390_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcImportance",1413,G__G__TMVA4_390_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModelLinear",1400,G__G__TMVA4_390_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModelRules",1320,G__G__TMVA4_390_0_21, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetModelFull",1200,G__G__TMVA4_390_0_22, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetImportanceCut",1642,G__G__TMVA4_390_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0' minimp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRuleMinDist",1404,G__G__TMVA4_390_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - d", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGDTau",737,G__G__TMVA4_390_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0.0' t", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGDPathStep",1248,G__G__TMVA4_390_0_26, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 '0.01' s", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGDNPathSteps",1441,G__G__TMVA4_390_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 '100' n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetVisHistsUseImp",1724,G__G__TMVA4_390_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseImportanceVisHists",2172,G__G__TMVA4_390_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseCoefficientsVisHists",2364,G__G__TMVA4_390_0_30, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeVisHists",1211,G__G__TMVA4_390_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillVisHistCut",1405,G__G__TMVA4_390_0_32, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TMVA::Rule' - 10 - rule u 'vector<TH2F*,allocator<TH2F*> >' 'vector<TH2F*>' 1 - hlist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillVisHistCorr",1511,G__G__TMVA4_390_0_33, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TMVA::Rule' - 10 - rule u 'vector<TH2F*,allocator<TH2F*> >' 'vector<TH2F*>' 1 - hlist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillCut",691,G__G__TMVA4_390_0_34, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TH2F' - 0 - h2 U 'TMVA::Rule' - 10 - rule "
"i - 'Int_t' 0 - vind", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillLin",682,G__G__TMVA4_390_0_35, 121, -1, -1, 0, 2, 1, 1, 0, 
"U 'TH2F' - 0 - h2 i - 'Int_t' 0 - vind", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillCorr",797,G__G__TMVA4_390_0_36, 121, -1, -1, 0, 4, 1, 1, 0, 
"U 'TH2F' - 0 - h2 U 'TMVA::Rule' - 10 - rule "
"i - 'Int_t' 0 - v1 i - 'Int_t' 0 - v2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NormVisHists",1241,G__G__TMVA4_390_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<TH2F*,allocator<TH2F*> >' 'vector<TH2F*>' 1 - hlist", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MakeDebugHists",1392,G__G__TMVA4_390_0_38, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCorrVars",1106,G__G__TMVA4_390_0_39, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 1, 0, 
"u 'TString' - 1 - title u 'TString' - 1 - var1 "
"u 'TString' - 1 - var2", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNTreeSample",1376,G__G__TMVA4_390_0_40, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNEveEff",927,G__G__TMVA4_390_0_41, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "reweighted number of events = sum(wi)", (void*) NULL, 0);
   G__memfunc_setup("GetTrainingEvent",1630,G__G__TMVA4_390_0_42, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 1, 1, 1, 9, "h - 'UInt_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrainingEventWeight",2246,G__G__TMVA4_390_0_43, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "h - 'UInt_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTrainingEvents",1745,G__G__TMVA4_390_0_44, 117, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR), G__defined_typename("vector<const TMVA::Event*>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRndmSampleEvents",1928,G__G__TMVA4_390_0_45, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' 'vector<const TMVA::Event*>' 1 - evevec h - 'UInt_t' 0 - nevents", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetForest",915,G__G__TMVA4_390_0_46, 117, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR), G__defined_typename("vector<const TMVA::DecisionTree*>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRuleEnsemble",1507,G__G__TMVA4_390_0_47, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleEnsemble), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRuleEnsemblePtr",1817,G__G__TMVA4_390_0_48, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleEnsemble), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRuleFitParams",1599,G__G__TMVA4_390_0_49, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitParams), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRuleFitParamsPtr",1909,G__G__TMVA4_390_0_50, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitParams), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethodRuleFit",1596,G__G__TMVA4_390_0_51, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMethodRuleFit), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMethodBase",1276,G__G__TMVA4_390_0_52, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMethodBase), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RuleFit",699,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFit), -1, 0, 1, 1, 4, 0, "u 'TMVA::RuleFit' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Copy",411,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TMVA::RuleFit' - 11 - other", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA4_390_0_56, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::RuleFit::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_390_0_57, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::RuleFit::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_390_0_58, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::RuleFit::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_390_0_59, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::RuleFit::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA4_390_0_60, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA4_390_0_61, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__TMVA4_390_0_62, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_390_0_63, 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__TMVA4_390_0_64, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::RuleFit::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_390_0_65, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::RuleFit::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_390_0_66, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::RuleFit::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_390_0_67, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::RuleFit::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~RuleFit", 825, G__G__TMVA4_390_0_68, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLRuleFitAPI(void) {
   /* TMVA::RuleFitAPI */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPI));
   G__memfunc_setup("RuleFitAPI",917,G__G__TMVA4_428_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPI), -1, 0, 3, 1, 1, 0, 
"U 'TMVA::MethodRuleFit' - 10 - rfbase U 'TMVA::RuleFit' - 0 - rulefit "
"i 'TMVA::EMsgType' - 0 - minType", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WelcomeMessage",1425,G__G__TMVA4_428_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HowtoSetupRF",1210,G__G__TMVA4_428_0_3, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRFWorkDir",1158,G__G__TMVA4_428_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - wdir", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckRFWorkDir",1336,G__G__TMVA4_428_0_5, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TrainRuleFit",1209,G__G__TMVA4_428_0_6, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TestRuleFit",1115,G__G__TMVA4_428_0_7, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("VarImp",591,G__G__TMVA4_428_0_8, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadModelSum",1186,G__G__TMVA4_428_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRFWorkDir",1146,G__G__TMVA4_428_0_10, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("InitRuleFit",1103,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillRealParmsDef",1565,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FillIntParmsDef",1476,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ImportSetup",1164,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrainParms",1325,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTestParms",1231,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RunRuleFit",1008,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRFTrain",962,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRFPredict",1167,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetRFVarimp",1075,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetRFName",825,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TString), -1, 0, 1, 1, 2, 0, "u 'TString' - 0 - name", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OpenRFile",868,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0, 
"u 'TString' - 0 - name u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OpenRFile",868,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0, 
"u 'TString' - 0 - name u 'basic_ifstream<char,char_traits<char> >' 'ifstream' 1 - f", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteInt",822,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 2, 0, 
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - f I - 'Int_t' 10 - v "
"i - 'Int_t' 0 '1' n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteFloat",1025,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 3, 1, 2, 0, 
"u 'basic_ofstream<char,char_traits<char> >' 'ofstream' 1 - f F - 'Float_t' 10 - v "
"i - 'Int_t' 0 '1' n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadInt",679,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 8, 
"u 'basic_ifstream<char,char_traits<char> >' 'ifstream' 1 - f I - 'Int_t' 0 - v "
"i - 'Int_t' 0 '1' n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadFloat",882,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 2, 8, 
"u 'basic_ifstream<char,char_traits<char> >' 'ifstream' 1 - f F - 'Float_t' 0 - v "
"i - 'Int_t' 0 '1' n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteAll",804,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteIntParms",1337,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteRealParms",1426,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteLx",719,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteProgram",1251,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteRealVarImp",1502,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteRfOut",1019,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteRfStatus",1351,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteRuleFitMod",1510,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteRuleFitSum",1531,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteTrain",1033,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteVarNames",1320,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteVarImp",1114,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteYhat",929,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("WriteTest",939,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadYhat",786,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadIntParms",1194,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadRealParms",1283,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadLx",576,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadProgram",1108,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadRealVarImp",1359,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadRfOut",876,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadRfStatus",1208,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadRuleFitMod",1367,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadRuleFitSum",1388,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTrainX",978,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTrainY",979,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadTrainW",977,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadVarNames",1177,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ReadVarImp",971,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RuleFitAPI",917,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRuleFitAPI), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA4_428_0_59, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::RuleFitAPI::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_428_0_60, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::RuleFitAPI::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_428_0_61, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::RuleFitAPI::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_428_0_62, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::RuleFitAPI::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA4_428_0_63, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA4_428_0_64, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__TMVA4_428_0_65, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_428_0_66, 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__TMVA4_428_0_67, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::RuleFitAPI::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_428_0_68, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::RuleFitAPI::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_428_0_69, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::RuleFitAPI::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_428_0_70, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::RuleFitAPI::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~RuleFitAPI", 1043, G__G__TMVA4_428_0_71, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLIMethod(void) {
   /* TMVA::IMethod */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLIMethod));
   G__memfunc_setup("GetName",673,G__G__TMVA4_435_0_2, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("GetMvaValue",1089,G__G__TMVA4_435_0_3, 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, 3);
   G__memfunc_setup("Train",510,G__G__TMVA4_435_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ReadWeightsFromStream",2135,G__G__TMVA4_435_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("WriteMonitoringHistosToFile",2798,G__G__TMVA4_435_0_6, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("MakeClass",884,G__G__TMVA4_435_0_7, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TString' - 11 'TString(\"\")' classFileName", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CreateRanking",1310,G__G__TMVA4_435_0_8, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLRanking), -1, 0, 0, 1, 1, 1, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("PrintHelpMessage",1627,G__G__TMVA4_435_0_9, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Init",404,G__G__TMVA4_435_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("DeclareOptions",1436,G__G__TMVA4_435_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ProcessOptions",1483,G__G__TMVA4_435_0_12, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("HasAnalysisType",1538,G__G__TMVA4_435_0_13, 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, 3);
   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, 3);
   G__memfunc_setup("GetHelpMessage",1390,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Class",502,G__G__TMVA4_435_0_16, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::IMethod::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_435_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::IMethod::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_435_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::IMethod::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_435_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::IMethod::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__TMVA4_435_0_20, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__TMVA4_435_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__TMVA4_435_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA4_435_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_435_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::IMethod::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_435_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::IMethod::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_435_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::IMethod::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_435_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::IMethod::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~IMethod", 808, G__G__TMVA4_435_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA4_435_0_29, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLIMethod), -1, 1, 1, 1, 1, 0, "u 'TMVA::IMethod' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLVariableIdentityTransform(void) {
   /* TMVA::VariableIdentityTransform */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform));
   G__memfunc_setup("VariableIdentityTransform",2604,G__G__TMVA4_441_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform), -1, 0, 1, 1, 1, 0, "u 'TMVA::DataSetInfo' - 1 - dsi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Initialize",1042,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrepareTransformation",2214,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteTransformationToStream",2833,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadTransformationFromStream",2899,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AttachXMLTo",1033,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFromXML",1025,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - trfnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Transform",956,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9, 
"U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InverseTransform",1688,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9, 
"U 'TMVA::Event' - 50 - ev i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeFunction",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName "
"i - 'Int_t' 0 - part h - 'UInt_t' 0 - trCounter "
"i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA4_441_0_11, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::VariableIdentityTransform::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_441_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableIdentityTransform::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_441_0_13, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::VariableIdentityTransform::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_441_0_14, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::VariableIdentityTransform::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_441_0_18, 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__TMVA4_441_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableIdentityTransform::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_441_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableIdentityTransform::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_441_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableIdentityTransform::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_441_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableIdentityTransform::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("VariableIdentityTransform", 2604, G__G__TMVA4_441_0_23, (int) ('i'), 
G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform), -1, 0, 1, 1, 1, 0, "u 'TMVA::VariableIdentityTransform' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~VariableIdentityTransform", 2730, G__G__TMVA4_441_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLVariableDecorrTransform(void) {
   /* TMVA::VariableDecorrTransform */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform));
   G__memfunc_setup("VariableDecorrTransform",2369,G__G__TMVA4_443_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform), -1, 0, 1, 1, 1, 0, "u 'TMVA::DataSetInfo' - 1 - dsi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Initialize",1042,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrepareTransformation",2214,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Transform",956,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9, 
"U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InverseTransform",1688,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9, 
"U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteTransformationToStream",2833,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadTransformationFromStream",2899,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AttachXMLTo",1033,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFromXML",1025,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - trfnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintTransformation",2020,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - o", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeFunction",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName "
"i - 'Int_t' 0 - part h - 'UInt_t' 0 - trCounter "
"i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTransformationStrings",2529,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR), G__defined_typename("vector<TString>"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CalcSQRMats",1022,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - - i - 'Int_t' 0 - maxCls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CalcCovarianceMatrices",2214,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgR), G__defined_typename("vector<TMatrixDSym*>"), 0, 2, 1, 4, 0, 
"u 'vector<const TMVA::Event*,allocator<const TMVA::Event*> >' - 11 - events i - 'Int_t' 0 - maxCls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA4_443_0_15, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::VariableDecorrTransform::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_443_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableDecorrTransform::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_443_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::VariableDecorrTransform::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_443_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::VariableDecorrTransform::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_443_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__TMVA4_443_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableDecorrTransform::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_443_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableDecorrTransform::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_443_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableDecorrTransform::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_443_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableDecorrTransform::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("VariableDecorrTransform", 2369, G__G__TMVA4_443_0_27, (int) ('i'), 
G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform), -1, 0, 1, 1, 1, 0, "u 'TMVA::VariableDecorrTransform' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~VariableDecorrTransform", 2495, G__G__TMVA4_443_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLVariablePCATransform(void) {
   /* TMVA::VariablePCATransform */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariablePCATransform));
   G__memfunc_setup("VariablePCATransform",1974,G__G__TMVA4_510_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariablePCATransform), -1, 0, 1, 1, 1, 0, "u 'TMVA::DataSetInfo' - 1 - dsi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Initialize",1042,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrepareTransformation",2214,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Transform",956,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9, 
"U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InverseTransform",1688,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9, 
"U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteTransformationToStream",2833,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadTransformationFromStream",2899,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AttachXMLTo",1033,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFromXML",1025,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - trfnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeFunction",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName "
"i - 'Int_t' 0 - part h - 'UInt_t' 0 - trCounter "
"i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CalculatePrincipalComponents",2902,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("X2P",218,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - - u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - - "
"i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("P2X",218,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 8, 
"u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - - u 'vector<float,allocator<float> >' 'vector<Float_t>' 11 - - "
"i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA4_510_0_14, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::VariablePCATransform::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_510_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariablePCATransform::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_510_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::VariablePCATransform::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_510_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::VariablePCATransform::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_510_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_510_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariablePCATransform::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_510_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariablePCATransform::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_510_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariablePCATransform::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_510_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariablePCATransform::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("VariablePCATransform", 1974, G__G__TMVA4_510_0_26, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariablePCATransform), -1, 0, 1, 1, 1, 0, "u 'TMVA::VariablePCATransform' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~VariablePCATransform", 2100, G__G__TMVA4_510_0_27, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLVariableGaussTransform(void) {
   /* TMVA::VariableGaussTransform */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableGaussTransform));
   G__memfunc_setup("VariableGaussTransform",2277,G__G__TMVA4_542_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableGaussTransform), -1, 0, 2, 1, 1, 0, 
"u 'TMVA::DataSetInfo' - 1 - dsi u 'TString' - 0 '\"\"' strcor", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Initialize",1042,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrepareTransformation",2214,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Transform",956,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9, 
"U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InverseTransform",1688,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9, 
"U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteTransformationToStream",2833,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadTransformationFromStream",2899,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AttachXMLTo",1033,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFromXML",1025,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - trfnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintTransformation",2020,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - o", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeFunction",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName "
"i - 'Int_t' 0 - part h - 'UInt_t' 0 - trCounter "
"i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCumulativeDist",1747,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CleanUpCumulativeArrays",2361,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TString' - 0 '\"ALL\"' opt", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("OldCumulant",1128,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 4, 8, 
"f - 'Float_t' 0 - x U 'TH1' - 0 - h", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA4_542_0_15, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::VariableGaussTransform::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_542_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableGaussTransform::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_542_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::VariableGaussTransform::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_542_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::VariableGaussTransform::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_542_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__TMVA4_542_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableGaussTransform::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_542_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableGaussTransform::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_542_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableGaussTransform::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_542_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableGaussTransform::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("VariableGaussTransform", 2277, G__G__TMVA4_542_0_27, (int) ('i'), 
G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableGaussTransform), -1, 0, 1, 1, 1, 0, "u 'TMVA::VariableGaussTransform' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~VariableGaussTransform", 2403, G__G__TMVA4_542_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLVariableNormalizeTransform(void) {
   /* TMVA::VariableNormalizeTransform */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform));
   G__memfunc_setup("VariableNormalizeTransform",2707,G__G__TMVA4_555_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform), -1, 0, 1, 1, 1, 0, "u 'TMVA::DataSetInfo' - 1 - dsi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Initialize",1042,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrepareTransformation",2214,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Transform",956,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9, 
"U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InverseTransform",1688,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9, 
"U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteTransformationToStream",2833,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadTransformationFromStream",2899,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("BuildTransformationFromVarInfo",3088,G__G__TMVA4_555_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<TMVA::VariableInfo,allocator<TMVA::VariableInfo> >' 'vector<TMVA::VariableInfo>' 11 - var", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AttachXMLTo",1033,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFromXML",1025,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - trfnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintTransformation",2020,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - o", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeFunction",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName "
"i - 'Int_t' 0 - part h - 'UInt_t' 0 - trCounter "
"i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTransformationStrings",2529,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR), G__defined_typename("vector<TString>"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CalcNormalizationParams",2366,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - events", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__TMVA4_555_0_15, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::VariableNormalizeTransform::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_555_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableNormalizeTransform::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_555_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::VariableNormalizeTransform::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_555_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::VariableNormalizeTransform::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_555_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__TMVA4_555_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableNormalizeTransform::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_555_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableNormalizeTransform::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_555_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableNormalizeTransform::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_555_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableNormalizeTransform::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("VariableNormalizeTransform", 2707, G__G__TMVA4_555_0_27, (int) ('i'), 
G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform), -1, 0, 1, 1, 1, 0, "u 'TMVA::VariableNormalizeTransform' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~VariableNormalizeTransform", 2833, G__G__TMVA4_555_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLVariableRearrangeTransform(void) {
   /* TMVA::VariableRearrangeTransform */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableRearrangeTransform));
   G__memfunc_setup("VariableRearrangeTransform",2681,G__G__TMVA4_560_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableRearrangeTransform), -1, 0, 1, 1, 1, 0, "u 'TMVA::DataSetInfo' - 1 - dsi", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Initialize",1042,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrepareTransformation",2214,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 0, "u 'vector<TMVA::Event*,allocator<TMVA::Event*> >' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Transform",956,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9, 
"U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InverseTransform",1688,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLEvent), -1, 0, 2, 1, 1, 9, 
"U 'TMVA::Event' - 50 - - i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("WriteTransformationToStream",2833,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadTransformationFromStream",2899,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 0, 
"u 'basic_istream<char,char_traits<char> >' 'istream' 1 - - u 'TString' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AttachXMLTo",1033,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - parent", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReadFromXML",1025,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - trfnode", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintTransformation",2020,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - o", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MakeFunction",1220,(G__InterfaceMethod) NULL,121, -1, -1, 0, 5, 1, 1, 0, 
"u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - fout u 'TString' - 11 - fncName "
"i - 'Int_t' 0 - part h - 'UInt_t' 0 - trCounter "
"i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetTransformationStrings",2529,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR), G__defined_typename("vector<TString>"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - cls", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__TMVA4_560_0_13, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::VariableRearrangeTransform::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__TMVA4_560_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableRearrangeTransform::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__TMVA4_560_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::VariableRearrangeTransform::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__TMVA4_560_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::VariableRearrangeTransform::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA4LN_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__TMVA4_560_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - ClassDef_StreamerNVirtual_b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__TMVA4_560_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableRearrangeTransform::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__TMVA4_560_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableRearrangeTransform::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__TMVA4_560_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::VariableRearrangeTransform::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__TMVA4_560_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::VariableRearrangeTransform::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("VariableRearrangeTransform", 2681, G__G__TMVA4_560_0_25, (int) ('i'), 
G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLVariableRearrangeTransform), -1, 0, 1, 1, 1, 0, "u 'TMVA::VariableRearrangeTransform' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~VariableRearrangeTransform", 2807, G__G__TMVA4_560_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMVAcLcLROCCalc(void) {
   /* TMVA::ROCCalc */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLROCCalc));
   G__memfunc_setup("ROCCalc",599,G__G__TMVA4_562_0_1, 105, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLROCCalc), -1, 0, 3, 1, 1, 0, 
"U 'TH1' - 0 - mvaS U 'TH1' - 0 - mvaB "
"u 'TString' - 0 '\"\"' nameSuffix", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetROC",516,G__G__TMVA4_562_0_2, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TH1D), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEffSForEffBof",1491,G__G__TMVA4_562_0_3, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - effBref d - 'Double_t' 1 - effSerr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSignalReferenceCut",2105,G__G__TMVA4_562_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetROCIntegral",1338,G__G__TMVA4_562_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSignificance",1507,G__G__TMVA4_562_0_6, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TH1), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - nStot i - 'Int_t' 0 - nBtot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPurity",941,G__G__TMVA4_562_0_7, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TH1), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 - nStot i - 'Int_t' 0 - nBtot", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ApplySignalAndBackgroundStyle",2952,G__G__TMVA4_562_0_8, 121, -1, -1, 0, 3, 1, 1, 0, 
"U 'TH1' - 0 - sig U 'TH1' - 0 - bkg "
"U 'TH1' - 0 '0' any", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMvaSpdf",977,G__G__TMVA4_562_0_9, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TH1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetMvaBpdf",960,G__G__TMVA4_562_0_10, 85, G__get_linked_tagnum(&G__G__TMVA4LN_TH1), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Root",420,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 0 - -", (char*)NULL, (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 - theCut", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("ROCCalc", 599, G__G__TMVA4_562_0_14, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLROCCalc), -1, 0, 1, 1, 1, 0, "u 'TMVA::ROCCalc' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ROCCalc", 725, G__G__TMVA4_562_0_15, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__TMVA4_562_0_16, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA4LN_TMVAcLcLROCCalc), -1, 1, 1, 1, 1, 0, "u 'TMVA::ROCCalc' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncG__TMVA4() {
}

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();

}

static void G__cpp_setup_global1() {
}

static void G__cpp_setup_global2() {
}

static void G__cpp_setup_global3() {
}

static void G__cpp_setup_global4() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__TMVA4() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
  G__cpp_setup_global3();
  G__cpp_setup_global4();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {
}

static void G__cpp_setup_func5() {
}

static void G__cpp_setup_func6() {
}

static void G__cpp_setup_func7() {
}

static void G__cpp_setup_func8() {
}

static void G__cpp_setup_func9() {
}

static void G__cpp_setup_func10() {
}

static void G__cpp_setup_func11() {
}

static void G__cpp_setup_func12() {
}

static void G__cpp_setup_func13() {
}

static void G__cpp_setup_func14() {
}

static void G__cpp_setup_func15() {
}

static void G__cpp_setup_func16() {
}

static void G__cpp_setup_func17() {
}

static void G__cpp_setup_func18() {
}

static void G__cpp_setup_func19() {
}

static void G__cpp_setup_func20() {
}

static void G__cpp_setup_func21() {
}

static void G__cpp_setup_func22() {
}

static void G__cpp_setup_func23() {
}

static void G__cpp_setup_func24() {
}

static void G__cpp_setup_func25() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__TMVA4() {
  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();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__TMVA4LN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_ios_base = { "ios_base" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_basic_istreamlEcharcOchar_traitslEchargRsPgR = { "basic_istream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_basic_ioslEcharcOchar_traitslEchargRsPgR = { "basic_ios<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR = { "basic_ifstream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR = { "basic_ofstream<char,char_traits<char> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_string = { "string" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR = { "basic_ostringstream<char,char_traits<char>,allocator<char> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TObjArray = { "TObjArray" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__TMVA4LN_TFormula = { "TFormula" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVA = { "TMVA" , 110 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTNeuron = { "TMVA::TNeuron" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLMsgLogger = { "TMVA::MsgLogger" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTSynapse = { "TMVA::TSynapse" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTActivation = { "TMVA::TActivation" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLEMsgType = { "TMVA::EMsgType" , 101 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTypes = { "TMVA::Types" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA = { "TMVA::Types::EMVA" , 101 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform = { "TMVA::Types::EVariableTransform" , 101 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTypescLcLEAnalysisType = { "TMVA::Types::EAnalysisType" , 101 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTypescLcLESBType = { "TMVA::Types::ESBType" , 101 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTypescLcLETreeType = { "TMVA::Types::ETreeType" , 101 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTypescLcLEBoostStage = { "TMVA::Types::EBoostStage" , 101 , -1 };
G__linked_taginfo G__G__TMVA4LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR = { "map<TString,TMVA::Types::EMVA,less<TString>,allocator<pair<const TString,TMVA::Types::EMVA> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTNeuronInput = { "TMVA::TNeuronInput" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTActivationChooser = { "TMVA::TActivationChooser" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTActivationChoosercLcLEActivationType = { "TMVA::TActivationChooser::EActivationType" , 101 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTActivationSigmoid = { "TMVA::TActivationSigmoid" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTActivationIdentity = { "TMVA::TActivationIdentity" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTActivationTanh = { "TMVA::TActivationTanh" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTActivationRadial = { "TMVA::TActivationRadial" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTNeuronInputSum = { "TMVA::TNeuronInputSum" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum = { "TMVA::TNeuronInputSqSum" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs = { "TMVA::TNeuronInputAbs" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTNeuronInputChooser = { "TMVA::TNeuronInputChooser" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLTNeuronInputChoosercLcLENeuronInputType = { "TMVA::TNeuronInputChooser::ENeuronInputType" , 101 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRank = { "TMVA::Rank" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRanking = { "TMVA::Ranking" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgR = { "vector<TMVA::Rank,allocator<TMVA::Rank> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::Rank,allocator<TMVA::Rank> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TH1D = { "TH1D" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TH1 = { "TH1" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TH2F = { "TH2F" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLNode = { "TMVA::Node" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLEvent = { "TMVA::Event" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLBinaryTree = { "TMVA::BinaryTree" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR = { "vector<float,allocator<float> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<float,allocator<float> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<double,allocator<double> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR = { "vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR = { "vector<TMVA::Event*,allocator<TMVA::Event*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::Event*,allocator<TMVA::Event*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR = { "pair<double,const TMVA::Event*>" , 115 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR = { "vector<pair<double,const TMVA::Event*>,allocator<pair<double,const TMVA::Event*> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<double,const TMVA::Event*>,allocator<pair<double,const TMVA::Event*> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR = { "map<string,TObjArray*,less<string>,allocator<pair<const string,TObjArray*> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMatrixTlEdoublegR = { "TMatrixT<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR = { "vector<float*,allocator<float*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<float*,allocator<float*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLVariableTransformBase = { "TMVA::VariableTransformBase" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLDataSetInfo = { "TMVA::DataSetInfo" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR = { "vector<TMVA::VariableInfo,allocator<TMVA::VariableInfo> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::VariableInfo,allocator<TMVA::VariableInfo> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR = { "vector<TMVA::ClassInfo*,allocator<TMVA::ClassInfo*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::ClassInfo*,allocator<TMVA::ClassInfo*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLDecisionTree = { "TMVA::DecisionTree" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR = { "vector<const TMVA::Event*,allocator<const TMVA::Event*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const TMVA::Event*,allocator<const TMVA::Event*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgR = { "vector<const TMVA::Node*,allocator<const TMVA::Node*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const TMVA::Node*,allocator<const TMVA::Node*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlEcharcOallocatorlEchargRsPgR = { "vector<char,allocator<char> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR = { "reverse_iterator<vector<char,allocator<char> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRuleEnsemble = { "TMVA::RuleEnsemble" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRule = { "TMVA::Rule" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLMethodBase = { "TMVA::MethodBase" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRuleFit = { "TMVA::RuleFit" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLMethodRuleFit = { "TMVA::MethodRuleFit" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR = { "vector<const TMVA::DecisionTree*,allocator<const TMVA::DecisionTree*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const TMVA::DecisionTree*,allocator<const TMVA::DecisionTree*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgR = { "vector<TMVA::Rule*,allocator<TMVA::Rule*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::Rule*,allocator<TMVA::Rule*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR = { "vector<TH1F*,allocator<TH1F*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TH1F*,allocator<TH1F*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR = { "vector<vector<unsigned int,allocator<unsigned int> >,allocator<vector<unsigned int,allocator<unsigned int> > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_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__TMVA4LN_TMVAcLcLRuleFitParams = { "TMVA::RuleFitParams" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR = { "vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlETH2FmUcOallocatorlETH2FmUgRsPgR = { "vector<TH2F*,allocator<TH2F*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETH2FmUcOallocatorlETH2FmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TH2F*,allocator<TH2F*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR = { "map<TMVA::EMsgType,string,less<TMVA::EMsgType>,allocator<pair<const TMVA::EMsgType,string> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRuleFitAPI = { "TMVA::RuleFitAPI" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFMode = { "TMVA::RuleFitAPI::ERFMode" , 101 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLEModel = { "TMVA::RuleFitAPI::EModel" , 101 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFProgram = { "TMVA::RuleFitAPI::ERFProgram" , 101 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLIntParms = { "TMVA::RuleFitAPI::IntParms" , 115 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLRealParms = { "TMVA::RuleFitAPI::RealParms" , 115 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLIMethod = { "TMVA::IMethod" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_pairlEcharcOunsignedsPintgR = { "pair<char,unsigned int>" , 115 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgR = { "vector<pair<char,unsigned int>,allocator<pair<char,unsigned int> > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgRcLcLiterator = { "vector<pair<char,unsigned int>,allocator<pair<char,unsigned int> > >::iterator" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<char,unsigned int>,allocator<pair<char,unsigned int> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform = { "TMVA::VariableIdentityTransform" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMatrixTSymlEdoublegR = { "TMatrixTSym<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform = { "TMVA::VariableDecorrTransform" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgR = { "vector<TMatrixT<double>*,allocator<TMatrixT<double>*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMatrixT<double>*,allocator<TMatrixT<double>*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgR = { "vector<TMatrixTSym<double>*,allocator<TMatrixTSym<double>*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMatrixTSym<double>*,allocator<TMatrixTSym<double>*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TElementActionTlEdoublegR = { "TElementActionT<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TElementPosActionTlEdoublegR = { "TElementPosActionT<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMatrixTSparselEdoublegR = { "TMatrixTSparse<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMatrixTRow_constlEdoublegR = { "TMatrixTRow_const<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMatrixTRowlEdoublegR = { "TMatrixTRow<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMatrixTDiag_constlEdoublegR = { "TMatrixTDiag_const<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMatrixTColumn_constlEdoublegR = { "TMatrixTColumn_const<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMatrixTSparseRow_constlEdoublegR = { "TMatrixTSparseRow_const<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMatrixTSparseRowlEdoublegR = { "TMatrixTSparseRow<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMatrixTSparseDiag_constlEdoublegR = { "TMatrixTSparseDiag_const<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMatrixTFlat_constlEdoublegR = { "TMatrixTFlat_const<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMatrixTSub_constlEdoublegR = { "TMatrixTSub_const<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMatrixTColumnlEdoublegR = { "TMatrixTColumn<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMatrixTDiaglEdoublegR = { "TMatrixTDiag<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMatrixTFlatlEdoublegR = { "TMatrixTFlat<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMatrixTSublEdoublegR = { "TMatrixTSub<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMatrixTSparseDiaglEdoublegR = { "TMatrixTSparseDiag<double>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLVariablePCATransform = { "TMVA::VariablePCATransform" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgR = { "vector<TVectorT<double>*,allocator<TVectorT<double>*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVectorT<double>*,allocator<TVectorT<double>*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLOptionlEboolgR = { "TMVA::Option<bool>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlEboolcOallocatorlEboolgRsPgR = { "vector<bool,allocator<bool> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<bool,allocator<bool> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLOptionlEboolmUgR = { "TMVA::Option<bool*>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLOptionlEfloatgR = { "TMVA::Option<float>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TSpline = { "TSpline" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLPDF = { "TMVA::PDF" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLVariableGaussTransform = { "TMVA::VariableGaussTransform" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgR = { "vector<vector<TH1F*,allocator<TH1F*> >,allocator<vector<TH1F*,allocator<TH1F*> > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<TH1F*,allocator<TH1F*> >,allocator<vector<TH1F*,allocator<TH1F*> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR = { "vector<TMVA::PDF*,allocator<TMVA::PDF*> >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::PDF*,allocator<TMVA::PDF*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgR = { "vector<vector<TMVA::PDF*,allocator<TMVA::PDF*> >,allocator<vector<TMVA::PDF*,allocator<TMVA::PDF*> > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<TMVA::PDF*,allocator<TMVA::PDF*> >,allocator<vector<TMVA::PDF*,allocator<TMVA::PDF*> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform = { "TMVA::VariableNormalizeTransform" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR = { "vector<vector<float,allocator<float> >,allocator<vector<float,allocator<float> > > >" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<float,allocator<float> >,allocator<vector<float,allocator<float> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLVariableRearrangeTransform = { "TMVA::VariableRearrangeTransform" , 99 , -1 };
G__linked_taginfo G__G__TMVA4LN_TMVAcLcLROCCalc = { "TMVA::ROCCalc" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__TMVA4() {
  G__G__TMVA4LN_TClass.tagnum = -1 ;
  G__G__TMVA4LN_TBuffer.tagnum = -1 ;
  G__G__TMVA4LN_TMemberInspector.tagnum = -1 ;
  G__G__TMVA4LN_TObject.tagnum = -1 ;
  G__G__TMVA4LN_TString.tagnum = -1 ;
  G__G__TMVA4LN_ios_base.tagnum = -1 ;
  G__G__TMVA4LN_basic_istreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_basic_ioslEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_string.tagnum = -1 ;
  G__G__TMVA4LN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_TObjArray.tagnum = -1 ;
  G__G__TMVA4LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__TMVA4LN_TFormula.tagnum = -1 ;
  G__G__TMVA4LN_TMVA.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTNeuron.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLMsgLogger.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTSynapse.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTActivation.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLEMsgType.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTypes.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTypescLcLEAnalysisType.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTypescLcLESBType.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTypescLcLETreeType.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTypescLcLEBoostStage.tagnum = -1 ;
  G__G__TMVA4LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTNeuronInput.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTActivationChooser.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTActivationChoosercLcLEActivationType.tagnum = -1 ;
  G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTActivationSigmoid.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTActivationIdentity.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTActivationTanh.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTActivationRadial.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTNeuronInputSum.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTNeuronInputChooser.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLTNeuronInputChoosercLcLENeuronInputType.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLRank.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLRanking.tagnum = -1 ;
  G__G__TMVA4LN_vectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_TVectorTlEfloatgR.tagnum = -1 ;
  G__G__TMVA4LN_TVectorTlEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_TH1D.tagnum = -1 ;
  G__G__TMVA4LN_TH1.tagnum = -1 ;
  G__G__TMVA4LN_TMatrixTBaselEfloatgR.tagnum = -1 ;
  G__G__TMVA4LN_TMatrixTBaselEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_TH2F.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLNode.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLEvent.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLBinaryTree.tagnum = -1 ;
  G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_TMatrixTlEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLVariableTransformBase.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLDataSetInfo.tagnum = -1 ;
  G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLDecisionTree.tagnum = -1 ;
  G__G__TMVA4LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlEcharcOallocatorlEchargRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLRuleEnsemble.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLRule.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLMethodBase.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLRuleFit.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLMethodRuleFit.tagnum = -1 ;
  G__G__TMVA4LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLRuleFitParams.tagnum = -1 ;
  G__G__TMVA4LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlETH2FmUcOallocatorlETH2FmUgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlETH2FmUcOallocatorlETH2FmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLRuleFitAPI.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFMode.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLEModel.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFProgram.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLIntParms.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLRealParms.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLIMethod.tagnum = -1 ;
  G__G__TMVA4LN_pairlEcharcOunsignedsPintgR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgRcLcLiterator.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform.tagnum = -1 ;
  G__G__TMVA4LN_TMatrixTSymlEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform.tagnum = -1 ;
  G__G__TMVA4LN_vectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_TElementActionTlEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_TElementPosActionTlEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_TMatrixTSparselEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_TMatrixTRow_constlEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_TMatrixTRowlEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_TMatrixTDiag_constlEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_TMatrixTColumn_constlEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_TMatrixTSparseRow_constlEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_TMatrixTSparseRowlEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_TMatrixTSparseDiag_constlEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_TMatrixTFlat_constlEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_TMatrixTSub_constlEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_TMatrixTColumnlEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_TMatrixTDiaglEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_TMatrixTFlatlEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_TMatrixTSublEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_TMatrixTSparseDiaglEdoublegR.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLVariablePCATransform.tagnum = -1 ;
  G__G__TMVA4LN_vectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLOptionlEboolgR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlEboolcOallocatorlEboolgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLOptionlEboolmUgR.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLOptionlEfloatgR.tagnum = -1 ;
  G__G__TMVA4LN_TSpline.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLPDF.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLVariableGaussTransform.tagnum = -1 ;
  G__G__TMVA4LN_vectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_vectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform.tagnum = -1 ;
  G__G__TMVA4LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLVariableRearrangeTransform.tagnum = -1 ;
  G__G__TMVA4LN_TMVAcLcLROCCalc.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__TMVA4() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TClass);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TObject);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TString);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_ios_base);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_basic_istreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_basic_ioslEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_basic_ifstreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_basic_ofstreamlEcharcOchar_traitslEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_string);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_basic_ostringstreamlEcharcOchar_traitslEchargRcOallocatorlEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TObjArray);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TFormula);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVA),0,-1,0,(char*)NULL,G__setup_memvarTMVA,G__setup_memfuncTMVA);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTNeuron),sizeof(TMVA::TNeuron),-1,292096,"Neuron class used by MethodANNBase derivative ANNs",G__setup_memvarTMVAcLcLTNeuron,G__setup_memfuncTMVAcLcLTNeuron);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLMsgLogger),sizeof(TMVA::MsgLogger),-1,327424,"Ostringstream derivative to redirect and format logging output",G__setup_memvarTMVAcLcLMsgLogger,G__setup_memfuncTMVAcLcLMsgLogger);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTSynapse),sizeof(TMVA::TSynapse),-1,292096,"Synapse class used by MethodANNBase and derivatives",G__setup_memvarTMVAcLcLTSynapse,G__setup_memfuncTMVAcLcLTSynapse);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTActivation),sizeof(TMVA::TActivation),-1,263430,"Interface for TNeuron activation function classes",G__setup_memvarTMVAcLcLTActivation,G__setup_memfuncTMVAcLcLTActivation);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLEMsgType);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTypes),sizeof(TMVA::Types),-1,263424,(char*)NULL,G__setup_memvarTMVAcLcLTypes,G__setup_memfuncTMVAcLcLTypes);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTypescLcLEMVA);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTypescLcLEVariableTransform);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTypescLcLEAnalysisType);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTypescLcLESBType);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTypescLcLETreeType);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTypescLcLEBoostStage);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTNeuronInput),sizeof(TMVA::TNeuronInput),-1,263426,"Interface for TNeuron input calculation classes",G__setup_memvarTMVAcLcLTNeuronInput,G__setup_memfuncTMVAcLcLTNeuronInput);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTActivationChooser),sizeof(TMVA::TActivationChooser),-1,263424,"Class for choosing activation functions",G__setup_memvarTMVAcLcLTActivationChooser,G__setup_memfuncTMVAcLcLTActivationChooser);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTActivationChoosercLcLEActivationType);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETStringcOallocatorlETStringgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTActivationSigmoid),sizeof(TMVA::TActivationSigmoid),-1,263424,"Sigmoid activation function for TNeuron",G__setup_memvarTMVAcLcLTActivationSigmoid,G__setup_memfuncTMVAcLcLTActivationSigmoid);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTActivationIdentity),sizeof(TMVA::TActivationIdentity),-1,263424,"Identity activation function for TNeuron",G__setup_memvarTMVAcLcLTActivationIdentity,G__setup_memfuncTMVAcLcLTActivationIdentity);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTActivationTanh),sizeof(TMVA::TActivationTanh),-1,263424,"Tanh sigmoid activation function for TNeuron",G__setup_memvarTMVAcLcLTActivationTanh,G__setup_memfuncTMVAcLcLTActivationTanh);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTActivationRadial),sizeof(TMVA::TActivationRadial),-1,263424,"Radial basis activation function for TNeuron",G__setup_memvarTMVAcLcLTActivationRadial,G__setup_memfuncTMVAcLcLTActivationRadial);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSum),sizeof(TMVA::TNeuronInputSum),-1,263424,"Calculates weighted sum of neuron inputs",G__setup_memvarTMVAcLcLTNeuronInputSum,G__setup_memfuncTMVAcLcLTNeuronInputSum);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTNeuronInputSqSum),sizeof(TMVA::TNeuronInputSqSum),-1,263424,"Calculates square of  weighted sum of neuron inputs",G__setup_memvarTMVAcLcLTNeuronInputSqSum,G__setup_memfuncTMVAcLcLTNeuronInputSqSum);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTNeuronInputAbs),sizeof(TMVA::TNeuronInputAbs),-1,263424,"Calculates the sum of the absolute values of the weighted inputs",G__setup_memvarTMVAcLcLTNeuronInputAbs,G__setup_memfuncTMVAcLcLTNeuronInputAbs);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChooser),sizeof(TMVA::TNeuronInputChooser),-1,263424,"Class for choosing neuron input functions ",G__setup_memvarTMVAcLcLTNeuronInputChooser,G__setup_memfuncTMVAcLcLTNeuronInputChooser);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLTNeuronInputChoosercLcLENeuronInputType);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRank);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRanking),sizeof(TMVA::Ranking),-1,296192,"Method-specific ranking for input variables ",G__setup_memvarTMVAcLcLRanking,G__setup_memfuncTMVAcLcLRanking);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLRankcOallocatorlETMVAcLcLRankgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TVectorTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TVectorTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TH1D);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TH1);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTBaselEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTBaselEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TH2F);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLNode);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLEvent);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLBinaryTree);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEfloatcOallocatorlEfloatgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEdoublecOallocatorlEdoublegRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEintcOallocatorlEintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLVariableTransformBase),sizeof(TMVA::VariableTransformBase),-1,324617,"Base class for variable transformations",G__setup_memvarTMVAcLcLVariableTransformBase,G__setup_memfuncTMVAcLcLVariableTransformBase);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLDataSetInfo);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLDecisionTree);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLEventmUcOallocatorlEconstsPTMVAcLcLEventmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLNodemUcOallocatorlEconstsPTMVAcLcLNodemUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEcharcOallocatorlEchargRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRuleEnsemble);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRule);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLMethodBase);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRuleFit),sizeof(TMVA::RuleFit),-1,296704,"Calculations for Friedman's RuleFit method",G__setup_memvarTMVAcLcLRuleFit,G__setup_memfuncTMVAcLcLRuleFit);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLMethodRuleFit);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLDecisionTreemUcOallocatorlEconstsPTMVAcLcLDecisionTreemUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLRulemUcOallocatorlETMVAcLcLRulemUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcOallocatorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRuleFitParams);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETH2FmUcOallocatorlETH2FmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETH2FmUcOallocatorlETH2FmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRuleFitAPI),sizeof(TMVA::RuleFitAPI),-1,296192,"Friedman's RuleFit method",G__setup_memvarTMVAcLcLRuleFitAPI,G__setup_memfuncTMVAcLcLRuleFitAPI);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFMode);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLEModel);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLERFProgram);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLIntParms);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLRuleFitAPIcLcLRealParms);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLIMethod),sizeof(TMVA::IMethod),-1,263438,"Method Interface",G__setup_memvarTMVAcLcLIMethod,G__setup_memfuncTMVAcLcLIMethod);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_pairlEcharcOunsignedsPintgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgRcLcLiterator);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEpairlEcharcOunsignedsPintgRcOallocatorlEpairlEcharcOunsignedsPintgRsPgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLVariableIdentityTransform),sizeof(TMVA::VariableIdentityTransform),-1,324608,"Variable transformation: identity",G__setup_memvarTMVAcLcLVariableIdentityTransform,G__setup_memfuncTMVAcLcLVariableIdentityTransform);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTSymlEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLVariableDecorrTransform),sizeof(TMVA::VariableDecorrTransform),-1,324608,"Variable transformation: decorrelation",G__setup_memvarTMVAcLcLVariableDecorrTransform,G__setup_memfuncTMVAcLcLVariableDecorrTransform);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMatrixTlEdoublegRmUcOallocatorlETMatrixTlEdoublegRmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMatrixTSymlEdoublegRmUcOallocatorlETMatrixTSymlEdoublegRmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TElementActionTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TElementPosActionTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTSparselEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTRow_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTRowlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTDiag_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTColumn_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTSparseRow_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTSparseRowlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTSparseDiag_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTFlat_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTSub_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTColumnlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTDiaglEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTFlatlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTSublEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMatrixTSparseDiaglEdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLVariablePCATransform),sizeof(TMVA::VariablePCATransform),-1,324608,"Variable transformation: Principal Value Composition",G__setup_memvarTMVAcLcLVariablePCATransform,G__setup_memfuncTMVAcLcLVariablePCATransform);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETVectorTlEdoublegRmUcOallocatorlETVectorTlEdoublegRmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLOptionlEboolgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEboolcOallocatorlEboolgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLOptionlEboolmUgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLOptionlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TSpline);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLPDF);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLVariableGaussTransform),sizeof(TMVA::VariableGaussTransform),-1,324608,"Variable transformation: Gauss transformation",G__setup_memvarTMVAcLcLVariableGaussTransform,G__setup_memfuncTMVAcLcLVariableGaussTransform);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcOallocatorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRcOallocatorlEvectorlETMVAcLcLPDFmUcOallocatorlETMVAcLcLPDFmUgRsPgRsPgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLVariableNormalizeTransform),sizeof(TMVA::VariableNormalizeTransform),-1,324608,"Variable transformation: normalization",G__setup_memvarTMVAcLcLVariableNormalizeTransform,G__setup_memfuncTMVAcLcLVariableNormalizeTransform);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__TMVA4LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLVariableRearrangeTransform),sizeof(TMVA::VariableRearrangeTransform),-1,324608,"Variable transformation: normalization",G__setup_memvarTMVAcLcLVariableRearrangeTransform,G__setup_memfuncTMVAcLcLVariableRearrangeTransform);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA4LN_TMVAcLcLROCCalc),sizeof(TMVA::ROCCalc),-1,295936,(char*)NULL,G__setup_memvarTMVAcLcLROCCalc,G__setup_memfuncTMVAcLcLROCCalc);
}
extern "C" void G__cpp_setupG__TMVA4(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__TMVA4()");
  G__set_cpp_environmentG__TMVA4();
  G__cpp_setup_tagtableG__TMVA4();

  G__cpp_setup_inheritanceG__TMVA4();

  G__cpp_setup_typetableG__TMVA4();

  G__cpp_setup_memvarG__TMVA4();

  G__cpp_setup_memfuncG__TMVA4();
  G__cpp_setup_globalG__TMVA4();
  G__cpp_setup_funcG__TMVA4();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__TMVA4();
  return;
}
class G__cpp_setup_initG__TMVA4 {
  public:
    G__cpp_setup_initG__TMVA4() { G__add_setup_func("G__TMVA4",(G__incsetup)(&G__cpp_setupG__TMVA4)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__TMVA4() { G__remove_setup_func("G__TMVA4"); }
};
G__cpp_setup_initG__TMVA4 G__cpp_setup_initializerG__TMVA4;