G__MLP.cxx

Go to the documentation of this file.

//
// File generated by core/utils/src/rootcint_tmp at Wed Apr 20 13:44:25 2011

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

#define R__DICTIONARY_FILENAME mathdImlpdIsrcdIG__MLP
#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__MLP.h"

#include "TClass.h"
#include "TBuffer.h"
#include "TMemberInspector.h"
#include "TError.h"

#ifndef G__ROOT
#define G__ROOT
#endif

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

// START OF SHADOWS

namespace ROOT {
   namespace Shadow {
   } // of namespace Shadow
} // of namespace ROOT
// END OF SHADOWS

namespace ROOT {
   void TNeuron_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TNeuron(void *p = 0);
   static void *newArray_TNeuron(Long_t size, void *p);
   static void delete_TNeuron(void *p);
   static void deleteArray_TNeuron(void *p);
   static void destruct_TNeuron(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TNeuron*)
   {
      ::TNeuron *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TNeuron >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TNeuron", ::TNeuron::Class_Version(), "include/TNeuron.h", 48,
                  typeid(::TNeuron), DefineBehavior(ptr, ptr),
                  &::TNeuron::Dictionary, isa_proxy, 4,
                  sizeof(::TNeuron) );
      instance.SetNew(&new_TNeuron);
      instance.SetNewArray(&newArray_TNeuron);
      instance.SetDelete(&delete_TNeuron);
      instance.SetDeleteArray(&deleteArray_TNeuron);
      instance.SetDestructor(&destruct_TNeuron);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TNeuron*)
   {
      return GenerateInitInstanceLocal((::TNeuron*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TNeuron*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TSynapse_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TSynapse(void *p = 0);
   static void *newArray_TSynapse(Long_t size, void *p);
   static void delete_TSynapse(void *p);
   static void deleteArray_TSynapse(void *p);
   static void destruct_TSynapse(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TSynapse*)
   {
      ::TSynapse *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TSynapse >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TSynapse", ::TSynapse::Class_Version(), "include/TSynapse.h", 32,
                  typeid(::TSynapse), DefineBehavior(ptr, ptr),
                  &::TSynapse::Dictionary, isa_proxy, 4,
                  sizeof(::TSynapse) );
      instance.SetNew(&new_TSynapse);
      instance.SetNewArray(&newArray_TSynapse);
      instance.SetDelete(&delete_TSynapse);
      instance.SetDeleteArray(&deleteArray_TSynapse);
      instance.SetDestructor(&destruct_TSynapse);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TSynapse*)
   {
      return GenerateInitInstanceLocal((::TSynapse*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TSynapse*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMultiLayerPerceptron_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TMultiLayerPerceptron(void *p = 0);
   static void *newArray_TMultiLayerPerceptron(Long_t size, void *p);
   static void delete_TMultiLayerPerceptron(void *p);
   static void deleteArray_TMultiLayerPerceptron(void *p);
   static void destruct_TMultiLayerPerceptron(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMultiLayerPerceptron*)
   {
      ::TMultiLayerPerceptron *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMultiLayerPerceptron >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMultiLayerPerceptron", ::TMultiLayerPerceptron::Class_Version(), "include/TMultiLayerPerceptron.h", 58,
                  typeid(::TMultiLayerPerceptron), DefineBehavior(ptr, ptr),
                  &::TMultiLayerPerceptron::Dictionary, isa_proxy, 4,
                  sizeof(::TMultiLayerPerceptron) );
      instance.SetNew(&new_TMultiLayerPerceptron);
      instance.SetNewArray(&newArray_TMultiLayerPerceptron);
      instance.SetDelete(&delete_TMultiLayerPerceptron);
      instance.SetDeleteArray(&deleteArray_TMultiLayerPerceptron);
      instance.SetDestructor(&destruct_TMultiLayerPerceptron);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMultiLayerPerceptron*)
   {
      return GenerateInitInstanceLocal((::TMultiLayerPerceptron*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMultiLayerPerceptron*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TMLPAnalyzer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TMLPAnalyzer(void *p);
   static void deleteArray_TMLPAnalyzer(void *p);
   static void destruct_TMLPAnalyzer(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMLPAnalyzer*)
   {
      ::TMLPAnalyzer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMLPAnalyzer >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TMLPAnalyzer", ::TMLPAnalyzer::Class_Version(), "include/TMLPAnalyzer.h", 38,
                  typeid(::TMLPAnalyzer), DefineBehavior(ptr, ptr),
                  &::TMLPAnalyzer::Dictionary, isa_proxy, 4,
                  sizeof(::TMLPAnalyzer) );
      instance.SetDelete(&delete_TMLPAnalyzer);
      instance.SetDeleteArray(&deleteArray_TMLPAnalyzer);
      instance.SetDestructor(&destruct_TMLPAnalyzer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TMLPAnalyzer*)
   {
      return GenerateInitInstanceLocal((::TMLPAnalyzer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMLPAnalyzer*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

//______________________________________________________________________________
TClass *TNeuron::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
TClass *TSynapse::fgIsA = 0;  // static to hold class pointer

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

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

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

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

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

//______________________________________________________________________________
TClass *TMultiLayerPerceptron::fgIsA = 0;  // static to hold class pointer

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

//______________________________________________________________________________
const char *TMultiLayerPerceptron::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMultiLayerPerceptron*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TMultiLayerPerceptron::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMultiLayerPerceptron*)0x0)->GetImplFileLine();
}

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

//______________________________________________________________________________
TClass *TMultiLayerPerceptron::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMultiLayerPerceptron*)0x0)->GetClass();
   return fgIsA;
}

//______________________________________________________________________________
TClass *TMLPAnalyzer::fgIsA = 0;  // static to hold class pointer

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

//______________________________________________________________________________
const char *TMLPAnalyzer::ImplFileName()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMLPAnalyzer*)0x0)->GetImplFileName();
}

//______________________________________________________________________________
int TMLPAnalyzer::ImplFileLine()
{
   return ::ROOT::GenerateInitInstanceLocal((const ::TMLPAnalyzer*)0x0)->GetImplFileLine();
}

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

//______________________________________________________________________________
TClass *TMLPAnalyzer::Class()
{
   if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMLPAnalyzer*)0x0)->GetClass();
   return fgIsA;
}

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

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

//______________________________________________________________________________
void TNeuron::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TNeuron.
      TClass *R__cl = ::TNeuron::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fpre", &fpre);
      R__insp.InspectMember(fpre, "fpre.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fpost", &fpost);
      R__insp.InspectMember(fpost, "fpost.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "flayer", &flayer);
      R__insp.InspectMember(flayer, "flayer.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWeight", &fWeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNorm[2]", fNorm);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExtF", &fExtF);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fExtD", &fExtD);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFormula", &fFormula);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fIndex", &fIndex);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNewInput", &fNewInput);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fInput", &fInput);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNewValue", &fNewValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fValue", &fValue);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNewDeriv", &fNewDeriv);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDerivative", &fDerivative);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNewDeDw", &fNewDeDw);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDeDw", &fDeDw);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDEDw", &fDEDw);
      TNamed::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TNeuron(void *p) {
      return  p ? new(p) ::TNeuron : new ::TNeuron;
   }
   static void *newArray_TNeuron(Long_t nElements, void *p) {
      return p ? new(p) ::TNeuron[nElements] : new ::TNeuron[nElements];
   }
   // Wrapper around operator delete
   static void delete_TNeuron(void *p) {
      delete ((::TNeuron*)p);
   }
   static void deleteArray_TNeuron(void *p) {
      delete [] ((::TNeuron*)p);
   }
   static void destruct_TNeuron(void *p) {
      typedef ::TNeuron current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TNeuron

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

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

//______________________________________________________________________________
void TSynapse::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TSynapse.
      TClass *R__cl = ::TSynapse::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fpre", &fpre);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fpost", &fpost);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fweight", &fweight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDEDw", &fDEDw);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TSynapse(void *p) {
      return  p ? new(p) ::TSynapse : new ::TSynapse;
   }
   static void *newArray_TSynapse(Long_t nElements, void *p) {
      return p ? new(p) ::TSynapse[nElements] : new ::TSynapse[nElements];
   }
   // Wrapper around operator delete
   static void delete_TSynapse(void *p) {
      delete ((::TSynapse*)p);
   }
   static void deleteArray_TSynapse(void *p) {
      delete [] ((::TSynapse*)p);
   }
   static void destruct_TSynapse(void *p) {
      typedef ::TSynapse current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TSynapse

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

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

//______________________________________________________________________________
void TMultiLayerPerceptron::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TMultiLayerPerceptron.
      TClass *R__cl = ::TMultiLayerPerceptron::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fData", &fData);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentTree", &fCurrentTree);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCurrentTreeWeight", &fCurrentTreeWeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fNetwork", &fNetwork);
      R__insp.InspectMember(fNetwork, "fNetwork.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFirstLayer", &fFirstLayer);
      R__insp.InspectMember(fFirstLayer, "fFirstLayer.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastLayer", &fLastLayer);
      R__insp.InspectMember(fLastLayer, "fLastLayer.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fSynapses", &fSynapses);
      R__insp.InspectMember(fSynapses, "fSynapses.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStructure", &fStructure);
      R__insp.InspectMember(fStructure, "fStructure.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fWeight", &fWeight);
      R__insp.InspectMember(fWeight, "fWeight.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fType", &fType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fOutType", &fOutType);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fextF", &fextF);
      R__insp.InspectMember(fextF, "fextF.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fextD", &fextD);
      R__insp.InspectMember(fextD, "fextD.");
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTraining", &fTraining);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTest", &fTest);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLearningMethod", &fLearningMethod);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEventWeight", &fEventWeight);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fManager", &fManager);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEta", &fEta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEpsilon", &fEpsilon);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDelta", &fDelta);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEtaDecay", &fEtaDecay);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTau", &fTau);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastAlpha", &fLastAlpha);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fReset", &fReset);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrainingOwner", &fTrainingOwner);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fTestOwner", &fTestOwner);
      TObject::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TMultiLayerPerceptron(void *p) {
      return  p ? new(p) ::TMultiLayerPerceptron : new ::TMultiLayerPerceptron;
   }
   static void *newArray_TMultiLayerPerceptron(Long_t nElements, void *p) {
      return p ? new(p) ::TMultiLayerPerceptron[nElements] : new ::TMultiLayerPerceptron[nElements];
   }
   // Wrapper around operator delete
   static void delete_TMultiLayerPerceptron(void *p) {
      delete ((::TMultiLayerPerceptron*)p);
   }
   static void deleteArray_TMultiLayerPerceptron(void *p) {
      delete [] ((::TMultiLayerPerceptron*)p);
   }
   static void destruct_TMultiLayerPerceptron(void *p) {
      typedef ::TMultiLayerPerceptron current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMultiLayerPerceptron

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

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

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

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TMLPAnalyzer(void *p) {
      delete ((::TMLPAnalyzer*)p);
   }
   static void deleteArray_TMLPAnalyzer(void *p) {
      delete [] ((::TMLPAnalyzer*)p);
   }
   static void destruct_TMLPAnalyzer(void *p) {
      typedef ::TMLPAnalyzer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::TMLPAnalyzer

/********************************************************
* math/mlp/src/G__MLP.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__MLP();

extern "C" void G__set_cpp_environmentG__MLP() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TMLPAnalyzer.h");
  G__add_compiledheader("TMultiLayerPerceptron.h");
  G__add_compiledheader("TNeuron.h");
  G__add_compiledheader("TSynapse.h");
  G__cpp_reset_tagtableG__MLP();
}
#include <new>
extern "C" int G__cpp_dllrevG__MLP() { return(30051515); }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static int G__G__MLP_100_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 68, (long) ((const TNeuron*) G__getstructoffset())->GetNormalisation());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

static int G__G__MLP_101_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TSynapse*) G__getstructoffset())->GetPre());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_101_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TSynapse*) G__getstructoffset())->GetPost());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

static int G__G__MLP_102_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMultiLayerPerceptron* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (TNeuron::ENeuronType) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (TNeuron::ENeuronType) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (TNeuron::ENeuronType) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (TNeuron::ENeuronType) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (TNeuron::ENeuronType) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (TNeuron::ENeuronType) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron((const char*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron((const char*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1]));
     }
     break;
   case 1:
     //m: 1
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron((const char*) G__int(libp->para[0]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron((const char*) 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__MLPLN_TMultiLayerPerceptron));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMultiLayerPerceptron* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TTree*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (TNeuron::ENeuronType) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (const char*) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TTree*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (TNeuron::ENeuronType) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (const char*) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TTree*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (TNeuron::ENeuronType) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TTree*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (TNeuron::ENeuronType) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TTree*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (TNeuron::ENeuronType) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TTree*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]), (TNeuron::ENeuronType) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TTree*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TTree*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
, (const char*) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TTree*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TTree*) G__int(libp->para[2]), (const char*) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TTree*) G__int(libp->para[2]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TTree*) G__int(libp->para[2]));
     }
     break;
   case 2:
     //m: 2
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron((const char*) G__int(libp->para[0]), (const char*) 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__MLPLN_TMultiLayerPerceptron));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMultiLayerPerceptron* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (TEventList*) G__int(libp->para[2]), (TEventList*) G__int(libp->para[3])
, (TNeuron::ENeuronType) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (TEventList*) G__int(libp->para[2]), (TEventList*) G__int(libp->para[3])
, (TNeuron::ENeuronType) G__int(libp->para[4]), (const char*) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (TEventList*) G__int(libp->para[2]), (TEventList*) G__int(libp->para[3])
, (TNeuron::ENeuronType) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (TEventList*) G__int(libp->para[2]), (TEventList*) G__int(libp->para[3])
, (TNeuron::ENeuronType) G__int(libp->para[4]), (const char*) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (TEventList*) G__int(libp->para[2]), (TEventList*) G__int(libp->para[3])
, (TNeuron::ENeuronType) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (TEventList*) G__int(libp->para[2]), (TEventList*) G__int(libp->para[3])
, (TNeuron::ENeuronType) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (TEventList*) G__int(libp->para[2]), (TEventList*) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (TTree*) G__int(libp->para[1])
, (TEventList*) G__int(libp->para[2]), (TEventList*) G__int(libp->para[3]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptron));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   TMultiLayerPerceptron* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 8:
     //m: 8
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TTree*) G__int(libp->para[2]), (TEventList*) G__int(libp->para[3])
, (TEventList*) G__int(libp->para[4]), (TNeuron::ENeuronType) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (const char*) G__int(libp->para[7]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TTree*) G__int(libp->para[2]), (TEventList*) G__int(libp->para[3])
, (TEventList*) G__int(libp->para[4]), (TNeuron::ENeuronType) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]), (const char*) G__int(libp->para[7]));
     }
     break;
   case 7:
     //m: 7
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TTree*) G__int(libp->para[2]), (TEventList*) G__int(libp->para[3])
, (TEventList*) G__int(libp->para[4]), (TNeuron::ENeuronType) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TTree*) G__int(libp->para[2]), (TEventList*) G__int(libp->para[3])
, (TEventList*) G__int(libp->para[4]), (TNeuron::ENeuronType) G__int(libp->para[5])
, (const char*) G__int(libp->para[6]));
     }
     break;
   case 6:
     //m: 6
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TTree*) G__int(libp->para[2]), (TEventList*) G__int(libp->para[3])
, (TEventList*) G__int(libp->para[4]), (TNeuron::ENeuronType) G__int(libp->para[5]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TTree*) G__int(libp->para[2]), (TEventList*) G__int(libp->para[3])
, (TEventList*) G__int(libp->para[4]), (TNeuron::ENeuronType) G__int(libp->para[5]));
     }
     break;
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TTree*) G__int(libp->para[2]), (TEventList*) G__int(libp->para[3])
, (TEventList*) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) TMultiLayerPerceptron(
(const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (TTree*) G__int(libp->para[2]), (TEventList*) G__int(libp->para[3])
, (TEventList*) G__int(libp->para[4]));
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptron));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiLayerPerceptron*) G__getstructoffset())->SetData((TTree*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiLayerPerceptron*) G__getstructoffset())->SetTrainingDataSet((TEventList*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiLayerPerceptron*) G__getstructoffset())->SetTestDataSet((TEventList*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiLayerPerceptron*) G__getstructoffset())->SetTrainingDataSet((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiLayerPerceptron*) G__getstructoffset())->SetTestDataSet((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiLayerPerceptron*) G__getstructoffset())->SetLearningMethod((TMultiLayerPerceptron::ELearningMethod) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiLayerPerceptron*) G__getstructoffset())->SetEventWeight((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((TMultiLayerPerceptron*) G__getstructoffset())->Train((Int_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])
, (Double_t) G__double(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((TMultiLayerPerceptron*) G__getstructoffset())->Train((Int_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((TMultiLayerPerceptron*) G__getstructoffset())->Train((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__MLP_102_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiLayerPerceptron*) G__getstructoffset())->GetError((TMultiLayerPerceptron::EDataSet) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TMultiLayerPerceptron*) G__getstructoffset())->ComputeDEDw();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const TMultiLayerPerceptron*) G__getstructoffset())->Randomize();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiLayerPerceptron*) G__getstructoffset())->SetEta((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiLayerPerceptron*) G__getstructoffset())->SetEpsilon((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiLayerPerceptron*) G__getstructoffset())->SetDelta((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiLayerPerceptron*) G__getstructoffset())->SetEtaDecay((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiLayerPerceptron*) G__getstructoffset())->SetTau((Double_t) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMultiLayerPerceptron*) G__getstructoffset())->SetReset((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiLayerPerceptron*) G__getstructoffset())->GetEta());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiLayerPerceptron*) G__getstructoffset())->GetEpsilon());
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__MLP_102_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiLayerPerceptron*) G__getstructoffset())->GetEtaDecay());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiLayerPerceptron*) G__getstructoffset())->GetTau());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMultiLayerPerceptron*) G__getstructoffset())->GetReset());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const TString* pobj;
         const TString xobj = ((const TMultiLayerPerceptron*) G__getstructoffset())->GetStructure();
         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__MLP_102_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const TMultiLayerPerceptron*) G__getstructoffset())->GetType());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TMultiLayerPerceptron*) G__getstructoffset())->DrawResult((Int_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TMultiLayerPerceptron*) G__getstructoffset())->DrawResult((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((const TMultiLayerPerceptron*) G__getstructoffset())->DrawResult();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__MLP_102_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      ((TMultiLayerPerceptron*) G__getstructoffset())->LoadWeights((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((TMultiLayerPerceptron*) G__getstructoffset())->LoadWeights();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const TMultiLayerPerceptron*) G__getstructoffset())->Evaluate((Int_t) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_102_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      ((const TMultiLayerPerceptron*) G__getstructoffset())->Export((Option_t*) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1]));
      G__setnull(result7);
      break;
   case 1:
      ((const TMultiLayerPerceptron*) G__getstructoffset())->Export((Option_t*) G__int(libp->para[0]));
      G__setnull(result7);
      break;
   case 0:
      ((const TMultiLayerPerceptron*) G__getstructoffset())->Export();
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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


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

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

static int G__G__MLP_105_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMLPAnalyzer*) G__getstructoffset())->DrawNetwork((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
, (const char*) G__int(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_105_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMLPAnalyzer*) G__getstructoffset())->DrawDInput((Int_t) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_105_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMLPAnalyzer*) G__getstructoffset())->DrawDInputs();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_105_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TMLPAnalyzer*) G__getstructoffset())->DrawTruthDeviation((Int_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TMLPAnalyzer*) G__getstructoffset())->DrawTruthDeviation((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TMLPAnalyzer*) G__getstructoffset())->DrawTruthDeviation());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_105_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 1:
      G__letint(result7, 85, (long) ((TMLPAnalyzer*) G__getstructoffset())->DrawTruthDeviations((Option_t*) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TMLPAnalyzer*) G__getstructoffset())->DrawTruthDeviations());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__MLP_105_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 85, (long) ((TMLPAnalyzer*) G__getstructoffset())->DrawTruthDeviationInsOut((Int_t) G__int(libp->para[0]), (Option_t*) G__int(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 85, (long) ((TMLPAnalyzer*) G__getstructoffset())->DrawTruthDeviationInsOut((Int_t) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 85, (long) ((TMLPAnalyzer*) G__getstructoffset())->DrawTruthDeviationInsOut());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_105_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMLPAnalyzer*) G__getstructoffset())->CheckNetwork();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_105_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TMLPAnalyzer*) G__getstructoffset())->GatherInformations();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__MLP_105_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 85, (long) ((const TMLPAnalyzer*) G__getstructoffset())->GetIOTree());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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


/* Setting up global function */

/*********************************************************
* Member function Stub
*********************************************************/

/* TNeuron */

/* TSynapse */

/* TMultiLayerPerceptron */

/* TMLPAnalyzer */

/*********************************************************
* Global function Stub
*********************************************************/

/*********************************************************
* Get size of pointer to member function
*********************************************************/
class G__Sizep2memfuncG__MLP {
 public:
  G__Sizep2memfuncG__MLP(): p(&G__Sizep2memfuncG__MLP::sizep2memfunc) {}
    size_t sizep2memfunc() { return(sizeof(p)); }
  private:
    size_t (G__Sizep2memfuncG__MLP::*p)();
};

size_t G__get_sizep2memfuncG__MLP()
{
  G__Sizep2memfuncG__MLP a;
  G__setsizep2memfunc((int)a.sizep2memfunc());
  return((size_t)a.sizep2memfunc());
}


/*********************************************************
* virtual base class offset calculation interface
*********************************************************/

   /* Setting up class inheritance */

/*********************************************************
* Inheritance information setup/
*********************************************************/
extern "C" void G__cpp_setup_inheritanceG__MLP() {

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MLPLN_TNeuron))) {
     TNeuron *G__Lderived;
     G__Lderived=(TNeuron*)0x1000;
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MLPLN_TNeuron),G__get_linked_tagnum(&G__G__MLPLN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MLPLN_TNeuron),G__get_linked_tagnum(&G__G__MLPLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MLPLN_TSynapse))) {
     TSynapse *G__Lderived;
     G__Lderived=(TSynapse*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MLPLN_TSynapse),G__get_linked_tagnum(&G__G__MLPLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptron))) {
     TMultiLayerPerceptron *G__Lderived;
     G__Lderived=(TMultiLayerPerceptron*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptron),G__get_linked_tagnum(&G__G__MLPLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MLPLN_TMLPAnalyzer))) {
     TMLPAnalyzer *G__Lderived;
     G__Lderived=(TMLPAnalyzer*)0x1000;
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__MLPLN_TMLPAnalyzer),G__get_linked_tagnum(&G__G__MLPLN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
}

/*********************************************************
* typedef information setup/
*********************************************************/
extern "C" void G__cpp_setup_typetableG__MLP() {

   /* 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("Double_t",100,-1,0,-1);
   G__setnewtype(-1,"Double 8 bytes",0);
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("Option_t",99,-1,256,-1);
   G__setnewtype(-1,"Option string (const char)",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__MLPLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MLPLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MLPLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MLPLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MLPLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__MLPLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MLPLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MLPLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MLPLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MLPLN_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__MLPLN_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__MLPLN_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__MLPLN_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__MLPLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TMatrixTBaselEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TMatrixTBaselEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TVectorTlEfloatgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TVectorTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixT<Double_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TMatrixTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow_const<Double_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TMatrixTRow_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn_const<Double_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TMatrixTColumn_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag_const<Double_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TMatrixTDiag_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat_const<Double_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TMatrixTFlat_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub_const<Double_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TMatrixTSub_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow_const<Double_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TMatrixTSparseRow_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag_const<Double_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TMatrixTSparseDiag_constlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTRow<Double_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TMatrixTRowlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTColumn<Double_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TMatrixTColumnlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTDiag<Double_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TMatrixTDiaglEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTFlat<Double_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TMatrixTFlatlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSub<Double_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TMatrixTSublEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseRow<Double_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TMatrixTSparseRowlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TMatrixTSparseDiag<Double_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TMatrixTSparseDiaglEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementActionT<Double_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TElementActionTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("TElementPosActionT<Double_t>",117,G__get_linked_tagnum(&G__G__MLPLN_TElementPosActionTlEdoublegR),0,-1);
   G__setnewtype(-1,NULL,0);
}

/*********************************************************
* Data Member information setup/
*********************************************************/

   /* Setting up class,struct,union tag member variable */

   /* TNeuron */
static void G__setup_memvarTNeuron(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MLPLN_TNeuron));
   { TNeuron *p; p=(TNeuron*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MLPLN_TNeuroncLcLENeuronType),-1,-2,1,G__FastAllocString(2048).Format("kOff=%lldLL",(long long)TNeuron::kOff).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MLPLN_TNeuroncLcLENeuronType),-1,-2,1,G__FastAllocString(2048).Format("kLinear=%lldLL",(long long)TNeuron::kLinear).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MLPLN_TNeuroncLcLENeuronType),-1,-2,1,G__FastAllocString(2048).Format("kSigmoid=%lldLL",(long long)TNeuron::kSigmoid).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MLPLN_TNeuroncLcLENeuronType),-1,-2,1,G__FastAllocString(2048).Format("kTanh=%lldLL",(long long)TNeuron::kTanh).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MLPLN_TNeuroncLcLENeuronType),-1,-2,1,G__FastAllocString(2048).Format("kGauss=%lldLL",(long long)TNeuron::kGauss).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MLPLN_TNeuroncLcLENeuronType),-1,-2,1,G__FastAllocString(2048).Format("kSoftmax=%lldLL",(long long)TNeuron::kSoftmax).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MLPLN_TNeuroncLcLENeuronType),-1,-2,1,G__FastAllocString(2048).Format("kExternal=%lldLL",(long long)TNeuron::kExternal).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MLPLN_TObjArray),-1,-1,4,"fpre=",0,"pointers to the previous level in a network");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MLPLN_TObjArray),-1,-1,4,"fpost=",0,"pointers to the next level in a network");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MLPLN_TObjArray),-1,-1,4,"flayer=",0,"pointers to the current level in a network (neurons, not synapses)");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fWeight=",0,"weight used for computation");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fNorm[2]=",0,"normalisation to mean=0, RMS=1.");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__MLPLN_TNeuroncLcLENeuronType),-1,-1,4,"fType=",0,"neuron type");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MLPLN_TFormula),-1,-1,4,"fExtF=",0,"function   (external mode)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MLPLN_TFormula),-1,-1,4,"fExtD=",0,"derivative (external mode)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MLPLN_TTreeFormula),-1,-1,4,"fFormula=",0,"! formula to be used for inputs and outputs");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIndex=",0,"! index in the formula");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNewInput=",0,"! do we need to compute fInput again ?");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fInput=",0,"! buffer containing the last neuron input");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNewValue=",0,"! do we need to compute fValue again ?");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fValue=",0,"! buffer containing the last neuron output");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNewDeriv=",0,"! do we need to compute fDerivative again ?");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDerivative=",0,"! buffer containing the last neuron derivative");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fNewDeDw=",0,"! do we need to compute fDeDw again ?");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDeDw=",0,"! buffer containing the last derivative of the error");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDEDw=",0,"! buffer containing the sum over all examples of DeDw");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MLPLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TSynapse */
static void G__setup_memvarTSynapse(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MLPLN_TSynapse));
   { TSynapse *p; p=(TSynapse*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MLPLN_TNeuron),-1,-1,4,"fpre=",0,"the neuron before the synapse");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MLPLN_TNeuron),-1,-1,4,"fpost=",0,"the neuron after the synapse");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fweight=",0,"the weight of the synapse");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDEDw=",0,"! the derivative of the total error wrt the synapse weight");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MLPLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMultiLayerPerceptron */
static void G__setup_memvarTMultiLayerPerceptron(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptron));
   { TMultiLayerPerceptron *p; p=(TMultiLayerPerceptron*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptroncLcLELearningMethod),-1,-2,1,G__FastAllocString(2048).Format("kStochastic=%lldLL",(long long)TMultiLayerPerceptron::kStochastic).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptroncLcLELearningMethod),-1,-2,1,G__FastAllocString(2048).Format("kBatch=%lldLL",(long long)TMultiLayerPerceptron::kBatch).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptroncLcLELearningMethod),-1,-2,1,G__FastAllocString(2048).Format("kSteepestDescent=%lldLL",(long long)TMultiLayerPerceptron::kSteepestDescent).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptroncLcLELearningMethod),-1,-2,1,G__FastAllocString(2048).Format("kRibierePolak=%lldLL",(long long)TMultiLayerPerceptron::kRibierePolak).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptroncLcLELearningMethod),-1,-2,1,G__FastAllocString(2048).Format("kFletcherReeves=%lldLL",(long long)TMultiLayerPerceptron::kFletcherReeves).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptroncLcLELearningMethod),-1,-2,1,G__FastAllocString(2048).Format("kBFGS=%lldLL",(long long)TMultiLayerPerceptron::kBFGS).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptroncLcLEDataSet),-1,-2,1,G__FastAllocString(2048).Format("kTraining=%lldLL",(long long)TMultiLayerPerceptron::kTraining).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptroncLcLEDataSet),-1,-2,1,G__FastAllocString(2048).Format("kTest=%lldLL",(long long)TMultiLayerPerceptron::kTest).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MLPLN_TTree),-1,-1,4,"fData=",0,"! pointer to the tree used as datasource");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCurrentTree=",0,"! index of the current tree in a chain");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCurrentTreeWeight=",0,"! weight of the current tree in a chain");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MLPLN_TObjArray),-1,-1,4,"fNetwork=",0,"Collection of all the neurons in the network");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MLPLN_TObjArray),-1,-1,4,"fFirstLayer=",0,"Collection of the input neurons; subset of fNetwork");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MLPLN_TObjArray),-1,-1,4,"fLastLayer=",0,"Collection of the output neurons; subset of fNetwork");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MLPLN_TObjArray),-1,-1,4,"fSynapses=",0,"Collection of all the synapses in the network");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MLPLN_TString),-1,-1,4,"fStructure=",0,"String containing the network structure");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MLPLN_TString),-1,-1,4,"fWeight=",0,"String containing the event weight");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__MLPLN_TNeuroncLcLENeuronType),-1,-1,4,"fType=",0,"Type of hidden neurons");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__MLPLN_TNeuroncLcLENeuronType),-1,-1,4,"fOutType=",0,"Type of output neurons");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MLPLN_TString),-1,-1,4,"fextF=",0,"String containing the function name");
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MLPLN_TString),-1,-1,4,"fextD=",0,"String containing the derivative name");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MLPLN_TEventList),-1,-1,4,"fTraining=",0,"! EventList defining the events in the training dataset");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MLPLN_TEventList),-1,-1,4,"fTest=",0,"! EventList defining the events in the test dataset");
   G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptroncLcLELearningMethod),-1,-1,4,"fLearningMethod=",0,"! The Learning Method");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MLPLN_TTreeFormula),-1,-1,4,"fEventWeight=",0,"! formula representing the event weight");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MLPLN_TTreeFormulaManager),-1,-1,4,"fManager=",0,"! TTreeFormulaManager for the weight and neurons");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEta=",0,"! Eta - used in stochastic minimisation - Default=0.1");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEpsilon=",0,"! Epsilon - used in stochastic minimisation - Default=0.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDelta=",0,"! Delta - used in stochastic minimisation - Default=0.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEtaDecay=",0,"! EtaDecay - Eta *= EtaDecay at each epoch - Default=1.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTau=",0,"! Tau - used in line search - Default=3.");
   G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fLastAlpha=",0,"! internal parameter used in line search");
   G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fReset=",0,"! number of epochs between two resets of the search direction to the steepest descent - Default=50");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTrainingOwner=",0,"! internal flag whether one has to delete fTraining or not");
   G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTestOwner=",0,"! internal flag whether one has to delete fTest or not");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MLPLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TMLPAnalyzer */
static void G__setup_memvarTMLPAnalyzer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MLPLN_TMLPAnalyzer));
   { TMLPAnalyzer *p; p=(TMLPAnalyzer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptron),-1,-1,4,"fNetwork=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MLPLN_TTree),-1,-1,4,"fAnalysisTree=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MLPLN_TTree),-1,-1,4,"fIOTree=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MLPLN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

extern "C" void G__cpp_setup_memvarG__MLP() {
}
/***********************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
************************************************************
***********************************************************/

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncTNeuron(void) {
   /* TNeuron */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MLPLN_TNeuron));
   G__memfunc_setup("TNeuron",715,G__G__MLP_100_0_1, 105, G__get_linked_tagnum(&G__G__MLPLN_TNeuron), -1, 0, 5, 1, 1, 0, 
"i 'TNeuron::ENeuronType' - 0 'kSigmoid' type C - - 10 '\"\"' name "
"C - - 10 '\"\"' title C - - 10 '\"\"' extF "
"C - - 10 '\"\"' extD", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPre",583,G__G__MLP_100_0_2, 85, G__get_linked_tagnum(&G__G__MLPLN_TSynapse), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPost",710,G__G__MLP_100_0_3, 85, G__get_linked_tagnum(&G__G__MLPLN_TSynapse), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInLayer",980,G__G__MLP_100_0_4, 85, G__get_linked_tagnum(&G__G__MLPLN_TNeuron), -1, 0, 1, 1, 1, 8, "i - 'Int_t' 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UseBranch",891,G__G__MLP_100_0_5, 85, G__get_linked_tagnum(&G__G__MLPLN_TTreeFormula), -1, 0, 2, 1, 1, 0, 
"U 'TTree' - 0 - - C - - 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInput",816,G__G__MLP_100_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValue",797,G__G__MLP_100_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDerivative",1331,G__G__MLP_100_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetError",810,G__G__MLP_100_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTarget",903,G__G__MLP_100_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDeDw",644,G__G__MLP_100_0_11, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBranch",878,G__G__MLP_100_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetType",706,G__G__MLP_100_0_13, 105, G__get_linked_tagnum(&G__G__MLPLN_TNeuroncLcLENeuronType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWeight",916,G__G__MLP_100_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWeight",904,G__G__MLP_100_0_15, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNormalisation",1676,G__G__MLP_100_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - 'Double_t' 0 - mean d - 'Double_t' 0 - RMS", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNormalisation",1664,G__G__MLP_100_0_17, 68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetNewEvent",1112,G__G__MLP_100_0_18, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDEDw",624,G__G__MLP_100_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDEDw",612,G__G__MLP_100_0_20, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ForceExternalValue",1839,G__G__MLP_100_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddInLayer",957,G__G__MLP_100_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TNeuron' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Sigmoid",716,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 2, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DSigmoid",784,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 2, 8, "d - 'Double_t' 0 - x", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPre",560,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TSynapse' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AddPost",687,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TSynapse' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TNeuron",715,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MLPLN_TNeuron), -1, 0, 1, 1, 4, 0, "u 'TNeuron' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MLPLN_TNeuron), -1, 1, 1, 1, 4, 0, "u 'TNeuron' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__MLP_100_0_29, 85, G__get_linked_tagnum(&G__G__MLPLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TNeuron::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__MLP_100_0_30, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNeuron::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__MLP_100_0_31, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TNeuron::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__MLP_100_0_32, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TNeuron::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MLPLN_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 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__MLP_100_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__MLP_100_0_37, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNeuron::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__MLP_100_0_38, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNeuron::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__MLP_100_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TNeuron::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__MLP_100_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TNeuron::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TNeuron", 841, G__G__MLP_100_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTSynapse(void) {
   /* TSynapse */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MLPLN_TSynapse));
   G__memfunc_setup("TSynapse",823,G__G__MLP_101_0_1, 105, G__get_linked_tagnum(&G__G__MLPLN_TSynapse), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TSynapse",823,G__G__MLP_101_0_2, 105, G__get_linked_tagnum(&G__G__MLPLN_TSynapse), -1, 0, 3, 1, 1, 0, 
"U 'TNeuron' - 0 - - U 'TNeuron' - 0 - - "
"d - 'Double_t' 0 '1' w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPre",595,G__G__MLP_101_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TNeuron' - 0 - pre", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPost",722,G__G__MLP_101_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TNeuron' - 0 - post", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPre",583,G__G__MLP_101_0_5, 85, G__get_linked_tagnum(&G__G__MLPLN_TNeuron), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetPost",710,G__G__MLP_101_0_6, 85, G__get_linked_tagnum(&G__G__MLPLN_TNeuron), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetWeight",916,G__G__MLP_101_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - w", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetWeight",904,G__G__MLP_101_0_8, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetValue",797,G__G__MLP_101_0_9, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDeDw",644,G__G__MLP_101_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDEDw",624,G__G__MLP_101_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDEDw",612,G__G__MLP_101_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__MLP_101_0_13, 85, G__get_linked_tagnum(&G__G__MLPLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TSynapse::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__MLP_101_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSynapse::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__MLP_101_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TSynapse::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__MLP_101_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TSynapse::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MLPLN_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 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__MLP_101_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__MLP_101_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSynapse::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__MLP_101_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSynapse::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__MLP_101_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TSynapse::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__MLP_101_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TSynapse::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TSynapse", 823, G__G__MLP_101_0_25, (int) ('i'), G__get_linked_tagnum(&G__G__MLPLN_TSynapse), -1, 0, 1, 1, 1, 0, "u 'TSynapse' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TSynapse", 949, G__G__MLP_101_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__MLP_101_0_27, (int) ('u'), G__get_linked_tagnum(&G__G__MLPLN_TSynapse), -1, 1, 1, 1, 1, 0, "u 'TSynapse' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMultiLayerPerceptron(void) {
   /* TMultiLayerPerceptron */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptron));
   G__memfunc_setup("TMultiLayerPerceptron",2174,G__G__MLP_102_0_1, 105, G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptron), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMultiLayerPerceptron",2174,G__G__MLP_102_0_2, 105, G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptron), -1, 0, 7, 1, 1, 0, 
"C - - 10 - layout U 'TTree' - 0 '0' data "
"C - - 10 '\"Entry$%2==0\"' training C - - 10 '\"\"' test "
"i 'TNeuron::ENeuronType' - 0 'TNeuron::kSigmoid' type C - - 10 '\"\"' extF "
"C - - 10 '\"\"' extD", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMultiLayerPerceptron",2174,G__G__MLP_102_0_3, 105, G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptron), -1, 0, 8, 1, 1, 0, 
"C - - 10 - layout C - - 10 - weight "
"U 'TTree' - 0 '0' data C - - 10 '\"Entry$%2==0\"' training "
"C - - 10 '\"\"' test i 'TNeuron::ENeuronType' - 0 'TNeuron::kSigmoid' type "
"C - - 10 '\"\"' extF C - - 10 '\"\"' extD", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMultiLayerPerceptron",2174,G__G__MLP_102_0_4, 105, G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptron), -1, 0, 7, 1, 1, 0, 
"C - - 10 - layout U 'TTree' - 0 - data "
"U 'TEventList' - 0 - training U 'TEventList' - 0 - test "
"i 'TNeuron::ENeuronType' - 0 'TNeuron::kSigmoid' type C - - 10 '\"\"' extF "
"C - - 10 '\"\"' extD", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMultiLayerPerceptron",2174,G__G__MLP_102_0_5, 105, G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptron), -1, 0, 8, 1, 1, 0, 
"C - - 10 - layout C - - 10 - weight "
"U 'TTree' - 0 - data U 'TEventList' - 0 - training "
"U 'TEventList' - 0 - test i 'TNeuron::ENeuronType' - 0 'TNeuron::kSigmoid' type "
"C - - 10 '\"\"' extF C - - 10 '\"\"' extD", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetData",678,G__G__MLP_102_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TTree' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrainingDataSet",1806,G__G__MLP_102_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEventList' - 0 - train", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTestDataSet",1394,G__G__MLP_102_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TEventList' - 0 - test", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTrainingDataSet",1806,G__G__MLP_102_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - train", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTestDataSet",1394,G__G__MLP_102_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - test", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLearningMethod",1725,G__G__MLP_102_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TMultiLayerPerceptron::ELearningMethod' - 0 - method", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEventWeight",1430,G__G__MLP_102_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Train",510,G__G__MLP_102_0_13, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - nEpoch C - 'Option_t' 10 '\"text\"' option "
"d - 'Double_t' 0 '0' minE", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Result",639,G__G__MLP_102_0_14, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - event i - 'Int_t' 0 '0' index", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetError",810,G__G__MLP_102_0_15, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - event", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetError",810,G__G__MLP_102_0_16, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i 'TMultiLayerPerceptron::EDataSet' - 0 - set", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ComputeDEDw",1057,G__G__MLP_102_0_17, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Randomize",937,G__G__MLP_102_0_18, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEta",582,G__G__MLP_102_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - eta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEpsilon",1030,G__G__MLP_102_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - eps", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetDelta",790,G__G__MLP_102_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - delta", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetEtaDecay",1068,G__G__MLP_102_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - ed", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetTau",598,G__G__MLP_102_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - tau", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetReset",815,G__G__MLP_102_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - reset", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEta",570,G__G__MLP_102_0_25, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEpsilon",1018,G__G__MLP_102_0_26, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetDelta",778,G__G__MLP_102_0_27, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEtaDecay",1056,G__G__MLP_102_0_28, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetTau",586,G__G__MLP_102_0_29, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetReset",803,G__G__MLP_102_0_30, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetStructure",1265,G__G__MLP_102_0_31, 117, G__get_linked_tagnum(&G__G__MLPLN_TString), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetType",706,G__G__MLP_102_0_32, 105, G__get_linked_tagnum(&G__G__MLPLN_TNeuroncLcLENeuronType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawResult",1037,G__G__MLP_102_0_33, 121, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 '0' index C - 'Option_t' 10 '\"test\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DumpWeights",1137,G__G__MLP_102_0_34, 121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 '\"-\"' filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LoadWeights",1115,G__G__MLP_102_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' filename", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Evaluate",823,G__G__MLP_102_0_36, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - index D - 'Double_t' 0 - params", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Export",642,G__G__MLP_102_0_37, 121, -1, -1, 0, 2, 1, 1, 8, 
"C - 'Option_t' 10 '\"NNfunction\"' filename C - 'Option_t' 10 '\"C++\"' language", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Draw",398,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("AttachData",975,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildNetwork",1242,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetEntry",818,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MLP_Stochastic",1373,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MLP_Batch",810,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LineSearch",990,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 2, 1, 2, 0, 
"D - 'Double_t' 0 - - D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SteepestDir",1132,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ConjugateGradientsDir",2144,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"D - 'Double_t' 0 - - d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGammaDelta",1273,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - - u 'TMatrixT<double>' 'TMatrixD' 1 - - "
"D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetBFGSH",650,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 3, 1, 2, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - - u 'TMatrixT<double>' 'TMatrixD' 1 - - "
"u 'TMatrixT<double>' 'TMatrixD' 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BFGSDir",577,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 2, 0, 
"u 'TMatrixT<double>' 'TMatrixD' 1 - - D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DerivDir",793,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 2, 0, "D - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCrossEntropyBinary",2176,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetCrossEntropy",1563,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetSumSquareError",1744,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMultiLayerPerceptron",2174,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptron), -1, 0, 1, 1, 4, 0, "u 'TMultiLayerPerceptron' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MLPLN_TMultiLayerPerceptron), -1, 1, 1, 1, 4, 0, "u 'TMultiLayerPerceptron' - 11 - -", "Not implemented", (void*) NULL, 0);
   G__memfunc_setup("ExpandStructure",1585,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildFirstLayer",1525,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TString' - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildHiddenLayers",1708,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "u 'TString' - 1 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildOneHiddenLayer",1883,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 5, 1, 4, 0, 
"u 'TString' - 11 - sNumNodes i - 'Int_t' 1 - layer "
"i - 'Int_t' 1 - prevStart i - 'Int_t' 1 - prevStop "
"g - 'Bool_t' 0 - lastLayer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("BuildLastLayer",1409,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
"u 'TString' - 1 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Shuffle",717,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 8, 
"I - 'Int_t' 0 - - i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MLP_Line",720,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 4, 0, 
"D - 'Double_t' 0 - - D - 'Double_t' 0 - - "
"d - 'Double_t' 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__MLP_102_0_63, 85, G__get_linked_tagnum(&G__G__MLPLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMultiLayerPerceptron::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__MLP_102_0_64, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMultiLayerPerceptron::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__MLP_102_0_65, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMultiLayerPerceptron::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__MLP_102_0_66, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMultiLayerPerceptron::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MLPLN_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 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__MLP_102_0_70, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__MLP_102_0_71, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMultiLayerPerceptron::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__MLP_102_0_72, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMultiLayerPerceptron::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__MLP_102_0_73, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMultiLayerPerceptron::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__MLP_102_0_74, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMultiLayerPerceptron::DeclFileLine) ), 0);
   // automatic destructor
   G__memfunc_setup("~TMultiLayerPerceptron", 2300, G__G__MLP_102_0_75, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTMLPAnalyzer(void) {
   /* TMLPAnalyzer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MLPLN_TMLPAnalyzer));
   G__memfunc_setup("GetLayers",912,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNeurons",1034,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "i - 'Int_t' 0 - layer", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetNeuronFormula",1645,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MLPLN_TString), -1, 0, 1, 1, 2, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetInputNeuronTitle",1961,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 1, 1, 2, 1, "i - 'Int_t' 0 - in", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetOutputNeuronTitle",2090,(G__InterfaceMethod) NULL, 67, -1, -1, 0, 1, 1, 2, 1, "i - 'Int_t' 0 - out", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMLPAnalyzer",1155,G__G__MLP_105_0_6, 105, G__get_linked_tagnum(&G__G__MLPLN_TMLPAnalyzer), -1, 0, 1, 1, 1, 0, "u 'TMultiLayerPerceptron' - 1 - net", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TMLPAnalyzer",1155,G__G__MLP_105_0_7, 105, G__get_linked_tagnum(&G__G__MLPLN_TMLPAnalyzer), -1, 0, 1, 1, 1, 0, "U 'TMultiLayerPerceptron' - 0 - net", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawNetwork",1144,G__G__MLP_105_0_8, 121, -1, -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - neuron C - - 10 - signal "
"C - - 10 - bg", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawDInput",994,G__G__MLP_105_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawDInputs",1109,G__G__MLP_105_0_10, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawTruthDeviation",1864,G__G__MLP_105_0_11, 85, G__get_linked_tagnum(&G__G__MLPLN_TProfile), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '0' outnode C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawTruthDeviations",1979,G__G__MLP_105_0_12, 85, G__get_linked_tagnum(&G__G__MLPLN_THStack), -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawTruthDeviationInOut",2359,G__G__MLP_105_0_13, 85, G__get_linked_tagnum(&G__G__MLPLN_TProfile), -1, 0, 3, 1, 1, 0, 
"i - 'Int_t' 0 - innode i - 'Int_t' 0 '0' outnode "
"C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DrawTruthDeviationInsOut",2474,G__G__MLP_105_0_14, 85, G__get_linked_tagnum(&G__G__MLPLN_THStack), -1, 0, 2, 1, 1, 0, 
"i - 'Int_t' 0 '0' outnode C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CheckNetwork",1224,G__G__MLP_105_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GatherInformations",1876,G__G__MLP_105_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetIOTree",840,G__G__MLP_105_0_17, 85, G__get_linked_tagnum(&G__G__MLPLN_TTree), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__MLP_105_0_18, 85, G__get_linked_tagnum(&G__G__MLPLN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMLPAnalyzer::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__MLP_105_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMLPAnalyzer::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__MLP_105_0_20, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMLPAnalyzer::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__MLP_105_0_21, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMLPAnalyzer::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MLPLN_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 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__MLP_105_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__MLP_105_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMLPAnalyzer::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__MLP_105_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMLPAnalyzer::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__MLP_105_0_28, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMLPAnalyzer::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__MLP_105_0_29, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMLPAnalyzer::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TMLPAnalyzer", 1155, G__G__MLP_105_0_30, (int) ('i'), G__get_linked_tagnum(&G__G__MLPLN_TMLPAnalyzer), -1, 0, 1, 1, 1, 0, "u 'TMLPAnalyzer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TMLPAnalyzer", 1281, G__G__MLP_105_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__MLP_105_0_32, (int) ('u'), G__get_linked_tagnum(&G__G__MLPLN_TMLPAnalyzer), -1, 1, 1, 1, 1, 0, "u 'TMLPAnalyzer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}


/*********************************************************
* Member function information setup
*********************************************************/
extern "C" void G__cpp_setup_memfuncG__MLP() {
}

/*********************************************************
* 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() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__MLP() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
}

/*********************************************************
* 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() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__MLP() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__MLPLN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TString = { "TString" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TObjArray = { "TObjArray" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TTree = { "TTree" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TNeuron = { "TNeuron" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TSynapse = { "TSynapse" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TMultiLayerPerceptron = { "TMultiLayerPerceptron" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TProfile = { "TProfile" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_THStack = { "THStack" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TMLPAnalyzer = { "TMLPAnalyzer" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
G__linked_taginfo G__G__MLPLN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TElementActionTlEdoublegR = { "TElementActionT<double>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TElementPosActionTlEdoublegR = { "TElementPosActionT<double>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TMatrixTlEdoublegR = { "TMatrixT<double>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TMatrixTRow_constlEdoublegR = { "TMatrixTRow_const<double>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TMatrixTRowlEdoublegR = { "TMatrixTRow<double>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TMatrixTDiag_constlEdoublegR = { "TMatrixTDiag_const<double>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TMatrixTColumn_constlEdoublegR = { "TMatrixTColumn_const<double>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TMatrixTFlat_constlEdoublegR = { "TMatrixTFlat_const<double>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TMatrixTSub_constlEdoublegR = { "TMatrixTSub_const<double>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TMatrixTSparseRow_constlEdoublegR = { "TMatrixTSparseRow_const<double>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TMatrixTSparseDiag_constlEdoublegR = { "TMatrixTSparseDiag_const<double>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TMatrixTColumnlEdoublegR = { "TMatrixTColumn<double>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TMatrixTDiaglEdoublegR = { "TMatrixTDiag<double>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TMatrixTFlatlEdoublegR = { "TMatrixTFlat<double>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TMatrixTSublEdoublegR = { "TMatrixTSub<double>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TMatrixTSparseRowlEdoublegR = { "TMatrixTSparseRow<double>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TMatrixTSparseDiaglEdoublegR = { "TMatrixTSparseDiag<double>" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TTreeFormula = { "TTreeFormula" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TFormula = { "TFormula" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TNeuroncLcLENeuronType = { "TNeuron::ENeuronType" , 101 , -1 };
G__linked_taginfo G__G__MLPLN_TEventList = { "TEventList" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TTreeFormulaManager = { "TTreeFormulaManager" , 99 , -1 };
G__linked_taginfo G__G__MLPLN_TMultiLayerPerceptroncLcLELearningMethod = { "TMultiLayerPerceptron::ELearningMethod" , 101 , -1 };
G__linked_taginfo G__G__MLPLN_TMultiLayerPerceptroncLcLEDataSet = { "TMultiLayerPerceptron::EDataSet" , 101 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__MLP() {
  G__G__MLPLN_TClass.tagnum = -1 ;
  G__G__MLPLN_TBuffer.tagnum = -1 ;
  G__G__MLPLN_TMemberInspector.tagnum = -1 ;
  G__G__MLPLN_TObject.tagnum = -1 ;
  G__G__MLPLN_TNamed.tagnum = -1 ;
  G__G__MLPLN_TString.tagnum = -1 ;
  G__G__MLPLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__MLPLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__MLPLN_TObjArray.tagnum = -1 ;
  G__G__MLPLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__MLPLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__MLPLN_TTree.tagnum = -1 ;
  G__G__MLPLN_TNeuron.tagnum = -1 ;
  G__G__MLPLN_TSynapse.tagnum = -1 ;
  G__G__MLPLN_TMultiLayerPerceptron.tagnum = -1 ;
  G__G__MLPLN_TProfile.tagnum = -1 ;
  G__G__MLPLN_THStack.tagnum = -1 ;
  G__G__MLPLN_TMLPAnalyzer.tagnum = -1 ;
  G__G__MLPLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
  G__G__MLPLN_TMatrixTBaselEfloatgR.tagnum = -1 ;
  G__G__MLPLN_TMatrixTBaselEdoublegR.tagnum = -1 ;
  G__G__MLPLN_TVectorTlEfloatgR.tagnum = -1 ;
  G__G__MLPLN_TVectorTlEdoublegR.tagnum = -1 ;
  G__G__MLPLN_TElementActionTlEdoublegR.tagnum = -1 ;
  G__G__MLPLN_TElementPosActionTlEdoublegR.tagnum = -1 ;
  G__G__MLPLN_TMatrixTlEdoublegR.tagnum = -1 ;
  G__G__MLPLN_TMatrixTRow_constlEdoublegR.tagnum = -1 ;
  G__G__MLPLN_TMatrixTRowlEdoublegR.tagnum = -1 ;
  G__G__MLPLN_TMatrixTDiag_constlEdoublegR.tagnum = -1 ;
  G__G__MLPLN_TMatrixTColumn_constlEdoublegR.tagnum = -1 ;
  G__G__MLPLN_TMatrixTFlat_constlEdoublegR.tagnum = -1 ;
  G__G__MLPLN_TMatrixTSub_constlEdoublegR.tagnum = -1 ;
  G__G__MLPLN_TMatrixTSparseRow_constlEdoublegR.tagnum = -1 ;
  G__G__MLPLN_TMatrixTSparseDiag_constlEdoublegR.tagnum = -1 ;
  G__G__MLPLN_TMatrixTColumnlEdoublegR.tagnum = -1 ;
  G__G__MLPLN_TMatrixTDiaglEdoublegR.tagnum = -1 ;
  G__G__MLPLN_TMatrixTFlatlEdoublegR.tagnum = -1 ;
  G__G__MLPLN_TMatrixTSublEdoublegR.tagnum = -1 ;
  G__G__MLPLN_TMatrixTSparseRowlEdoublegR.tagnum = -1 ;
  G__G__MLPLN_TMatrixTSparseDiaglEdoublegR.tagnum = -1 ;
  G__G__MLPLN_TTreeFormula.tagnum = -1 ;
  G__G__MLPLN_TFormula.tagnum = -1 ;
  G__G__MLPLN_TNeuroncLcLENeuronType.tagnum = -1 ;
  G__G__MLPLN_TEventList.tagnum = -1 ;
  G__G__MLPLN_TTreeFormulaManager.tagnum = -1 ;
  G__G__MLPLN_TMultiLayerPerceptroncLcLELearningMethod.tagnum = -1 ;
  G__G__MLPLN_TMultiLayerPerceptroncLcLEDataSet.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__MLP() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TClass);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TObject);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TNamed);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TString);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TObjArray);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TTree);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MLPLN_TNeuron),sizeof(TNeuron),-1,327424,"Neuron for MultiLayerPerceptrons",G__setup_memvarTNeuron,G__setup_memfuncTNeuron);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MLPLN_TSynapse),sizeof(TSynapse),-1,324864,"simple weighted bidirectionnal connection between 2 neurons",G__setup_memvarTSynapse,G__setup_memfuncTSynapse);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MLPLN_TMultiLayerPerceptron),sizeof(TMultiLayerPerceptron),-1,327424,"a Neural Network",G__setup_memvarTMultiLayerPerceptron,G__setup_memfuncTMultiLayerPerceptron);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TProfile);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_THStack);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MLPLN_TMLPAnalyzer),sizeof(TMLPAnalyzer),-1,324608,"A simple analysis class for MLP",G__setup_memvarTMLPAnalyzer,G__setup_memfuncTMLPAnalyzer);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TMatrixTBaselEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TMatrixTBaselEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TVectorTlEfloatgR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TVectorTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TElementActionTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TElementPosActionTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TMatrixTlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TMatrixTRow_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TMatrixTRowlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TMatrixTDiag_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TMatrixTColumn_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TMatrixTFlat_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TMatrixTSub_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TMatrixTSparseRow_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TMatrixTSparseDiag_constlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TMatrixTColumnlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TMatrixTDiaglEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TMatrixTFlatlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TMatrixTSublEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TMatrixTSparseRowlEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TMatrixTSparseDiaglEdoublegR);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TTreeFormula);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TFormula);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TNeuroncLcLENeuronType);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TEventList);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TTreeFormulaManager);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TMultiLayerPerceptroncLcLELearningMethod);
   G__get_linked_tagnum_fwd(&G__G__MLPLN_TMultiLayerPerceptroncLcLEDataSet);
}
extern "C" void G__cpp_setupG__MLP(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__MLP()");
  G__set_cpp_environmentG__MLP();
  G__cpp_setup_tagtableG__MLP();

  G__cpp_setup_inheritanceG__MLP();

  G__cpp_setup_typetableG__MLP();

  G__cpp_setup_memvarG__MLP();

  G__cpp_setup_memfuncG__MLP();
  G__cpp_setup_globalG__MLP();
  G__cpp_setup_funcG__MLP();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__MLP();
  return;
}
class G__cpp_setup_initG__MLP {
  public:
    G__cpp_setup_initG__MLP() { G__add_setup_func("G__MLP",(G__incsetup)(&G__cpp_setupG__MLP)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__MLP() { G__remove_setup_func("G__MLP"); }
};
G__cpp_setup_initG__MLP G__cpp_setup_initializerG__MLP;

---