ROOT_528-00b_version: tmva/src/G_

00001 //
00002 // File generated by core/utils/src/rootcint_tmp at Wed Apr 20 14:08:23 2011
00003 
00004 // Do NOT change. Changes will be lost next time file is generated
00005 //
00006 
00007 #define R__DICTIONARY_FILENAME tmvadIsrcdIG__TMVA3
00008 #include "RConfig.h" //rootcint 4834
00009 #if !defined(R__ACCESS_IN_SYMBOL)
00010 //Break the privacy of classes -- Disabled for the moment
00011 #define private public
00012 #define protected public
00013 #endif
00014 
00015 // Since CINT ignores the std namespace, we need to do so in this file.
00016 namespace std {} using namespace std;
00017 #include "G__TMVA3.h"
00018 
00019 #include "TClass.h"
00020 #include "TBuffer.h"
00021 #include "TMemberInspector.h"
00022 #include "TError.h"
00023 
00024 #ifndef G__ROOT
00025 #define G__ROOT
00026 #endif
00027 
00028 #include "RtypesImp.h"
00029 #include "TIsAProxy.h"
00030 
00031 // START OF SHADOWS
00032 
00033 namespace ROOT {
00034    namespace Shadow {
00035       namespace TMVA {
00036 
00037       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00038       typedef ::TMVA::Config Config;
00039       #else
00040       class Config  {
00041          public:
00042          //friend XX;
00043          #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00044          typedef ::TMVA::Config::VariablePlotting VariablePlotting;
00045          #else
00046          class VariablePlotting  {
00047             public:
00048             //friend XX;
00049             float fTimesRMS; //
00050             int fNbins1D; //
00051             int fNbins2D; //
00052             int fMaxNumOfAllowedVariablesForScatterPlots; //
00053             int fNbinsXOfROCCurve; //
00054          };
00055          #endif
00056 
00057          #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00058          typedef ::TMVA::Config::IONames IONames;
00059          #else
00060          class IONames  {
00061             public:
00062             //friend XX;
00063             ::TString fWeightFileDir; //
00064             ::TString fWeightFileExtension; //
00065             ::TString fOptionsReferenceFileDir; //
00066          };
00067          #endif
00068 
00069          // To force the creation of a virtual table, throw just in case.
00070          virtual ~Config() throw() {};
00071       };
00072       #endif
00073       } 
00074       namespace TMVA {
00075 
00076       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00077       typedef ::TMVA::BDTEventWrapper BDTEventWrapper;
00078       #else
00079       class BDTEventWrapper  {
00080          public:
00081          //friend XX;
00082          :: TMVA::Event* fEvent; //pointer to the event
00083          double fBkgWeight; //cumulative background weight for splitting
00084          double fSigWeight; //same for the signal weights
00085       };
00086       #endif
00087       } 
00088       namespace TMVA {
00089 
00090       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00091       typedef ::TMVA::CCTreeWrapper CCTreeWrapper;
00092       #else
00093       class CCTreeWrapper  {
00094          public:
00095          //friend XX;
00096          #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00097          typedef ::TMVA::CCTreeWrapper::CCTreeNode CCTreeNode;
00098          #else
00099          class CCTreeNode  :  virtual public ::TMVA::Node {
00100             public:
00101             //friend XX;
00102             // To force the creation of a virtual table, throw just in case.
00103             virtual ~CCTreeNode() throw() {};
00104             int fNLeafDaughters; //! number of terminal descendants
00105             double fNodeResubstitutionEstimate; //! R(t) = misclassification rate for node t
00106             double fResubstitutionEstimate; //! R(T_t) = sum[t' in ~T_t]{ R(t) }
00107             double fAlphaC; //! critical point, g(t) = alpha_c(t)
00108             double fMinAlphaC; //! G(t), minimum critical point of t and its descendants
00109             ::TMVA::DecisionTreeNode* fDTNode; //! pointer to wrapped node in the decision tree
00110          };
00111          #endif
00112 
00113          typedef ::std::vector< ::TMVA::Event*, ::allocator< ::TMVA::Event*> > EventList;
00114          ::TMVA::SeparationBase* fQualityIndex; //! pointer to the used quality index calculator
00115          ::TMVA::DecisionTree* fDTParent; //! pointer to underlying DecisionTree
00116          CCTreeNode* fRoot; //! the root node of the (wrapped) decision Tree
00117       };
00118       #endif
00119       } 
00120       namespace TMVA {
00121 
00122       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00123       typedef ::TMVA::CCPruner CCPruner;
00124       #else
00125       class CCPruner  {
00126          public:
00127          //friend XX;
00128          typedef ::std::vector< ::TMVA::Event*, ::allocator< ::TMVA::Event*> > EventList;
00129          float fAlpha; //! regularization parameter in CC pruning
00130          :: TMVA::CCPruner::EventList* fValidationSample; //! the event sample to select the optimally-pruned tree
00131          :: TMVA::DataSet* fValidationDataSet; //! the event sample to select the optimally-pruned tree
00132          ::TMVA::SeparationBase* fQualityIndex; //! the quality index used to calculate R(t), R(T) = sum[t in ~T]{ R(t) }
00133          bool fOwnQIndex; //! flag indicates if fQualityIndex is owned by this
00134          ::TMVA::DecisionTree* fTree; //! (pruned) decision tree
00135          vector< ::TMVA::DecisionTreeNode* > fPruneSequence; //! map of weakest links (i.e., branches to prune) -> pruning index
00136          vector< Float_t > fPruneStrengthList; //! map of alpha -> pruning index
00137          vector< Float_t > fQualityIndexList; //! map of R(T) -> pruning index
00138          int fOptimalK; //! index of the optimal tree in the pruned tree sequence
00139          bool fDebug; //! debug flag
00140       };
00141       #endif
00142       } 
00143       namespace TMVA {
00144 
00145       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00146       typedef ::TMVA::CostComplexityPruneTool CostComplexityPruneTool;
00147       #else
00148       class CostComplexityPruneTool  :  public ::TMVA::IPruneTool {
00149          public:
00150          //friend XX;
00151          // To force the creation of a virtual table, throw just in case.
00152          virtual ~CostComplexityPruneTool() throw() {};
00153          ::TMVA::SeparationBase* fQualityIndexTool; //! the quality index used to calculate R(t), R(T) = sum[t in ~T]{ R(t) }
00154          vector< ::TMVA::DecisionTreeNode*, allocator< ::TMVA::DecisionTreeNode* >  > fPruneSequence; //! map of weakest links (i.e., branches to prune) -> pruning index
00155          vector< Double_t > fPruneStrengthList; //! map of alpha -> pruning index
00156          vector< Double_t > fQualityIndexList; //! map of R(T) -> pruning index
00157          int fOptimalK; //! the optimal index of the prune sequence
00158          ::TMVA::MsgLogger* fLogger; //! output stream to save logging information
00159       };
00160       #endif
00161       } 
00162    } // of namespace Shadow
00163 } // of namespace ROOT
00164 // END OF SHADOWS
00165 
00166 namespace TMVA {
00167    namespace ROOT {
00168       inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
00169       static void TMVA_Dictionary();
00170 
00171       // Function generating the singleton type initializer
00172       inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
00173       {
00174          static ::ROOT::TGenericClassInfo 
00175             instance("TMVA", 0 /*version*/, "./include/TMVA/OptimizeConfigParameters.h", 59,
00176                      ::ROOT::DefineBehavior((void*)0,(void*)0),
00177                      &TMVA_Dictionary, 0);
00178          return &instance;
00179       }
00180       // Insure that the inline function is _not_ optimized away by the compiler
00181       ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;  
00182       // Static variable to force the class initialization
00183       static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));
00184 
00185       // Dictionary for non-ClassDef classes
00186       static void TMVA_Dictionary() {
00187          GenerateInitInstance()->GetClass();
00188       }
00189 
00190    }
00191 }
00192 
00193 namespace ROOT {
00194    void TMVAcLcLConfig_ShowMembers(void *obj, TMemberInspector &R__insp);
00195 
00196    // Function generating the singleton type initializer
00197    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::Config*)
00198    {
00199       ::TMVA::Config *ptr = 0;
00200       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::Config >(0);
00201       static ::ROOT::TGenericClassInfo 
00202          instance("TMVA::Config", ::TMVA::Config::Class_Version(), "./include/TMVA/Config.h", 51,
00203                   typeid(::TMVA::Config), DefineBehavior(ptr, ptr),
00204                   &::TMVA::Config::Dictionary, isa_proxy, 4,
00205                   sizeof(::TMVA::Config) );
00206       return &instance;
00207    }
00208    TGenericClassInfo *GenerateInitInstance(const ::TMVA::Config*)
00209    {
00210       return GenerateInitInstanceLocal((::TMVA::Config*)0);
00211    }
00212    // Static variable to force the class initialization
00213    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::Config*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00214 } // end of namespace ROOT
00215 
00216 namespace ROOT {
00217    void TMVAcLcLConfigcLcLVariablePlotting_ShowMembers(void *obj, TMemberInspector &R__insp);
00218    static void TMVAcLcLConfigcLcLVariablePlotting_Dictionary();
00219    static void *new_TMVAcLcLConfigcLcLVariablePlotting(void *p = 0);
00220    static void *newArray_TMVAcLcLConfigcLcLVariablePlotting(Long_t size, void *p);
00221    static void delete_TMVAcLcLConfigcLcLVariablePlotting(void *p);
00222    static void deleteArray_TMVAcLcLConfigcLcLVariablePlotting(void *p);
00223    static void destruct_TMVAcLcLConfigcLcLVariablePlotting(void *p);
00224 
00225    // Function generating the singleton type initializer
00226    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::Config::VariablePlotting*)
00227    {
00228       // Make sure the shadow class has the right sizeof
00229       R__ASSERT(sizeof(::TMVA::Config::VariablePlotting) == sizeof(::ROOT::Shadow::TMVA::Config::VariablePlotting));
00230       ::TMVA::Config::VariablePlotting *ptr = 0;
00231       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TMVA::Config::VariablePlotting),0);
00232       static ::ROOT::TGenericClassInfo 
00233          instance("TMVA::Config::VariablePlotting", "./include/TMVA/Config.h", 79,
00234                   typeid(::TMVA::Config::VariablePlotting), DefineBehavior(ptr, ptr),
00235                   &TMVAcLcLConfigcLcLVariablePlotting_ShowMembers, &TMVAcLcLConfigcLcLVariablePlotting_Dictionary, isa_proxy, 4,
00236                   sizeof(::TMVA::Config::VariablePlotting) );
00237       instance.SetNew(&new_TMVAcLcLConfigcLcLVariablePlotting);
00238       instance.SetNewArray(&newArray_TMVAcLcLConfigcLcLVariablePlotting);
00239       instance.SetDelete(&delete_TMVAcLcLConfigcLcLVariablePlotting);
00240       instance.SetDeleteArray(&deleteArray_TMVAcLcLConfigcLcLVariablePlotting);
00241       instance.SetDestructor(&destruct_TMVAcLcLConfigcLcLVariablePlotting);
00242       return &instance;
00243    }
00244    TGenericClassInfo *GenerateInitInstance(const ::TMVA::Config::VariablePlotting*)
00245    {
00246       return GenerateInitInstanceLocal((::TMVA::Config::VariablePlotting*)0);
00247    }
00248    // Static variable to force the class initialization
00249    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::Config::VariablePlotting*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00250 
00251    // Dictionary for non-ClassDef classes
00252    static void TMVAcLcLConfigcLcLVariablePlotting_Dictionary() {
00253       ::ROOT::GenerateInitInstanceLocal((const ::TMVA::Config::VariablePlotting*)0x0)->GetClass();
00254    }
00255 
00256 } // end of namespace ROOT
00257 
00258 namespace ROOT {
00259    void TMVAcLcLConfigcLcLIONames_ShowMembers(void *obj, TMemberInspector &R__insp);
00260    static void TMVAcLcLConfigcLcLIONames_Dictionary();
00261    static void *new_TMVAcLcLConfigcLcLIONames(void *p = 0);
00262    static void *newArray_TMVAcLcLConfigcLcLIONames(Long_t size, void *p);
00263    static void delete_TMVAcLcLConfigcLcLIONames(void *p);
00264    static void deleteArray_TMVAcLcLConfigcLcLIONames(void *p);
00265    static void destruct_TMVAcLcLConfigcLcLIONames(void *p);
00266 
00267    // Function generating the singleton type initializer
00268    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::Config::IONames*)
00269    {
00270       // Make sure the shadow class has the right sizeof
00271       R__ASSERT(sizeof(::TMVA::Config::IONames) == sizeof(::ROOT::Shadow::TMVA::Config::IONames));
00272       ::TMVA::Config::IONames *ptr = 0;
00273       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TMVA::Config::IONames),0);
00274       static ::ROOT::TGenericClassInfo 
00275          instance("TMVA::Config::IONames", "./include/TMVA/Config.h", 91,
00276                   typeid(::TMVA::Config::IONames), DefineBehavior(ptr, ptr),
00277                   &TMVAcLcLConfigcLcLIONames_ShowMembers, &TMVAcLcLConfigcLcLIONames_Dictionary, isa_proxy, 4,
00278                   sizeof(::TMVA::Config::IONames) );
00279       instance.SetNew(&new_TMVAcLcLConfigcLcLIONames);
00280       instance.SetNewArray(&newArray_TMVAcLcLConfigcLcLIONames);
00281       instance.SetDelete(&delete_TMVAcLcLConfigcLcLIONames);
00282       instance.SetDeleteArray(&deleteArray_TMVAcLcLConfigcLcLIONames);
00283       instance.SetDestructor(&destruct_TMVAcLcLConfigcLcLIONames);
00284       return &instance;
00285    }
00286    TGenericClassInfo *GenerateInitInstance(const ::TMVA::Config::IONames*)
00287    {
00288       return GenerateInitInstanceLocal((::TMVA::Config::IONames*)0);
00289    }
00290    // Static variable to force the class initialization
00291    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::Config::IONames*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00292 
00293    // Dictionary for non-ClassDef classes
00294    static void TMVAcLcLConfigcLcLIONames_Dictionary() {
00295       ::ROOT::GenerateInitInstanceLocal((const ::TMVA::Config::IONames*)0x0)->GetClass();
00296    }
00297 
00298 } // end of namespace ROOT
00299 
00300 namespace ROOT {
00301    void TMVAcLcLKDEKernel_ShowMembers(void *obj, TMemberInspector &R__insp);
00302    static void *new_TMVAcLcLKDEKernel(void *p = 0);
00303    static void *newArray_TMVAcLcLKDEKernel(Long_t size, void *p);
00304    static void delete_TMVAcLcLKDEKernel(void *p);
00305    static void deleteArray_TMVAcLcLKDEKernel(void *p);
00306    static void destruct_TMVAcLcLKDEKernel(void *p);
00307 
00308    // Function generating the singleton type initializer
00309    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::KDEKernel*)
00310    {
00311       ::TMVA::KDEKernel *ptr = 0;
00312       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::KDEKernel >(0);
00313       static ::ROOT::TGenericClassInfo 
00314          instance("TMVA::KDEKernel", ::TMVA::KDEKernel::Class_Version(), "./include/TMVA/KDEKernel.h", 48,
00315                   typeid(::TMVA::KDEKernel), DefineBehavior(ptr, ptr),
00316                   &::TMVA::KDEKernel::Dictionary, isa_proxy, 4,
00317                   sizeof(::TMVA::KDEKernel) );
00318       instance.SetNew(&new_TMVAcLcLKDEKernel);
00319       instance.SetNewArray(&newArray_TMVAcLcLKDEKernel);
00320       instance.SetDelete(&delete_TMVAcLcLKDEKernel);
00321       instance.SetDeleteArray(&deleteArray_TMVAcLcLKDEKernel);
00322       instance.SetDestructor(&destruct_TMVAcLcLKDEKernel);
00323       return &instance;
00324    }
00325    TGenericClassInfo *GenerateInitInstance(const ::TMVA::KDEKernel*)
00326    {
00327       return GenerateInitInstanceLocal((::TMVA::KDEKernel*)0);
00328    }
00329    // Static variable to force the class initialization
00330    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::KDEKernel*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00331 } // end of namespace ROOT
00332 
00333 namespace ROOT {
00334    void TMVAcLcLInterval_ShowMembers(void *obj, TMemberInspector &R__insp);
00335    static void delete_TMVAcLcLInterval(void *p);
00336    static void deleteArray_TMVAcLcLInterval(void *p);
00337    static void destruct_TMVAcLcLInterval(void *p);
00338 
00339    // Function generating the singleton type initializer
00340    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::Interval*)
00341    {
00342       ::TMVA::Interval *ptr = 0;
00343       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::Interval >(0);
00344       static ::ROOT::TGenericClassInfo 
00345          instance("TMVA::Interval", ::TMVA::Interval::Class_Version(), "./include/TMVA/Interval.h", 63,
00346                   typeid(::TMVA::Interval), DefineBehavior(ptr, ptr),
00347                   &::TMVA::Interval::Dictionary, isa_proxy, 4,
00348                   sizeof(::TMVA::Interval) );
00349       instance.SetDelete(&delete_TMVAcLcLInterval);
00350       instance.SetDeleteArray(&deleteArray_TMVAcLcLInterval);
00351       instance.SetDestructor(&destruct_TMVAcLcLInterval);
00352       return &instance;
00353    }
00354    TGenericClassInfo *GenerateInitInstance(const ::TMVA::Interval*)
00355    {
00356       return GenerateInitInstanceLocal((::TMVA::Interval*)0);
00357    }
00358    // Static variable to force the class initialization
00359    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::Interval*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00360 } // end of namespace ROOT
00361 
00362 namespace ROOT {
00363    void TMVAcLcLIFitterTarget_ShowMembers(void *obj, TMemberInspector &R__insp);
00364    static void delete_TMVAcLcLIFitterTarget(void *p);
00365    static void deleteArray_TMVAcLcLIFitterTarget(void *p);
00366    static void destruct_TMVAcLcLIFitterTarget(void *p);
00367 
00368    // Function generating the singleton type initializer
00369    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::IFitterTarget*)
00370    {
00371       ::TMVA::IFitterTarget *ptr = 0;
00372       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::IFitterTarget >(0);
00373       static ::ROOT::TGenericClassInfo 
00374          instance("TMVA::IFitterTarget", ::TMVA::IFitterTarget::Class_Version(), "include/TMVA/IFitterTarget.h", 46,
00375                   typeid(::TMVA::IFitterTarget), DefineBehavior(ptr, ptr),
00376                   &::TMVA::IFitterTarget::Dictionary, isa_proxy, 4,
00377                   sizeof(::TMVA::IFitterTarget) );
00378       instance.SetDelete(&delete_TMVAcLcLIFitterTarget);
00379       instance.SetDeleteArray(&deleteArray_TMVAcLcLIFitterTarget);
00380       instance.SetDestructor(&destruct_TMVAcLcLIFitterTarget);
00381       return &instance;
00382    }
00383    TGenericClassInfo *GenerateInitInstance(const ::TMVA::IFitterTarget*)
00384    {
00385       return GenerateInitInstanceLocal((::TMVA::IFitterTarget*)0);
00386    }
00387    // Static variable to force the class initialization
00388    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::IFitterTarget*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00389 } // end of namespace ROOT
00390 
00391 namespace ROOT {
00392    void TMVAcLcLFitterBase_ShowMembers(void *obj, TMemberInspector &R__insp);
00393    static void delete_TMVAcLcLFitterBase(void *p);
00394    static void deleteArray_TMVAcLcLFitterBase(void *p);
00395    static void destruct_TMVAcLcLFitterBase(void *p);
00396 
00397    // Function generating the singleton type initializer
00398    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::FitterBase*)
00399    {
00400       ::TMVA::FitterBase *ptr = 0;
00401       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::FitterBase >(0);
00402       static ::ROOT::TGenericClassInfo 
00403          instance("TMVA::FitterBase", ::TMVA::FitterBase::Class_Version(), "./include/TMVA/FitterBase.h", 57,
00404                   typeid(::TMVA::FitterBase), DefineBehavior(ptr, ptr),
00405                   &::TMVA::FitterBase::Dictionary, isa_proxy, 4,
00406                   sizeof(::TMVA::FitterBase) );
00407       instance.SetDelete(&delete_TMVAcLcLFitterBase);
00408       instance.SetDeleteArray(&deleteArray_TMVAcLcLFitterBase);
00409       instance.SetDestructor(&destruct_TMVAcLcLFitterBase);
00410       return &instance;
00411    }
00412    TGenericClassInfo *GenerateInitInstance(const ::TMVA::FitterBase*)
00413    {
00414       return GenerateInitInstanceLocal((::TMVA::FitterBase*)0);
00415    }
00416    // Static variable to force the class initialization
00417    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::FitterBase*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00418 } // end of namespace ROOT
00419 
00420 namespace ROOT {
00421    void TMVAcLcLMCFitter_ShowMembers(void *obj, TMemberInspector &R__insp);
00422    static void delete_TMVAcLcLMCFitter(void *p);
00423    static void deleteArray_TMVAcLcLMCFitter(void *p);
00424    static void destruct_TMVAcLcLMCFitter(void *p);
00425 
00426    // Function generating the singleton type initializer
00427    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::MCFitter*)
00428    {
00429       ::TMVA::MCFitter *ptr = 0;
00430       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::MCFitter >(0);
00431       static ::ROOT::TGenericClassInfo 
00432          instance("TMVA::MCFitter", ::TMVA::MCFitter::Class_Version(), "./include/TMVA/MCFitter.h", 45,
00433                   typeid(::TMVA::MCFitter), DefineBehavior(ptr, ptr),
00434                   &::TMVA::MCFitter::Dictionary, isa_proxy, 4,
00435                   sizeof(::TMVA::MCFitter) );
00436       instance.SetDelete(&delete_TMVAcLcLMCFitter);
00437       instance.SetDeleteArray(&deleteArray_TMVAcLcLMCFitter);
00438       instance.SetDestructor(&destruct_TMVAcLcLMCFitter);
00439       return &instance;
00440    }
00441    TGenericClassInfo *GenerateInitInstance(const ::TMVA::MCFitter*)
00442    {
00443       return GenerateInitInstanceLocal((::TMVA::MCFitter*)0);
00444    }
00445    // Static variable to force the class initialization
00446    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::MCFitter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00447 } // end of namespace ROOT
00448 
00449 namespace ROOT {
00450    void TMVAcLcLGeneticFitter_ShowMembers(void *obj, TMemberInspector &R__insp);
00451    static void delete_TMVAcLcLGeneticFitter(void *p);
00452    static void deleteArray_TMVAcLcLGeneticFitter(void *p);
00453    static void destruct_TMVAcLcLGeneticFitter(void *p);
00454 
00455    // Function generating the singleton type initializer
00456    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::GeneticFitter*)
00457    {
00458       ::TMVA::GeneticFitter *ptr = 0;
00459       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::GeneticFitter >(0);
00460       static ::ROOT::TGenericClassInfo 
00461          instance("TMVA::GeneticFitter", ::TMVA::GeneticFitter::Class_Version(), "./include/TMVA/GeneticFitter.h", 45,
00462                   typeid(::TMVA::GeneticFitter), DefineBehavior(ptr, ptr),
00463                   &::TMVA::GeneticFitter::Dictionary, isa_proxy, 4,
00464                   sizeof(::TMVA::GeneticFitter) );
00465       instance.SetDelete(&delete_TMVAcLcLGeneticFitter);
00466       instance.SetDeleteArray(&deleteArray_TMVAcLcLGeneticFitter);
00467       instance.SetDestructor(&destruct_TMVAcLcLGeneticFitter);
00468       return &instance;
00469    }
00470    TGenericClassInfo *GenerateInitInstance(const ::TMVA::GeneticFitter*)
00471    {
00472       return GenerateInitInstanceLocal((::TMVA::GeneticFitter*)0);
00473    }
00474    // Static variable to force the class initialization
00475    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::GeneticFitter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00476 } // end of namespace ROOT
00477 
00478 namespace ROOT {
00479    void TMVAcLcLSimulatedAnnealingFitter_ShowMembers(void *obj, TMemberInspector &R__insp);
00480    static void delete_TMVAcLcLSimulatedAnnealingFitter(void *p);
00481    static void deleteArray_TMVAcLcLSimulatedAnnealingFitter(void *p);
00482    static void destruct_TMVAcLcLSimulatedAnnealingFitter(void *p);
00483 
00484    // Function generating the singleton type initializer
00485    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::SimulatedAnnealingFitter*)
00486    {
00487       ::TMVA::SimulatedAnnealingFitter *ptr = 0;
00488       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::SimulatedAnnealingFitter >(0);
00489       static ::ROOT::TGenericClassInfo 
00490          instance("TMVA::SimulatedAnnealingFitter", ::TMVA::SimulatedAnnealingFitter::Class_Version(), "./include/TMVA/SimulatedAnnealingFitter.h", 49,
00491                   typeid(::TMVA::SimulatedAnnealingFitter), DefineBehavior(ptr, ptr),
00492                   &::TMVA::SimulatedAnnealingFitter::Dictionary, isa_proxy, 4,
00493                   sizeof(::TMVA::SimulatedAnnealingFitter) );
00494       instance.SetDelete(&delete_TMVAcLcLSimulatedAnnealingFitter);
00495       instance.SetDeleteArray(&deleteArray_TMVAcLcLSimulatedAnnealingFitter);
00496       instance.SetDestructor(&destruct_TMVAcLcLSimulatedAnnealingFitter);
00497       return &instance;
00498    }
00499    TGenericClassInfo *GenerateInitInstance(const ::TMVA::SimulatedAnnealingFitter*)
00500    {
00501       return GenerateInitInstanceLocal((::TMVA::SimulatedAnnealingFitter*)0);
00502    }
00503    // Static variable to force the class initialization
00504    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::SimulatedAnnealingFitter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00505 } // end of namespace ROOT
00506 
00507 namespace ROOT {
00508    void TMVAcLcLMinuitWrapper_ShowMembers(void *obj, TMemberInspector &R__insp);
00509    static void delete_TMVAcLcLMinuitWrapper(void *p);
00510    static void deleteArray_TMVAcLcLMinuitWrapper(void *p);
00511    static void destruct_TMVAcLcLMinuitWrapper(void *p);
00512 
00513    // Function generating the singleton type initializer
00514    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::MinuitWrapper*)
00515    {
00516       ::TMVA::MinuitWrapper *ptr = 0;
00517       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::MinuitWrapper >(0);
00518       static ::ROOT::TGenericClassInfo 
00519          instance("TMVA::MinuitWrapper", ::TMVA::MinuitWrapper::Class_Version(), "./include/TMVA/MinuitWrapper.h", 49,
00520                   typeid(::TMVA::MinuitWrapper), DefineBehavior(ptr, ptr),
00521                   &::TMVA::MinuitWrapper::Dictionary, isa_proxy, 4,
00522                   sizeof(::TMVA::MinuitWrapper) );
00523       instance.SetDelete(&delete_TMVAcLcLMinuitWrapper);
00524       instance.SetDeleteArray(&deleteArray_TMVAcLcLMinuitWrapper);
00525       instance.SetDestructor(&destruct_TMVAcLcLMinuitWrapper);
00526       return &instance;
00527    }
00528    TGenericClassInfo *GenerateInitInstance(const ::TMVA::MinuitWrapper*)
00529    {
00530       return GenerateInitInstanceLocal((::TMVA::MinuitWrapper*)0);
00531    }
00532    // Static variable to force the class initialization
00533    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::MinuitWrapper*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00534 } // end of namespace ROOT
00535 
00536 namespace ROOT {
00537    void TMVAcLcLMinuitFitter_ShowMembers(void *obj, TMemberInspector &R__insp);
00538    static void delete_TMVAcLcLMinuitFitter(void *p);
00539    static void deleteArray_TMVAcLcLMinuitFitter(void *p);
00540    static void destruct_TMVAcLcLMinuitFitter(void *p);
00541 
00542    // Function generating the singleton type initializer
00543    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::MinuitFitter*)
00544    {
00545       ::TMVA::MinuitFitter *ptr = 0;
00546       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::MinuitFitter >(0);
00547       static ::ROOT::TGenericClassInfo 
00548          instance("TMVA::MinuitFitter", ::TMVA::MinuitFitter::Class_Version(), "./include/TMVA/MinuitFitter.h", 51,
00549                   typeid(::TMVA::MinuitFitter), DefineBehavior(ptr, ptr),
00550                   &::TMVA::MinuitFitter::Dictionary, isa_proxy, 4,
00551                   sizeof(::TMVA::MinuitFitter) );
00552       instance.SetDelete(&delete_TMVAcLcLMinuitFitter);
00553       instance.SetDeleteArray(&deleteArray_TMVAcLcLMinuitFitter);
00554       instance.SetDestructor(&destruct_TMVAcLcLMinuitFitter);
00555       return &instance;
00556    }
00557    TGenericClassInfo *GenerateInitInstance(const ::TMVA::MinuitFitter*)
00558    {
00559       return GenerateInitInstanceLocal((::TMVA::MinuitFitter*)0);
00560    }
00561    // Static variable to force the class initialization
00562    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::MinuitFitter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00563 } // end of namespace ROOT
00564 
00565 namespace ROOT {
00566    void TMVAcLcLPDEFoamCell_ShowMembers(void *obj, TMemberInspector &R__insp);
00567    static void *new_TMVAcLcLPDEFoamCell(void *p = 0);
00568    static void *newArray_TMVAcLcLPDEFoamCell(Long_t size, void *p);
00569    static void delete_TMVAcLcLPDEFoamCell(void *p);
00570    static void deleteArray_TMVAcLcLPDEFoamCell(void *p);
00571    static void destruct_TMVAcLcLPDEFoamCell(void *p);
00572 
00573    // Function generating the singleton type initializer
00574    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoamCell*)
00575    {
00576       ::TMVA::PDEFoamCell *ptr = 0;
00577       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoamCell >(0);
00578       static ::ROOT::TGenericClassInfo 
00579          instance("TMVA::PDEFoamCell", ::TMVA::PDEFoamCell::Class_Version(), "include/TMVA/PDEFoamCell.h", 45,
00580                   typeid(::TMVA::PDEFoamCell), DefineBehavior(ptr, ptr),
00581                   &::TMVA::PDEFoamCell::Dictionary, isa_proxy, 4,
00582                   sizeof(::TMVA::PDEFoamCell) );
00583       instance.SetNew(&new_TMVAcLcLPDEFoamCell);
00584       instance.SetNewArray(&newArray_TMVAcLcLPDEFoamCell);
00585       instance.SetDelete(&delete_TMVAcLcLPDEFoamCell);
00586       instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoamCell);
00587       instance.SetDestructor(&destruct_TMVAcLcLPDEFoamCell);
00588       return &instance;
00589    }
00590    TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoamCell*)
00591    {
00592       return GenerateInitInstanceLocal((::TMVA::PDEFoamCell*)0);
00593    }
00594    // Static variable to force the class initialization
00595    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoamCell*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00596 } // end of namespace ROOT
00597 
00598 namespace ROOT {
00599    void TMVAcLcLPDEFoamVect_ShowMembers(void *obj, TMemberInspector &R__insp);
00600    static void *new_TMVAcLcLPDEFoamVect(void *p = 0);
00601    static void *newArray_TMVAcLcLPDEFoamVect(Long_t size, void *p);
00602    static void delete_TMVAcLcLPDEFoamVect(void *p);
00603    static void deleteArray_TMVAcLcLPDEFoamVect(void *p);
00604    static void destruct_TMVAcLcLPDEFoamVect(void *p);
00605 
00606    // Function generating the singleton type initializer
00607    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoamVect*)
00608    {
00609       ::TMVA::PDEFoamVect *ptr = 0;
00610       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoamVect >(0);
00611       static ::ROOT::TGenericClassInfo 
00612          instance("TMVA::PDEFoamVect", ::TMVA::PDEFoamVect::Class_Version(), "include/TMVA/PDEFoamVect.h", 36,
00613                   typeid(::TMVA::PDEFoamVect), DefineBehavior(ptr, ptr),
00614                   &::TMVA::PDEFoamVect::Dictionary, isa_proxy, 4,
00615                   sizeof(::TMVA::PDEFoamVect) );
00616       instance.SetNew(&new_TMVAcLcLPDEFoamVect);
00617       instance.SetNewArray(&newArray_TMVAcLcLPDEFoamVect);
00618       instance.SetDelete(&delete_TMVAcLcLPDEFoamVect);
00619       instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoamVect);
00620       instance.SetDestructor(&destruct_TMVAcLcLPDEFoamVect);
00621       return &instance;
00622    }
00623    TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoamVect*)
00624    {
00625       return GenerateInitInstanceLocal((::TMVA::PDEFoamVect*)0);
00626    }
00627    // Static variable to force the class initialization
00628    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoamVect*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00629 } // end of namespace ROOT
00630 
00631 namespace ROOT {
00632    void TMVAcLcLPDEFoamDistr_ShowMembers(void *obj, TMemberInspector &R__insp);
00633    static void *new_TMVAcLcLPDEFoamDistr(void *p = 0);
00634    static void *newArray_TMVAcLcLPDEFoamDistr(Long_t size, void *p);
00635    static void delete_TMVAcLcLPDEFoamDistr(void *p);
00636    static void deleteArray_TMVAcLcLPDEFoamDistr(void *p);
00637    static void destruct_TMVAcLcLPDEFoamDistr(void *p);
00638 
00639    // Function generating the singleton type initializer
00640    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoamDistr*)
00641    {
00642       ::TMVA::PDEFoamDistr *ptr = 0;
00643       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoamDistr >(0);
00644       static ::ROOT::TGenericClassInfo 
00645          instance("TMVA::PDEFoamDistr", ::TMVA::PDEFoamDistr::Class_Version(), "include/TMVA/PDEFoamDistr.h", 70,
00646                   typeid(::TMVA::PDEFoamDistr), DefineBehavior(ptr, ptr),
00647                   &::TMVA::PDEFoamDistr::Dictionary, isa_proxy, 4,
00648                   sizeof(::TMVA::PDEFoamDistr) );
00649       instance.SetNew(&new_TMVAcLcLPDEFoamDistr);
00650       instance.SetNewArray(&newArray_TMVAcLcLPDEFoamDistr);
00651       instance.SetDelete(&delete_TMVAcLcLPDEFoamDistr);
00652       instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoamDistr);
00653       instance.SetDestructor(&destruct_TMVAcLcLPDEFoamDistr);
00654       return &instance;
00655    }
00656    TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoamDistr*)
00657    {
00658       return GenerateInitInstanceLocal((::TMVA::PDEFoamDistr*)0);
00659    }
00660    // Static variable to force the class initialization
00661    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoamDistr*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00662 } // end of namespace ROOT
00663 
00664 namespace ROOT {
00665    void TMVAcLcLPDEFoam_ShowMembers(void *obj, TMemberInspector &R__insp);
00666    static void *new_TMVAcLcLPDEFoam(void *p = 0);
00667    static void *newArray_TMVAcLcLPDEFoam(Long_t size, void *p);
00668    static void delete_TMVAcLcLPDEFoam(void *p);
00669    static void deleteArray_TMVAcLcLPDEFoam(void *p);
00670    static void destruct_TMVAcLcLPDEFoam(void *p);
00671 
00672    // Function generating the singleton type initializer
00673    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::PDEFoam*)
00674    {
00675       ::TMVA::PDEFoam *ptr = 0;
00676       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::PDEFoam >(0);
00677       static ::ROOT::TGenericClassInfo 
00678          instance("TMVA::PDEFoam", ::TMVA::PDEFoam::Class_Version(), "./include/TMVA/PDEFoam.h", 107,
00679                   typeid(::TMVA::PDEFoam), DefineBehavior(ptr, ptr),
00680                   &::TMVA::PDEFoam::Dictionary, isa_proxy, 4,
00681                   sizeof(::TMVA::PDEFoam) );
00682       instance.SetNew(&new_TMVAcLcLPDEFoam);
00683       instance.SetNewArray(&newArray_TMVAcLcLPDEFoam);
00684       instance.SetDelete(&delete_TMVAcLcLPDEFoam);
00685       instance.SetDeleteArray(&deleteArray_TMVAcLcLPDEFoam);
00686       instance.SetDestructor(&destruct_TMVAcLcLPDEFoam);
00687       return &instance;
00688    }
00689    TGenericClassInfo *GenerateInitInstance(const ::TMVA::PDEFoam*)
00690    {
00691       return GenerateInitInstanceLocal((::TMVA::PDEFoam*)0);
00692    }
00693    // Static variable to force the class initialization
00694    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::PDEFoam*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00695 } // end of namespace ROOT
00696 
00697 namespace ROOT {
00698    void TMVAcLcLBDTEventWrapper_ShowMembers(void *obj, TMemberInspector &R__insp);
00699    static void TMVAcLcLBDTEventWrapper_Dictionary();
00700    static void delete_TMVAcLcLBDTEventWrapper(void *p);
00701    static void deleteArray_TMVAcLcLBDTEventWrapper(void *p);
00702    static void destruct_TMVAcLcLBDTEventWrapper(void *p);
00703 
00704    // Function generating the singleton type initializer
00705    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::BDTEventWrapper*)
00706    {
00707       // Make sure the shadow class has the right sizeof
00708       R__ASSERT(sizeof(::TMVA::BDTEventWrapper) == sizeof(::ROOT::Shadow::TMVA::BDTEventWrapper));
00709       ::TMVA::BDTEventWrapper *ptr = 0;
00710       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TMVA::BDTEventWrapper),0);
00711       static ::ROOT::TGenericClassInfo 
00712          instance("TMVA::BDTEventWrapper", "./include/TMVA/BDTEventWrapper.h", 31,
00713                   typeid(::TMVA::BDTEventWrapper), DefineBehavior(ptr, ptr),
00714                   &TMVAcLcLBDTEventWrapper_ShowMembers, &TMVAcLcLBDTEventWrapper_Dictionary, isa_proxy, 4,
00715                   sizeof(::TMVA::BDTEventWrapper) );
00716       instance.SetDelete(&delete_TMVAcLcLBDTEventWrapper);
00717       instance.SetDeleteArray(&deleteArray_TMVAcLcLBDTEventWrapper);
00718       instance.SetDestructor(&destruct_TMVAcLcLBDTEventWrapper);
00719       return &instance;
00720    }
00721    TGenericClassInfo *GenerateInitInstance(const ::TMVA::BDTEventWrapper*)
00722    {
00723       return GenerateInitInstanceLocal((::TMVA::BDTEventWrapper*)0);
00724    }
00725    // Static variable to force the class initialization
00726    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::BDTEventWrapper*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00727 
00728    // Dictionary for non-ClassDef classes
00729    static void TMVAcLcLBDTEventWrapper_Dictionary() {
00730       ::ROOT::GenerateInitInstanceLocal((const ::TMVA::BDTEventWrapper*)0x0)->GetClass();
00731    }
00732 
00733 } // end of namespace ROOT
00734 
00735 namespace ROOT {
00736    void TMVAcLcLCCTreeWrapper_ShowMembers(void *obj, TMemberInspector &R__insp);
00737    static void TMVAcLcLCCTreeWrapper_Dictionary();
00738    static void delete_TMVAcLcLCCTreeWrapper(void *p);
00739    static void deleteArray_TMVAcLcLCCTreeWrapper(void *p);
00740    static void destruct_TMVAcLcLCCTreeWrapper(void *p);
00741 
00742    // Function generating the singleton type initializer
00743    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::CCTreeWrapper*)
00744    {
00745       // Make sure the shadow class has the right sizeof
00746       R__ASSERT(sizeof(::TMVA::CCTreeWrapper) == sizeof(::ROOT::Shadow::TMVA::CCTreeWrapper));
00747       ::TMVA::CCTreeWrapper *ptr = 0;
00748       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TMVA::CCTreeWrapper),0);
00749       static ::ROOT::TGenericClassInfo 
00750          instance("TMVA::CCTreeWrapper", "./include/TMVA/CCTreeWrapper.h", 46,
00751                   typeid(::TMVA::CCTreeWrapper), DefineBehavior(ptr, ptr),
00752                   &TMVAcLcLCCTreeWrapper_ShowMembers, &TMVAcLcLCCTreeWrapper_Dictionary, isa_proxy, 4,
00753                   sizeof(::TMVA::CCTreeWrapper) );
00754       instance.SetDelete(&delete_TMVAcLcLCCTreeWrapper);
00755       instance.SetDeleteArray(&deleteArray_TMVAcLcLCCTreeWrapper);
00756       instance.SetDestructor(&destruct_TMVAcLcLCCTreeWrapper);
00757       return &instance;
00758    }
00759    TGenericClassInfo *GenerateInitInstance(const ::TMVA::CCTreeWrapper*)
00760    {
00761       return GenerateInitInstanceLocal((::TMVA::CCTreeWrapper*)0);
00762    }
00763    // Static variable to force the class initialization
00764    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::CCTreeWrapper*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00765 
00766    // Dictionary for non-ClassDef classes
00767    static void TMVAcLcLCCTreeWrapper_Dictionary() {
00768       ::ROOT::GenerateInitInstanceLocal((const ::TMVA::CCTreeWrapper*)0x0)->GetClass();
00769    }
00770 
00771 } // end of namespace ROOT
00772 
00773 namespace ROOT {
00774    void TMVAcLcLCCPruner_ShowMembers(void *obj, TMemberInspector &R__insp);
00775    static void TMVAcLcLCCPruner_Dictionary();
00776    static void delete_TMVAcLcLCCPruner(void *p);
00777    static void deleteArray_TMVAcLcLCCPruner(void *p);
00778    static void destruct_TMVAcLcLCCPruner(void *p);
00779 
00780    // Function generating the singleton type initializer
00781    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::CCPruner*)
00782    {
00783       // Make sure the shadow class has the right sizeof
00784       R__ASSERT(sizeof(::TMVA::CCPruner) == sizeof(::ROOT::Shadow::TMVA::CCPruner));
00785       ::TMVA::CCPruner *ptr = 0;
00786       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TMVA::CCPruner),0);
00787       static ::ROOT::TGenericClassInfo 
00788          instance("TMVA::CCPruner", "./include/TMVA/CCPruner.h", 64,
00789                   typeid(::TMVA::CCPruner), DefineBehavior(ptr, ptr),
00790                   &TMVAcLcLCCPruner_ShowMembers, &TMVAcLcLCCPruner_Dictionary, isa_proxy, 4,
00791                   sizeof(::TMVA::CCPruner) );
00792       instance.SetDelete(&delete_TMVAcLcLCCPruner);
00793       instance.SetDeleteArray(&deleteArray_TMVAcLcLCCPruner);
00794       instance.SetDestructor(&destruct_TMVAcLcLCCPruner);
00795       return &instance;
00796    }
00797    TGenericClassInfo *GenerateInitInstance(const ::TMVA::CCPruner*)
00798    {
00799       return GenerateInitInstanceLocal((::TMVA::CCPruner*)0);
00800    }
00801    // Static variable to force the class initialization
00802    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::CCPruner*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00803 
00804    // Dictionary for non-ClassDef classes
00805    static void TMVAcLcLCCPruner_Dictionary() {
00806       ::ROOT::GenerateInitInstanceLocal((const ::TMVA::CCPruner*)0x0)->GetClass();
00807    }
00808 
00809 } // end of namespace ROOT
00810 
00811 namespace ROOT {
00812    void TMVAcLcLCostComplexityPruneTool_ShowMembers(void *obj, TMemberInspector &R__insp);
00813    static void TMVAcLcLCostComplexityPruneTool_Dictionary();
00814    static void *new_TMVAcLcLCostComplexityPruneTool(void *p = 0);
00815    static void *newArray_TMVAcLcLCostComplexityPruneTool(Long_t size, void *p);
00816    static void delete_TMVAcLcLCostComplexityPruneTool(void *p);
00817    static void deleteArray_TMVAcLcLCostComplexityPruneTool(void *p);
00818    static void destruct_TMVAcLcLCostComplexityPruneTool(void *p);
00819 
00820    // Function generating the singleton type initializer
00821    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::CostComplexityPruneTool*)
00822    {
00823       // Make sure the shadow class has the right sizeof
00824       R__ASSERT(sizeof(::TMVA::CostComplexityPruneTool) == sizeof(::ROOT::Shadow::TMVA::CostComplexityPruneTool));
00825       ::TMVA::CostComplexityPruneTool *ptr = 0;
00826       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::TMVA::CostComplexityPruneTool),0);
00827       static ::ROOT::TGenericClassInfo 
00828          instance("TMVA::CostComplexityPruneTool", "./include/TMVA/CostComplexityPruneTool.h", 71,
00829                   typeid(::TMVA::CostComplexityPruneTool), DefineBehavior(ptr, ptr),
00830                   &TMVAcLcLCostComplexityPruneTool_ShowMembers, &TMVAcLcLCostComplexityPruneTool_Dictionary, isa_proxy, 4,
00831                   sizeof(::TMVA::CostComplexityPruneTool) );
00832       instance.SetNew(&new_TMVAcLcLCostComplexityPruneTool);
00833       instance.SetNewArray(&newArray_TMVAcLcLCostComplexityPruneTool);
00834       instance.SetDelete(&delete_TMVAcLcLCostComplexityPruneTool);
00835       instance.SetDeleteArray(&deleteArray_TMVAcLcLCostComplexityPruneTool);
00836       instance.SetDestructor(&destruct_TMVAcLcLCostComplexityPruneTool);
00837       return &instance;
00838    }
00839    TGenericClassInfo *GenerateInitInstance(const ::TMVA::CostComplexityPruneTool*)
00840    {
00841       return GenerateInitInstanceLocal((::TMVA::CostComplexityPruneTool*)0);
00842    }
00843    // Static variable to force the class initialization
00844    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::CostComplexityPruneTool*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00845 
00846    // Dictionary for non-ClassDef classes
00847    static void TMVAcLcLCostComplexityPruneTool_Dictionary() {
00848       ::ROOT::GenerateInitInstanceLocal((const ::TMVA::CostComplexityPruneTool*)0x0)->GetClass();
00849    }
00850 
00851 } // end of namespace ROOT
00852 
00853 namespace ROOT {
00854    void TMVAcLcLSVEvent_ShowMembers(void *obj, TMemberInspector &R__insp);
00855    static void *new_TMVAcLcLSVEvent(void *p = 0);
00856    static void *newArray_TMVAcLcLSVEvent(Long_t size, void *p);
00857    static void delete_TMVAcLcLSVEvent(void *p);
00858    static void deleteArray_TMVAcLcLSVEvent(void *p);
00859    static void destruct_TMVAcLcLSVEvent(void *p);
00860 
00861    // Function generating the singleton type initializer
00862    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::SVEvent*)
00863    {
00864       ::TMVA::SVEvent *ptr = 0;
00865       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::SVEvent >(0);
00866       static ::ROOT::TGenericClassInfo 
00867          instance("TMVA::SVEvent", ::TMVA::SVEvent::Class_Version(), "./include/TMVA/SVEvent.h", 42,
00868                   typeid(::TMVA::SVEvent), DefineBehavior(ptr, ptr),
00869                   &::TMVA::SVEvent::Dictionary, isa_proxy, 4,
00870                   sizeof(::TMVA::SVEvent) );
00871       instance.SetNew(&new_TMVAcLcLSVEvent);
00872       instance.SetNewArray(&newArray_TMVAcLcLSVEvent);
00873       instance.SetDelete(&delete_TMVAcLcLSVEvent);
00874       instance.SetDeleteArray(&deleteArray_TMVAcLcLSVEvent);
00875       instance.SetDestructor(&destruct_TMVAcLcLSVEvent);
00876       return &instance;
00877    }
00878    TGenericClassInfo *GenerateInitInstance(const ::TMVA::SVEvent*)
00879    {
00880       return GenerateInitInstanceLocal((::TMVA::SVEvent*)0);
00881    }
00882    // Static variable to force the class initialization
00883    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::SVEvent*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00884 } // end of namespace ROOT
00885 
00886 namespace ROOT {
00887    void TMVAcLcLOptimizeConfigParameters_ShowMembers(void *obj, TMemberInspector &R__insp);
00888    static void delete_TMVAcLcLOptimizeConfigParameters(void *p);
00889    static void deleteArray_TMVAcLcLOptimizeConfigParameters(void *p);
00890    static void destruct_TMVAcLcLOptimizeConfigParameters(void *p);
00891 
00892    // Function generating the singleton type initializer
00893    static TGenericClassInfo *GenerateInitInstanceLocal(const ::TMVA::OptimizeConfigParameters*)
00894    {
00895       ::TMVA::OptimizeConfigParameters *ptr = 0;
00896       static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TMVA::OptimizeConfigParameters >(0);
00897       static ::ROOT::TGenericClassInfo 
00898          instance("TMVA::OptimizeConfigParameters", ::TMVA::OptimizeConfigParameters::Class_Version(), "./include/TMVA/OptimizeConfigParameters.h", 63,
00899                   typeid(::TMVA::OptimizeConfigParameters), DefineBehavior(ptr, ptr),
00900                   &::TMVA::OptimizeConfigParameters::Dictionary, isa_proxy, 4,
00901                   sizeof(::TMVA::OptimizeConfigParameters) );
00902       instance.SetDelete(&delete_TMVAcLcLOptimizeConfigParameters);
00903       instance.SetDeleteArray(&deleteArray_TMVAcLcLOptimizeConfigParameters);
00904       instance.SetDestructor(&destruct_TMVAcLcLOptimizeConfigParameters);
00905       return &instance;
00906    }
00907    TGenericClassInfo *GenerateInitInstance(const ::TMVA::OptimizeConfigParameters*)
00908    {
00909       return GenerateInitInstanceLocal((::TMVA::OptimizeConfigParameters*)0);
00910    }
00911    // Static variable to force the class initialization
00912    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TMVA::OptimizeConfigParameters*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00913 } // end of namespace ROOT
00914 
00915       namespace TMVA {
00916 //______________________________________________________________________________
00917 TClass *Config::fgIsA = 0;  // static to hold class pointer
00918 
00919 //______________________________________________________________________________
00920 const char *Config::Class_Name()
00921 {
00922    return "TMVA::Config";
00923 }
00924 
00925 //______________________________________________________________________________
00926 const char *Config::ImplFileName()
00927 {
00928    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::Config*)0x0)->GetImplFileName();
00929 }
00930 
00931 //______________________________________________________________________________
00932 int Config::ImplFileLine()
00933 {
00934    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::Config*)0x0)->GetImplFileLine();
00935 }
00936 
00937 //______________________________________________________________________________
00938 void Config::Dictionary()
00939 {
00940    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::Config*)0x0)->GetClass();
00941 }
00942 
00943 //______________________________________________________________________________
00944 TClass *Config::Class()
00945 {
00946    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::Config*)0x0)->GetClass();
00947    return fgIsA;
00948 }
00949 
00950 } // namespace TMVA
00951       namespace TMVA {
00952 //______________________________________________________________________________
00953 TClass *KDEKernel::fgIsA = 0;  // static to hold class pointer
00954 
00955 //______________________________________________________________________________
00956 const char *KDEKernel::Class_Name()
00957 {
00958    return "TMVA::KDEKernel";
00959 }
00960 
00961 //______________________________________________________________________________
00962 const char *KDEKernel::ImplFileName()
00963 {
00964    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::KDEKernel*)0x0)->GetImplFileName();
00965 }
00966 
00967 //______________________________________________________________________________
00968 int KDEKernel::ImplFileLine()
00969 {
00970    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::KDEKernel*)0x0)->GetImplFileLine();
00971 }
00972 
00973 //______________________________________________________________________________
00974 void KDEKernel::Dictionary()
00975 {
00976    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::KDEKernel*)0x0)->GetClass();
00977 }
00978 
00979 //______________________________________________________________________________
00980 TClass *KDEKernel::Class()
00981 {
00982    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::KDEKernel*)0x0)->GetClass();
00983    return fgIsA;
00984 }
00985 
00986 } // namespace TMVA
00987       namespace TMVA {
00988 //______________________________________________________________________________
00989 TClass *Interval::fgIsA = 0;  // static to hold class pointer
00990 
00991 //______________________________________________________________________________
00992 const char *Interval::Class_Name()
00993 {
00994    return "TMVA::Interval";
00995 }
00996 
00997 //______________________________________________________________________________
00998 const char *Interval::ImplFileName()
00999 {
01000    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::Interval*)0x0)->GetImplFileName();
01001 }
01002 
01003 //______________________________________________________________________________
01004 int Interval::ImplFileLine()
01005 {
01006    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::Interval*)0x0)->GetImplFileLine();
01007 }
01008 
01009 //______________________________________________________________________________
01010 void Interval::Dictionary()
01011 {
01012    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::Interval*)0x0)->GetClass();
01013 }
01014 
01015 //______________________________________________________________________________
01016 TClass *Interval::Class()
01017 {
01018    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::Interval*)0x0)->GetClass();
01019    return fgIsA;
01020 }
01021 
01022 } // namespace TMVA
01023       namespace TMVA {
01024 //______________________________________________________________________________
01025 TClass *IFitterTarget::fgIsA = 0;  // static to hold class pointer
01026 
01027 //______________________________________________________________________________
01028 const char *IFitterTarget::Class_Name()
01029 {
01030    return "TMVA::IFitterTarget";
01031 }
01032 
01033 //______________________________________________________________________________
01034 const char *IFitterTarget::ImplFileName()
01035 {
01036    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::IFitterTarget*)0x0)->GetImplFileName();
01037 }
01038 
01039 //______________________________________________________________________________
01040 int IFitterTarget::ImplFileLine()
01041 {
01042    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::IFitterTarget*)0x0)->GetImplFileLine();
01043 }
01044 
01045 //______________________________________________________________________________
01046 void IFitterTarget::Dictionary()
01047 {
01048    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::IFitterTarget*)0x0)->GetClass();
01049 }
01050 
01051 //______________________________________________________________________________
01052 TClass *IFitterTarget::Class()
01053 {
01054    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::IFitterTarget*)0x0)->GetClass();
01055    return fgIsA;
01056 }
01057 
01058 } // namespace TMVA
01059       namespace TMVA {
01060 //______________________________________________________________________________
01061 TClass *FitterBase::fgIsA = 0;  // static to hold class pointer
01062 
01063 //______________________________________________________________________________
01064 const char *FitterBase::Class_Name()
01065 {
01066    return "TMVA::FitterBase";
01067 }
01068 
01069 //______________________________________________________________________________
01070 const char *FitterBase::ImplFileName()
01071 {
01072    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::FitterBase*)0x0)->GetImplFileName();
01073 }
01074 
01075 //______________________________________________________________________________
01076 int FitterBase::ImplFileLine()
01077 {
01078    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::FitterBase*)0x0)->GetImplFileLine();
01079 }
01080 
01081 //______________________________________________________________________________
01082 void FitterBase::Dictionary()
01083 {
01084    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::FitterBase*)0x0)->GetClass();
01085 }
01086 
01087 //______________________________________________________________________________
01088 TClass *FitterBase::Class()
01089 {
01090    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::FitterBase*)0x0)->GetClass();
01091    return fgIsA;
01092 }
01093 
01094 } // namespace TMVA
01095       namespace TMVA {
01096 //______________________________________________________________________________
01097 TClass *MCFitter::fgIsA = 0;  // static to hold class pointer
01098 
01099 //______________________________________________________________________________
01100 const char *MCFitter::Class_Name()
01101 {
01102    return "TMVA::MCFitter";
01103 }
01104 
01105 //______________________________________________________________________________
01106 const char *MCFitter::ImplFileName()
01107 {
01108    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::MCFitter*)0x0)->GetImplFileName();
01109 }
01110 
01111 //______________________________________________________________________________
01112 int MCFitter::ImplFileLine()
01113 {
01114    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::MCFitter*)0x0)->GetImplFileLine();
01115 }
01116 
01117 //______________________________________________________________________________
01118 void MCFitter::Dictionary()
01119 {
01120    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::MCFitter*)0x0)->GetClass();
01121 }
01122 
01123 //______________________________________________________________________________
01124 TClass *MCFitter::Class()
01125 {
01126    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::MCFitter*)0x0)->GetClass();
01127    return fgIsA;
01128 }
01129 
01130 } // namespace TMVA
01131       namespace TMVA {
01132 //______________________________________________________________________________
01133 TClass *GeneticFitter::fgIsA = 0;  // static to hold class pointer
01134 
01135 //______________________________________________________________________________
01136 const char *GeneticFitter::Class_Name()
01137 {
01138    return "TMVA::GeneticFitter";
01139 }
01140 
01141 //______________________________________________________________________________
01142 const char *GeneticFitter::ImplFileName()
01143 {
01144    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::GeneticFitter*)0x0)->GetImplFileName();
01145 }
01146 
01147 //______________________________________________________________________________
01148 int GeneticFitter::ImplFileLine()
01149 {
01150    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::GeneticFitter*)0x0)->GetImplFileLine();
01151 }
01152 
01153 //______________________________________________________________________________
01154 void GeneticFitter::Dictionary()
01155 {
01156    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::GeneticFitter*)0x0)->GetClass();
01157 }
01158 
01159 //______________________________________________________________________________
01160 TClass *GeneticFitter::Class()
01161 {
01162    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::GeneticFitter*)0x0)->GetClass();
01163    return fgIsA;
01164 }
01165 
01166 } // namespace TMVA
01167       namespace TMVA {
01168 //______________________________________________________________________________
01169 TClass *SimulatedAnnealingFitter::fgIsA = 0;  // static to hold class pointer
01170 
01171 //______________________________________________________________________________
01172 const char *SimulatedAnnealingFitter::Class_Name()
01173 {
01174    return "TMVA::SimulatedAnnealingFitter";
01175 }
01176 
01177 //______________________________________________________________________________
01178 const char *SimulatedAnnealingFitter::ImplFileName()
01179 {
01180    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::SimulatedAnnealingFitter*)0x0)->GetImplFileName();
01181 }
01182 
01183 //______________________________________________________________________________
01184 int SimulatedAnnealingFitter::ImplFileLine()
01185 {
01186    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::SimulatedAnnealingFitter*)0x0)->GetImplFileLine();
01187 }
01188 
01189 //______________________________________________________________________________
01190 void SimulatedAnnealingFitter::Dictionary()
01191 {
01192    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::SimulatedAnnealingFitter*)0x0)->GetClass();
01193 }
01194 
01195 //______________________________________________________________________________
01196 TClass *SimulatedAnnealingFitter::Class()
01197 {
01198    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::SimulatedAnnealingFitter*)0x0)->GetClass();
01199    return fgIsA;
01200 }
01201 
01202 } // namespace TMVA
01203       namespace TMVA {
01204 //______________________________________________________________________________
01205 TClass *MinuitWrapper::fgIsA = 0;  // static to hold class pointer
01206 
01207 //______________________________________________________________________________
01208 const char *MinuitWrapper::Class_Name()
01209 {
01210    return "TMVA::MinuitWrapper";
01211 }
01212 
01213 //______________________________________________________________________________
01214 const char *MinuitWrapper::ImplFileName()
01215 {
01216    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::MinuitWrapper*)0x0)->GetImplFileName();
01217 }
01218 
01219 //______________________________________________________________________________
01220 int MinuitWrapper::ImplFileLine()
01221 {
01222    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::MinuitWrapper*)0x0)->GetImplFileLine();
01223 }
01224 
01225 //______________________________________________________________________________
01226 void MinuitWrapper::Dictionary()
01227 {
01228    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::MinuitWrapper*)0x0)->GetClass();
01229 }
01230 
01231 //______________________________________________________________________________
01232 TClass *MinuitWrapper::Class()
01233 {
01234    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::MinuitWrapper*)0x0)->GetClass();
01235    return fgIsA;
01236 }
01237 
01238 } // namespace TMVA
01239       namespace TMVA {
01240 //______________________________________________________________________________
01241 TClass *MinuitFitter::fgIsA = 0;  // static to hold class pointer
01242 
01243 //______________________________________________________________________________
01244 const char *MinuitFitter::Class_Name()
01245 {
01246    return "TMVA::MinuitFitter";
01247 }
01248 
01249 //______________________________________________________________________________
01250 const char *MinuitFitter::ImplFileName()
01251 {
01252    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::MinuitFitter*)0x0)->GetImplFileName();
01253 }
01254 
01255 //______________________________________________________________________________
01256 int MinuitFitter::ImplFileLine()
01257 {
01258    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::MinuitFitter*)0x0)->GetImplFileLine();
01259 }
01260 
01261 //______________________________________________________________________________
01262 void MinuitFitter::Dictionary()
01263 {
01264    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::MinuitFitter*)0x0)->GetClass();
01265 }
01266 
01267 //______________________________________________________________________________
01268 TClass *MinuitFitter::Class()
01269 {
01270    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::MinuitFitter*)0x0)->GetClass();
01271    return fgIsA;
01272 }
01273 
01274 } // namespace TMVA
01275       namespace TMVA {
01276 //______________________________________________________________________________
01277 TClass *PDEFoamCell::fgIsA = 0;  // static to hold class pointer
01278 
01279 //______________________________________________________________________________
01280 const char *PDEFoamCell::Class_Name()
01281 {
01282    return "TMVA::PDEFoamCell";
01283 }
01284 
01285 //______________________________________________________________________________
01286 const char *PDEFoamCell::ImplFileName()
01287 {
01288    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::PDEFoamCell*)0x0)->GetImplFileName();
01289 }
01290 
01291 //______________________________________________________________________________
01292 int PDEFoamCell::ImplFileLine()
01293 {
01294    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::PDEFoamCell*)0x0)->GetImplFileLine();
01295 }
01296 
01297 //______________________________________________________________________________
01298 void PDEFoamCell::Dictionary()
01299 {
01300    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::PDEFoamCell*)0x0)->GetClass();
01301 }
01302 
01303 //______________________________________________________________________________
01304 TClass *PDEFoamCell::Class()
01305 {
01306    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::PDEFoamCell*)0x0)->GetClass();
01307    return fgIsA;
01308 }
01309 
01310 } // namespace TMVA
01311       namespace TMVA {
01312 //______________________________________________________________________________
01313 TClass *PDEFoamVect::fgIsA = 0;  // static to hold class pointer
01314 
01315 //______________________________________________________________________________
01316 const char *PDEFoamVect::Class_Name()
01317 {
01318    return "TMVA::PDEFoamVect";
01319 }
01320 
01321 //______________________________________________________________________________
01322 const char *PDEFoamVect::ImplFileName()
01323 {
01324    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::PDEFoamVect*)0x0)->GetImplFileName();
01325 }
01326 
01327 //______________________________________________________________________________
01328 int PDEFoamVect::ImplFileLine()
01329 {
01330    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::PDEFoamVect*)0x0)->GetImplFileLine();
01331 }
01332 
01333 //______________________________________________________________________________
01334 void PDEFoamVect::Dictionary()
01335 {
01336    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::PDEFoamVect*)0x0)->GetClass();
01337 }
01338 
01339 //______________________________________________________________________________
01340 TClass *PDEFoamVect::Class()
01341 {
01342    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::PDEFoamVect*)0x0)->GetClass();
01343    return fgIsA;
01344 }
01345 
01346 } // namespace TMVA
01347       namespace TMVA {
01348 //______________________________________________________________________________
01349 TClass *PDEFoamDistr::fgIsA = 0;  // static to hold class pointer
01350 
01351 //______________________________________________________________________________
01352 const char *PDEFoamDistr::Class_Name()
01353 {
01354    return "TMVA::PDEFoamDistr";
01355 }
01356 
01357 //______________________________________________________________________________
01358 const char *PDEFoamDistr::ImplFileName()
01359 {
01360    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDistr*)0x0)->GetImplFileName();
01361 }
01362 
01363 //______________________________________________________________________________
01364 int PDEFoamDistr::ImplFileLine()
01365 {
01366    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDistr*)0x0)->GetImplFileLine();
01367 }
01368 
01369 //______________________________________________________________________________
01370 void PDEFoamDistr::Dictionary()
01371 {
01372    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDistr*)0x0)->GetClass();
01373 }
01374 
01375 //______________________________________________________________________________
01376 TClass *PDEFoamDistr::Class()
01377 {
01378    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::PDEFoamDistr*)0x0)->GetClass();
01379    return fgIsA;
01380 }
01381 
01382 } // namespace TMVA
01383       namespace TMVA {
01384 //______________________________________________________________________________
01385 TClass *PDEFoam::fgIsA = 0;  // static to hold class pointer
01386 
01387 //______________________________________________________________________________
01388 const char *PDEFoam::Class_Name()
01389 {
01390    return "TMVA::PDEFoam";
01391 }
01392 
01393 //______________________________________________________________________________
01394 const char *PDEFoam::ImplFileName()
01395 {
01396    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::PDEFoam*)0x0)->GetImplFileName();
01397 }
01398 
01399 //______________________________________________________________________________
01400 int PDEFoam::ImplFileLine()
01401 {
01402    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::PDEFoam*)0x0)->GetImplFileLine();
01403 }
01404 
01405 //______________________________________________________________________________
01406 void PDEFoam::Dictionary()
01407 {
01408    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::PDEFoam*)0x0)->GetClass();
01409 }
01410 
01411 //______________________________________________________________________________
01412 TClass *PDEFoam::Class()
01413 {
01414    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::PDEFoam*)0x0)->GetClass();
01415    return fgIsA;
01416 }
01417 
01418 } // namespace TMVA
01419       namespace TMVA {
01420 //______________________________________________________________________________
01421 TClass *SVEvent::fgIsA = 0;  // static to hold class pointer
01422 
01423 //______________________________________________________________________________
01424 const char *SVEvent::Class_Name()
01425 {
01426    return "TMVA::SVEvent";
01427 }
01428 
01429 //______________________________________________________________________________
01430 const char *SVEvent::ImplFileName()
01431 {
01432    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::SVEvent*)0x0)->GetImplFileName();
01433 }
01434 
01435 //______________________________________________________________________________
01436 int SVEvent::ImplFileLine()
01437 {
01438    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::SVEvent*)0x0)->GetImplFileLine();
01439 }
01440 
01441 //______________________________________________________________________________
01442 void SVEvent::Dictionary()
01443 {
01444    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::SVEvent*)0x0)->GetClass();
01445 }
01446 
01447 //______________________________________________________________________________
01448 TClass *SVEvent::Class()
01449 {
01450    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::SVEvent*)0x0)->GetClass();
01451    return fgIsA;
01452 }
01453 
01454 } // namespace TMVA
01455       namespace TMVA {
01456 //______________________________________________________________________________
01457 TClass *OptimizeConfigParameters::fgIsA = 0;  // static to hold class pointer
01458 
01459 //______________________________________________________________________________
01460 const char *OptimizeConfigParameters::Class_Name()
01461 {
01462    return "TMVA::OptimizeConfigParameters";
01463 }
01464 
01465 //______________________________________________________________________________
01466 const char *OptimizeConfigParameters::ImplFileName()
01467 {
01468    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::OptimizeConfigParameters*)0x0)->GetImplFileName();
01469 }
01470 
01471 //______________________________________________________________________________
01472 int OptimizeConfigParameters::ImplFileLine()
01473 {
01474    return ::ROOT::GenerateInitInstanceLocal((const ::TMVA::OptimizeConfigParameters*)0x0)->GetImplFileLine();
01475 }
01476 
01477 //______________________________________________________________________________
01478 void OptimizeConfigParameters::Dictionary()
01479 {
01480    fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::OptimizeConfigParameters*)0x0)->GetClass();
01481 }
01482 
01483 //______________________________________________________________________________
01484 TClass *OptimizeConfigParameters::Class()
01485 {
01486    if (!fgIsA) fgIsA = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::OptimizeConfigParameters*)0x0)->GetClass();
01487    return fgIsA;
01488 }
01489 
01490 } // namespace TMVA
01491       namespace TMVA {
01492 //______________________________________________________________________________
01493 void Config::Streamer(TBuffer &R__b)
01494 {
01495    // Stream an object of class TMVA::Config.
01496 
01497    if (R__b.IsReading()) {
01498       R__b.ReadClassBuffer(TMVA::Config::Class(),this);
01499    } else {
01500       R__b.WriteClassBuffer(TMVA::Config::Class(),this);
01501    }
01502 }
01503 
01504 } // namespace TMVA
01505 //______________________________________________________________________________
01506       namespace TMVA {
01507 void Config::ShowMembers(TMemberInspector &R__insp)
01508 {
01509       // Inspect the data members of an object of class TMVA::Config.
01510       TClass *R__cl = ::TMVA::Config::IsA();
01511       if (R__cl || R__insp.IsA()) { }
01512       R__insp.Inspect(R__cl, R__insp.GetParent(), "fVariablePlotting", (void*)&fVariablePlotting);
01513       R__insp.InspectMember("TMVA::Config::VariablePlotting", (void*)&fVariablePlotting, "fVariablePlotting.", false);
01514       R__insp.Inspect(R__cl, R__insp.GetParent(), "fIONames", (void*)&fIONames);
01515       R__insp.InspectMember("TMVA::Config::IONames", (void*)&fIONames, "fIONames.", false);
01516       R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseColoredConsole", &fUseColoredConsole);
01517       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSilent", &fSilent);
01518       R__insp.Inspect(R__cl, R__insp.GetParent(), "fWriteOptionsReference", &fWriteOptionsReference);
01519       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrawProgressBar", &fDrawProgressBar);
01520       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
01521 }
01522 
01523 } // namespace TMVA
01524 namespace ROOT {
01525 } // end of namespace ROOT for class ::TMVA::Config
01526 
01527 //______________________________________________________________________________
01528 namespace ROOT {
01529    void TMVAcLcLConfigcLcLVariablePlotting_ShowMembers(void *obj, TMemberInspector &R__insp)
01530    {
01531       // Inspect the data members of an object of class TMVA::Config::VariablePlotting.
01532       typedef ::ROOT::Shadow::TMVA::Config::VariablePlotting ShadowClass;
01533       ShadowClass *sobj = (ShadowClass*)obj;
01534       if (sobj) { } // Dummy usage just in case there is no datamember.
01535 
01536       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::Config::VariablePlotting*)0x0)->GetClass();
01537       if (R__cl || R__insp.IsA()) { }
01538       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTimesRMS", &sobj->fTimesRMS);
01539       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbins1D", &sobj->fNbins1D);
01540       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbins2D", &sobj->fNbins2D);
01541       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxNumOfAllowedVariablesForScatterPlots", &sobj->fMaxNumOfAllowedVariablesForScatterPlots);
01542       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbinsXOfROCCurve", &sobj->fNbinsXOfROCCurve);
01543    }
01544 
01545 }
01546 
01547 namespace ROOT {
01548    // Wrappers around operator new
01549    static void *new_TMVAcLcLConfigcLcLVariablePlotting(void *p) {
01550       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::Config::VariablePlotting : new ::TMVA::Config::VariablePlotting;
01551    }
01552    static void *newArray_TMVAcLcLConfigcLcLVariablePlotting(Long_t nElements, void *p) {
01553       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::Config::VariablePlotting[nElements] : new ::TMVA::Config::VariablePlotting[nElements];
01554    }
01555    // Wrapper around operator delete
01556    static void delete_TMVAcLcLConfigcLcLVariablePlotting(void *p) {
01557       delete ((::TMVA::Config::VariablePlotting*)p);
01558    }
01559    static void deleteArray_TMVAcLcLConfigcLcLVariablePlotting(void *p) {
01560       delete [] ((::TMVA::Config::VariablePlotting*)p);
01561    }
01562    static void destruct_TMVAcLcLConfigcLcLVariablePlotting(void *p) {
01563       typedef ::TMVA::Config::VariablePlotting current_t;
01564       ((current_t*)p)->~current_t();
01565    }
01566 } // end of namespace ROOT for class ::TMVA::Config::VariablePlotting
01567 
01568 //______________________________________________________________________________
01569 namespace ROOT {
01570    void TMVAcLcLConfigcLcLIONames_ShowMembers(void *obj, TMemberInspector &R__insp)
01571    {
01572       // Inspect the data members of an object of class TMVA::Config::IONames.
01573       typedef ::ROOT::Shadow::TMVA::Config::IONames ShadowClass;
01574       ShadowClass *sobj = (ShadowClass*)obj;
01575       if (sobj) { } // Dummy usage just in case there is no datamember.
01576 
01577       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::Config::IONames*)0x0)->GetClass();
01578       if (R__cl || R__insp.IsA()) { }
01579       R__insp.Inspect(R__cl, R__insp.GetParent(), "fWeightFileDir", &sobj->fWeightFileDir);
01580       R__insp.InspectMember(sobj->fWeightFileDir, "fWeightFileDir.");
01581       R__insp.Inspect(R__cl, R__insp.GetParent(), "fWeightFileExtension", &sobj->fWeightFileExtension);
01582       R__insp.InspectMember(sobj->fWeightFileExtension, "fWeightFileExtension.");
01583       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptionsReferenceFileDir", &sobj->fOptionsReferenceFileDir);
01584       R__insp.InspectMember(sobj->fOptionsReferenceFileDir, "fOptionsReferenceFileDir.");
01585    }
01586 
01587 }
01588 
01589 namespace ROOT {
01590    // Wrappers around operator new
01591    static void *new_TMVAcLcLConfigcLcLIONames(void *p) {
01592       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::Config::IONames : new ::TMVA::Config::IONames;
01593    }
01594    static void *newArray_TMVAcLcLConfigcLcLIONames(Long_t nElements, void *p) {
01595       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::Config::IONames[nElements] : new ::TMVA::Config::IONames[nElements];
01596    }
01597    // Wrapper around operator delete
01598    static void delete_TMVAcLcLConfigcLcLIONames(void *p) {
01599       delete ((::TMVA::Config::IONames*)p);
01600    }
01601    static void deleteArray_TMVAcLcLConfigcLcLIONames(void *p) {
01602       delete [] ((::TMVA::Config::IONames*)p);
01603    }
01604    static void destruct_TMVAcLcLConfigcLcLIONames(void *p) {
01605       typedef ::TMVA::Config::IONames current_t;
01606       ((current_t*)p)->~current_t();
01607    }
01608 } // end of namespace ROOT for class ::TMVA::Config::IONames
01609 
01610       namespace TMVA {
01611 //______________________________________________________________________________
01612 void KDEKernel::Streamer(TBuffer &R__b)
01613 {
01614    // Stream an object of class TMVA::KDEKernel.
01615 
01616    if (R__b.IsReading()) {
01617       R__b.ReadClassBuffer(TMVA::KDEKernel::Class(),this);
01618    } else {
01619       R__b.WriteClassBuffer(TMVA::KDEKernel::Class(),this);
01620    }
01621 }
01622 
01623 } // namespace TMVA
01624 //______________________________________________________________________________
01625       namespace TMVA {
01626 void KDEKernel::ShowMembers(TMemberInspector &R__insp)
01627 {
01628       // Inspect the data members of an object of class TMVA::KDEKernel.
01629       TClass *R__cl = ::TMVA::KDEKernel::IsA();
01630       if (R__cl || R__insp.IsA()) { }
01631       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigma", &fSigma);
01632       R__insp.Inspect(R__cl, R__insp.GetParent(), "fIter", &fIter);
01633       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLowerEdge", &fLowerEdge);
01634       R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpperEdge", &fUpperEdge);
01635       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFineFactor", &fFineFactor);
01636       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fKernel_integ", &fKernel_integ);
01637       R__insp.Inspect(R__cl, R__insp.GetParent(), "fKDEborder", &fKDEborder);
01638       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHist", &fHist);
01639       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFirstIterHist", &fFirstIterHist);
01640       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fSigmaHist", &fSigmaHist);
01641       R__insp.Inspect(R__cl, R__insp.GetParent(), "fHiddenIteration", &fHiddenIteration);
01642       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
01643 }
01644 
01645 } // namespace TMVA
01646 namespace ROOT {
01647    // Wrappers around operator new
01648    static void *new_TMVAcLcLKDEKernel(void *p) {
01649       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::KDEKernel : new ::TMVA::KDEKernel;
01650    }
01651    static void *newArray_TMVAcLcLKDEKernel(Long_t nElements, void *p) {
01652       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::KDEKernel[nElements] : new ::TMVA::KDEKernel[nElements];
01653    }
01654    // Wrapper around operator delete
01655    static void delete_TMVAcLcLKDEKernel(void *p) {
01656       delete ((::TMVA::KDEKernel*)p);
01657    }
01658    static void deleteArray_TMVAcLcLKDEKernel(void *p) {
01659       delete [] ((::TMVA::KDEKernel*)p);
01660    }
01661    static void destruct_TMVAcLcLKDEKernel(void *p) {
01662       typedef ::TMVA::KDEKernel current_t;
01663       ((current_t*)p)->~current_t();
01664    }
01665 } // end of namespace ROOT for class ::TMVA::KDEKernel
01666 
01667       namespace TMVA {
01668 //______________________________________________________________________________
01669 void Interval::Streamer(TBuffer &R__b)
01670 {
01671    // Stream an object of class TMVA::Interval.
01672 
01673    if (R__b.IsReading()) {
01674       R__b.ReadClassBuffer(TMVA::Interval::Class(),this);
01675    } else {
01676       R__b.WriteClassBuffer(TMVA::Interval::Class(),this);
01677    }
01678 }
01679 
01680 } // namespace TMVA
01681 //______________________________________________________________________________
01682       namespace TMVA {
01683 void Interval::ShowMembers(TMemberInspector &R__insp)
01684 {
01685       // Inspect the data members of an object of class TMVA::Interval.
01686       TClass *R__cl = ::TMVA::Interval::IsA();
01687       if (R__cl || R__insp.IsA()) { }
01688       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMin", &fMin);
01689       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMax", &fMax);
01690       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNbins", &fNbins);
01691 }
01692 
01693 } // namespace TMVA
01694 namespace ROOT {
01695    // Wrapper around operator delete
01696    static void delete_TMVAcLcLInterval(void *p) {
01697       delete ((::TMVA::Interval*)p);
01698    }
01699    static void deleteArray_TMVAcLcLInterval(void *p) {
01700       delete [] ((::TMVA::Interval*)p);
01701    }
01702    static void destruct_TMVAcLcLInterval(void *p) {
01703       typedef ::TMVA::Interval current_t;
01704       ((current_t*)p)->~current_t();
01705    }
01706 } // end of namespace ROOT for class ::TMVA::Interval
01707 
01708       namespace TMVA {
01709 //______________________________________________________________________________
01710 void FitterBase::Streamer(TBuffer &R__b)
01711 {
01712    // Stream an object of class TMVA::FitterBase.
01713 
01714    if (R__b.IsReading()) {
01715       R__b.ReadClassBuffer(TMVA::FitterBase::Class(),this);
01716    } else {
01717       R__b.WriteClassBuffer(TMVA::FitterBase::Class(),this);
01718    }
01719 }
01720 
01721 } // namespace TMVA
01722 //______________________________________________________________________________
01723       namespace TMVA {
01724 void FitterBase::ShowMembers(TMemberInspector &R__insp)
01725 {
01726       // Inspect the data members of an object of class TMVA::FitterBase.
01727       TClass *R__cl = ::TMVA::FitterBase::IsA();
01728       if (R__cl || R__insp.IsA()) { }
01729       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRanges", (void*)&fRanges);
01730       R__insp.InspectMember("const vector<TMVA::Interval*>", (void*)&fRanges, "fRanges.", false);
01731       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNpars", &fNpars);
01732       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
01733       R__insp.Inspect(R__cl, R__insp.GetParent(), "fClassName", &fClassName);
01734       R__insp.InspectMember(fClassName, "fClassName.");
01735       //This works around a msvc bug and should be harmless on other platforms
01736       typedef TMVA::Configurable baseClass1;
01737       baseClass1::ShowMembers(R__insp);
01738 }
01739 
01740 } // namespace TMVA
01741 namespace ROOT {
01742    // Wrapper around operator delete
01743    static void delete_TMVAcLcLFitterBase(void *p) {
01744       delete ((::TMVA::FitterBase*)p);
01745    }
01746    static void deleteArray_TMVAcLcLFitterBase(void *p) {
01747       delete [] ((::TMVA::FitterBase*)p);
01748    }
01749    static void destruct_TMVAcLcLFitterBase(void *p) {
01750       typedef ::TMVA::FitterBase current_t;
01751       ((current_t*)p)->~current_t();
01752    }
01753 } // end of namespace ROOT for class ::TMVA::FitterBase
01754 
01755       namespace TMVA {
01756 //______________________________________________________________________________
01757 void MCFitter::Streamer(TBuffer &R__b)
01758 {
01759    // Stream an object of class TMVA::MCFitter.
01760 
01761    if (R__b.IsReading()) {
01762       R__b.ReadClassBuffer(TMVA::MCFitter::Class(),this);
01763    } else {
01764       R__b.WriteClassBuffer(TMVA::MCFitter::Class(),this);
01765    }
01766 }
01767 
01768 } // namespace TMVA
01769 //______________________________________________________________________________
01770       namespace TMVA {
01771 void MCFitter::ShowMembers(TMemberInspector &R__insp)
01772 {
01773       // Inspect the data members of an object of class TMVA::MCFitter.
01774       TClass *R__cl = ::TMVA::MCFitter::IsA();
01775       if (R__cl || R__insp.IsA()) { }
01776       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSamples", &fSamples);
01777       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigma", &fSigma);
01778       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSeed", &fSeed);
01779       //This works around a msvc bug and should be harmless on other platforms
01780       typedef TMVA::FitterBase baseClass1;
01781       baseClass1::ShowMembers(R__insp);
01782 }
01783 
01784 } // namespace TMVA
01785 namespace ROOT {
01786    // Wrapper around operator delete
01787    static void delete_TMVAcLcLMCFitter(void *p) {
01788       delete ((::TMVA::MCFitter*)p);
01789    }
01790    static void deleteArray_TMVAcLcLMCFitter(void *p) {
01791       delete [] ((::TMVA::MCFitter*)p);
01792    }
01793    static void destruct_TMVAcLcLMCFitter(void *p) {
01794       typedef ::TMVA::MCFitter current_t;
01795       ((current_t*)p)->~current_t();
01796    }
01797 } // end of namespace ROOT for class ::TMVA::MCFitter
01798 
01799       namespace TMVA {
01800 //______________________________________________________________________________
01801 void GeneticFitter::Streamer(TBuffer &R__b)
01802 {
01803    // Stream an object of class TMVA::GeneticFitter.
01804 
01805    if (R__b.IsReading()) {
01806       R__b.ReadClassBuffer(TMVA::GeneticFitter::Class(),this);
01807    } else {
01808       R__b.WriteClassBuffer(TMVA::GeneticFitter::Class(),this);
01809    }
01810 }
01811 
01812 } // namespace TMVA
01813 //______________________________________________________________________________
01814       namespace TMVA {
01815 void GeneticFitter::ShowMembers(TMemberInspector &R__insp)
01816 {
01817       // Inspect the data members of an object of class TMVA::GeneticFitter.
01818       TClass *R__cl = ::TMVA::GeneticFitter::IsA();
01819       if (R__cl || R__insp.IsA()) { }
01820       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCycles", &fCycles);
01821       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNsteps", &fNsteps);
01822       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPopSize", &fPopSize);
01823       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSC_steps", &fSC_steps);
01824       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSC_rate", &fSC_rate);
01825       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSC_factor", &fSC_factor);
01826       R__insp.Inspect(R__cl, R__insp.GetParent(), "fConvCrit", &fConvCrit);
01827       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSaveBestFromGeneration", &fSaveBestFromGeneration);
01828       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSaveBestFromCycle", &fSaveBestFromCycle);
01829       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTrim", &fTrim);
01830       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSeed", &fSeed);
01831       //This works around a msvc bug and should be harmless on other platforms
01832       typedef TMVA::FitterBase baseClass1;
01833       baseClass1::ShowMembers(R__insp);
01834 }
01835 
01836 } // namespace TMVA
01837 namespace ROOT {
01838    // Wrapper around operator delete
01839    static void delete_TMVAcLcLGeneticFitter(void *p) {
01840       delete ((::TMVA::GeneticFitter*)p);
01841    }
01842    static void deleteArray_TMVAcLcLGeneticFitter(void *p) {
01843       delete [] ((::TMVA::GeneticFitter*)p);
01844    }
01845    static void destruct_TMVAcLcLGeneticFitter(void *p) {
01846       typedef ::TMVA::GeneticFitter current_t;
01847       ((current_t*)p)->~current_t();
01848    }
01849 } // end of namespace ROOT for class ::TMVA::GeneticFitter
01850 
01851       namespace TMVA {
01852 //______________________________________________________________________________
01853 void SimulatedAnnealingFitter::Streamer(TBuffer &R__b)
01854 {
01855    // Stream an object of class TMVA::SimulatedAnnealingFitter.
01856 
01857    if (R__b.IsReading()) {
01858       R__b.ReadClassBuffer(TMVA::SimulatedAnnealingFitter::Class(),this);
01859    } else {
01860       R__b.WriteClassBuffer(TMVA::SimulatedAnnealingFitter::Class(),this);
01861    }
01862 }
01863 
01864 } // namespace TMVA
01865 //______________________________________________________________________________
01866       namespace TMVA {
01867 void SimulatedAnnealingFitter::ShowMembers(TMemberInspector &R__insp)
01868 {
01869       // Inspect the data members of an object of class TMVA::SimulatedAnnealingFitter.
01870       TClass *R__cl = ::TMVA::SimulatedAnnealingFitter::IsA();
01871       if (R__cl || R__insp.IsA()) { }
01872       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxCalls", &fMaxCalls);
01873       R__insp.Inspect(R__cl, R__insp.GetParent(), "fInitialTemperature", &fInitialTemperature);
01874       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinTemperature", &fMinTemperature);
01875       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEps", &fEps);
01876       R__insp.Inspect(R__cl, R__insp.GetParent(), "fKernelTemperatureS", &fKernelTemperatureS);
01877       R__insp.InspectMember(fKernelTemperatureS, "fKernelTemperatureS.");
01878       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTemperatureScale", &fTemperatureScale);
01879       R__insp.Inspect(R__cl, R__insp.GetParent(), "fAdaptiveSpeed", &fAdaptiveSpeed);
01880       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTemperatureAdaptiveStep", &fTemperatureAdaptiveStep);
01881       R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseDefaultScale", &fUseDefaultScale);
01882       R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseDefaultTemperature", &fUseDefaultTemperature);
01883       //This works around a msvc bug and should be harmless on other platforms
01884       typedef TMVA::FitterBase baseClass1;
01885       baseClass1::ShowMembers(R__insp);
01886 }
01887 
01888 } // namespace TMVA
01889 namespace ROOT {
01890    // Wrapper around operator delete
01891    static void delete_TMVAcLcLSimulatedAnnealingFitter(void *p) {
01892       delete ((::TMVA::SimulatedAnnealingFitter*)p);
01893    }
01894    static void deleteArray_TMVAcLcLSimulatedAnnealingFitter(void *p) {
01895       delete [] ((::TMVA::SimulatedAnnealingFitter*)p);
01896    }
01897    static void destruct_TMVAcLcLSimulatedAnnealingFitter(void *p) {
01898       typedef ::TMVA::SimulatedAnnealingFitter current_t;
01899       ((current_t*)p)->~current_t();
01900    }
01901 } // end of namespace ROOT for class ::TMVA::SimulatedAnnealingFitter
01902 
01903       namespace TMVA {
01904 //______________________________________________________________________________
01905 void MinuitFitter::Streamer(TBuffer &R__b)
01906 {
01907    // Stream an object of class TMVA::MinuitFitter.
01908 
01909    if (R__b.IsReading()) {
01910       R__b.ReadClassBuffer(TMVA::MinuitFitter::Class(),this);
01911    } else {
01912       R__b.WriteClassBuffer(TMVA::MinuitFitter::Class(),this);
01913    }
01914 }
01915 
01916 } // namespace TMVA
01917 //______________________________________________________________________________
01918       namespace TMVA {
01919 void MinuitFitter::ShowMembers(TMemberInspector &R__insp)
01920 {
01921       // Inspect the data members of an object of class TMVA::MinuitFitter.
01922       TClass *R__cl = ::TMVA::MinuitFitter::IsA();
01923       if (R__cl || R__insp.IsA()) { }
01924       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMinWrap", &fMinWrap);
01925       R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorLevel", &fErrorLevel);
01926       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPrintLevel", &fPrintLevel);
01927       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFitStrategy", &fFitStrategy);
01928       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPrintWarnings", &fPrintWarnings);
01929       R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseImprove", &fUseImprove);
01930       R__insp.Inspect(R__cl, R__insp.GetParent(), "fUseMinos", &fUseMinos);
01931       R__insp.Inspect(R__cl, R__insp.GetParent(), "fBatch", &fBatch);
01932       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxCalls", &fMaxCalls);
01933       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTolerance", &fTolerance);
01934       //This works around a msvc bug and should be harmless on other platforms
01935       typedef TMVA::FitterBase baseClass1;
01936       baseClass1::ShowMembers(R__insp);
01937       //This works around a msvc bug and should be harmless on other platforms
01938       typedef TMVA::IFitterTarget baseClass2;
01939       baseClass2::ShowMembers(R__insp);
01940 }
01941 
01942 } // namespace TMVA
01943 namespace ROOT {
01944    // Wrapper around operator delete
01945    static void delete_TMVAcLcLMinuitFitter(void *p) {
01946       delete ((::TMVA::MinuitFitter*)p);
01947    }
01948    static void deleteArray_TMVAcLcLMinuitFitter(void *p) {
01949       delete [] ((::TMVA::MinuitFitter*)p);
01950    }
01951    static void destruct_TMVAcLcLMinuitFitter(void *p) {
01952       typedef ::TMVA::MinuitFitter current_t;
01953       ((current_t*)p)->~current_t();
01954    }
01955 } // end of namespace ROOT for class ::TMVA::MinuitFitter
01956 
01957       namespace TMVA {
01958 //______________________________________________________________________________
01959 void MinuitWrapper::Streamer(TBuffer &R__b)
01960 {
01961    // Stream an object of class TMVA::MinuitWrapper.
01962 
01963    if (R__b.IsReading()) {
01964       R__b.ReadClassBuffer(TMVA::MinuitWrapper::Class(),this);
01965    } else {
01966       R__b.WriteClassBuffer(TMVA::MinuitWrapper::Class(),this);
01967    }
01968 }
01969 
01970 } // namespace TMVA
01971 //______________________________________________________________________________
01972       namespace TMVA {
01973 void MinuitWrapper::ShowMembers(TMemberInspector &R__insp)
01974 {
01975       // Inspect the data members of an object of class TMVA::MinuitWrapper.
01976       TClass *R__cl = ::TMVA::MinuitWrapper::IsA();
01977       if (R__cl || R__insp.IsA()) { }
01978       R__insp.Inspect(R__cl, R__insp.GetParent(), "fParameters", (void*)&fParameters);
01979       R__insp.InspectMember("vector<Double_t>", (void*)&fParameters, "fParameters.", false);
01980       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNumPar", &fNumPar);
01981       TMinuit::ShowMembers(R__insp);
01982 }
01983 
01984 } // namespace TMVA
01985 namespace ROOT {
01986    // Wrapper around operator delete
01987    static void delete_TMVAcLcLMinuitWrapper(void *p) {
01988       delete ((::TMVA::MinuitWrapper*)p);
01989    }
01990    static void deleteArray_TMVAcLcLMinuitWrapper(void *p) {
01991       delete [] ((::TMVA::MinuitWrapper*)p);
01992    }
01993    static void destruct_TMVAcLcLMinuitWrapper(void *p) {
01994       typedef ::TMVA::MinuitWrapper current_t;
01995       ((current_t*)p)->~current_t();
01996    }
01997 } // end of namespace ROOT for class ::TMVA::MinuitWrapper
01998 
01999       namespace TMVA {
02000 //______________________________________________________________________________
02001 void IFitterTarget::Streamer(TBuffer &R__b)
02002 {
02003    // Stream an object of class TMVA::IFitterTarget.
02004 
02005    if (R__b.IsReading()) {
02006       R__b.ReadClassBuffer(TMVA::IFitterTarget::Class(),this);
02007    } else {
02008       R__b.WriteClassBuffer(TMVA::IFitterTarget::Class(),this);
02009    }
02010 }
02011 
02012 } // namespace TMVA
02013 //______________________________________________________________________________
02014       namespace TMVA {
02015 void IFitterTarget::ShowMembers(TMemberInspector &R__insp)
02016 {
02017       // Inspect the data members of an object of class TMVA::IFitterTarget.
02018       TClass *R__cl = ::TMVA::IFitterTarget::IsA();
02019       if (R__cl || R__insp.IsA()) { }
02020 }
02021 
02022 } // namespace TMVA
02023 namespace ROOT {
02024    // Wrapper around operator delete
02025    static void delete_TMVAcLcLIFitterTarget(void *p) {
02026       delete ((::TMVA::IFitterTarget*)p);
02027    }
02028    static void deleteArray_TMVAcLcLIFitterTarget(void *p) {
02029       delete [] ((::TMVA::IFitterTarget*)p);
02030    }
02031    static void destruct_TMVAcLcLIFitterTarget(void *p) {
02032       typedef ::TMVA::IFitterTarget current_t;
02033       ((current_t*)p)->~current_t();
02034    }
02035 } // end of namespace ROOT for class ::TMVA::IFitterTarget
02036 
02037       namespace TMVA {
02038 //______________________________________________________________________________
02039 void PDEFoam::Streamer(TBuffer &R__b)
02040 {
02041    // Stream an object of class TMVA::PDEFoam.
02042 
02043    if (R__b.IsReading()) {
02044       R__b.ReadClassBuffer(TMVA::PDEFoam::Class(),this);
02045    } else {
02046       R__b.WriteClassBuffer(TMVA::PDEFoam::Class(),this);
02047    }
02048 }
02049 
02050 } // namespace TMVA
02051 //______________________________________________________________________________
02052       namespace TMVA {
02053 void PDEFoam::ShowMembers(TMemberInspector &R__insp)
02054 {
02055       // Inspect the data members of an object of class TMVA::PDEFoam.
02056       TClass *R__cl = ::TMVA::PDEFoam::IsA();
02057       if (R__cl || R__insp.IsA()) { }
02058       R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", &fName);
02059       R__insp.InspectMember(fName, "fName.");
02060       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDim", &fDim);
02061       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNCells", &fNCells);
02062       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNBin", &fNBin);
02063       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNSampl", &fNSampl);
02064       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEvPerBin", &fEvPerBin);
02065       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMaskDiv", &fMaskDiv);
02066       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fInhiDiv", &fInhiDiv);
02067       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNoAct", &fNoAct);
02068       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLastCe", &fLastCe);
02069       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCells", &fCells);
02070       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fHistEdg", &fHistEdg);
02071       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRvec", &fRvec);
02072       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPseRan", &fPseRan);
02073       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fAlpha", &fAlpha);
02074       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFoamType", &fFoamType);
02075       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXmin", &fXmin);
02076       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fXmax", &fXmax);
02077       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNElements", &fNElements);
02078       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNmin", &fNmin);
02079       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMaxDepth", &fMaxDepth);
02080       R__insp.Inspect(R__cl, R__insp.GetParent(), "fVolFrac", &fVolFrac);
02081       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFillFoamWithOrigWeights", &fFillFoamWithOrigWeights);
02082       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDTSeparation", &fDTSeparation);
02083       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPeekMax", &fPeekMax);
02084       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDistr", &fDistr);
02085       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTimer", &fTimer);
02086       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fVariableNames", &fVariableNames);
02087       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
02088       TObject::ShowMembers(R__insp);
02089 }
02090 
02091 } // namespace TMVA
02092 namespace ROOT {
02093    // Wrappers around operator new
02094    static void *new_TMVAcLcLPDEFoam(void *p) {
02095       return  p ? new(p) ::TMVA::PDEFoam : new ::TMVA::PDEFoam;
02096    }
02097    static void *newArray_TMVAcLcLPDEFoam(Long_t nElements, void *p) {
02098       return p ? new(p) ::TMVA::PDEFoam[nElements] : new ::TMVA::PDEFoam[nElements];
02099    }
02100    // Wrapper around operator delete
02101    static void delete_TMVAcLcLPDEFoam(void *p) {
02102       delete ((::TMVA::PDEFoam*)p);
02103    }
02104    static void deleteArray_TMVAcLcLPDEFoam(void *p) {
02105       delete [] ((::TMVA::PDEFoam*)p);
02106    }
02107    static void destruct_TMVAcLcLPDEFoam(void *p) {
02108       typedef ::TMVA::PDEFoam current_t;
02109       ((current_t*)p)->~current_t();
02110    }
02111 } // end of namespace ROOT for class ::TMVA::PDEFoam
02112 
02113       namespace TMVA {
02114 //______________________________________________________________________________
02115 void PDEFoamDistr::Streamer(TBuffer &R__b)
02116 {
02117    // Stream an object of class TMVA::PDEFoamDistr.
02118 
02119    if (R__b.IsReading()) {
02120       R__b.ReadClassBuffer(TMVA::PDEFoamDistr::Class(),this);
02121    } else {
02122       R__b.WriteClassBuffer(TMVA::PDEFoamDistr::Class(),this);
02123    }
02124 }
02125 
02126 } // namespace TMVA
02127 //______________________________________________________________________________
02128       namespace TMVA {
02129 void PDEFoamDistr::ShowMembers(TMemberInspector &R__insp)
02130 {
02131       // Inspect the data members of an object of class TMVA::PDEFoamDistr.
02132       TClass *R__cl = ::TMVA::PDEFoamDistr::IsA();
02133       if (R__cl || R__insp.IsA()) { }
02134       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fPDEFoam", &fPDEFoam);
02135       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fBst", &fBst);
02136       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDensityCalc", &fDensityCalc);
02137       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
02138       TObject::ShowMembers(R__insp);
02139 }
02140 
02141 } // namespace TMVA
02142 namespace ROOT {
02143    // Wrappers around operator new
02144    static void *new_TMVAcLcLPDEFoamDistr(void *p) {
02145       return  p ? new(p) ::TMVA::PDEFoamDistr : new ::TMVA::PDEFoamDistr;
02146    }
02147    static void *newArray_TMVAcLcLPDEFoamDistr(Long_t nElements, void *p) {
02148       return p ? new(p) ::TMVA::PDEFoamDistr[nElements] : new ::TMVA::PDEFoamDistr[nElements];
02149    }
02150    // Wrapper around operator delete
02151    static void delete_TMVAcLcLPDEFoamDistr(void *p) {
02152       delete ((::TMVA::PDEFoamDistr*)p);
02153    }
02154    static void deleteArray_TMVAcLcLPDEFoamDistr(void *p) {
02155       delete [] ((::TMVA::PDEFoamDistr*)p);
02156    }
02157    static void destruct_TMVAcLcLPDEFoamDistr(void *p) {
02158       typedef ::TMVA::PDEFoamDistr current_t;
02159       ((current_t*)p)->~current_t();
02160    }
02161 } // end of namespace ROOT for class ::TMVA::PDEFoamDistr
02162 
02163       namespace TMVA {
02164 //______________________________________________________________________________
02165 void PDEFoamVect::Streamer(TBuffer &R__b)
02166 {
02167    // Stream an object of class TMVA::PDEFoamVect.
02168 
02169    if (R__b.IsReading()) {
02170       R__b.ReadClassBuffer(TMVA::PDEFoamVect::Class(),this);
02171    } else {
02172       R__b.WriteClassBuffer(TMVA::PDEFoamVect::Class(),this);
02173    }
02174 }
02175 
02176 } // namespace TMVA
02177 //______________________________________________________________________________
02178       namespace TMVA {
02179 void PDEFoamVect::ShowMembers(TMemberInspector &R__insp)
02180 {
02181       // Inspect the data members of an object of class TMVA::PDEFoamVect.
02182       TClass *R__cl = ::TMVA::PDEFoamVect::IsA();
02183       if (R__cl || R__insp.IsA()) { }
02184       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDim", &fDim);
02185       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fCoords", &fCoords);
02186       TObject::ShowMembers(R__insp);
02187 }
02188 
02189 } // namespace TMVA
02190 namespace ROOT {
02191    // Wrappers around operator new
02192    static void *new_TMVAcLcLPDEFoamVect(void *p) {
02193       return  p ? new(p) ::TMVA::PDEFoamVect : new ::TMVA::PDEFoamVect;
02194    }
02195    static void *newArray_TMVAcLcLPDEFoamVect(Long_t nElements, void *p) {
02196       return p ? new(p) ::TMVA::PDEFoamVect[nElements] : new ::TMVA::PDEFoamVect[nElements];
02197    }
02198    // Wrapper around operator delete
02199    static void delete_TMVAcLcLPDEFoamVect(void *p) {
02200       delete ((::TMVA::PDEFoamVect*)p);
02201    }
02202    static void deleteArray_TMVAcLcLPDEFoamVect(void *p) {
02203       delete [] ((::TMVA::PDEFoamVect*)p);
02204    }
02205    static void destruct_TMVAcLcLPDEFoamVect(void *p) {
02206       typedef ::TMVA::PDEFoamVect current_t;
02207       ((current_t*)p)->~current_t();
02208    }
02209 } // end of namespace ROOT for class ::TMVA::PDEFoamVect
02210 
02211       namespace TMVA {
02212 //______________________________________________________________________________
02213 void PDEFoamCell::Streamer(TBuffer &R__b)
02214 {
02215    // Stream an object of class TMVA::PDEFoamCell.
02216 
02217    if (R__b.IsReading()) {
02218       R__b.ReadClassBuffer(TMVA::PDEFoamCell::Class(),this);
02219    } else {
02220       R__b.WriteClassBuffer(TMVA::PDEFoamCell::Class(),this);
02221    }
02222 }
02223 
02224 } // namespace TMVA
02225 //______________________________________________________________________________
02226       namespace TMVA {
02227 void PDEFoamCell::ShowMembers(TMemberInspector &R__insp)
02228 {
02229       // Inspect the data members of an object of class TMVA::PDEFoamCell.
02230       TClass *R__cl = ::TMVA::PDEFoamCell::IsA();
02231       if (R__cl || R__insp.IsA()) { }
02232       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDim", &fDim);
02233       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSerial", &fSerial);
02234       R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &fStatus);
02235       R__insp.Inspect(R__cl, R__insp.GetParent(), "fParent", &fParent);
02236       R__insp.InspectMember(fParent, "fParent.");
02237       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDaught0", &fDaught0);
02238       R__insp.InspectMember(fDaught0, "fDaught0.");
02239       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDaught1", &fDaught1);
02240       R__insp.InspectMember(fDaught1, "fDaught1.");
02241       R__insp.Inspect(R__cl, R__insp.GetParent(), "fXdiv", &fXdiv);
02242       R__insp.Inspect(R__cl, R__insp.GetParent(), "fBest", &fBest);
02243       R__insp.Inspect(R__cl, R__insp.GetParent(), "fVolume", &fVolume);
02244       R__insp.Inspect(R__cl, R__insp.GetParent(), "fIntegral", &fIntegral);
02245       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDrive", &fDrive);
02246       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fElement", &fElement);
02247       TObject::ShowMembers(R__insp);
02248 }
02249 
02250 } // namespace TMVA
02251 namespace ROOT {
02252    // Wrappers around operator new
02253    static void *new_TMVAcLcLPDEFoamCell(void *p) {
02254       return  p ? new(p) ::TMVA::PDEFoamCell : new ::TMVA::PDEFoamCell;
02255    }
02256    static void *newArray_TMVAcLcLPDEFoamCell(Long_t nElements, void *p) {
02257       return p ? new(p) ::TMVA::PDEFoamCell[nElements] : new ::TMVA::PDEFoamCell[nElements];
02258    }
02259    // Wrapper around operator delete
02260    static void delete_TMVAcLcLPDEFoamCell(void *p) {
02261       delete ((::TMVA::PDEFoamCell*)p);
02262    }
02263    static void deleteArray_TMVAcLcLPDEFoamCell(void *p) {
02264       delete [] ((::TMVA::PDEFoamCell*)p);
02265    }
02266    static void destruct_TMVAcLcLPDEFoamCell(void *p) {
02267       typedef ::TMVA::PDEFoamCell current_t;
02268       ((current_t*)p)->~current_t();
02269    }
02270 } // end of namespace ROOT for class ::TMVA::PDEFoamCell
02271 
02272 //______________________________________________________________________________
02273 namespace ROOT {
02274    void TMVAcLcLBDTEventWrapper_ShowMembers(void *obj, TMemberInspector &R__insp)
02275    {
02276       // Inspect the data members of an object of class TMVA::BDTEventWrapper.
02277       typedef ::ROOT::Shadow::TMVA::BDTEventWrapper ShadowClass;
02278       ShadowClass *sobj = (ShadowClass*)obj;
02279       if (sobj) { } // Dummy usage just in case there is no datamember.
02280 
02281       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::BDTEventWrapper*)0x0)->GetClass();
02282       if (R__cl || R__insp.IsA()) { }
02283       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fEvent", &sobj->fEvent);
02284       R__insp.Inspect(R__cl, R__insp.GetParent(), "fBkgWeight", &sobj->fBkgWeight);
02285       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSigWeight", &sobj->fSigWeight);
02286    }
02287 
02288 }
02289 
02290 namespace ROOT {
02291    // Wrapper around operator delete
02292    static void delete_TMVAcLcLBDTEventWrapper(void *p) {
02293       delete ((::TMVA::BDTEventWrapper*)p);
02294    }
02295    static void deleteArray_TMVAcLcLBDTEventWrapper(void *p) {
02296       delete [] ((::TMVA::BDTEventWrapper*)p);
02297    }
02298    static void destruct_TMVAcLcLBDTEventWrapper(void *p) {
02299       typedef ::TMVA::BDTEventWrapper current_t;
02300       ((current_t*)p)->~current_t();
02301    }
02302 } // end of namespace ROOT for class ::TMVA::BDTEventWrapper
02303 
02304 //______________________________________________________________________________
02305 namespace ROOT {
02306    void TMVAcLcLCCTreeWrapper_ShowMembers(void *obj, TMemberInspector &R__insp)
02307    {
02308       // Inspect the data members of an object of class TMVA::CCTreeWrapper.
02309       typedef ::ROOT::Shadow::TMVA::CCTreeWrapper ShadowClass;
02310       ShadowClass *sobj = (ShadowClass*)obj;
02311       if (sobj) { } // Dummy usage just in case there is no datamember.
02312 
02313       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::CCTreeWrapper*)0x0)->GetClass();
02314       if (R__cl || R__insp.IsA()) { }
02315       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fQualityIndex", &sobj->fQualityIndex);
02316       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDTParent", &sobj->fDTParent);
02317       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fRoot", &sobj->fRoot);
02318    }
02319 
02320 }
02321 
02322 namespace ROOT {
02323    // Wrapper around operator delete
02324    static void delete_TMVAcLcLCCTreeWrapper(void *p) {
02325       delete ((::TMVA::CCTreeWrapper*)p);
02326    }
02327    static void deleteArray_TMVAcLcLCCTreeWrapper(void *p) {
02328       delete [] ((::TMVA::CCTreeWrapper*)p);
02329    }
02330    static void destruct_TMVAcLcLCCTreeWrapper(void *p) {
02331       typedef ::TMVA::CCTreeWrapper current_t;
02332       ((current_t*)p)->~current_t();
02333    }
02334 } // end of namespace ROOT for class ::TMVA::CCTreeWrapper
02335 
02336 //______________________________________________________________________________
02337 namespace ROOT {
02338    void TMVAcLcLCCPruner_ShowMembers(void *obj, TMemberInspector &R__insp)
02339    {
02340       // Inspect the data members of an object of class TMVA::CCPruner.
02341       typedef ::ROOT::Shadow::TMVA::CCPruner ShadowClass;
02342       ShadowClass *sobj = (ShadowClass*)obj;
02343       if (sobj) { } // Dummy usage just in case there is no datamember.
02344 
02345       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::CCPruner*)0x0)->GetClass();
02346       if (R__cl || R__insp.IsA()) { }
02347       R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlpha", &sobj->fAlpha);
02348       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fValidationSample", &sobj->fValidationSample);
02349       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fValidationDataSet", &sobj->fValidationDataSet);
02350       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fQualityIndex", &sobj->fQualityIndex);
02351       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOwnQIndex", &sobj->fOwnQIndex);
02352       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fTree", &sobj->fTree);
02353       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPruneSequence", (void*)&sobj->fPruneSequence);
02354       R__insp.InspectMember("vector<TMVA::DecisionTreeNode*>", (void*)&sobj->fPruneSequence, "fPruneSequence.", true);
02355       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPruneStrengthList", (void*)&sobj->fPruneStrengthList);
02356       R__insp.InspectMember("vector<Float_t>", (void*)&sobj->fPruneStrengthList, "fPruneStrengthList.", true);
02357       R__insp.Inspect(R__cl, R__insp.GetParent(), "fQualityIndexList", (void*)&sobj->fQualityIndexList);
02358       R__insp.InspectMember("vector<Float_t>", (void*)&sobj->fQualityIndexList, "fQualityIndexList.", true);
02359       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptimalK", &sobj->fOptimalK);
02360       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDebug", &sobj->fDebug);
02361    }
02362 
02363 }
02364 
02365 namespace ROOT {
02366    // Wrapper around operator delete
02367    static void delete_TMVAcLcLCCPruner(void *p) {
02368       delete ((::TMVA::CCPruner*)p);
02369    }
02370    static void deleteArray_TMVAcLcLCCPruner(void *p) {
02371       delete [] ((::TMVA::CCPruner*)p);
02372    }
02373    static void destruct_TMVAcLcLCCPruner(void *p) {
02374       typedef ::TMVA::CCPruner current_t;
02375       ((current_t*)p)->~current_t();
02376    }
02377 } // end of namespace ROOT for class ::TMVA::CCPruner
02378 
02379 //______________________________________________________________________________
02380 namespace ROOT {
02381    void TMVAcLcLCostComplexityPruneTool_ShowMembers(void *obj, TMemberInspector &R__insp)
02382    {
02383       // Inspect the data members of an object of class TMVA::CostComplexityPruneTool.
02384       typedef ::ROOT::Shadow::TMVA::CostComplexityPruneTool ShadowClass;
02385       ShadowClass *sobj = (ShadowClass*)obj;
02386       if (sobj) { } // Dummy usage just in case there is no datamember.
02387 
02388       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::TMVA::CostComplexityPruneTool*)0x0)->GetClass();
02389       if (R__cl || R__insp.IsA()) { }
02390       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fQualityIndexTool", &sobj->fQualityIndexTool);
02391       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPruneSequence", (void*)&sobj->fPruneSequence);
02392       R__insp.InspectMember("vector<TMVA::DecisionTreeNode*,allocator<TMVA::DecisionTreeNode*> >", (void*)&sobj->fPruneSequence, "fPruneSequence.", true);
02393       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPruneStrengthList", (void*)&sobj->fPruneStrengthList);
02394       R__insp.InspectMember("vector<Double_t>", (void*)&sobj->fPruneStrengthList, "fPruneStrengthList.", true);
02395       R__insp.Inspect(R__cl, R__insp.GetParent(), "fQualityIndexList", (void*)&sobj->fQualityIndexList);
02396       R__insp.InspectMember("vector<Double_t>", (void*)&sobj->fQualityIndexList, "fQualityIndexList.", true);
02397       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptimalK", &sobj->fOptimalK);
02398       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &sobj->fLogger);
02399       R__insp.GenericShowMembers("TMVA::IPruneTool", ( ::TMVA::IPruneTool * )( (::TMVA::CostComplexityPruneTool*) obj ), false);
02400    }
02401 
02402 }
02403 
02404 namespace ROOT {
02405    // Wrappers around operator new
02406    static void *new_TMVAcLcLCostComplexityPruneTool(void *p) {
02407       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::CostComplexityPruneTool : new ::TMVA::CostComplexityPruneTool;
02408    }
02409    static void *newArray_TMVAcLcLCostComplexityPruneTool(Long_t nElements, void *p) {
02410       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::CostComplexityPruneTool[nElements] : new ::TMVA::CostComplexityPruneTool[nElements];
02411    }
02412    // Wrapper around operator delete
02413    static void delete_TMVAcLcLCostComplexityPruneTool(void *p) {
02414       delete ((::TMVA::CostComplexityPruneTool*)p);
02415    }
02416    static void deleteArray_TMVAcLcLCostComplexityPruneTool(void *p) {
02417       delete [] ((::TMVA::CostComplexityPruneTool*)p);
02418    }
02419    static void destruct_TMVAcLcLCostComplexityPruneTool(void *p) {
02420       typedef ::TMVA::CostComplexityPruneTool current_t;
02421       ((current_t*)p)->~current_t();
02422    }
02423 } // end of namespace ROOT for class ::TMVA::CostComplexityPruneTool
02424 
02425       namespace TMVA {
02426 //______________________________________________________________________________
02427 void SVEvent::Streamer(TBuffer &R__b)
02428 {
02429    // Stream an object of class TMVA::SVEvent.
02430 
02431    if (R__b.IsReading()) {
02432       R__b.ReadClassBuffer(TMVA::SVEvent::Class(),this);
02433    } else {
02434       R__b.WriteClassBuffer(TMVA::SVEvent::Class(),this);
02435    }
02436 }
02437 
02438 } // namespace TMVA
02439 //______________________________________________________________________________
02440       namespace TMVA {
02441 void SVEvent::ShowMembers(TMemberInspector &R__insp)
02442 {
02443       // Inspect the data members of an object of class TMVA::SVEvent.
02444       TClass *R__cl = ::TMVA::SVEvent::IsA();
02445       if (R__cl || R__insp.IsA()) { }
02446       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDataVector", (void*)&fDataVector);
02447       R__insp.InspectMember("vector<Float_t>", (void*)&fDataVector, "fDataVector.", false);
02448       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCweight", &fCweight);
02449       R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlpha", &fAlpha);
02450       R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlpha_p", &fAlpha_p);
02451       R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorCache", &fErrorCache);
02452       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNVar", &fNVar);
02453       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTypeFlag", &fTypeFlag);
02454       R__insp.Inspect(R__cl, R__insp.GetParent(), "fIdx", &fIdx);
02455       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNs", &fNs);
02456       R__insp.Inspect(R__cl, R__insp.GetParent(), "fIsShrinked", &fIsShrinked);
02457       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLine", &fLine);
02458       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTarget", &fTarget);
02459 }
02460 
02461 } // namespace TMVA
02462 namespace ROOT {
02463    // Wrappers around operator new
02464    static void *new_TMVAcLcLSVEvent(void *p) {
02465       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::SVEvent : new ::TMVA::SVEvent;
02466    }
02467    static void *newArray_TMVAcLcLSVEvent(Long_t nElements, void *p) {
02468       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::TMVA::SVEvent[nElements] : new ::TMVA::SVEvent[nElements];
02469    }
02470    // Wrapper around operator delete
02471    static void delete_TMVAcLcLSVEvent(void *p) {
02472       delete ((::TMVA::SVEvent*)p);
02473    }
02474    static void deleteArray_TMVAcLcLSVEvent(void *p) {
02475       delete [] ((::TMVA::SVEvent*)p);
02476    }
02477    static void destruct_TMVAcLcLSVEvent(void *p) {
02478       typedef ::TMVA::SVEvent current_t;
02479       ((current_t*)p)->~current_t();
02480    }
02481 } // end of namespace ROOT for class ::TMVA::SVEvent
02482 
02483       namespace TMVA {
02484 //______________________________________________________________________________
02485 void OptimizeConfigParameters::Streamer(TBuffer &R__b)
02486 {
02487    // Stream an object of class TMVA::OptimizeConfigParameters.
02488 
02489    if (R__b.IsReading()) {
02490       R__b.ReadClassBuffer(TMVA::OptimizeConfigParameters::Class(),this);
02491    } else {
02492       R__b.WriteClassBuffer(TMVA::OptimizeConfigParameters::Class(),this);
02493    }
02494 }
02495 
02496 } // namespace TMVA
02497 //______________________________________________________________________________
02498       namespace TMVA {
02499 void OptimizeConfigParameters::ShowMembers(TMemberInspector &R__insp)
02500 {
02501       // Inspect the data members of an object of class TMVA::OptimizeConfigParameters.
02502       TClass *R__cl = ::TMVA::OptimizeConfigParameters::IsA();
02503       if (R__cl || R__insp.IsA()) { }
02504       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMethod", &fMethod);
02505       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFOMvsIter", (void*)&fFOMvsIter);
02506       R__insp.InspectMember("vector<Float_t>", (void*)&fFOMvsIter, "fFOMvsIter.", false);
02507       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTuneParameters", (void*)&fTuneParameters);
02508       R__insp.InspectMember("map<TString,TMVA::Interval>", (void*)&fTuneParameters, "fTuneParameters.", false);
02509       R__insp.Inspect(R__cl, R__insp.GetParent(), "fTunedParameters", (void*)&fTunedParameters);
02510       R__insp.InspectMember("map<TString,Double_t>", (void*)&fTunedParameters, "fTunedParameters.", false);
02511       R__insp.Inspect(R__cl, R__insp.GetParent(), "fAlreadyTrainedParCombination", (void*)&fAlreadyTrainedParCombination);
02512       R__insp.InspectMember("map<std::vector<Double_t>,Double_t>", (void*)&fAlreadyTrainedParCombination, "fAlreadyTrainedParCombination.", false);
02513       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFOMType", &fFOMType);
02514       R__insp.InspectMember(fFOMType, "fFOMType.");
02515       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptimizationFitType", &fOptimizationFitType);
02516       R__insp.InspectMember(fOptimizationFitType, "fOptimizationFitType.");
02517       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMvaSig", &fMvaSig);
02518       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMvaBkg", &fMvaBkg);
02519       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMvaSigFineBin", &fMvaSigFineBin);
02520       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMvaBkgFineBin", &fMvaBkgFineBin);
02521       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fLogger", &fLogger);
02522       //This works around a msvc bug and should be harmless on other platforms
02523       typedef TMVA::IFitterTarget baseClass1;
02524       baseClass1::ShowMembers(R__insp);
02525 }
02526 
02527 } // namespace TMVA
02528 namespace ROOT {
02529    // Wrapper around operator delete
02530    static void delete_TMVAcLcLOptimizeConfigParameters(void *p) {
02531       delete ((::TMVA::OptimizeConfigParameters*)p);
02532    }
02533    static void deleteArray_TMVAcLcLOptimizeConfigParameters(void *p) {
02534       delete [] ((::TMVA::OptimizeConfigParameters*)p);
02535    }
02536    static void destruct_TMVAcLcLOptimizeConfigParameters(void *p) {
02537       typedef ::TMVA::OptimizeConfigParameters current_t;
02538       ((current_t*)p)->~current_t();
02539    }
02540 } // end of namespace ROOT for class ::TMVA::OptimizeConfigParameters
02541 
02542 /********************************************************
02543 * tmva/src/G__TMVA3.cxx
02544 * CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED
02545 *          FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().
02546 *          CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.
02547 ********************************************************/
02548 
02549 #ifdef G__MEMTEST
02550 #undef malloc
02551 #undef free
02552 #endif
02553 
02554 #if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
02555 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
02556 #endif
02557 
02558 extern "C" void G__cpp_reset_tagtableG__TMVA3();
02559 
02560 extern "C" void G__set_cpp_environmentG__TMVA3() {
02561   G__add_compiledheader("TObject.h");
02562   G__add_compiledheader("TMemberInspector.h");
02563   G__add_compiledheader("include/TMVA/Config.h");
02564   G__add_compiledheader("include/TMVA/KDEKernel.h");
02565   G__add_compiledheader("include/TMVA/Interval.h");
02566   G__add_compiledheader("include/TMVA/FitterBase.h");
02567   G__add_compiledheader("include/TMVA/MCFitter.h");
02568   G__add_compiledheader("include/TMVA/GeneticFitter.h");
02569   G__add_compiledheader("include/TMVA/SimulatedAnnealingFitter.h");
02570   G__add_compiledheader("include/TMVA/MinuitFitter.h");
02571   G__add_compiledheader("include/TMVA/MinuitWrapper.h");
02572   G__add_compiledheader("include/TMVA/IFitterTarget.h");
02573   G__add_compiledheader("include/TMVA/PDEFoam.h");
02574   G__add_compiledheader("include/TMVA/PDEFoamDistr.h");
02575   G__add_compiledheader("include/TMVA/PDEFoamVect.h");
02576   G__add_compiledheader("include/TMVA/PDEFoamCell.h");
02577   G__add_compiledheader("include/TMVA/BDTEventWrapper.h");
02578   G__add_compiledheader("include/TMVA/CCTreeWrapper.h");
02579   G__add_compiledheader("include/TMVA/CCPruner.h");
02580   G__add_compiledheader("include/TMVA/CostComplexityPruneTool.h");
02581   G__add_compiledheader("include/TMVA/SVEvent.h");
02582   G__add_compiledheader("include/TMVA/OptimizeConfigParameters.h");
02583   G__cpp_reset_tagtableG__TMVA3();
02584 }
02585 #include <new>
02586 extern "C" int G__cpp_dllrevG__TMVA3() { return(30051515); }
02587 
02588 /*********************************************************
02589 * Member function Interface Method
02590 *********************************************************/
02591 
02592 /* TMVA */
02593 static int G__G__TMVA3_110_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02594 {
02595       {
02596          const TMVA::Config& obj = TMVA::gConfig();
02597          result7->ref = (long) (&obj);
02598          result7->obj.i = (long) (&obj);
02599       }
02600    return(1 || funcname || hash || result7 || libp) ;
02601 }
02602 
02603 static int G__G__TMVA3_110_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02604 {
02605       {
02606          const ostream& obj = TMVA::operator<<(*(ostream*) libp->para[0].ref, *(TMVA::Node*) libp->para[1].ref);
02607          result7->ref = (long) (&obj);
02608          result7->obj.i = (long) (&obj);
02609       }
02610    return(1 || funcname || hash || result7 || libp) ;
02611 }
02612 
02613 static int G__G__TMVA3_110_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02614 {
02615       {
02616          const ostream& obj = TMVA::operator<<(*(ostream*) libp->para[0].ref, (TMVA::Node*) G__int(libp->para[1]));
02617          result7->ref = (long) (&obj);
02618          result7->obj.i = (long) (&obj);
02619       }
02620    return(1 || funcname || hash || result7 || libp) ;
02621 }
02622 
02623 static int G__G__TMVA3_110_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02624 {
02625       {
02626          const ostream& obj = TMVA::operator<<(*(ostream*) libp->para[0].ref, *(TMVA::BinaryTree*) libp->para[1].ref);
02627          result7->ref = (long) (&obj);
02628          result7->obj.i = (long) (&obj);
02629       }
02630    return(1 || funcname || hash || result7 || libp) ;
02631 }
02632 
02633 static int G__G__TMVA3_110_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02634 {
02635       {
02636          const istream& obj = TMVA::operator>>(*(istream*) libp->para[0].ref, *(TMVA::BinaryTree*) libp->para[1].ref);
02637          result7->ref = (long) (&obj);
02638          result7->obj.i = (long) (&obj);
02639       }
02640    return(1 || funcname || hash || result7 || libp) ;
02641 }
02642 
02643 static int G__G__TMVA3_110_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02644 {
02645       {
02646          const ostream& obj = TMVA::operator<<(*(ostream*) libp->para[0].ref, *(TMVA::Event*) libp->para[1].ref);
02647          result7->ref = (long) (&obj);
02648          result7->obj.i = (long) (&obj);
02649       }
02650    return(1 || funcname || hash || result7 || libp) ;
02651 }
02652 
02653 static int G__G__TMVA3_110_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02654 {
02655       {
02656          const ostream& obj = TMVA::operator<<(*(ostream*) libp->para[0].ref, *(TMVA::PDEFoam*) libp->para[1].ref);
02657          result7->ref = (long) (&obj);
02658          result7->obj.i = (long) (&obj);
02659       }
02660    return(1 || funcname || hash || result7 || libp) ;
02661 }
02662 
02663 static int G__G__TMVA3_110_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02664 {
02665       {
02666          const istream& obj = TMVA::operator>>(*(istream*) libp->para[0].ref, *(TMVA::PDEFoam*) libp->para[1].ref);
02667          result7->ref = (long) (&obj);
02668          result7->obj.i = (long) (&obj);
02669       }
02670    return(1 || funcname || hash || result7 || libp) ;
02671 }
02672 
02673 
02674 /* TMVA::Config */
02675 static int G__G__TMVA3_112_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02676 {
02677       {
02678          const TMVA::Config& obj = TMVA::Config::Instance();
02679          result7->ref = (long) (&obj);
02680          result7->obj.i = (long) (&obj);
02681       }
02682    return(1 || funcname || hash || result7 || libp) ;
02683 }
02684 
02685 static int G__G__TMVA3_112_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02686 {
02687       TMVA::Config::DestroyInstance();
02688       G__setnull(result7);
02689    return(1 || funcname || hash || result7 || libp) ;
02690 }
02691 
02692 static int G__G__TMVA3_112_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02693 {
02694       G__letint(result7, 103, (long) ((const TMVA::Config*) G__getstructoffset())->UseColor());
02695    return(1 || funcname || hash || result7 || libp) ;
02696 }
02697 
02698 static int G__G__TMVA3_112_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02699 {
02700       ((TMVA::Config*) G__getstructoffset())->SetUseColor((Bool_t) G__int(libp->para[0]));
02701       G__setnull(result7);
02702    return(1 || funcname || hash || result7 || libp) ;
02703 }
02704 
02705 static int G__G__TMVA3_112_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02706 {
02707       G__letint(result7, 103, (long) ((const TMVA::Config*) G__getstructoffset())->IsSilent());
02708    return(1 || funcname || hash || result7 || libp) ;
02709 }
02710 
02711 static int G__G__TMVA3_112_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02712 {
02713       ((TMVA::Config*) G__getstructoffset())->SetSilent((Bool_t) G__int(libp->para[0]));
02714       G__setnull(result7);
02715    return(1 || funcname || hash || result7 || libp) ;
02716 }
02717 
02718 static int G__G__TMVA3_112_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02719 {
02720       G__letint(result7, 103, (long) ((const TMVA::Config*) G__getstructoffset())->WriteOptionsReference());
02721    return(1 || funcname || hash || result7 || libp) ;
02722 }
02723 
02724 static int G__G__TMVA3_112_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02725 {
02726       ((TMVA::Config*) G__getstructoffset())->SetWriteOptionsReference((Bool_t) G__int(libp->para[0]));
02727       G__setnull(result7);
02728    return(1 || funcname || hash || result7 || libp) ;
02729 }
02730 
02731 static int G__G__TMVA3_112_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02732 {
02733       G__letint(result7, 103, (long) ((const TMVA::Config*) G__getstructoffset())->DrawProgressBar());
02734    return(1 || funcname || hash || result7 || libp) ;
02735 }
02736 
02737 static int G__G__TMVA3_112_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02738 {
02739       ((TMVA::Config*) G__getstructoffset())->SetDrawProgressBar((Bool_t) G__int(libp->para[0]));
02740       G__setnull(result7);
02741    return(1 || funcname || hash || result7 || libp) ;
02742 }
02743 
02744 static int G__G__TMVA3_112_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02745 {
02746       {
02747          const TMVA::Config::VariablePlotting& obj = ((TMVA::Config*) G__getstructoffset())->GetVariablePlotting();
02748          result7->ref = (long) (&obj);
02749          result7->obj.i = (long) (&obj);
02750       }
02751    return(1 || funcname || hash || result7 || libp) ;
02752 }
02753 
02754 static int G__G__TMVA3_112_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02755 {
02756       {
02757          const TMVA::Config::IONames& obj = ((TMVA::Config*) G__getstructoffset())->GetIONames();
02758          result7->ref = (long) (&obj);
02759          result7->obj.i = (long) (&obj);
02760       }
02761    return(1 || funcname || hash || result7 || libp) ;
02762 }
02763 
02764 static int G__G__TMVA3_112_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02765 {
02766       G__letint(result7, 85, (long) TMVA::Config::Class());
02767    return(1 || funcname || hash || result7 || libp) ;
02768 }
02769 
02770 static int G__G__TMVA3_112_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02771 {
02772       G__letint(result7, 67, (long) TMVA::Config::Class_Name());
02773    return(1 || funcname || hash || result7 || libp) ;
02774 }
02775 
02776 static int G__G__TMVA3_112_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02777 {
02778       G__letint(result7, 115, (long) TMVA::Config::Class_Version());
02779    return(1 || funcname || hash || result7 || libp) ;
02780 }
02781 
02782 static int G__G__TMVA3_112_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02783 {
02784       TMVA::Config::Dictionary();
02785       G__setnull(result7);
02786    return(1 || funcname || hash || result7 || libp) ;
02787 }
02788 
02789 static int G__G__TMVA3_112_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02790 {
02791       G__letint(result7, 85, (long) ((const TMVA::Config*) G__getstructoffset())->IsA());
02792    return(1 || funcname || hash || result7 || libp) ;
02793 }
02794 
02795 static int G__G__TMVA3_112_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02796 {
02797       ((TMVA::Config*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
02798       G__setnull(result7);
02799    return(1 || funcname || hash || result7 || libp) ;
02800 }
02801 
02802 static int G__G__TMVA3_112_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02803 {
02804       ((TMVA::Config*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
02805       G__setnull(result7);
02806    return(1 || funcname || hash || result7 || libp) ;
02807 }
02808 
02809 static int G__G__TMVA3_112_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02810 {
02811       ((TMVA::Config*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
02812       G__setnull(result7);
02813    return(1 || funcname || hash || result7 || libp) ;
02814 }
02815 
02816 static int G__G__TMVA3_112_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02817 {
02818       G__letint(result7, 67, (long) TMVA::Config::DeclFileName());
02819    return(1 || funcname || hash || result7 || libp) ;
02820 }
02821 
02822 static int G__G__TMVA3_112_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02823 {
02824       G__letint(result7, 105, (long) TMVA::Config::ImplFileLine());
02825    return(1 || funcname || hash || result7 || libp) ;
02826 }
02827 
02828 static int G__G__TMVA3_112_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02829 {
02830       G__letint(result7, 67, (long) TMVA::Config::ImplFileName());
02831    return(1 || funcname || hash || result7 || libp) ;
02832 }
02833 
02834 static int G__G__TMVA3_112_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02835 {
02836       G__letint(result7, 105, (long) TMVA::Config::DeclFileLine());
02837    return(1 || funcname || hash || result7 || libp) ;
02838 }
02839 
02840 // automatic copy constructor
02841 static int G__G__TMVA3_112_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02842 
02843 {
02844    TMVA::Config* p;
02845    void* tmp = (void*) G__int(libp->para[0]);
02846    p = new TMVA::Config(*(TMVA::Config*) tmp);
02847    result7->obj.i = (long) p;
02848    result7->ref = (long) p;
02849    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfig));
02850    return(1 || funcname || hash || result7 || libp) ;
02851 }
02852 
02853 // automatic assignment operator
02854 static int G__G__TMVA3_112_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02855 {
02856    TMVA::Config* dest = (TMVA::Config*) G__getstructoffset();
02857    *dest = *(TMVA::Config*) libp->para[0].ref;
02858    const TMVA::Config& obj = *dest;
02859    result7->ref = (long) (&obj);
02860    result7->obj.i = (long) (&obj);
02861    return(1 || funcname || hash || result7 || libp) ;
02862 }
02863 
02864 
02865 /* TMVA::Config::VariablePlotting */
02866 // automatic default constructor
02867 static int G__G__TMVA3_113_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02868 {
02869    TMVA::Config::VariablePlotting *p;
02870    char* gvp = (char*) G__getgvp();
02871    int n = G__getaryconstruct();
02872    if (n) {
02873      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02874        p = new TMVA::Config::VariablePlotting[n];
02875      } else {
02876        p = new((void*) gvp) TMVA::Config::VariablePlotting[n];
02877      }
02878    } else {
02879      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02880        p = new TMVA::Config::VariablePlotting;
02881      } else {
02882        p = new((void*) gvp) TMVA::Config::VariablePlotting;
02883      }
02884    }
02885    result7->obj.i = (long) p;
02886    result7->ref = (long) p;
02887    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting));
02888    return(1 || funcname || hash || result7 || libp) ;
02889 }
02890 
02891 // automatic copy constructor
02892 static int G__G__TMVA3_113_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02893 
02894 {
02895    TMVA::Config::VariablePlotting* p;
02896    void* tmp = (void*) G__int(libp->para[0]);
02897    p = new TMVA::Config::VariablePlotting(*(TMVA::Config::VariablePlotting*) tmp);
02898    result7->obj.i = (long) p;
02899    result7->ref = (long) p;
02900    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting));
02901    return(1 || funcname || hash || result7 || libp) ;
02902 }
02903 
02904 // automatic destructor
02905 typedef TMVA::Config::VariablePlotting G__TTMVAcLcLConfigcLcLVariablePlotting;
02906 static int G__G__TMVA3_113_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02907 {
02908    char* gvp = (char*) G__getgvp();
02909    long soff = G__getstructoffset();
02910    int n = G__getaryconstruct();
02911    //
02912    //has_a_delete: 0
02913    //has_own_delete1arg: 0
02914    //has_own_delete2arg: 0
02915    //
02916    if (!soff) {
02917      return(1);
02918    }
02919    if (n) {
02920      if (gvp == (char*)G__PVOID) {
02921        delete[] (TMVA::Config::VariablePlotting*) soff;
02922      } else {
02923        G__setgvp((long) G__PVOID);
02924        for (int i = n - 1; i >= 0; --i) {
02925          ((TMVA::Config::VariablePlotting*) (soff+(sizeof(TMVA::Config::VariablePlotting)*i)))->~G__TTMVAcLcLConfigcLcLVariablePlotting();
02926        }
02927        G__setgvp((long)gvp);
02928      }
02929    } else {
02930      if (gvp == (char*)G__PVOID) {
02931        delete (TMVA::Config::VariablePlotting*) soff;
02932      } else {
02933        G__setgvp((long) G__PVOID);
02934        ((TMVA::Config::VariablePlotting*) (soff))->~G__TTMVAcLcLConfigcLcLVariablePlotting();
02935        G__setgvp((long)gvp);
02936      }
02937    }
02938    G__setnull(result7);
02939    return(1 || funcname || hash || result7 || libp) ;
02940 }
02941 
02942 // automatic assignment operator
02943 static int G__G__TMVA3_113_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02944 {
02945    TMVA::Config::VariablePlotting* dest = (TMVA::Config::VariablePlotting*) G__getstructoffset();
02946    *dest = *(TMVA::Config::VariablePlotting*) libp->para[0].ref;
02947    const TMVA::Config::VariablePlotting& obj = *dest;
02948    result7->ref = (long) (&obj);
02949    result7->obj.i = (long) (&obj);
02950    return(1 || funcname || hash || result7 || libp) ;
02951 }
02952 
02953 
02954 /* TMVA::Config::IONames */
02955 // automatic default constructor
02956 static int G__G__TMVA3_114_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02957 {
02958    TMVA::Config::IONames *p;
02959    char* gvp = (char*) G__getgvp();
02960    int n = G__getaryconstruct();
02961    if (n) {
02962      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02963        p = new TMVA::Config::IONames[n];
02964      } else {
02965        p = new((void*) gvp) TMVA::Config::IONames[n];
02966      }
02967    } else {
02968      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02969        p = new TMVA::Config::IONames;
02970      } else {
02971        p = new((void*) gvp) TMVA::Config::IONames;
02972      }
02973    }
02974    result7->obj.i = (long) p;
02975    result7->ref = (long) p;
02976    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames));
02977    return(1 || funcname || hash || result7 || libp) ;
02978 }
02979 
02980 // automatic copy constructor
02981 static int G__G__TMVA3_114_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02982 
02983 {
02984    TMVA::Config::IONames* p;
02985    void* tmp = (void*) G__int(libp->para[0]);
02986    p = new TMVA::Config::IONames(*(TMVA::Config::IONames*) tmp);
02987    result7->obj.i = (long) p;
02988    result7->ref = (long) p;
02989    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames));
02990    return(1 || funcname || hash || result7 || libp) ;
02991 }
02992 
02993 // automatic destructor
02994 typedef TMVA::Config::IONames G__TTMVAcLcLConfigcLcLIONames;
02995 static int G__G__TMVA3_114_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02996 {
02997    char* gvp = (char*) G__getgvp();
02998    long soff = G__getstructoffset();
02999    int n = G__getaryconstruct();
03000    //
03001    //has_a_delete: 0
03002    //has_own_delete1arg: 0
03003    //has_own_delete2arg: 0
03004    //
03005    if (!soff) {
03006      return(1);
03007    }
03008    if (n) {
03009      if (gvp == (char*)G__PVOID) {
03010        delete[] (TMVA::Config::IONames*) soff;
03011      } else {
03012        G__setgvp((long) G__PVOID);
03013        for (int i = n - 1; i >= 0; --i) {
03014          ((TMVA::Config::IONames*) (soff+(sizeof(TMVA::Config::IONames)*i)))->~G__TTMVAcLcLConfigcLcLIONames();
03015        }
03016        G__setgvp((long)gvp);
03017      }
03018    } else {
03019      if (gvp == (char*)G__PVOID) {
03020        delete (TMVA::Config::IONames*) soff;
03021      } else {
03022        G__setgvp((long) G__PVOID);
03023        ((TMVA::Config::IONames*) (soff))->~G__TTMVAcLcLConfigcLcLIONames();
03024        G__setgvp((long)gvp);
03025      }
03026    }
03027    G__setnull(result7);
03028    return(1 || funcname || hash || result7 || libp) ;
03029 }
03030 
03031 // automatic assignment operator
03032 static int G__G__TMVA3_114_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03033 {
03034    TMVA::Config::IONames* dest = (TMVA::Config::IONames*) G__getstructoffset();
03035    *dest = *(TMVA::Config::IONames*) libp->para[0].ref;
03036    const TMVA::Config::IONames& obj = *dest;
03037    result7->ref = (long) (&obj);
03038    result7->obj.i = (long) (&obj);
03039    return(1 || funcname || hash || result7 || libp) ;
03040 }
03041 
03042 
03043 /* TMVA::KDEKernel */
03044 static int G__G__TMVA3_118_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03045 {
03046    TMVA::KDEKernel* p = NULL;
03047    char* gvp = (char*) G__getgvp();
03048    switch (libp->paran) {
03049    case 6:
03050      //m: 6
03051      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03052        p = new TMVA::KDEKernel(
03053 (TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
03054 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
03055 , (TMVA::KDEKernel::EKernelBorder) G__int(libp->para[4]), (Float_t) G__double(libp->para[5]));
03056      } else {
03057        p = new((void*) gvp) TMVA::KDEKernel(
03058 (TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
03059 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
03060 , (TMVA::KDEKernel::EKernelBorder) G__int(libp->para[4]), (Float_t) G__double(libp->para[5]));
03061      }
03062      break;
03063    case 5:
03064      //m: 5
03065      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03066        p = new TMVA::KDEKernel(
03067 (TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
03068 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
03069 , (TMVA::KDEKernel::EKernelBorder) G__int(libp->para[4]));
03070      } else {
03071        p = new((void*) gvp) TMVA::KDEKernel(
03072 (TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
03073 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3])
03074 , (TMVA::KDEKernel::EKernelBorder) G__int(libp->para[4]));
03075      }
03076      break;
03077    case 4:
03078      //m: 4
03079      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03080        p = new TMVA::KDEKernel(
03081 (TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
03082 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
03083      } else {
03084        p = new((void*) gvp) TMVA::KDEKernel(
03085 (TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
03086 , (Float_t) G__double(libp->para[2]), (Float_t) G__double(libp->para[3]));
03087      }
03088      break;
03089    case 3:
03090      //m: 3
03091      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03092        p = new TMVA::KDEKernel(
03093 (TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
03094 , (Float_t) G__double(libp->para[2]));
03095      } else {
03096        p = new((void*) gvp) TMVA::KDEKernel(
03097 (TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]), (TH1*) G__int(libp->para[1])
03098 , (Float_t) G__double(libp->para[2]));
03099      }
03100      break;
03101    case 2:
03102      //m: 2
03103      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03104        p = new TMVA::KDEKernel((TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
03105      } else {
03106        p = new((void*) gvp) TMVA::KDEKernel((TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]), (TH1*) G__int(libp->para[1]));
03107      }
03108      break;
03109    case 1:
03110      //m: 1
03111      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03112        p = new TMVA::KDEKernel((TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]));
03113      } else {
03114        p = new((void*) gvp) TMVA::KDEKernel((TMVA::KDEKernel::EKernelIter) G__int(libp->para[0]));
03115      }
03116      break;
03117    case 0:
03118      int n = G__getaryconstruct();
03119      if (n) {
03120        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03121          p = new TMVA::KDEKernel[n];
03122        } else {
03123          p = new((void*) gvp) TMVA::KDEKernel[n];
03124        }
03125      } else {
03126        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03127          p = new TMVA::KDEKernel;
03128        } else {
03129          p = new((void*) gvp) TMVA::KDEKernel;
03130        }
03131      }
03132      break;
03133    }
03134    result7->obj.i = (long) p;
03135    result7->ref = (long) p;
03136    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernel));
03137    return(1 || funcname || hash || result7 || libp) ;
03138 }
03139 
03140 static int G__G__TMVA3_118_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03141 {
03142       G__letdouble(result7, 102, (double) ((TMVA::KDEKernel*) G__getstructoffset())->GetBinKernelIntegral((Float_t) G__double(libp->para[0]), (Float_t) G__double(libp->para[1])
03143 , (Float_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3])));
03144    return(1 || funcname || hash || result7 || libp) ;
03145 }
03146 
03147 static int G__G__TMVA3_118_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03148 {
03149    switch (libp->paran) {
03150    case 1:
03151       ((TMVA::KDEKernel*) G__getstructoffset())->SetKernelType((TMVA::KDEKernel::EKernelType) G__int(libp->para[0]));
03152       G__setnull(result7);
03153       break;
03154    case 0:
03155       ((TMVA::KDEKernel*) G__getstructoffset())->SetKernelType();
03156       G__setnull(result7);
03157       break;
03158    }
03159    return(1 || funcname || hash || result7 || libp) ;
03160 }
03161 
03162 static int G__G__TMVA3_118_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03163 {
03164       G__letint(result7, 67, (long) ((const TMVA::KDEKernel*) G__getstructoffset())->GetName());
03165    return(1 || funcname || hash || result7 || libp) ;
03166 }
03167 
03168 static int G__G__TMVA3_118_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03169 {
03170       G__letint(result7, 85, (long) TMVA::KDEKernel::Class());
03171    return(1 || funcname || hash || result7 || libp) ;
03172 }
03173 
03174 static int G__G__TMVA3_118_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03175 {
03176       G__letint(result7, 67, (long) TMVA::KDEKernel::Class_Name());
03177    return(1 || funcname || hash || result7 || libp) ;
03178 }
03179 
03180 static int G__G__TMVA3_118_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03181 {
03182       G__letint(result7, 115, (long) TMVA::KDEKernel::Class_Version());
03183    return(1 || funcname || hash || result7 || libp) ;
03184 }
03185 
03186 static int G__G__TMVA3_118_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03187 {
03188       TMVA::KDEKernel::Dictionary();
03189       G__setnull(result7);
03190    return(1 || funcname || hash || result7 || libp) ;
03191 }
03192 
03193 static int G__G__TMVA3_118_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03194 {
03195       G__letint(result7, 85, (long) ((const TMVA::KDEKernel*) G__getstructoffset())->IsA());
03196    return(1 || funcname || hash || result7 || libp) ;
03197 }
03198 
03199 static int G__G__TMVA3_118_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03200 {
03201       ((TMVA::KDEKernel*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
03202       G__setnull(result7);
03203    return(1 || funcname || hash || result7 || libp) ;
03204 }
03205 
03206 static int G__G__TMVA3_118_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03207 {
03208       ((TMVA::KDEKernel*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
03209       G__setnull(result7);
03210    return(1 || funcname || hash || result7 || libp) ;
03211 }
03212 
03213 static int G__G__TMVA3_118_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03214 {
03215       ((TMVA::KDEKernel*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
03216       G__setnull(result7);
03217    return(1 || funcname || hash || result7 || libp) ;
03218 }
03219 
03220 static int G__G__TMVA3_118_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03221 {
03222       G__letint(result7, 67, (long) TMVA::KDEKernel::DeclFileName());
03223    return(1 || funcname || hash || result7 || libp) ;
03224 }
03225 
03226 static int G__G__TMVA3_118_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03227 {
03228       G__letint(result7, 105, (long) TMVA::KDEKernel::ImplFileLine());
03229    return(1 || funcname || hash || result7 || libp) ;
03230 }
03231 
03232 static int G__G__TMVA3_118_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03233 {
03234       G__letint(result7, 67, (long) TMVA::KDEKernel::ImplFileName());
03235    return(1 || funcname || hash || result7 || libp) ;
03236 }
03237 
03238 static int G__G__TMVA3_118_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03239 {
03240       G__letint(result7, 105, (long) TMVA::KDEKernel::DeclFileLine());
03241    return(1 || funcname || hash || result7 || libp) ;
03242 }
03243 
03244 // automatic copy constructor
03245 static int G__G__TMVA3_118_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03246 
03247 {
03248    TMVA::KDEKernel* p;
03249    void* tmp = (void*) G__int(libp->para[0]);
03250    p = new TMVA::KDEKernel(*(TMVA::KDEKernel*) tmp);
03251    result7->obj.i = (long) p;
03252    result7->ref = (long) p;
03253    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernel));
03254    return(1 || funcname || hash || result7 || libp) ;
03255 }
03256 
03257 // automatic destructor
03258 typedef TMVA::KDEKernel G__TTMVAcLcLKDEKernel;
03259 static int G__G__TMVA3_118_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03260 {
03261    char* gvp = (char*) G__getgvp();
03262    long soff = G__getstructoffset();
03263    int n = G__getaryconstruct();
03264    //
03265    //has_a_delete: 0
03266    //has_own_delete1arg: 0
03267    //has_own_delete2arg: 0
03268    //
03269    if (!soff) {
03270      return(1);
03271    }
03272    if (n) {
03273      if (gvp == (char*)G__PVOID) {
03274        delete[] (TMVA::KDEKernel*) soff;
03275      } else {
03276        G__setgvp((long) G__PVOID);
03277        for (int i = n - 1; i >= 0; --i) {
03278          ((TMVA::KDEKernel*) (soff+(sizeof(TMVA::KDEKernel)*i)))->~G__TTMVAcLcLKDEKernel();
03279        }
03280        G__setgvp((long)gvp);
03281      }
03282    } else {
03283      if (gvp == (char*)G__PVOID) {
03284        delete (TMVA::KDEKernel*) soff;
03285      } else {
03286        G__setgvp((long) G__PVOID);
03287        ((TMVA::KDEKernel*) (soff))->~G__TTMVAcLcLKDEKernel();
03288        G__setgvp((long)gvp);
03289      }
03290    }
03291    G__setnull(result7);
03292    return(1 || funcname || hash || result7 || libp) ;
03293 }
03294 
03295 // automatic assignment operator
03296 static int G__G__TMVA3_118_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03297 {
03298    TMVA::KDEKernel* dest = (TMVA::KDEKernel*) G__getstructoffset();
03299    *dest = *(TMVA::KDEKernel*) libp->para[0].ref;
03300    const TMVA::KDEKernel& obj = *dest;
03301    result7->ref = (long) (&obj);
03302    result7->obj.i = (long) (&obj);
03303    return(1 || funcname || hash || result7 || libp) ;
03304 }
03305 
03306 
03307 /* TMVA::Interval */
03308 static int G__G__TMVA3_123_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03309 {
03310    TMVA::Interval* p = NULL;
03311    char* gvp = (char*) G__getgvp();
03312    switch (libp->paran) {
03313    case 3:
03314      //m: 3
03315      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03316        p = new TMVA::Interval(
03317 (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
03318 , (Int_t) G__int(libp->para[2]));
03319      } else {
03320        p = new((void*) gvp) TMVA::Interval(
03321 (Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])
03322 , (Int_t) G__int(libp->para[2]));
03323      }
03324      break;
03325    case 2:
03326      //m: 2
03327      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03328        p = new TMVA::Interval((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
03329      } else {
03330        p = new((void*) gvp) TMVA::Interval((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1]));
03331      }
03332      break;
03333    }
03334    result7->obj.i = (long) p;
03335    result7->ref = (long) p;
03336    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLInterval));
03337    return(1 || funcname || hash || result7 || libp) ;
03338 }
03339 
03340 static int G__G__TMVA3_123_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03341 {
03342    TMVA::Interval* p = NULL;
03343    char* gvp = (char*) G__getgvp();
03344    //m: 1
03345    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03346      p = new TMVA::Interval(*(TMVA::Interval*) libp->para[0].ref);
03347    } else {
03348      p = new((void*) gvp) TMVA::Interval(*(TMVA::Interval*) libp->para[0].ref);
03349    }
03350    result7->obj.i = (long) p;
03351    result7->ref = (long) p;
03352    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLInterval));
03353    return(1 || funcname || hash || result7 || libp) ;
03354 }
03355 
03356 static int G__G__TMVA3_123_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03357 {
03358       G__letdouble(result7, 100, (double) ((const TMVA::Interval*) G__getstructoffset())->GetMin());
03359    return(1 || funcname || hash || result7 || libp) ;
03360 }
03361 
03362 static int G__G__TMVA3_123_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03363 {
03364       G__letdouble(result7, 100, (double) ((const TMVA::Interval*) G__getstructoffset())->GetMax());
03365    return(1 || funcname || hash || result7 || libp) ;
03366 }
03367 
03368 static int G__G__TMVA3_123_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03369 {
03370       G__letdouble(result7, 100, (double) ((const TMVA::Interval*) G__getstructoffset())->GetWidth());
03371    return(1 || funcname || hash || result7 || libp) ;
03372 }
03373 
03374 static int G__G__TMVA3_123_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03375 {
03376       G__letint(result7, 105, (long) ((const TMVA::Interval*) G__getstructoffset())->GetNbins());
03377    return(1 || funcname || hash || result7 || libp) ;
03378 }
03379 
03380 static int G__G__TMVA3_123_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03381 {
03382       G__letdouble(result7, 100, (double) ((const TMVA::Interval*) G__getstructoffset())->GetMean());
03383    return(1 || funcname || hash || result7 || libp) ;
03384 }
03385 
03386 static int G__G__TMVA3_123_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03387 {
03388       G__letdouble(result7, 100, (double) ((const TMVA::Interval*) G__getstructoffset())->GetRndm(*(TRandom3*) libp->para[0].ref));
03389    return(1 || funcname || hash || result7 || libp) ;
03390 }
03391 
03392 static int G__G__TMVA3_123_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03393 {
03394       G__letdouble(result7, 100, (double) ((const TMVA::Interval*) G__getstructoffset())->GetElement((Int_t) G__int(libp->para[0])));
03395    return(1 || funcname || hash || result7 || libp) ;
03396 }
03397 
03398 static int G__G__TMVA3_123_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03399 {
03400       G__letdouble(result7, 100, (double) ((const TMVA::Interval*) G__getstructoffset())->GetStepSize());
03401    return(1 || funcname || hash || result7 || libp) ;
03402 }
03403 
03404 static int G__G__TMVA3_123_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03405 {
03406       ((TMVA::Interval*) G__getstructoffset())->SetMax((Double_t) G__double(libp->para[0]));
03407       G__setnull(result7);
03408    return(1 || funcname || hash || result7 || libp) ;
03409 }
03410 
03411 static int G__G__TMVA3_123_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03412 {
03413       ((TMVA::Interval*) G__getstructoffset())->SetMin((Double_t) G__double(libp->para[0]));
03414       G__setnull(result7);
03415    return(1 || funcname || hash || result7 || libp) ;
03416 }
03417 
03418 static int G__G__TMVA3_123_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03419 {
03420       G__letint(result7, 85, (long) TMVA::Interval::Class());
03421    return(1 || funcname || hash || result7 || libp) ;
03422 }
03423 
03424 static int G__G__TMVA3_123_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03425 {
03426       G__letint(result7, 67, (long) TMVA::Interval::Class_Name());
03427    return(1 || funcname || hash || result7 || libp) ;
03428 }
03429 
03430 static int G__G__TMVA3_123_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03431 {
03432       G__letint(result7, 115, (long) TMVA::Interval::Class_Version());
03433    return(1 || funcname || hash || result7 || libp) ;
03434 }
03435 
03436 static int G__G__TMVA3_123_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03437 {
03438       TMVA::Interval::Dictionary();
03439       G__setnull(result7);
03440    return(1 || funcname || hash || result7 || libp) ;
03441 }
03442 
03443 static int G__G__TMVA3_123_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03444 {
03445       G__letint(result7, 85, (long) ((const TMVA::Interval*) G__getstructoffset())->IsA());
03446    return(1 || funcname || hash || result7 || libp) ;
03447 }
03448 
03449 static int G__G__TMVA3_123_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03450 {
03451       ((TMVA::Interval*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
03452       G__setnull(result7);
03453    return(1 || funcname || hash || result7 || libp) ;
03454 }
03455 
03456 static int G__G__TMVA3_123_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03457 {
03458       ((TMVA::Interval*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
03459       G__setnull(result7);
03460    return(1 || funcname || hash || result7 || libp) ;
03461 }
03462 
03463 static int G__G__TMVA3_123_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03464 {
03465       ((TMVA::Interval*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
03466       G__setnull(result7);
03467    return(1 || funcname || hash || result7 || libp) ;
03468 }
03469 
03470 static int G__G__TMVA3_123_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03471 {
03472       G__letint(result7, 67, (long) TMVA::Interval::DeclFileName());
03473    return(1 || funcname || hash || result7 || libp) ;
03474 }
03475 
03476 static int G__G__TMVA3_123_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03477 {
03478       G__letint(result7, 105, (long) TMVA::Interval::ImplFileLine());
03479    return(1 || funcname || hash || result7 || libp) ;
03480 }
03481 
03482 static int G__G__TMVA3_123_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03483 {
03484       G__letint(result7, 67, (long) TMVA::Interval::ImplFileName());
03485    return(1 || funcname || hash || result7 || libp) ;
03486 }
03487 
03488 static int G__G__TMVA3_123_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03489 {
03490       G__letint(result7, 105, (long) TMVA::Interval::DeclFileLine());
03491    return(1 || funcname || hash || result7 || libp) ;
03492 }
03493 
03494 // automatic destructor
03495 typedef TMVA::Interval G__TTMVAcLcLInterval;
03496 static int G__G__TMVA3_123_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03497 {
03498    char* gvp = (char*) G__getgvp();
03499    long soff = G__getstructoffset();
03500    int n = G__getaryconstruct();
03501    //
03502    //has_a_delete: 0
03503    //has_own_delete1arg: 0
03504    //has_own_delete2arg: 0
03505    //
03506    if (!soff) {
03507      return(1);
03508    }
03509    if (n) {
03510      if (gvp == (char*)G__PVOID) {
03511        delete[] (TMVA::Interval*) soff;
03512      } else {
03513        G__setgvp((long) G__PVOID);
03514        for (int i = n - 1; i >= 0; --i) {
03515          ((TMVA::Interval*) (soff+(sizeof(TMVA::Interval)*i)))->~G__TTMVAcLcLInterval();
03516        }
03517        G__setgvp((long)gvp);
03518      }
03519    } else {
03520      if (gvp == (char*)G__PVOID) {
03521        delete (TMVA::Interval*) soff;
03522      } else {
03523        G__setgvp((long) G__PVOID);
03524        ((TMVA::Interval*) (soff))->~G__TTMVAcLcLInterval();
03525        G__setgvp((long)gvp);
03526      }
03527    }
03528    G__setnull(result7);
03529    return(1 || funcname || hash || result7 || libp) ;
03530 }
03531 
03532 // automatic assignment operator
03533 static int G__G__TMVA3_123_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03534 {
03535    TMVA::Interval* dest = (TMVA::Interval*) G__getstructoffset();
03536    *dest = *(TMVA::Interval*) libp->para[0].ref;
03537    const TMVA::Interval& obj = *dest;
03538    result7->ref = (long) (&obj);
03539    result7->obj.i = (long) (&obj);
03540    return(1 || funcname || hash || result7 || libp) ;
03541 }
03542 
03543 
03544 /* TMVA::IFitterTarget */
03545 static int G__G__TMVA3_186_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03546 {
03547       G__letdouble(result7, 100, (double) ((TMVA::IFitterTarget*) G__getstructoffset())->EstimatorFunction(*(vector<Double_t>*) libp->para[0].ref));
03548    return(1 || funcname || hash || result7 || libp) ;
03549 }
03550 
03551 static int G__G__TMVA3_186_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03552 {
03553       ((TMVA::IFitterTarget*) G__getstructoffset())->ProgressNotifier(*((TString*) G__int(libp->para[0])), *((TString*) G__int(libp->para[1])));
03554       G__setnull(result7);
03555    return(1 || funcname || hash || result7 || libp) ;
03556 }
03557 
03558 static int G__G__TMVA3_186_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03559 {
03560       G__letint(result7, 85, (long) TMVA::IFitterTarget::Class());
03561    return(1 || funcname || hash || result7 || libp) ;
03562 }
03563 
03564 static int G__G__TMVA3_186_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03565 {
03566       G__letint(result7, 67, (long) TMVA::IFitterTarget::Class_Name());
03567    return(1 || funcname || hash || result7 || libp) ;
03568 }
03569 
03570 static int G__G__TMVA3_186_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03571 {
03572       G__letint(result7, 115, (long) TMVA::IFitterTarget::Class_Version());
03573    return(1 || funcname || hash || result7 || libp) ;
03574 }
03575 
03576 static int G__G__TMVA3_186_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03577 {
03578       TMVA::IFitterTarget::Dictionary();
03579       G__setnull(result7);
03580    return(1 || funcname || hash || result7 || libp) ;
03581 }
03582 
03583 static int G__G__TMVA3_186_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03584 {
03585       G__letint(result7, 85, (long) ((const TMVA::IFitterTarget*) G__getstructoffset())->IsA());
03586    return(1 || funcname || hash || result7 || libp) ;
03587 }
03588 
03589 static int G__G__TMVA3_186_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03590 {
03591       ((TMVA::IFitterTarget*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
03592       G__setnull(result7);
03593    return(1 || funcname || hash || result7 || libp) ;
03594 }
03595 
03596 static int G__G__TMVA3_186_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03597 {
03598       ((TMVA::IFitterTarget*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
03599       G__setnull(result7);
03600    return(1 || funcname || hash || result7 || libp) ;
03601 }
03602 
03603 static int G__G__TMVA3_186_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03604 {
03605       ((TMVA::IFitterTarget*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
03606       G__setnull(result7);
03607    return(1 || funcname || hash || result7 || libp) ;
03608 }
03609 
03610 static int G__G__TMVA3_186_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03611 {
03612       G__letint(result7, 67, (long) TMVA::IFitterTarget::DeclFileName());
03613    return(1 || funcname || hash || result7 || libp) ;
03614 }
03615 
03616 static int G__G__TMVA3_186_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03617 {
03618       G__letint(result7, 105, (long) TMVA::IFitterTarget::ImplFileLine());
03619    return(1 || funcname || hash || result7 || libp) ;
03620 }
03621 
03622 static int G__G__TMVA3_186_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03623 {
03624       G__letint(result7, 67, (long) TMVA::IFitterTarget::ImplFileName());
03625    return(1 || funcname || hash || result7 || libp) ;
03626 }
03627 
03628 static int G__G__TMVA3_186_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03629 {
03630       G__letint(result7, 105, (long) TMVA::IFitterTarget::DeclFileLine());
03631    return(1 || funcname || hash || result7 || libp) ;
03632 }
03633 
03634 // automatic destructor
03635 typedef TMVA::IFitterTarget G__TTMVAcLcLIFitterTarget;
03636 static int G__G__TMVA3_186_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03637 {
03638    char* gvp = (char*) G__getgvp();
03639    long soff = G__getstructoffset();
03640    int n = G__getaryconstruct();
03641    //
03642    //has_a_delete: 0
03643    //has_own_delete1arg: 0
03644    //has_own_delete2arg: 0
03645    //
03646    if (!soff) {
03647      return(1);
03648    }
03649    if (n) {
03650      if (gvp == (char*)G__PVOID) {
03651        delete[] (TMVA::IFitterTarget*) soff;
03652      } else {
03653        G__setgvp((long) G__PVOID);
03654        for (int i = n - 1; i >= 0; --i) {
03655          ((TMVA::IFitterTarget*) (soff+(sizeof(TMVA::IFitterTarget)*i)))->~G__TTMVAcLcLIFitterTarget();
03656        }
03657        G__setgvp((long)gvp);
03658      }
03659    } else {
03660      if (gvp == (char*)G__PVOID) {
03661        delete (TMVA::IFitterTarget*) soff;
03662      } else {
03663        G__setgvp((long) G__PVOID);
03664        ((TMVA::IFitterTarget*) (soff))->~G__TTMVAcLcLIFitterTarget();
03665        G__setgvp((long)gvp);
03666      }
03667    }
03668    G__setnull(result7);
03669    return(1 || funcname || hash || result7 || libp) ;
03670 }
03671 
03672 // automatic assignment operator
03673 static int G__G__TMVA3_186_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03674 {
03675    TMVA::IFitterTarget* dest = (TMVA::IFitterTarget*) G__getstructoffset();
03676    *dest = *(TMVA::IFitterTarget*) libp->para[0].ref;
03677    const TMVA::IFitterTarget& obj = *dest;
03678    result7->ref = (long) (&obj);
03679    result7->obj.i = (long) (&obj);
03680    return(1 || funcname || hash || result7 || libp) ;
03681 }
03682 
03683 
03684 /* TMVA::FitterBase */
03685 static int G__G__TMVA3_187_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03686 {
03687       G__letdouble(result7, 100, (double) ((TMVA::FitterBase*) G__getstructoffset())->Run());
03688    return(1 || funcname || hash || result7 || libp) ;
03689 }
03690 
03691 static int G__G__TMVA3_187_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03692 {
03693       G__letdouble(result7, 100, (double) ((TMVA::FitterBase*) G__getstructoffset())->Run(*(vector<Double_t>*) libp->para[0].ref));
03694    return(1 || funcname || hash || result7 || libp) ;
03695 }
03696 
03697 static int G__G__TMVA3_187_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03698 {
03699       G__letdouble(result7, 100, (double) ((TMVA::FitterBase*) G__getstructoffset())->EstimatorFunction(*(vector<Double_t>*) libp->para[0].ref));
03700    return(1 || funcname || hash || result7 || libp) ;
03701 }
03702 
03703 static int G__G__TMVA3_187_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03704 {
03705       {
03706          const TMVA::IFitterTarget& obj = ((const TMVA::FitterBase*) G__getstructoffset())->GetFitterTarget();
03707          result7->ref = (long) (&obj);
03708          result7->obj.i = (long) (&obj);
03709       }
03710    return(1 || funcname || hash || result7 || libp) ;
03711 }
03712 
03713 static int G__G__TMVA3_187_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03714 {
03715       G__letint(result7, 105, (long) ((const TMVA::FitterBase*) G__getstructoffset())->GetNpars());
03716    return(1 || funcname || hash || result7 || libp) ;
03717 }
03718 
03719 static int G__G__TMVA3_187_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03720 {
03721       G__letint(result7, 85, (long) TMVA::FitterBase::Class());
03722    return(1 || funcname || hash || result7 || libp) ;
03723 }
03724 
03725 static int G__G__TMVA3_187_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03726 {
03727       G__letint(result7, 67, (long) TMVA::FitterBase::Class_Name());
03728    return(1 || funcname || hash || result7 || libp) ;
03729 }
03730 
03731 static int G__G__TMVA3_187_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03732 {
03733       G__letint(result7, 115, (long) TMVA::FitterBase::Class_Version());
03734    return(1 || funcname || hash || result7 || libp) ;
03735 }
03736 
03737 static int G__G__TMVA3_187_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03738 {
03739       TMVA::FitterBase::Dictionary();
03740       G__setnull(result7);
03741    return(1 || funcname || hash || result7 || libp) ;
03742 }
03743 
03744 static int G__G__TMVA3_187_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03745 {
03746       ((TMVA::FitterBase*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
03747       G__setnull(result7);
03748    return(1 || funcname || hash || result7 || libp) ;
03749 }
03750 
03751 static int G__G__TMVA3_187_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03752 {
03753       G__letint(result7, 67, (long) TMVA::FitterBase::DeclFileName());
03754    return(1 || funcname || hash || result7 || libp) ;
03755 }
03756 
03757 static int G__G__TMVA3_187_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03758 {
03759       G__letint(result7, 105, (long) TMVA::FitterBase::ImplFileLine());
03760    return(1 || funcname || hash || result7 || libp) ;
03761 }
03762 
03763 static int G__G__TMVA3_187_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03764 {
03765       G__letint(result7, 67, (long) TMVA::FitterBase::ImplFileName());
03766    return(1 || funcname || hash || result7 || libp) ;
03767 }
03768 
03769 static int G__G__TMVA3_187_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03770 {
03771       G__letint(result7, 105, (long) TMVA::FitterBase::DeclFileLine());
03772    return(1 || funcname || hash || result7 || libp) ;
03773 }
03774 
03775 // automatic destructor
03776 typedef TMVA::FitterBase G__TTMVAcLcLFitterBase;
03777 static int G__G__TMVA3_187_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03778 {
03779    char* gvp = (char*) G__getgvp();
03780    long soff = G__getstructoffset();
03781    int n = G__getaryconstruct();
03782    //
03783    //has_a_delete: 1
03784    //has_own_delete1arg: 0
03785    //has_own_delete2arg: 0
03786    //
03787    if (!soff) {
03788      return(1);
03789    }
03790    if (n) {
03791      if (gvp == (char*)G__PVOID) {
03792        delete[] (TMVA::FitterBase*) soff;
03793      } else {
03794        G__setgvp((long) G__PVOID);
03795        for (int i = n - 1; i >= 0; --i) {
03796          ((TMVA::FitterBase*) (soff+(sizeof(TMVA::FitterBase)*i)))->~G__TTMVAcLcLFitterBase();
03797        }
03798        G__setgvp((long)gvp);
03799      }
03800    } else {
03801      if (gvp == (char*)G__PVOID) {
03802        delete (TMVA::FitterBase*) soff;
03803      } else {
03804        G__setgvp((long) G__PVOID);
03805        ((TMVA::FitterBase*) (soff))->~G__TTMVAcLcLFitterBase();
03806        G__setgvp((long)gvp);
03807      }
03808    }
03809    G__setnull(result7);
03810    return(1 || funcname || hash || result7 || libp) ;
03811 }
03812 
03813 
03814 /* TMVA::MCFitter */
03815 static int G__G__TMVA3_196_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03816 {
03817    TMVA::MCFitter* p = NULL;
03818    char* gvp = (char*) G__getgvp();
03819    //m: 4
03820    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03821      p = new TMVA::MCFitter(
03822 *(TMVA::IFitterTarget*) libp->para[0].ref, *(TString*) libp->para[1].ref
03823 , *(vector<TMVA::Interval*>*) libp->para[2].ref, *(TString*) libp->para[3].ref);
03824    } else {
03825      p = new((void*) gvp) TMVA::MCFitter(
03826 *(TMVA::IFitterTarget*) libp->para[0].ref, *(TString*) libp->para[1].ref
03827 , *(vector<TMVA::Interval*>*) libp->para[2].ref, *(TString*) libp->para[3].ref);
03828    }
03829    result7->obj.i = (long) p;
03830    result7->ref = (long) p;
03831    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMCFitter));
03832    return(1 || funcname || hash || result7 || libp) ;
03833 }
03834 
03835 static int G__G__TMVA3_196_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03836 {
03837       ((TMVA::MCFitter*) G__getstructoffset())->SetParameters((Int_t) G__int(libp->para[0]));
03838       G__setnull(result7);
03839    return(1 || funcname || hash || result7 || libp) ;
03840 }
03841 
03842 static int G__G__TMVA3_196_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03843 {
03844       G__letint(result7, 85, (long) TMVA::MCFitter::Class());
03845    return(1 || funcname || hash || result7 || libp) ;
03846 }
03847 
03848 static int G__G__TMVA3_196_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03849 {
03850       G__letint(result7, 67, (long) TMVA::MCFitter::Class_Name());
03851    return(1 || funcname || hash || result7 || libp) ;
03852 }
03853 
03854 static int G__G__TMVA3_196_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03855 {
03856       G__letint(result7, 115, (long) TMVA::MCFitter::Class_Version());
03857    return(1 || funcname || hash || result7 || libp) ;
03858 }
03859 
03860 static int G__G__TMVA3_196_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03861 {
03862       TMVA::MCFitter::Dictionary();
03863       G__setnull(result7);
03864    return(1 || funcname || hash || result7 || libp) ;
03865 }
03866 
03867 static int G__G__TMVA3_196_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03868 {
03869       ((TMVA::MCFitter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
03870       G__setnull(result7);
03871    return(1 || funcname || hash || result7 || libp) ;
03872 }
03873 
03874 static int G__G__TMVA3_196_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03875 {
03876       G__letint(result7, 67, (long) TMVA::MCFitter::DeclFileName());
03877    return(1 || funcname || hash || result7 || libp) ;
03878 }
03879 
03880 static int G__G__TMVA3_196_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03881 {
03882       G__letint(result7, 105, (long) TMVA::MCFitter::ImplFileLine());
03883    return(1 || funcname || hash || result7 || libp) ;
03884 }
03885 
03886 static int G__G__TMVA3_196_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03887 {
03888       G__letint(result7, 67, (long) TMVA::MCFitter::ImplFileName());
03889    return(1 || funcname || hash || result7 || libp) ;
03890 }
03891 
03892 static int G__G__TMVA3_196_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03893 {
03894       G__letint(result7, 105, (long) TMVA::MCFitter::DeclFileLine());
03895    return(1 || funcname || hash || result7 || libp) ;
03896 }
03897 
03898 // automatic destructor
03899 typedef TMVA::MCFitter G__TTMVAcLcLMCFitter;
03900 static int G__G__TMVA3_196_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03901 {
03902    char* gvp = (char*) G__getgvp();
03903    long soff = G__getstructoffset();
03904    int n = G__getaryconstruct();
03905    //
03906    //has_a_delete: 1
03907    //has_own_delete1arg: 0
03908    //has_own_delete2arg: 0
03909    //
03910    if (!soff) {
03911      return(1);
03912    }
03913    if (n) {
03914      if (gvp == (char*)G__PVOID) {
03915        delete[] (TMVA::MCFitter*) soff;
03916      } else {
03917        G__setgvp((long) G__PVOID);
03918        for (int i = n - 1; i >= 0; --i) {
03919          ((TMVA::MCFitter*) (soff+(sizeof(TMVA::MCFitter)*i)))->~G__TTMVAcLcLMCFitter();
03920        }
03921        G__setgvp((long)gvp);
03922      }
03923    } else {
03924      if (gvp == (char*)G__PVOID) {
03925        delete (TMVA::MCFitter*) soff;
03926      } else {
03927        G__setgvp((long) G__PVOID);
03928        ((TMVA::MCFitter*) (soff))->~G__TTMVAcLcLMCFitter();
03929        G__setgvp((long)gvp);
03930      }
03931    }
03932    G__setnull(result7);
03933    return(1 || funcname || hash || result7 || libp) ;
03934 }
03935 
03936 
03937 /* TMVA::GeneticFitter */
03938 static int G__G__TMVA3_197_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03939 {
03940    TMVA::GeneticFitter* p = NULL;
03941    char* gvp = (char*) G__getgvp();
03942    //m: 4
03943    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03944      p = new TMVA::GeneticFitter(
03945 *(TMVA::IFitterTarget*) libp->para[0].ref, *(TString*) libp->para[1].ref
03946 , *(vector<TMVA::Interval*>*) libp->para[2].ref, *(TString*) libp->para[3].ref);
03947    } else {
03948      p = new((void*) gvp) TMVA::GeneticFitter(
03949 *(TMVA::IFitterTarget*) libp->para[0].ref, *(TString*) libp->para[1].ref
03950 , *(vector<TMVA::Interval*>*) libp->para[2].ref, *(TString*) libp->para[3].ref);
03951    }
03952    result7->obj.i = (long) p;
03953    result7->ref = (long) p;
03954    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLGeneticFitter));
03955    return(1 || funcname || hash || result7 || libp) ;
03956 }
03957 
03958 static int G__G__TMVA3_197_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03959 {
03960       ((TMVA::GeneticFitter*) G__getstructoffset())->SetParameters(
03961 (Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
03962 , (Int_t) G__int(libp->para[2]), (Int_t) G__int(libp->para[3])
03963 , (Int_t) G__int(libp->para[4]), (Double_t) G__double(libp->para[5])
03964 , (Double_t) G__double(libp->para[6]));
03965       G__setnull(result7);
03966    return(1 || funcname || hash || result7 || libp) ;
03967 }
03968 
03969 static int G__G__TMVA3_197_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03970 {
03971       G__letdouble(result7, 100, (double) ((TMVA::GeneticFitter*) G__getstructoffset())->NewFitness((Double_t) G__double(libp->para[0]), (Double_t) G__double(libp->para[1])));
03972    return(1 || funcname || hash || result7 || libp) ;
03973 }
03974 
03975 static int G__G__TMVA3_197_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03976 {
03977       G__letint(result7, 85, (long) TMVA::GeneticFitter::Class());
03978    return(1 || funcname || hash || result7 || libp) ;
03979 }
03980 
03981 static int G__G__TMVA3_197_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03982 {
03983       G__letint(result7, 67, (long) TMVA::GeneticFitter::Class_Name());
03984    return(1 || funcname || hash || result7 || libp) ;
03985 }
03986 
03987 static int G__G__TMVA3_197_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03988 {
03989       G__letint(result7, 115, (long) TMVA::GeneticFitter::Class_Version());
03990    return(1 || funcname || hash || result7 || libp) ;
03991 }
03992 
03993 static int G__G__TMVA3_197_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03994 {
03995       TMVA::GeneticFitter::Dictionary();
03996       G__setnull(result7);
03997    return(1 || funcname || hash || result7 || libp) ;
03998 }
03999 
04000 static int G__G__TMVA3_197_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04001 {
04002       ((TMVA::GeneticFitter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04003       G__setnull(result7);
04004    return(1 || funcname || hash || result7 || libp) ;
04005 }
04006 
04007 static int G__G__TMVA3_197_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04008 {
04009       G__letint(result7, 67, (long) TMVA::GeneticFitter::DeclFileName());
04010    return(1 || funcname || hash || result7 || libp) ;
04011 }
04012 
04013 static int G__G__TMVA3_197_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04014 {
04015       G__letint(result7, 105, (long) TMVA::GeneticFitter::ImplFileLine());
04016    return(1 || funcname || hash || result7 || libp) ;
04017 }
04018 
04019 static int G__G__TMVA3_197_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04020 {
04021       G__letint(result7, 67, (long) TMVA::GeneticFitter::ImplFileName());
04022    return(1 || funcname || hash || result7 || libp) ;
04023 }
04024 
04025 static int G__G__TMVA3_197_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04026 {
04027       G__letint(result7, 105, (long) TMVA::GeneticFitter::DeclFileLine());
04028    return(1 || funcname || hash || result7 || libp) ;
04029 }
04030 
04031 // automatic destructor
04032 typedef TMVA::GeneticFitter G__TTMVAcLcLGeneticFitter;
04033 static int G__G__TMVA3_197_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04034 {
04035    char* gvp = (char*) G__getgvp();
04036    long soff = G__getstructoffset();
04037    int n = G__getaryconstruct();
04038    //
04039    //has_a_delete: 1
04040    //has_own_delete1arg: 0
04041    //has_own_delete2arg: 0
04042    //
04043    if (!soff) {
04044      return(1);
04045    }
04046    if (n) {
04047      if (gvp == (char*)G__PVOID) {
04048        delete[] (TMVA::GeneticFitter*) soff;
04049      } else {
04050        G__setgvp((long) G__PVOID);
04051        for (int i = n - 1; i >= 0; --i) {
04052          ((TMVA::GeneticFitter*) (soff+(sizeof(TMVA::GeneticFitter)*i)))->~G__TTMVAcLcLGeneticFitter();
04053        }
04054        G__setgvp((long)gvp);
04055      }
04056    } else {
04057      if (gvp == (char*)G__PVOID) {
04058        delete (TMVA::GeneticFitter*) soff;
04059      } else {
04060        G__setgvp((long) G__PVOID);
04061        ((TMVA::GeneticFitter*) (soff))->~G__TTMVAcLcLGeneticFitter();
04062        G__setgvp((long)gvp);
04063      }
04064    }
04065    G__setnull(result7);
04066    return(1 || funcname || hash || result7 || libp) ;
04067 }
04068 
04069 
04070 /* TMVA::SimulatedAnnealingFitter */
04071 static int G__G__TMVA3_198_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04072 {
04073    TMVA::SimulatedAnnealingFitter* p = NULL;
04074    char* gvp = (char*) G__getgvp();
04075    //m: 4
04076    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04077      p = new TMVA::SimulatedAnnealingFitter(
04078 *(TMVA::IFitterTarget*) libp->para[0].ref, *(TString*) libp->para[1].ref
04079 , *(vector<TMVA::Interval*>*) libp->para[2].ref, *(TString*) libp->para[3].ref);
04080    } else {
04081      p = new((void*) gvp) TMVA::SimulatedAnnealingFitter(
04082 *(TMVA::IFitterTarget*) libp->para[0].ref, *(TString*) libp->para[1].ref
04083 , *(vector<TMVA::Interval*>*) libp->para[2].ref, *(TString*) libp->para[3].ref);
04084    }
04085    result7->obj.i = (long) p;
04086    result7->ref = (long) p;
04087    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter));
04088    return(1 || funcname || hash || result7 || libp) ;
04089 }
04090 
04091 static int G__G__TMVA3_198_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04092 {
04093       ((TMVA::SimulatedAnnealingFitter*) G__getstructoffset())->SetParameters(
04094 (Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1])
04095 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
04096 , *((TString*) G__int(libp->para[4])), (Double_t) G__double(libp->para[5])
04097 , (Double_t) G__double(libp->para[6]), (Bool_t) G__int(libp->para[7])
04098 , (Bool_t) G__int(libp->para[8]));
04099       G__setnull(result7);
04100    return(1 || funcname || hash || result7 || libp) ;
04101 }
04102 
04103 static int G__G__TMVA3_198_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04104 {
04105       G__letint(result7, 85, (long) TMVA::SimulatedAnnealingFitter::Class());
04106    return(1 || funcname || hash || result7 || libp) ;
04107 }
04108 
04109 static int G__G__TMVA3_198_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04110 {
04111       G__letint(result7, 67, (long) TMVA::SimulatedAnnealingFitter::Class_Name());
04112    return(1 || funcname || hash || result7 || libp) ;
04113 }
04114 
04115 static int G__G__TMVA3_198_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04116 {
04117       G__letint(result7, 115, (long) TMVA::SimulatedAnnealingFitter::Class_Version());
04118    return(1 || funcname || hash || result7 || libp) ;
04119 }
04120 
04121 static int G__G__TMVA3_198_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04122 {
04123       TMVA::SimulatedAnnealingFitter::Dictionary();
04124       G__setnull(result7);
04125    return(1 || funcname || hash || result7 || libp) ;
04126 }
04127 
04128 static int G__G__TMVA3_198_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04129 {
04130       ((TMVA::SimulatedAnnealingFitter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04131       G__setnull(result7);
04132    return(1 || funcname || hash || result7 || libp) ;
04133 }
04134 
04135 static int G__G__TMVA3_198_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04136 {
04137       G__letint(result7, 67, (long) TMVA::SimulatedAnnealingFitter::DeclFileName());
04138    return(1 || funcname || hash || result7 || libp) ;
04139 }
04140 
04141 static int G__G__TMVA3_198_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04142 {
04143       G__letint(result7, 105, (long) TMVA::SimulatedAnnealingFitter::ImplFileLine());
04144    return(1 || funcname || hash || result7 || libp) ;
04145 }
04146 
04147 static int G__G__TMVA3_198_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04148 {
04149       G__letint(result7, 67, (long) TMVA::SimulatedAnnealingFitter::ImplFileName());
04150    return(1 || funcname || hash || result7 || libp) ;
04151 }
04152 
04153 static int G__G__TMVA3_198_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04154 {
04155       G__letint(result7, 105, (long) TMVA::SimulatedAnnealingFitter::DeclFileLine());
04156    return(1 || funcname || hash || result7 || libp) ;
04157 }
04158 
04159 // automatic destructor
04160 typedef TMVA::SimulatedAnnealingFitter G__TTMVAcLcLSimulatedAnnealingFitter;
04161 static int G__G__TMVA3_198_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04162 {
04163    char* gvp = (char*) G__getgvp();
04164    long soff = G__getstructoffset();
04165    int n = G__getaryconstruct();
04166    //
04167    //has_a_delete: 1
04168    //has_own_delete1arg: 0
04169    //has_own_delete2arg: 0
04170    //
04171    if (!soff) {
04172      return(1);
04173    }
04174    if (n) {
04175      if (gvp == (char*)G__PVOID) {
04176        delete[] (TMVA::SimulatedAnnealingFitter*) soff;
04177      } else {
04178        G__setgvp((long) G__PVOID);
04179        for (int i = n - 1; i >= 0; --i) {
04180          ((TMVA::SimulatedAnnealingFitter*) (soff+(sizeof(TMVA::SimulatedAnnealingFitter)*i)))->~G__TTMVAcLcLSimulatedAnnealingFitter();
04181        }
04182        G__setgvp((long)gvp);
04183      }
04184    } else {
04185      if (gvp == (char*)G__PVOID) {
04186        delete (TMVA::SimulatedAnnealingFitter*) soff;
04187      } else {
04188        G__setgvp((long) G__PVOID);
04189        ((TMVA::SimulatedAnnealingFitter*) (soff))->~G__TTMVAcLcLSimulatedAnnealingFitter();
04190        G__setgvp((long)gvp);
04191      }
04192    }
04193    G__setnull(result7);
04194    return(1 || funcname || hash || result7 || libp) ;
04195 }
04196 
04197 
04198 /* TMVA::MinuitWrapper */
04199 static int G__G__TMVA3_200_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04200 {
04201    TMVA::MinuitWrapper* p = NULL;
04202    char* gvp = (char*) G__getgvp();
04203    //m: 2
04204    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04205      p = new TMVA::MinuitWrapper(*(TMVA::IFitterTarget*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
04206    } else {
04207      p = new((void*) gvp) TMVA::MinuitWrapper(*(TMVA::IFitterTarget*) libp->para[0].ref, (Int_t) G__int(libp->para[1]));
04208    }
04209    result7->obj.i = (long) p;
04210    result7->ref = (long) p;
04211    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitWrapper));
04212    return(1 || funcname || hash || result7 || libp) ;
04213 }
04214 
04215 static int G__G__TMVA3_200_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04216 {
04217       ((TMVA::MinuitWrapper*) G__getstructoffset())->SetFitterTarget(*(TMVA::IFitterTarget*) libp->para[0].ref);
04218       G__setnull(result7);
04219    return(1 || funcname || hash || result7 || libp) ;
04220 }
04221 
04222 static int G__G__TMVA3_200_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04223 {
04224       G__letint(result7, 105, (long) ((TMVA::MinuitWrapper*) G__getstructoffset())->ExecuteCommand((const char*) G__int(libp->para[0]), (Double_t*) G__int(libp->para[1])
04225 , (Int_t) G__int(libp->para[2])));
04226    return(1 || funcname || hash || result7 || libp) ;
04227 }
04228 
04229 static int G__G__TMVA3_200_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04230 {
04231       G__letint(result7, 105, (long) ((TMVA::MinuitWrapper*) G__getstructoffset())->GetStats(*(Double_t*) G__Doubleref(&libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
04232 , *(Double_t*) G__Doubleref(&libp->para[2]), *(Int_t*) G__Intref(&libp->para[3])
04233 , *(Int_t*) G__Intref(&libp->para[4])));
04234    return(1 || funcname || hash || result7 || libp) ;
04235 }
04236 
04237 static int G__G__TMVA3_200_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04238 {
04239       G__letint(result7, 105, (long) ((TMVA::MinuitWrapper*) G__getstructoffset())->GetErrors((Int_t) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])
04240 , *(Double_t*) G__Doubleref(&libp->para[2]), *(Double_t*) G__Doubleref(&libp->para[3])
04241 , *(Double_t*) G__Doubleref(&libp->para[4])));
04242    return(1 || funcname || hash || result7 || libp) ;
04243 }
04244 
04245 static int G__G__TMVA3_200_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04246 {
04247       G__letint(result7, 105, (long) ((TMVA::MinuitWrapper*) G__getstructoffset())->SetParameter((Int_t) G__int(libp->para[0]), (const char*) G__int(libp->para[1])
04248 , (Double_t) G__double(libp->para[2]), (Double_t) G__double(libp->para[3])
04249 , (Double_t) G__double(libp->para[4]), (Double_t) G__double(libp->para[5])));
04250    return(1 || funcname || hash || result7 || libp) ;
04251 }
04252 
04253 static int G__G__TMVA3_200_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04254 {
04255       G__letint(result7, 85, (long) TMVA::MinuitWrapper::Class());
04256    return(1 || funcname || hash || result7 || libp) ;
04257 }
04258 
04259 static int G__G__TMVA3_200_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04260 {
04261       G__letint(result7, 67, (long) TMVA::MinuitWrapper::Class_Name());
04262    return(1 || funcname || hash || result7 || libp) ;
04263 }
04264 
04265 static int G__G__TMVA3_200_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04266 {
04267       G__letint(result7, 115, (long) TMVA::MinuitWrapper::Class_Version());
04268    return(1 || funcname || hash || result7 || libp) ;
04269 }
04270 
04271 static int G__G__TMVA3_200_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04272 {
04273       TMVA::MinuitWrapper::Dictionary();
04274       G__setnull(result7);
04275    return(1 || funcname || hash || result7 || libp) ;
04276 }
04277 
04278 static int G__G__TMVA3_200_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04279 {
04280       ((TMVA::MinuitWrapper*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04281       G__setnull(result7);
04282    return(1 || funcname || hash || result7 || libp) ;
04283 }
04284 
04285 static int G__G__TMVA3_200_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04286 {
04287       G__letint(result7, 67, (long) TMVA::MinuitWrapper::DeclFileName());
04288    return(1 || funcname || hash || result7 || libp) ;
04289 }
04290 
04291 static int G__G__TMVA3_200_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04292 {
04293       G__letint(result7, 105, (long) TMVA::MinuitWrapper::ImplFileLine());
04294    return(1 || funcname || hash || result7 || libp) ;
04295 }
04296 
04297 static int G__G__TMVA3_200_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04298 {
04299       G__letint(result7, 67, (long) TMVA::MinuitWrapper::ImplFileName());
04300    return(1 || funcname || hash || result7 || libp) ;
04301 }
04302 
04303 static int G__G__TMVA3_200_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04304 {
04305       G__letint(result7, 105, (long) TMVA::MinuitWrapper::DeclFileLine());
04306    return(1 || funcname || hash || result7 || libp) ;
04307 }
04308 
04309 // automatic destructor
04310 typedef TMVA::MinuitWrapper G__TTMVAcLcLMinuitWrapper;
04311 static int G__G__TMVA3_200_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04312 {
04313    char* gvp = (char*) G__getgvp();
04314    long soff = G__getstructoffset();
04315    int n = G__getaryconstruct();
04316    //
04317    //has_a_delete: 1
04318    //has_own_delete1arg: 0
04319    //has_own_delete2arg: 0
04320    //
04321    if (!soff) {
04322      return(1);
04323    }
04324    if (n) {
04325      if (gvp == (char*)G__PVOID) {
04326        delete[] (TMVA::MinuitWrapper*) soff;
04327      } else {
04328        G__setgvp((long) G__PVOID);
04329        for (int i = n - 1; i >= 0; --i) {
04330          ((TMVA::MinuitWrapper*) (soff+(sizeof(TMVA::MinuitWrapper)*i)))->~G__TTMVAcLcLMinuitWrapper();
04331        }
04332        G__setgvp((long)gvp);
04333      }
04334    } else {
04335      if (gvp == (char*)G__PVOID) {
04336        delete (TMVA::MinuitWrapper*) soff;
04337      } else {
04338        G__setgvp((long) G__PVOID);
04339        ((TMVA::MinuitWrapper*) (soff))->~G__TTMVAcLcLMinuitWrapper();
04340        G__setgvp((long)gvp);
04341      }
04342    }
04343    G__setnull(result7);
04344    return(1 || funcname || hash || result7 || libp) ;
04345 }
04346 
04347 
04348 /* TMVA::MinuitFitter */
04349 static int G__G__TMVA3_201_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04350 {
04351       ((TMVA::MinuitFitter*) G__getstructoffset())->Init();
04352       G__setnull(result7);
04353    return(1 || funcname || hash || result7 || libp) ;
04354 }
04355 
04356 static int G__G__TMVA3_201_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04357 {
04358       G__letdouble(result7, 100, (double) ((TMVA::MinuitFitter*) G__getstructoffset())->EstimatorFunction(*(vector<Double_t>*) libp->para[0].ref));
04359    return(1 || funcname || hash || result7 || libp) ;
04360 }
04361 
04362 static int G__G__TMVA3_201_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04363 {
04364       G__letint(result7, 85, (long) TMVA::MinuitFitter::Class());
04365    return(1 || funcname || hash || result7 || libp) ;
04366 }
04367 
04368 static int G__G__TMVA3_201_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04369 {
04370       G__letint(result7, 67, (long) TMVA::MinuitFitter::Class_Name());
04371    return(1 || funcname || hash || result7 || libp) ;
04372 }
04373 
04374 static int G__G__TMVA3_201_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04375 {
04376       G__letint(result7, 115, (long) TMVA::MinuitFitter::Class_Version());
04377    return(1 || funcname || hash || result7 || libp) ;
04378 }
04379 
04380 static int G__G__TMVA3_201_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04381 {
04382       TMVA::MinuitFitter::Dictionary();
04383       G__setnull(result7);
04384    return(1 || funcname || hash || result7 || libp) ;
04385 }
04386 
04387 static int G__G__TMVA3_201_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04388 {
04389       ((TMVA::MinuitFitter*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04390       G__setnull(result7);
04391    return(1 || funcname || hash || result7 || libp) ;
04392 }
04393 
04394 static int G__G__TMVA3_201_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04395 {
04396       G__letint(result7, 67, (long) TMVA::MinuitFitter::DeclFileName());
04397    return(1 || funcname || hash || result7 || libp) ;
04398 }
04399 
04400 static int G__G__TMVA3_201_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04401 {
04402       G__letint(result7, 105, (long) TMVA::MinuitFitter::ImplFileLine());
04403    return(1 || funcname || hash || result7 || libp) ;
04404 }
04405 
04406 static int G__G__TMVA3_201_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04407 {
04408       G__letint(result7, 67, (long) TMVA::MinuitFitter::ImplFileName());
04409    return(1 || funcname || hash || result7 || libp) ;
04410 }
04411 
04412 static int G__G__TMVA3_201_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04413 {
04414       G__letint(result7, 105, (long) TMVA::MinuitFitter::DeclFileLine());
04415    return(1 || funcname || hash || result7 || libp) ;
04416 }
04417 
04418 // automatic destructor
04419 typedef TMVA::MinuitFitter G__TTMVAcLcLMinuitFitter;
04420 static int G__G__TMVA3_201_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04421 {
04422    char* gvp = (char*) G__getgvp();
04423    long soff = G__getstructoffset();
04424    int n = G__getaryconstruct();
04425    //
04426    //has_a_delete: 1
04427    //has_own_delete1arg: 0
04428    //has_own_delete2arg: 0
04429    //
04430    if (!soff) {
04431      return(1);
04432    }
04433    if (n) {
04434      if (gvp == (char*)G__PVOID) {
04435        delete[] (TMVA::MinuitFitter*) soff;
04436      } else {
04437        G__setgvp((long) G__PVOID);
04438        for (int i = n - 1; i >= 0; --i) {
04439          ((TMVA::MinuitFitter*) (soff+(sizeof(TMVA::MinuitFitter)*i)))->~G__TTMVAcLcLMinuitFitter();
04440        }
04441        G__setgvp((long)gvp);
04442      }
04443    } else {
04444      if (gvp == (char*)G__PVOID) {
04445        delete (TMVA::MinuitFitter*) soff;
04446      } else {
04447        G__setgvp((long) G__PVOID);
04448        ((TMVA::MinuitFitter*) (soff))->~G__TTMVAcLcLMinuitFitter();
04449        G__setgvp((long)gvp);
04450      }
04451    }
04452    G__setnull(result7);
04453    return(1 || funcname || hash || result7 || libp) ;
04454 }
04455 
04456 
04457 /* TMVA::PDEFoamCell */
04458 static int G__G__TMVA3_309_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04459 {
04460    TMVA::PDEFoamCell* p = NULL;
04461    char* gvp = (char*) G__getgvp();
04462    int n = G__getaryconstruct();
04463    if (n) {
04464      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04465        p = new TMVA::PDEFoamCell[n];
04466      } else {
04467        p = new((void*) gvp) TMVA::PDEFoamCell[n];
04468      }
04469    } else {
04470      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04471        p = new TMVA::PDEFoamCell;
04472      } else {
04473        p = new((void*) gvp) TMVA::PDEFoamCell;
04474      }
04475    }
04476    result7->obj.i = (long) p;
04477    result7->ref = (long) p;
04478    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell));
04479    return(1 || funcname || hash || result7 || libp) ;
04480 }
04481 
04482 static int G__G__TMVA3_309_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04483 {
04484    TMVA::PDEFoamCell* p = NULL;
04485    char* gvp = (char*) G__getgvp();
04486    //m: 1
04487    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04488      p = new TMVA::PDEFoamCell((Int_t) G__int(libp->para[0]));
04489    } else {
04490      p = new((void*) gvp) TMVA::PDEFoamCell((Int_t) G__int(libp->para[0]));
04491    }
04492    result7->obj.i = (long) p;
04493    result7->ref = (long) p;
04494    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell));
04495    return(1 || funcname || hash || result7 || libp) ;
04496 }
04497 
04498 static int G__G__TMVA3_309_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04499 {
04500    TMVA::PDEFoamCell* p = NULL;
04501    char* gvp = (char*) G__getgvp();
04502    //m: 1
04503    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04504      p = new TMVA::PDEFoamCell(*(TMVA::PDEFoamCell*) libp->para[0].ref);
04505    } else {
04506      p = new((void*) gvp) TMVA::PDEFoamCell(*(TMVA::PDEFoamCell*) libp->para[0].ref);
04507    }
04508    result7->obj.i = (long) p;
04509    result7->ref = (long) p;
04510    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell));
04511    return(1 || funcname || hash || result7 || libp) ;
04512 }
04513 
04514 static int G__G__TMVA3_309_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04515 {
04516       ((TMVA::PDEFoamCell*) G__getstructoffset())->Fill((Int_t) G__int(libp->para[0]), (TMVA::PDEFoamCell*) G__int(libp->para[1])
04517 , (TMVA::PDEFoamCell*) G__int(libp->para[2]), (TMVA::PDEFoamCell*) G__int(libp->para[3]));
04518       G__setnull(result7);
04519    return(1 || funcname || hash || result7 || libp) ;
04520 }
04521 
04522 static int G__G__TMVA3_309_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04523 {
04524       G__letdouble(result7, 100, (double) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetXdiv());
04525    return(1 || funcname || hash || result7 || libp) ;
04526 }
04527 
04528 static int G__G__TMVA3_309_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04529 {
04530       G__letint(result7, 105, (long) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetBest());
04531    return(1 || funcname || hash || result7 || libp) ;
04532 }
04533 
04534 static int G__G__TMVA3_309_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04535 {
04536       ((TMVA::PDEFoamCell*) G__getstructoffset())->SetBest((Int_t) G__int(libp->para[0]));
04537       G__setnull(result7);
04538    return(1 || funcname || hash || result7 || libp) ;
04539 }
04540 
04541 static int G__G__TMVA3_309_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04542 {
04543       ((TMVA::PDEFoamCell*) G__getstructoffset())->SetXdiv((Double_t) G__double(libp->para[0]));
04544       G__setnull(result7);
04545    return(1 || funcname || hash || result7 || libp) ;
04546 }
04547 
04548 static int G__G__TMVA3_309_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04549 {
04550       ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetHcub(*(TMVA::PDEFoamVect*) libp->para[0].ref, *(TMVA::PDEFoamVect*) libp->para[1].ref);
04551       G__setnull(result7);
04552    return(1 || funcname || hash || result7 || libp) ;
04553 }
04554 
04555 static int G__G__TMVA3_309_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04556 {
04557       ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetHSize(*(TMVA::PDEFoamVect*) libp->para[0].ref);
04558       G__setnull(result7);
04559    return(1 || funcname || hash || result7 || libp) ;
04560 }
04561 
04562 static int G__G__TMVA3_309_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04563 {
04564       ((TMVA::PDEFoamCell*) G__getstructoffset())->CalcVolume();
04565       G__setnull(result7);
04566    return(1 || funcname || hash || result7 || libp) ;
04567 }
04568 
04569 static int G__G__TMVA3_309_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04570 {
04571       G__letdouble(result7, 100, (double) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetVolume());
04572    return(1 || funcname || hash || result7 || libp) ;
04573 }
04574 
04575 static int G__G__TMVA3_309_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04576 {
04577       G__letdouble(result7, 100, (double) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetIntg());
04578    return(1 || funcname || hash || result7 || libp) ;
04579 }
04580 
04581 static int G__G__TMVA3_309_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04582 {
04583       G__letdouble(result7, 100, (double) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetDriv());
04584    return(1 || funcname || hash || result7 || libp) ;
04585 }
04586 
04587 static int G__G__TMVA3_309_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04588 {
04589       ((TMVA::PDEFoamCell*) G__getstructoffset())->SetIntg((Double_t) G__double(libp->para[0]));
04590       G__setnull(result7);
04591    return(1 || funcname || hash || result7 || libp) ;
04592 }
04593 
04594 static int G__G__TMVA3_309_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04595 {
04596       ((TMVA::PDEFoamCell*) G__getstructoffset())->SetDriv((Double_t) G__double(libp->para[0]));
04597       G__setnull(result7);
04598    return(1 || funcname || hash || result7 || libp) ;
04599 }
04600 
04601 static int G__G__TMVA3_309_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04602 {
04603       G__letint(result7, 105, (long) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetStat());
04604    return(1 || funcname || hash || result7 || libp) ;
04605 }
04606 
04607 static int G__G__TMVA3_309_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04608 {
04609       ((TMVA::PDEFoamCell*) G__getstructoffset())->SetStat((Int_t) G__int(libp->para[0]));
04610       G__setnull(result7);
04611    return(1 || funcname || hash || result7 || libp) ;
04612 }
04613 
04614 static int G__G__TMVA3_309_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04615 {
04616       G__letint(result7, 85, (long) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetPare());
04617    return(1 || funcname || hash || result7 || libp) ;
04618 }
04619 
04620 static int G__G__TMVA3_309_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04621 {
04622       G__letint(result7, 85, (long) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetDau0());
04623    return(1 || funcname || hash || result7 || libp) ;
04624 }
04625 
04626 static int G__G__TMVA3_309_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04627 {
04628       G__letint(result7, 85, (long) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetDau1());
04629    return(1 || funcname || hash || result7 || libp) ;
04630 }
04631 
04632 static int G__G__TMVA3_309_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04633 {
04634       ((TMVA::PDEFoamCell*) G__getstructoffset())->SetDau0((TMVA::PDEFoamCell*) G__int(libp->para[0]));
04635       G__setnull(result7);
04636    return(1 || funcname || hash || result7 || libp) ;
04637 }
04638 
04639 static int G__G__TMVA3_309_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04640 {
04641       ((TMVA::PDEFoamCell*) G__getstructoffset())->SetDau1((TMVA::PDEFoamCell*) G__int(libp->para[0]));
04642       G__setnull(result7);
04643    return(1 || funcname || hash || result7 || libp) ;
04644 }
04645 
04646 static int G__G__TMVA3_309_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04647 {
04648       ((TMVA::PDEFoamCell*) G__getstructoffset())->SetPare((TMVA::PDEFoamCell*) G__int(libp->para[0]));
04649       G__setnull(result7);
04650    return(1 || funcname || hash || result7 || libp) ;
04651 }
04652 
04653 static int G__G__TMVA3_309_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04654 {
04655       ((TMVA::PDEFoamCell*) G__getstructoffset())->SetSerial((Int_t) G__int(libp->para[0]));
04656       G__setnull(result7);
04657    return(1 || funcname || hash || result7 || libp) ;
04658 }
04659 
04660 static int G__G__TMVA3_309_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04661 {
04662       G__letint(result7, 105, (long) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetSerial());
04663    return(1 || funcname || hash || result7 || libp) ;
04664 }
04665 
04666 static int G__G__TMVA3_309_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04667 {
04668       G__letint(result7, 104, (long) ((TMVA::PDEFoamCell*) G__getstructoffset())->GetDepth());
04669    return(1 || funcname || hash || result7 || libp) ;
04670 }
04671 
04672 static int G__G__TMVA3_309_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04673 {
04674       ((TMVA::PDEFoamCell*) G__getstructoffset())->SetElement((TObject*) G__int(libp->para[0]));
04675       G__setnull(result7);
04676    return(1 || funcname || hash || result7 || libp) ;
04677 }
04678 
04679 static int G__G__TMVA3_309_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04680 {
04681       G__letint(result7, 85, (long) ((const TMVA::PDEFoamCell*) G__getstructoffset())->GetElement());
04682    return(1 || funcname || hash || result7 || libp) ;
04683 }
04684 
04685 static int G__G__TMVA3_309_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04686 {
04687       G__letint(result7, 85, (long) TMVA::PDEFoamCell::Class());
04688    return(1 || funcname || hash || result7 || libp) ;
04689 }
04690 
04691 static int G__G__TMVA3_309_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04692 {
04693       G__letint(result7, 67, (long) TMVA::PDEFoamCell::Class_Name());
04694    return(1 || funcname || hash || result7 || libp) ;
04695 }
04696 
04697 static int G__G__TMVA3_309_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04698 {
04699       G__letint(result7, 115, (long) TMVA::PDEFoamCell::Class_Version());
04700    return(1 || funcname || hash || result7 || libp) ;
04701 }
04702 
04703 static int G__G__TMVA3_309_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04704 {
04705       TMVA::PDEFoamCell::Dictionary();
04706       G__setnull(result7);
04707    return(1 || funcname || hash || result7 || libp) ;
04708 }
04709 
04710 static int G__G__TMVA3_309_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04711 {
04712       ((TMVA::PDEFoamCell*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04713       G__setnull(result7);
04714    return(1 || funcname || hash || result7 || libp) ;
04715 }
04716 
04717 static int G__G__TMVA3_309_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04718 {
04719       G__letint(result7, 67, (long) TMVA::PDEFoamCell::DeclFileName());
04720    return(1 || funcname || hash || result7 || libp) ;
04721 }
04722 
04723 static int G__G__TMVA3_309_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04724 {
04725       G__letint(result7, 105, (long) TMVA::PDEFoamCell::ImplFileLine());
04726    return(1 || funcname || hash || result7 || libp) ;
04727 }
04728 
04729 static int G__G__TMVA3_309_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04730 {
04731       G__letint(result7, 67, (long) TMVA::PDEFoamCell::ImplFileName());
04732    return(1 || funcname || hash || result7 || libp) ;
04733 }
04734 
04735 static int G__G__TMVA3_309_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04736 {
04737       G__letint(result7, 105, (long) TMVA::PDEFoamCell::DeclFileLine());
04738    return(1 || funcname || hash || result7 || libp) ;
04739 }
04740 
04741 // automatic destructor
04742 typedef TMVA::PDEFoamCell G__TTMVAcLcLPDEFoamCell;
04743 static int G__G__TMVA3_309_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04744 {
04745    char* gvp = (char*) G__getgvp();
04746    long soff = G__getstructoffset();
04747    int n = G__getaryconstruct();
04748    //
04749    //has_a_delete: 1
04750    //has_own_delete1arg: 0
04751    //has_own_delete2arg: 0
04752    //
04753    if (!soff) {
04754      return(1);
04755    }
04756    if (n) {
04757      if (gvp == (char*)G__PVOID) {
04758        delete[] (TMVA::PDEFoamCell*) soff;
04759      } else {
04760        G__setgvp((long) G__PVOID);
04761        for (int i = n - 1; i >= 0; --i) {
04762          ((TMVA::PDEFoamCell*) (soff+(sizeof(TMVA::PDEFoamCell)*i)))->~G__TTMVAcLcLPDEFoamCell();
04763        }
04764        G__setgvp((long)gvp);
04765      }
04766    } else {
04767      if (gvp == (char*)G__PVOID) {
04768        delete (TMVA::PDEFoamCell*) soff;
04769      } else {
04770        G__setgvp((long) G__PVOID);
04771        ((TMVA::PDEFoamCell*) (soff))->~G__TTMVAcLcLPDEFoamCell();
04772        G__setgvp((long)gvp);
04773      }
04774    }
04775    G__setnull(result7);
04776    return(1 || funcname || hash || result7 || libp) ;
04777 }
04778 
04779 // automatic assignment operator
04780 static int G__G__TMVA3_309_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04781 {
04782    TMVA::PDEFoamCell* dest = (TMVA::PDEFoamCell*) G__getstructoffset();
04783    *dest = *(TMVA::PDEFoamCell*) libp->para[0].ref;
04784    const TMVA::PDEFoamCell& obj = *dest;
04785    result7->ref = (long) (&obj);
04786    result7->obj.i = (long) (&obj);
04787    return(1 || funcname || hash || result7 || libp) ;
04788 }
04789 
04790 
04791 /* TMVA::PDEFoamVect */
04792 static int G__G__TMVA3_310_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04793 {
04794    TMVA::PDEFoamVect* p = NULL;
04795    char* gvp = (char*) G__getgvp();
04796    int n = G__getaryconstruct();
04797    if (n) {
04798      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04799        p = new TMVA::PDEFoamVect[n];
04800      } else {
04801        p = new((void*) gvp) TMVA::PDEFoamVect[n];
04802      }
04803    } else {
04804      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04805        p = new TMVA::PDEFoamVect;
04806      } else {
04807        p = new((void*) gvp) TMVA::PDEFoamVect;
04808      }
04809    }
04810    result7->obj.i = (long) p;
04811    result7->ref = (long) p;
04812    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect));
04813    return(1 || funcname || hash || result7 || libp) ;
04814 }
04815 
04816 static int G__G__TMVA3_310_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04817 {
04818    TMVA::PDEFoamVect* p = NULL;
04819    char* gvp = (char*) G__getgvp();
04820    //m: 1
04821    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04822      p = new TMVA::PDEFoamVect((Int_t) G__int(libp->para[0]));
04823    } else {
04824      p = new((void*) gvp) TMVA::PDEFoamVect((Int_t) G__int(libp->para[0]));
04825    }
04826    result7->obj.i = (long) p;
04827    result7->ref = (long) p;
04828    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect));
04829    return(1 || funcname || hash || result7 || libp) ;
04830 }
04831 
04832 static int G__G__TMVA3_310_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04833 {
04834    TMVA::PDEFoamVect* p = NULL;
04835    char* gvp = (char*) G__getgvp();
04836    //m: 1
04837    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04838      p = new TMVA::PDEFoamVect(*(TMVA::PDEFoamVect*) libp->para[0].ref);
04839    } else {
04840      p = new((void*) gvp) TMVA::PDEFoamVect(*(TMVA::PDEFoamVect*) libp->para[0].ref);
04841    }
04842    result7->obj.i = (long) p;
04843    result7->ref = (long) p;
04844    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect));
04845    return(1 || funcname || hash || result7 || libp) ;
04846 }
04847 
04848 static int G__G__TMVA3_310_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04849 {
04850       {
04851          const TMVA::PDEFoamVect& obj = ((TMVA::PDEFoamVect*) G__getstructoffset())->operator=(*(TMVA::PDEFoamVect*) libp->para[0].ref);
04852          result7->ref = (long) (&obj);
04853          result7->obj.i = (long) (&obj);
04854       }
04855    return(1 || funcname || hash || result7 || libp) ;
04856 }
04857 
04858 static int G__G__TMVA3_310_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04859 {
04860       {
04861          const Double_t& obj = ((TMVA::PDEFoamVect*) G__getstructoffset())->operator[]((Int_t) G__int(libp->para[0]));
04862          result7->ref = (long) (&obj);
04863          result7->obj.d = (double) (obj);
04864       }
04865    return(1 || funcname || hash || result7 || libp) ;
04866 }
04867 
04868 static int G__G__TMVA3_310_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04869 {
04870       {
04871          const TMVA::PDEFoamVect& obj = ((TMVA::PDEFoamVect*) G__getstructoffset())->operator=((Double_t*) G__int(libp->para[0]));
04872          result7->ref = (long) (&obj);
04873          result7->obj.i = (long) (&obj);
04874       }
04875    return(1 || funcname || hash || result7 || libp) ;
04876 }
04877 
04878 static int G__G__TMVA3_310_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04879 {
04880       {
04881          const TMVA::PDEFoamVect& obj = ((TMVA::PDEFoamVect*) G__getstructoffset())->operator=((Double_t) G__double(libp->para[0]));
04882          result7->ref = (long) (&obj);
04883          result7->obj.i = (long) (&obj);
04884       }
04885    return(1 || funcname || hash || result7 || libp) ;
04886 }
04887 
04888 static int G__G__TMVA3_310_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04889 {
04890       {
04891          const TMVA::PDEFoamVect& obj = ((TMVA::PDEFoamVect*) G__getstructoffset())->operator+=(*(TMVA::PDEFoamVect*) libp->para[0].ref);
04892          result7->ref = (long) (&obj);
04893          result7->obj.i = (long) (&obj);
04894       }
04895    return(1 || funcname || hash || result7 || libp) ;
04896 }
04897 
04898 static int G__G__TMVA3_310_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04899 {
04900       {
04901          const TMVA::PDEFoamVect& obj = ((TMVA::PDEFoamVect*) G__getstructoffset())->operator-=(*(TMVA::PDEFoamVect*) libp->para[0].ref);
04902          result7->ref = (long) (&obj);
04903          result7->obj.i = (long) (&obj);
04904       }
04905    return(1 || funcname || hash || result7 || libp) ;
04906 }
04907 
04908 static int G__G__TMVA3_310_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04909 {
04910       {
04911          const TMVA::PDEFoamVect& obj = ((TMVA::PDEFoamVect*) G__getstructoffset())->operator*=(*(Double_t*) G__Doubleref(&libp->para[0]));
04912          result7->ref = (long) (&obj);
04913          result7->obj.i = (long) (&obj);
04914       }
04915    return(1 || funcname || hash || result7 || libp) ;
04916 }
04917 
04918 static int G__G__TMVA3_310_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04919 {
04920       {
04921          TMVA::PDEFoamVect* pobj;
04922          TMVA::PDEFoamVect xobj = ((TMVA::PDEFoamVect*) G__getstructoffset())->operator+(*(TMVA::PDEFoamVect*) libp->para[0].ref);
04923          pobj = new TMVA::PDEFoamVect(xobj);
04924          result7->obj.i = (long) ((void*) pobj);
04925          result7->ref = result7->obj.i;
04926          G__store_tempobject(*result7);
04927       }
04928    return(1 || funcname || hash || result7 || libp) ;
04929 }
04930 
04931 static int G__G__TMVA3_310_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04932 {
04933       {
04934          TMVA::PDEFoamVect* pobj;
04935          TMVA::PDEFoamVect xobj = ((TMVA::PDEFoamVect*) G__getstructoffset())->operator-(*(TMVA::PDEFoamVect*) libp->para[0].ref);
04936          pobj = new TMVA::PDEFoamVect(xobj);
04937          result7->obj.i = (long) ((void*) pobj);
04938          result7->ref = result7->obj.i;
04939          G__store_tempobject(*result7);
04940       }
04941    return(1 || funcname || hash || result7 || libp) ;
04942 }
04943 
04944 static int G__G__TMVA3_310_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04945 {
04946       G__letint(result7, 105, (long) ((const TMVA::PDEFoamVect*) G__getstructoffset())->GetDim());
04947    return(1 || funcname || hash || result7 || libp) ;
04948 }
04949 
04950 static int G__G__TMVA3_310_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04951 {
04952       G__letdouble(result7, 100, (double) ((const TMVA::PDEFoamVect*) G__getstructoffset())->GetCoord((Int_t) G__int(libp->para[0])));
04953    return(1 || funcname || hash || result7 || libp) ;
04954 }
04955 
04956 static int G__G__TMVA3_310_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04957 {
04958       G__letint(result7, 85, (long) TMVA::PDEFoamVect::Class());
04959    return(1 || funcname || hash || result7 || libp) ;
04960 }
04961 
04962 static int G__G__TMVA3_310_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04963 {
04964       G__letint(result7, 67, (long) TMVA::PDEFoamVect::Class_Name());
04965    return(1 || funcname || hash || result7 || libp) ;
04966 }
04967 
04968 static int G__G__TMVA3_310_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04969 {
04970       G__letint(result7, 115, (long) TMVA::PDEFoamVect::Class_Version());
04971    return(1 || funcname || hash || result7 || libp) ;
04972 }
04973 
04974 static int G__G__TMVA3_310_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04975 {
04976       TMVA::PDEFoamVect::Dictionary();
04977       G__setnull(result7);
04978    return(1 || funcname || hash || result7 || libp) ;
04979 }
04980 
04981 static int G__G__TMVA3_310_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04982 {
04983       ((TMVA::PDEFoamVect*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
04984       G__setnull(result7);
04985    return(1 || funcname || hash || result7 || libp) ;
04986 }
04987 
04988 static int G__G__TMVA3_310_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04989 {
04990       G__letint(result7, 67, (long) TMVA::PDEFoamVect::DeclFileName());
04991    return(1 || funcname || hash || result7 || libp) ;
04992 }
04993 
04994 static int G__G__TMVA3_310_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04995 {
04996       G__letint(result7, 105, (long) TMVA::PDEFoamVect::ImplFileLine());
04997    return(1 || funcname || hash || result7 || libp) ;
04998 }
04999 
05000 static int G__G__TMVA3_310_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05001 {
05002       G__letint(result7, 67, (long) TMVA::PDEFoamVect::ImplFileName());
05003    return(1 || funcname || hash || result7 || libp) ;
05004 }
05005 
05006 static int G__G__TMVA3_310_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05007 {
05008       G__letint(result7, 105, (long) TMVA::PDEFoamVect::DeclFileLine());
05009    return(1 || funcname || hash || result7 || libp) ;
05010 }
05011 
05012 // automatic destructor
05013 typedef TMVA::PDEFoamVect G__TTMVAcLcLPDEFoamVect;
05014 static int G__G__TMVA3_310_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05015 {
05016    char* gvp = (char*) G__getgvp();
05017    long soff = G__getstructoffset();
05018    int n = G__getaryconstruct();
05019    //
05020    //has_a_delete: 1
05021    //has_own_delete1arg: 0
05022    //has_own_delete2arg: 0
05023    //
05024    if (!soff) {
05025      return(1);
05026    }
05027    if (n) {
05028      if (gvp == (char*)G__PVOID) {
05029        delete[] (TMVA::PDEFoamVect*) soff;
05030      } else {
05031        G__setgvp((long) G__PVOID);
05032        for (int i = n - 1; i >= 0; --i) {
05033          ((TMVA::PDEFoamVect*) (soff+(sizeof(TMVA::PDEFoamVect)*i)))->~G__TTMVAcLcLPDEFoamVect();
05034        }
05035        G__setgvp((long)gvp);
05036      }
05037    } else {
05038      if (gvp == (char*)G__PVOID) {
05039        delete (TMVA::PDEFoamVect*) soff;
05040      } else {
05041        G__setgvp((long) G__PVOID);
05042        ((TMVA::PDEFoamVect*) (soff))->~G__TTMVAcLcLPDEFoamVect();
05043        G__setgvp((long)gvp);
05044      }
05045    }
05046    G__setnull(result7);
05047    return(1 || funcname || hash || result7 || libp) ;
05048 }
05049 
05050 
05051 /* TMVA::PDEFoamDistr */
05052 static int G__G__TMVA3_311_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05053 {
05054    TMVA::PDEFoamDistr* p = NULL;
05055    char* gvp = (char*) G__getgvp();
05056    int n = G__getaryconstruct();
05057    if (n) {
05058      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05059        p = new TMVA::PDEFoamDistr[n];
05060      } else {
05061        p = new((void*) gvp) TMVA::PDEFoamDistr[n];
05062      }
05063    } else {
05064      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05065        p = new TMVA::PDEFoamDistr;
05066      } else {
05067        p = new((void*) gvp) TMVA::PDEFoamDistr;
05068      }
05069    }
05070    result7->obj.i = (long) p;
05071    result7->ref = (long) p;
05072    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDistr));
05073    return(1 || funcname || hash || result7 || libp) ;
05074 }
05075 
05076 static int G__G__TMVA3_311_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05077 {
05078    TMVA::PDEFoamDistr* p = NULL;
05079    char* gvp = (char*) G__getgvp();
05080    //m: 1
05081    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05082      p = new TMVA::PDEFoamDistr(*(TMVA::PDEFoamDistr*) libp->para[0].ref);
05083    } else {
05084      p = new((void*) gvp) TMVA::PDEFoamDistr(*(TMVA::PDEFoamDistr*) libp->para[0].ref);
05085    }
05086    result7->obj.i = (long) p;
05087    result7->ref = (long) p;
05088    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDistr));
05089    return(1 || funcname || hash || result7 || libp) ;
05090 }
05091 
05092 static int G__G__TMVA3_311_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05093 {
05094       ((TMVA::PDEFoamDistr*) G__getstructoffset())->Initialize();
05095       G__setnull(result7);
05096    return(1 || funcname || hash || result7 || libp) ;
05097 }
05098 
05099 static int G__G__TMVA3_311_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05100 {
05101    switch (libp->paran) {
05102    case 3:
05103       ((TMVA::PDEFoamDistr*) G__getstructoffset())->FillBinarySearchTree((TMVA::Event*) G__int(libp->para[0]), (TMVA::EFoamType) G__int(libp->para[1])
05104 , (Bool_t) G__int(libp->para[2]));
05105       G__setnull(result7);
05106       break;
05107    case 2:
05108       ((TMVA::PDEFoamDistr*) G__getstructoffset())->FillBinarySearchTree((TMVA::Event*) G__int(libp->para[0]), (TMVA::EFoamType) G__int(libp->para[1]));
05109       G__setnull(result7);
05110       break;
05111    }
05112    return(1 || funcname || hash || result7 || libp) ;
05113 }
05114 
05115 static int G__G__TMVA3_311_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05116 {
05117       G__letdouble(result7, 100, (double) ((TMVA::PDEFoamDistr*) G__getstructoffset())->Density((Double_t*) G__int(libp->para[0]), *(Double_t*) G__Doubleref(&libp->para[1])));
05118    return(1 || funcname || hash || result7 || libp) ;
05119 }
05120 
05121 static int G__G__TMVA3_311_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05122 {
05123       ((TMVA::PDEFoamDistr*) G__getstructoffset())->FillHist((TMVA::PDEFoamCell*) G__int(libp->para[0]), *(vector<TH1F*>*) libp->para[1].ref
05124 , *(vector<TH1F*>*) libp->para[2].ref, *(vector<TH1F*>*) libp->para[3].ref
05125 , *(vector<TH1F*>*) libp->para[4].ref);
05126       G__setnull(result7);
05127    return(1 || funcname || hash || result7 || libp) ;
05128 }
05129 
05130 static int G__G__TMVA3_311_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05131 {
05132       ((TMVA::PDEFoamDistr*) G__getstructoffset())->SetPDEFoam((TMVA::PDEFoam*) G__int(libp->para[0]));
05133       G__setnull(result7);
05134    return(1 || funcname || hash || result7 || libp) ;
05135 }
05136 
05137 static int G__G__TMVA3_311_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05138 {
05139       G__letint(result7, 85, (long) ((const TMVA::PDEFoamDistr*) G__getstructoffset())->GetPDEFoam());
05140    return(1 || funcname || hash || result7 || libp) ;
05141 }
05142 
05143 static int G__G__TMVA3_311_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05144 {
05145       ((TMVA::PDEFoamDistr*) G__getstructoffset())->SetDensityCalc((TMVA::TDensityCalc) G__int(libp->para[0]));
05146       G__setnull(result7);
05147    return(1 || funcname || hash || result7 || libp) ;
05148 }
05149 
05150 static int G__G__TMVA3_311_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05151 {
05152       G__letint(result7, 103, (long) ((TMVA::PDEFoamDistr*) G__getstructoffset())->FillDiscriminator());
05153    return(1 || funcname || hash || result7 || libp) ;
05154 }
05155 
05156 static int G__G__TMVA3_311_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05157 {
05158       G__letint(result7, 103, (long) ((TMVA::PDEFoamDistr*) G__getstructoffset())->FillTarget0());
05159    return(1 || funcname || hash || result7 || libp) ;
05160 }
05161 
05162 static int G__G__TMVA3_311_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05163 {
05164       G__letint(result7, 103, (long) ((TMVA::PDEFoamDistr*) G__getstructoffset())->FillEventDensity());
05165    return(1 || funcname || hash || result7 || libp) ;
05166 }
05167 
05168 static int G__G__TMVA3_311_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05169 {
05170       G__letint(result7, 85, (long) TMVA::PDEFoamDistr::Class());
05171    return(1 || funcname || hash || result7 || libp) ;
05172 }
05173 
05174 static int G__G__TMVA3_311_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05175 {
05176       G__letint(result7, 67, (long) TMVA::PDEFoamDistr::Class_Name());
05177    return(1 || funcname || hash || result7 || libp) ;
05178 }
05179 
05180 static int G__G__TMVA3_311_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05181 {
05182       G__letint(result7, 115, (long) TMVA::PDEFoamDistr::Class_Version());
05183    return(1 || funcname || hash || result7 || libp) ;
05184 }
05185 
05186 static int G__G__TMVA3_311_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05187 {
05188       TMVA::PDEFoamDistr::Dictionary();
05189       G__setnull(result7);
05190    return(1 || funcname || hash || result7 || libp) ;
05191 }
05192 
05193 static int G__G__TMVA3_311_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05194 {
05195       ((TMVA::PDEFoamDistr*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05196       G__setnull(result7);
05197    return(1 || funcname || hash || result7 || libp) ;
05198 }
05199 
05200 static int G__G__TMVA3_311_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05201 {
05202       G__letint(result7, 67, (long) TMVA::PDEFoamDistr::DeclFileName());
05203    return(1 || funcname || hash || result7 || libp) ;
05204 }
05205 
05206 static int G__G__TMVA3_311_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05207 {
05208       G__letint(result7, 105, (long) TMVA::PDEFoamDistr::ImplFileLine());
05209    return(1 || funcname || hash || result7 || libp) ;
05210 }
05211 
05212 static int G__G__TMVA3_311_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05213 {
05214       G__letint(result7, 67, (long) TMVA::PDEFoamDistr::ImplFileName());
05215    return(1 || funcname || hash || result7 || libp) ;
05216 }
05217 
05218 static int G__G__TMVA3_311_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05219 {
05220       G__letint(result7, 105, (long) TMVA::PDEFoamDistr::DeclFileLine());
05221    return(1 || funcname || hash || result7 || libp) ;
05222 }
05223 
05224 // automatic destructor
05225 typedef TMVA::PDEFoamDistr G__TTMVAcLcLPDEFoamDistr;
05226 static int G__G__TMVA3_311_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05227 {
05228    char* gvp = (char*) G__getgvp();
05229    long soff = G__getstructoffset();
05230    int n = G__getaryconstruct();
05231    //
05232    //has_a_delete: 1
05233    //has_own_delete1arg: 0
05234    //has_own_delete2arg: 0
05235    //
05236    if (!soff) {
05237      return(1);
05238    }
05239    if (n) {
05240      if (gvp == (char*)G__PVOID) {
05241        delete[] (TMVA::PDEFoamDistr*) soff;
05242      } else {
05243        G__setgvp((long) G__PVOID);
05244        for (int i = n - 1; i >= 0; --i) {
05245          ((TMVA::PDEFoamDistr*) (soff+(sizeof(TMVA::PDEFoamDistr)*i)))->~G__TTMVAcLcLPDEFoamDistr();
05246        }
05247        G__setgvp((long)gvp);
05248      }
05249    } else {
05250      if (gvp == (char*)G__PVOID) {
05251        delete (TMVA::PDEFoamDistr*) soff;
05252      } else {
05253        G__setgvp((long) G__PVOID);
05254        ((TMVA::PDEFoamDistr*) (soff))->~G__TTMVAcLcLPDEFoamDistr();
05255        G__setgvp((long)gvp);
05256      }
05257    }
05258    G__setnull(result7);
05259    return(1 || funcname || hash || result7 || libp) ;
05260 }
05261 
05262 
05263 /* TMVA::PDEFoam */
05264 static int G__G__TMVA3_312_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05265 {
05266    TMVA::PDEFoam* p = NULL;
05267    char* gvp = (char*) G__getgvp();
05268    int n = G__getaryconstruct();
05269    if (n) {
05270      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05271        p = new TMVA::PDEFoam[n];
05272      } else {
05273        p = new((void*) gvp) TMVA::PDEFoam[n];
05274      }
05275    } else {
05276      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05277        p = new TMVA::PDEFoam;
05278      } else {
05279        p = new((void*) gvp) TMVA::PDEFoam;
05280      }
05281    }
05282    result7->obj.i = (long) p;
05283    result7->ref = (long) p;
05284    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam));
05285    return(1 || funcname || hash || result7 || libp) ;
05286 }
05287 
05288 static int G__G__TMVA3_312_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05289 {
05290    TMVA::PDEFoam* p = NULL;
05291    char* gvp = (char*) G__getgvp();
05292    //m: 1
05293    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05294      p = new TMVA::PDEFoam(*(TString*) libp->para[0].ref);
05295    } else {
05296      p = new((void*) gvp) TMVA::PDEFoam(*(TString*) libp->para[0].ref);
05297    }
05298    result7->obj.i = (long) p;
05299    result7->ref = (long) p;
05300    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam));
05301    return(1 || funcname || hash || result7 || libp) ;
05302 }
05303 
05304 static int G__G__TMVA3_312_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05305 {
05306       ((TMVA::PDEFoam*) G__getstructoffset())->Init();
05307       G__setnull(result7);
05308    return(1 || funcname || hash || result7 || libp) ;
05309 }
05310 
05311 static int G__G__TMVA3_312_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05312 {
05313    switch (libp->paran) {
05314    case 2:
05315       ((TMVA::PDEFoam*) G__getstructoffset())->FillBinarySearchTree((TMVA::Event*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
05316       G__setnull(result7);
05317       break;
05318    case 1:
05319       ((TMVA::PDEFoam*) G__getstructoffset())->FillBinarySearchTree((TMVA::Event*) G__int(libp->para[0]));
05320       G__setnull(result7);
05321       break;
05322    }
05323    return(1 || funcname || hash || result7 || libp) ;
05324 }
05325 
05326 static int G__G__TMVA3_312_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05327 {
05328       ((TMVA::PDEFoam*) G__getstructoffset())->Create();
05329       G__setnull(result7);
05330    return(1 || funcname || hash || result7 || libp) ;
05331 }
05332 
05333 static int G__G__TMVA3_312_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05334 {
05335    switch (libp->paran) {
05336    case 2:
05337       ((TMVA::PDEFoam*) G__getstructoffset())->FillFoamCells((TMVA::Event*) G__int(libp->para[0]), (Bool_t) G__int(libp->para[1]));
05338       G__setnull(result7);
05339       break;
05340    case 1:
05341       ((TMVA::PDEFoam*) G__getstructoffset())->FillFoamCells((TMVA::Event*) G__int(libp->para[0]));
05342       G__setnull(result7);
05343       break;
05344    }
05345    return(1 || funcname || hash || result7 || libp) ;
05346 }
05347 
05348 static int G__G__TMVA3_312_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05349 {
05350       ((TMVA::PDEFoam*) G__getstructoffset())->CalcCellDiscr();
05351       G__setnull(result7);
05352    return(1 || funcname || hash || result7 || libp) ;
05353 }
05354 
05355 static int G__G__TMVA3_312_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05356 {
05357       ((TMVA::PDEFoam*) G__getstructoffset())->CalcCellTarget();
05358       G__setnull(result7);
05359    return(1 || funcname || hash || result7 || libp) ;
05360 }
05361 
05362 static int G__G__TMVA3_312_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05363 {
05364    switch (libp->paran) {
05365    case 1:
05366       ((TMVA::PDEFoam*) G__getstructoffset())->ResetCellElements((Bool_t) G__int(libp->para[0]));
05367       G__setnull(result7);
05368       break;
05369    case 0:
05370       ((TMVA::PDEFoam*) G__getstructoffset())->ResetCellElements();
05371       G__setnull(result7);
05372       break;
05373    }
05374    return(1 || funcname || hash || result7 || libp) ;
05375 }
05376 
05377 static int G__G__TMVA3_312_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05378 {
05379       ((TMVA::PDEFoam*) G__getstructoffset())->SetDim((Int_t) G__int(libp->para[0]));
05380       G__setnull(result7);
05381    return(1 || funcname || hash || result7 || libp) ;
05382 }
05383 
05384 static int G__G__TMVA3_312_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05385 {
05386       ((TMVA::PDEFoam*) G__getstructoffset())->SetnCells((Long_t) G__int(libp->para[0]));
05387       G__setnull(result7);
05388    return(1 || funcname || hash || result7 || libp) ;
05389 }
05390 
05391 static int G__G__TMVA3_312_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05392 {
05393       ((TMVA::PDEFoam*) G__getstructoffset())->SetnSampl((Long_t) G__int(libp->para[0]));
05394       G__setnull(result7);
05395    return(1 || funcname || hash || result7 || libp) ;
05396 }
05397 
05398 static int G__G__TMVA3_312_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05399 {
05400       ((TMVA::PDEFoam*) G__getstructoffset())->SetnBin((Int_t) G__int(libp->para[0]));
05401       G__setnull(result7);
05402    return(1 || funcname || hash || result7 || libp) ;
05403 }
05404 
05405 static int G__G__TMVA3_312_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05406 {
05407       ((TMVA::PDEFoam*) G__getstructoffset())->SetEvPerBin((Int_t) G__int(libp->para[0]));
05408       G__setnull(result7);
05409    return(1 || funcname || hash || result7 || libp) ;
05410 }
05411 
05412 static int G__G__TMVA3_312_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05413 {
05414       ((TMVA::PDEFoam*) G__getstructoffset())->SetInhiDiv((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1]));
05415       G__setnull(result7);
05416    return(1 || funcname || hash || result7 || libp) ;
05417 }
05418 
05419 static int G__G__TMVA3_312_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05420 {
05421       ((TMVA::PDEFoam*) G__getstructoffset())->SetNElements((UInt_t) G__int(libp->para[0]));
05422       G__setnull(result7);
05423    return(1 || funcname || hash || result7 || libp) ;
05424 }
05425 
05426 static int G__G__TMVA3_312_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05427 {
05428       ((TMVA::PDEFoam*) G__getstructoffset())->SetVolumeFraction((Float_t) G__double(libp->para[0]));
05429       G__setnull(result7);
05430    return(1 || funcname || hash || result7 || libp) ;
05431 }
05432 
05433 static int G__G__TMVA3_312_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05434 {
05435       ((TMVA::PDEFoam*) G__getstructoffset())->SetFoamType((TMVA::EFoamType) G__int(libp->para[0]));
05436       G__setnull(result7);
05437    return(1 || funcname || hash || result7 || libp) ;
05438 }
05439 
05440 static int G__G__TMVA3_312_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05441 {
05442       ((TMVA::PDEFoam*) G__getstructoffset())->SetFillFoamWithOrigWeights((Bool_t) G__int(libp->para[0]));
05443       G__setnull(result7);
05444    return(1 || funcname || hash || result7 || libp) ;
05445 }
05446 
05447 static int G__G__TMVA3_312_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05448 {
05449       ((TMVA::PDEFoam*) G__getstructoffset())->SetDTSeparation((TMVA::EDTSeparation) G__int(libp->para[0]));
05450       G__setnull(result7);
05451    return(1 || funcname || hash || result7 || libp) ;
05452 }
05453 
05454 static int G__G__TMVA3_312_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05455 {
05456       ((TMVA::PDEFoam*) G__getstructoffset())->SetPeekMax((Bool_t) G__int(libp->para[0]));
05457       G__setnull(result7);
05458    return(1 || funcname || hash || result7 || libp) ;
05459 }
05460 
05461 static int G__G__TMVA3_312_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05462 {
05463       G__letint(result7, 105, (long) ((const TMVA::PDEFoam*) G__getstructoffset())->GetTotDim());
05464    return(1 || funcname || hash || result7 || libp) ;
05465 }
05466 
05467 static int G__G__TMVA3_312_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05468 {
05469       {
05470          const TString* pobj;
05471          const TString xobj = ((const TMVA::PDEFoam*) G__getstructoffset())->GetFoamName();
05472          pobj = new TString(xobj);
05473          result7->obj.i = (long) ((void*) pobj);
05474          result7->ref = result7->obj.i;
05475          G__store_tempobject(*result7);
05476       }
05477    return(1 || funcname || hash || result7 || libp) ;
05478 }
05479 
05480 static int G__G__TMVA3_312_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05481 {
05482       G__letint(result7, 104, (long) ((const TMVA::PDEFoam*) G__getstructoffset())->GetNElements());
05483    return(1 || funcname || hash || result7 || libp) ;
05484 }
05485 
05486 static int G__G__TMVA3_312_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05487 {
05488       G__letdouble(result7, 102, (double) ((const TMVA::PDEFoam*) G__getstructoffset())->GetVolumeFraction());
05489    return(1 || funcname || hash || result7 || libp) ;
05490 }
05491 
05492 static int G__G__TMVA3_312_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05493 {
05494       G__letint(result7, 105, (long) ((const TMVA::PDEFoam*) G__getstructoffset())->GetFoamType());
05495    return(1 || funcname || hash || result7 || libp) ;
05496 }
05497 
05498 static int G__G__TMVA3_312_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05499 {
05500       G__letint(result7, 104, (long) ((const TMVA::PDEFoam*) G__getstructoffset())->GetNActiveCells());
05501    return(1 || funcname || hash || result7 || libp) ;
05502 }
05503 
05504 static int G__G__TMVA3_312_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05505 {
05506       G__letint(result7, 104, (long) ((const TMVA::PDEFoam*) G__getstructoffset())->GetNInActiveCells());
05507    return(1 || funcname || hash || result7 || libp) ;
05508 }
05509 
05510 static int G__G__TMVA3_312_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05511 {
05512       G__letint(result7, 104, (long) ((const TMVA::PDEFoam*) G__getstructoffset())->GetNCells());
05513    return(1 || funcname || hash || result7 || libp) ;
05514 }
05515 
05516 static int G__G__TMVA3_312_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05517 {
05518       G__letint(result7, 85, (long) ((const TMVA::PDEFoam*) G__getstructoffset())->GetRootCell());
05519    return(1 || funcname || hash || result7 || libp) ;
05520 }
05521 
05522 static int G__G__TMVA3_312_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05523 {
05524       ((TMVA::PDEFoam*) G__getstructoffset())->SetNmin((UInt_t) G__int(libp->para[0]));
05525       G__setnull(result7);
05526    return(1 || funcname || hash || result7 || libp) ;
05527 }
05528 
05529 static int G__G__TMVA3_312_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05530 {
05531       G__letint(result7, 104, (long) ((TMVA::PDEFoam*) G__getstructoffset())->GetNmin());
05532    return(1 || funcname || hash || result7 || libp) ;
05533 }
05534 
05535 static int G__G__TMVA3_312_0_59(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05536 {
05537       G__letint(result7, 103, (long) ((const TMVA::PDEFoam*) G__getstructoffset())->GetFillFoamWithOrigWeights());
05538    return(1 || funcname || hash || result7 || libp) ;
05539 }
05540 
05541 static int G__G__TMVA3_312_0_60(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05542 {
05543       ((TMVA::PDEFoam*) G__getstructoffset())->SetMaxDepth((UInt_t) G__int(libp->para[0]));
05544       G__setnull(result7);
05545    return(1 || funcname || hash || result7 || libp) ;
05546 }
05547 
05548 static int G__G__TMVA3_312_0_61(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05549 {
05550       G__letint(result7, 104, (long) ((const TMVA::PDEFoam*) G__getstructoffset())->GetMaxDepth());
05551    return(1 || funcname || hash || result7 || libp) ;
05552 }
05553 
05554 static int G__G__TMVA3_312_0_62(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05555 {
05556       ((TMVA::PDEFoam*) G__getstructoffset())->SetXmin((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
05557       G__setnull(result7);
05558    return(1 || funcname || hash || result7 || libp) ;
05559 }
05560 
05561 static int G__G__TMVA3_312_0_63(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05562 {
05563       ((TMVA::PDEFoam*) G__getstructoffset())->SetXmax((Int_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
05564       G__setnull(result7);
05565    return(1 || funcname || hash || result7 || libp) ;
05566 }
05567 
05568 static int G__G__TMVA3_312_0_64(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05569 {
05570       G__letdouble(result7, 100, (double) ((const TMVA::PDEFoam*) G__getstructoffset())->GetXmin((Int_t) G__int(libp->para[0])));
05571    return(1 || funcname || hash || result7 || libp) ;
05572 }
05573 
05574 static int G__G__TMVA3_312_0_65(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05575 {
05576       G__letdouble(result7, 100, (double) ((const TMVA::PDEFoam*) G__getstructoffset())->GetXmax((Int_t) G__int(libp->para[0])));
05577    return(1 || funcname || hash || result7 || libp) ;
05578 }
05579 
05580 static int G__G__TMVA3_312_0_66(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05581 {
05582       ((TMVA::PDEFoam*) G__getstructoffset())->AddVariableName((const char*) G__int(libp->para[0]));
05583       G__setnull(result7);
05584    return(1 || funcname || hash || result7 || libp) ;
05585 }
05586 
05587 static int G__G__TMVA3_312_0_67(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05588 {
05589       ((TMVA::PDEFoam*) G__getstructoffset())->AddVariableName((TObjString*) G__int(libp->para[0]));
05590       G__setnull(result7);
05591    return(1 || funcname || hash || result7 || libp) ;
05592 }
05593 
05594 static int G__G__TMVA3_312_0_68(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05595 {
05596       G__letint(result7, 85, (long) ((TMVA::PDEFoam*) G__getstructoffset())->GetVariableName((Int_t) G__int(libp->para[0])));
05597    return(1 || funcname || hash || result7 || libp) ;
05598 }
05599 
05600 static int G__G__TMVA3_312_0_69(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05601 {
05602       ((TMVA::PDEFoam*) G__getstructoffset())->DeleteBinarySearchTree();
05603       G__setnull(result7);
05604    return(1 || funcname || hash || result7 || libp) ;
05605 }
05606 
05607 static int G__G__TMVA3_312_0_70(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05608 {
05609       G__letdouble(result7, 102, (double) ((const TMVA::PDEFoam*) G__getstructoffset())->VarTransform((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])));
05610    return(1 || funcname || hash || result7 || libp) ;
05611 }
05612 
05613 static int G__G__TMVA3_312_0_71(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05614 {
05615       {
05616          const vector<Float_t>* pobj;
05617          const vector<Float_t> xobj = ((const TMVA::PDEFoam*) G__getstructoffset())->VarTransform(*(vector<Float_t>*) libp->para[0].ref);
05618          pobj = new vector<Float_t>(xobj);
05619          result7->obj.i = (long) ((void*) pobj);
05620          result7->ref = result7->obj.i;
05621          G__store_tempobject(*result7);
05622       }
05623    return(1 || funcname || hash || result7 || libp) ;
05624 }
05625 
05626 static int G__G__TMVA3_312_0_72(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05627 {
05628       G__letdouble(result7, 102, (double) ((const TMVA::PDEFoam*) G__getstructoffset())->VarTransformInvers((Int_t) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])));
05629    return(1 || funcname || hash || result7 || libp) ;
05630 }
05631 
05632 static int G__G__TMVA3_312_0_73(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05633 {
05634       {
05635          const vector<Float_t>* pobj;
05636          const vector<Float_t> xobj = ((const TMVA::PDEFoam*) G__getstructoffset())->VarTransformInvers(*(vector<Float_t>*) libp->para[0].ref);
05637          pobj = new vector<Float_t>(xobj);
05638          result7->obj.i = (long) ((void*) pobj);
05639          result7->ref = result7->obj.i;
05640          G__store_tempobject(*result7);
05641       }
05642    return(1 || funcname || hash || result7 || libp) ;
05643 }
05644 
05645 static int G__G__TMVA3_312_0_74(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05646 {
05647       ((TMVA::PDEFoam*) G__getstructoffset())->CheckAll((Int_t) G__int(libp->para[0]));
05648       G__setnull(result7);
05649    return(1 || funcname || hash || result7 || libp) ;
05650 }
05651 
05652 static int G__G__TMVA3_312_0_75(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05653 {
05654    switch (libp->paran) {
05655    case 1:
05656       ((TMVA::PDEFoam*) G__getstructoffset())->PrintCell((Long_t) G__int(libp->para[0]));
05657       G__setnull(result7);
05658       break;
05659    case 0:
05660       ((TMVA::PDEFoam*) G__getstructoffset())->PrintCell();
05661       G__setnull(result7);
05662       break;
05663    }
05664    return(1 || funcname || hash || result7 || libp) ;
05665 }
05666 
05667 static int G__G__TMVA3_312_0_76(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05668 {
05669       ((TMVA::PDEFoam*) G__getstructoffset())->PrintCells();
05670       G__setnull(result7);
05671    return(1 || funcname || hash || result7 || libp) ;
05672 }
05673 
05674 static int G__G__TMVA3_312_0_77(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05675 {
05676    switch (libp->paran) {
05677    case 1:
05678       ((TMVA::PDEFoam*) G__getstructoffset())->CheckCells((Bool_t) G__int(libp->para[0]));
05679       G__setnull(result7);
05680       break;
05681    case 0:
05682       ((TMVA::PDEFoam*) G__getstructoffset())->CheckCells();
05683       G__setnull(result7);
05684       break;
05685    }
05686    return(1 || funcname || hash || result7 || libp) ;
05687 }
05688 
05689 static int G__G__TMVA3_312_0_78(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05690 {
05691       ((TMVA::PDEFoam*) G__getstructoffset())->RemoveEmptyCell((Int_t) G__int(libp->para[0]));
05692       G__setnull(result7);
05693    return(1 || funcname || hash || result7 || libp) ;
05694 }
05695 
05696 static int G__G__TMVA3_312_0_79(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05697 {
05698       ((TMVA::PDEFoam*) G__getstructoffset())->PrintCellElements();
05699       G__setnull(result7);
05700    return(1 || funcname || hash || result7 || libp) ;
05701 }
05702 
05703 static int G__G__TMVA3_312_0_80(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05704 {
05705       {
05706          const TMVA::MsgLogger& obj = ((const TMVA::PDEFoam*) G__getstructoffset())->Log();
05707          result7->ref = (long) (&obj);
05708          result7->obj.i = (long) (&obj);
05709       }
05710    return(1 || funcname || hash || result7 || libp) ;
05711 }
05712 
05713 static int G__G__TMVA3_312_0_81(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05714 {
05715       ((TMVA::PDEFoam*) G__getstructoffset())->ReadStream(*(istream*) libp->para[0].ref);
05716       G__setnull(result7);
05717    return(1 || funcname || hash || result7 || libp) ;
05718 }
05719 
05720 static int G__G__TMVA3_312_0_82(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05721 {
05722       ((const TMVA::PDEFoam*) G__getstructoffset())->PrintStream(*(ostream*) libp->para[0].ref);
05723       G__setnull(result7);
05724    return(1 || funcname || hash || result7 || libp) ;
05725 }
05726 
05727 static int G__G__TMVA3_312_0_83(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05728 {
05729       ((TMVA::PDEFoam*) G__getstructoffset())->ReadXML((void*) G__int(libp->para[0]));
05730       G__setnull(result7);
05731    return(1 || funcname || hash || result7 || libp) ;
05732 }
05733 
05734 static int G__G__TMVA3_312_0_84(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05735 {
05736       ((TMVA::PDEFoam*) G__getstructoffset())->AddXMLTo((void*) G__int(libp->para[0]));
05737       G__setnull(result7);
05738    return(1 || funcname || hash || result7 || libp) ;
05739 }
05740 
05741 static int G__G__TMVA3_312_0_85(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05742 {
05743    switch (libp->paran) {
05744    case 5:
05745       G__letint(result7, 85, (long) ((TMVA::PDEFoam*) G__getstructoffset())->Project2((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05746 , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])
05747 , (UInt_t) G__int(libp->para[4])));
05748       break;
05749    case 4:
05750       G__letint(result7, 85, (long) ((TMVA::PDEFoam*) G__getstructoffset())->Project2((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05751 , (const char*) G__int(libp->para[2]), (const char*) G__int(libp->para[3])));
05752       break;
05753    case 3:
05754       G__letint(result7, 85, (long) ((TMVA::PDEFoam*) G__getstructoffset())->Project2((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05755 , (const char*) G__int(libp->para[2])));
05756       break;
05757    case 2:
05758       G__letint(result7, 85, (long) ((TMVA::PDEFoam*) G__getstructoffset())->Project2((Int_t) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
05759       break;
05760    }
05761    return(1 || funcname || hash || result7 || libp) ;
05762 }
05763 
05764 static int G__G__TMVA3_312_0_86(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05765 {
05766       G__letdouble(result7, 100, (double) ((TMVA::PDEFoam*) G__getstructoffset())->GetProjectionCellValue((TMVA::PDEFoamCell*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])
05767 , (Int_t) G__int(libp->para[2]), (TMVA::ECellValue) G__int(libp->para[3])));
05768    return(1 || funcname || hash || result7 || libp) ;
05769 }
05770 
05771 static int G__G__TMVA3_312_0_87(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05772 {
05773       G__letint(result7, 85, (long) ((TMVA::PDEFoam*) G__getstructoffset())->Draw1Dim((const char*) G__int(libp->para[0]), (Int_t) G__int(libp->para[1])));
05774    return(1 || funcname || hash || result7 || libp) ;
05775 }
05776 
05777 static int G__G__TMVA3_312_0_88(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05778 {
05779    switch (libp->paran) {
05780    case 5:
05781       ((TMVA::PDEFoam*) G__getstructoffset())->RootPlot2dim(*(TString*) libp->para[0].ref, *((TString*) G__int(libp->para[1]))
05782 , (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3])
05783 , (Bool_t) G__int(libp->para[4]));
05784       G__setnull(result7);
05785       break;
05786    case 4:
05787       ((TMVA::PDEFoam*) G__getstructoffset())->RootPlot2dim(*(TString*) libp->para[0].ref, *((TString*) G__int(libp->para[1]))
05788 , (Bool_t) G__int(libp->para[2]), (Bool_t) G__int(libp->para[3]));
05789       G__setnull(result7);
05790       break;
05791    case 3:
05792       ((TMVA::PDEFoam*) G__getstructoffset())->RootPlot2dim(*(TString*) libp->para[0].ref, *((TString*) G__int(libp->para[1]))
05793 , (Bool_t) G__int(libp->para[2]));
05794       G__setnull(result7);
05795       break;
05796    case 2:
05797       ((TMVA::PDEFoam*) G__getstructoffset())->RootPlot2dim(*(TString*) libp->para[0].ref, *((TString*) G__int(libp->para[1])));
05798       G__setnull(result7);
05799       break;
05800    }
05801    return(1 || funcname || hash || result7 || libp) ;
05802 }
05803 
05804 static int G__G__TMVA3_312_0_89(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05805 {
05806       G__letdouble(result7, 100, (double) ((TMVA::PDEFoam*) G__getstructoffset())->GetCellValue(*(vector<Float_t>*) libp->para[0].ref, (TMVA::ECellValue) G__int(libp->para[1])));
05807    return(1 || funcname || hash || result7 || libp) ;
05808 }
05809 
05810 static int G__G__TMVA3_312_0_90(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05811 {
05812    switch (libp->paran) {
05813    case 2:
05814       G__letdouble(result7, 100, (double) ((TMVA::PDEFoam*) G__getstructoffset())->GetCellDiscr(*(vector<Float_t>*) libp->para[0].ref, (TMVA::EKernel) G__int(libp->para[1])));
05815       break;
05816    case 1:
05817       G__letdouble(result7, 100, (double) ((TMVA::PDEFoam*) G__getstructoffset())->GetCellDiscr(*(vector<Float_t>*) libp->para[0].ref));
05818       break;
05819    }
05820    return(1 || funcname || hash || result7 || libp) ;
05821 }
05822 
05823 static int G__G__TMVA3_312_0_91(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05824 {
05825    switch (libp->paran) {
05826    case 2:
05827       G__letdouble(result7, 100, (double) ((TMVA::PDEFoam*) G__getstructoffset())->GetCellDensity(*(vector<Float_t>*) libp->para[0].ref, (TMVA::EKernel) G__int(libp->para[1])));
05828       break;
05829    case 1:
05830       G__letdouble(result7, 100, (double) ((TMVA::PDEFoam*) G__getstructoffset())->GetCellDensity(*(vector<Float_t>*) libp->para[0].ref));
05831       break;
05832    }
05833    return(1 || funcname || hash || result7 || libp) ;
05834 }
05835 
05836 static int G__G__TMVA3_312_0_92(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05837 {
05838       G__letdouble(result7, 100, (double) ((TMVA::PDEFoam*) G__getstructoffset())->GetAverageNeighborsValue(*(vector<Float_t>*) libp->para[0].ref, (TMVA::ECellValue) G__int(libp->para[1])));
05839    return(1 || funcname || hash || result7 || libp) ;
05840 }
05841 
05842 static int G__G__TMVA3_312_0_93(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05843 {
05844    switch (libp->paran) {
05845    case 2:
05846       G__letdouble(result7, 100, (double) ((TMVA::PDEFoam*) G__getstructoffset())->GetCellRegValue0(*(vector<Float_t>*) libp->para[0].ref, (TMVA::EKernel) G__int(libp->para[1])));
05847       break;
05848    case 1:
05849       G__letdouble(result7, 100, (double) ((TMVA::PDEFoam*) G__getstructoffset())->GetCellRegValue0(*(vector<Float_t>*) libp->para[0].ref));
05850       break;
05851    }
05852    return(1 || funcname || hash || result7 || libp) ;
05853 }
05854 
05855 static int G__G__TMVA3_312_0_94(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05856 {
05857    switch (libp->paran) {
05858    case 3:
05859       {
05860          vector<Float_t>* pobj;
05861          vector<Float_t> xobj = ((TMVA::PDEFoam*) G__getstructoffset())->GetProjectedRegValue(*(vector<Float_t>*) libp->para[0].ref, (TMVA::EKernel) G__int(libp->para[1])
05862 , (TMVA::ETargetSelection) G__int(libp->para[2]));
05863          pobj = new vector<Float_t>(xobj);
05864          result7->obj.i = (long) ((void*) pobj);
05865          result7->ref = result7->obj.i;
05866          G__store_tempobject(*result7);
05867       }
05868       break;
05869    case 2:
05870       {
05871          vector<Float_t>* pobj;
05872          vector<Float_t> xobj = ((TMVA::PDEFoam*) G__getstructoffset())->GetProjectedRegValue(*(vector<Float_t>*) libp->para[0].ref, (TMVA::EKernel) G__int(libp->para[1]));
05873          pobj = new vector<Float_t>(xobj);
05874          result7->obj.i = (long) ((void*) pobj);
05875          result7->ref = result7->obj.i;
05876          G__store_tempobject(*result7);
05877       }
05878       break;
05879    case 1:
05880       {
05881          vector<Float_t>* pobj;
05882          vector<Float_t> xobj = ((TMVA::PDEFoam*) G__getstructoffset())->GetProjectedRegValue(*(vector<Float_t>*) libp->para[0].ref);
05883          pobj = new vector<Float_t>(xobj);
05884          result7->obj.i = (long) ((void*) pobj);
05885          result7->ref = result7->obj.i;
05886          G__store_tempobject(*result7);
05887       }
05888       break;
05889    }
05890    return(1 || funcname || hash || result7 || libp) ;
05891 }
05892 
05893 static int G__G__TMVA3_312_0_95(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05894 {
05895       G__letint(result7, 85, (long) TMVA::PDEFoam::Class());
05896    return(1 || funcname || hash || result7 || libp) ;
05897 }
05898 
05899 static int G__G__TMVA3_312_0_96(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05900 {
05901       G__letint(result7, 67, (long) TMVA::PDEFoam::Class_Name());
05902    return(1 || funcname || hash || result7 || libp) ;
05903 }
05904 
05905 static int G__G__TMVA3_312_0_97(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05906 {
05907       G__letint(result7, 115, (long) TMVA::PDEFoam::Class_Version());
05908    return(1 || funcname || hash || result7 || libp) ;
05909 }
05910 
05911 static int G__G__TMVA3_312_0_98(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05912 {
05913       TMVA::PDEFoam::Dictionary();
05914       G__setnull(result7);
05915    return(1 || funcname || hash || result7 || libp) ;
05916 }
05917 
05918 static int G__G__TMVA3_312_0_102(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05919 {
05920       ((TMVA::PDEFoam*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
05921       G__setnull(result7);
05922    return(1 || funcname || hash || result7 || libp) ;
05923 }
05924 
05925 static int G__G__TMVA3_312_0_103(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05926 {
05927       G__letint(result7, 67, (long) TMVA::PDEFoam::DeclFileName());
05928    return(1 || funcname || hash || result7 || libp) ;
05929 }
05930 
05931 static int G__G__TMVA3_312_0_104(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05932 {
05933       G__letint(result7, 105, (long) TMVA::PDEFoam::ImplFileLine());
05934    return(1 || funcname || hash || result7 || libp) ;
05935 }
05936 
05937 static int G__G__TMVA3_312_0_105(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05938 {
05939       G__letint(result7, 67, (long) TMVA::PDEFoam::ImplFileName());
05940    return(1 || funcname || hash || result7 || libp) ;
05941 }
05942 
05943 static int G__G__TMVA3_312_0_106(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05944 {
05945       G__letint(result7, 105, (long) TMVA::PDEFoam::DeclFileLine());
05946    return(1 || funcname || hash || result7 || libp) ;
05947 }
05948 
05949 // automatic destructor
05950 typedef TMVA::PDEFoam G__TTMVAcLcLPDEFoam;
05951 static int G__G__TMVA3_312_0_107(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05952 {
05953    char* gvp = (char*) G__getgvp();
05954    long soff = G__getstructoffset();
05955    int n = G__getaryconstruct();
05956    //
05957    //has_a_delete: 1
05958    //has_own_delete1arg: 0
05959    //has_own_delete2arg: 0
05960    //
05961    if (!soff) {
05962      return(1);
05963    }
05964    if (n) {
05965      if (gvp == (char*)G__PVOID) {
05966        delete[] (TMVA::PDEFoam*) soff;
05967      } else {
05968        G__setgvp((long) G__PVOID);
05969        for (int i = n - 1; i >= 0; --i) {
05970          ((TMVA::PDEFoam*) (soff+(sizeof(TMVA::PDEFoam)*i)))->~G__TTMVAcLcLPDEFoam();
05971        }
05972        G__setgvp((long)gvp);
05973      }
05974    } else {
05975      if (gvp == (char*)G__PVOID) {
05976        delete (TMVA::PDEFoam*) soff;
05977      } else {
05978        G__setgvp((long) G__PVOID);
05979        ((TMVA::PDEFoam*) (soff))->~G__TTMVAcLcLPDEFoam();
05980        G__setgvp((long)gvp);
05981      }
05982    }
05983    G__setnull(result7);
05984    return(1 || funcname || hash || result7 || libp) ;
05985 }
05986 
05987 // automatic assignment operator
05988 static int G__G__TMVA3_312_0_108(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05989 {
05990    TMVA::PDEFoam* dest = (TMVA::PDEFoam*) G__getstructoffset();
05991    *dest = *(TMVA::PDEFoam*) libp->para[0].ref;
05992    const TMVA::PDEFoam& obj = *dest;
05993    result7->ref = (long) (&obj);
05994    result7->obj.i = (long) (&obj);
05995    return(1 || funcname || hash || result7 || libp) ;
05996 }
05997 
05998 
05999 /* TMVA::BDTEventWrapper */
06000 static int G__G__TMVA3_387_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06001 {
06002    TMVA::BDTEventWrapper* p = NULL;
06003    char* gvp = (char*) G__getgvp();
06004    //m: 1
06005    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06006      p = new TMVA::BDTEventWrapper((TMVA::Event*) G__int(libp->para[0]));
06007    } else {
06008      p = new((void*) gvp) TMVA::BDTEventWrapper((TMVA::Event*) G__int(libp->para[0]));
06009    }
06010    result7->obj.i = (long) p;
06011    result7->ref = (long) p;
06012    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLBDTEventWrapper));
06013    return(1 || funcname || hash || result7 || libp) ;
06014 }
06015 
06016 static int G__G__TMVA3_387_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06017 {
06018       G__letint(result7, 103, (long) ((const TMVA::BDTEventWrapper*) G__getstructoffset())->operator<(*(TMVA::BDTEventWrapper*) libp->para[0].ref));
06019    return(1 || funcname || hash || result7 || libp) ;
06020 }
06021 
06022 static int G__G__TMVA3_387_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06023 {
06024       ((TMVA::BDTEventWrapper*) G__getstructoffset())->SetCumulativeWeight((Bool_t) G__int(libp->para[0]), (Double_t) G__double(libp->para[1]));
06025       G__setnull(result7);
06026    return(1 || funcname || hash || result7 || libp) ;
06027 }
06028 
06029 static int G__G__TMVA3_387_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06030 {
06031       G__letdouble(result7, 100, (double) ((const TMVA::BDTEventWrapper*) G__getstructoffset())->GetCumulativeWeight((Bool_t) G__int(libp->para[0])));
06032    return(1 || funcname || hash || result7 || libp) ;
06033 }
06034 
06035 static int G__G__TMVA3_387_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06036 {
06037       TMVA::BDTEventWrapper::SetVarIndex((Int_t) G__int(libp->para[0]));
06038       G__setnull(result7);
06039    return(1 || funcname || hash || result7 || libp) ;
06040 }
06041 
06042 static int G__G__TMVA3_387_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06043 {
06044       G__letdouble(result7, 100, (double) ((const TMVA::BDTEventWrapper*) G__getstructoffset())->GetVal());
06045    return(1 || funcname || hash || result7 || libp) ;
06046 }
06047 
06048 static int G__G__TMVA3_387_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06049 {
06050       G__letint(result7, 85, (long) ((const TMVA::BDTEventWrapper*) G__getstructoffset())->operator*());
06051    return(1 || funcname || hash || result7 || libp) ;
06052 }
06053 
06054 // automatic copy constructor
06055 static int G__G__TMVA3_387_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06056 
06057 {
06058    TMVA::BDTEventWrapper* p;
06059    void* tmp = (void*) G__int(libp->para[0]);
06060    p = new TMVA::BDTEventWrapper(*(TMVA::BDTEventWrapper*) tmp);
06061    result7->obj.i = (long) p;
06062    result7->ref = (long) p;
06063    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLBDTEventWrapper));
06064    return(1 || funcname || hash || result7 || libp) ;
06065 }
06066 
06067 // automatic destructor
06068 typedef TMVA::BDTEventWrapper G__TTMVAcLcLBDTEventWrapper;
06069 static int G__G__TMVA3_387_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06070 {
06071    char* gvp = (char*) G__getgvp();
06072    long soff = G__getstructoffset();
06073    int n = G__getaryconstruct();
06074    //
06075    //has_a_delete: 0
06076    //has_own_delete1arg: 0
06077    //has_own_delete2arg: 0
06078    //
06079    if (!soff) {
06080      return(1);
06081    }
06082    if (n) {
06083      if (gvp == (char*)G__PVOID) {
06084        delete[] (TMVA::BDTEventWrapper*) soff;
06085      } else {
06086        G__setgvp((long) G__PVOID);
06087        for (int i = n - 1; i >= 0; --i) {
06088          ((TMVA::BDTEventWrapper*) (soff+(sizeof(TMVA::BDTEventWrapper)*i)))->~G__TTMVAcLcLBDTEventWrapper();
06089        }
06090        G__setgvp((long)gvp);
06091      }
06092    } else {
06093      if (gvp == (char*)G__PVOID) {
06094        delete (TMVA::BDTEventWrapper*) soff;
06095      } else {
06096        G__setgvp((long) G__PVOID);
06097        ((TMVA::BDTEventWrapper*) (soff))->~G__TTMVAcLcLBDTEventWrapper();
06098        G__setgvp((long)gvp);
06099      }
06100    }
06101    G__setnull(result7);
06102    return(1 || funcname || hash || result7 || libp) ;
06103 }
06104 
06105 
06106 /* TMVA::CCTreeWrapper */
06107 static int G__G__TMVA3_482_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06108 {
06109    TMVA::CCTreeWrapper* p = NULL;
06110    char* gvp = (char*) G__getgvp();
06111    //m: 2
06112    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06113      p = new TMVA::CCTreeWrapper((TMVA::DecisionTree*) G__int(libp->para[0]), (TMVA::SeparationBase*) G__int(libp->para[1]));
06114    } else {
06115      p = new((void*) gvp) TMVA::CCTreeWrapper((TMVA::DecisionTree*) G__int(libp->para[0]), (TMVA::SeparationBase*) G__int(libp->para[1]));
06116    }
06117    result7->obj.i = (long) p;
06118    result7->ref = (long) p;
06119    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrapper));
06120    return(1 || funcname || hash || result7 || libp) ;
06121 }
06122 
06123 static int G__G__TMVA3_482_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06124 {
06125    switch (libp->paran) {
06126    case 2:
06127       G__letdouble(result7, 100, (double) ((TMVA::CCTreeWrapper*) G__getstructoffset())->CheckEvent(*(TMVA::Event*) libp->para[0].ref, (Bool_t) G__int(libp->para[1])));
06128       break;
06129    case 1:
06130       G__letdouble(result7, 100, (double) ((TMVA::CCTreeWrapper*) G__getstructoffset())->CheckEvent(*(TMVA::Event*) libp->para[0].ref));
06131       break;
06132    }
06133    return(1 || funcname || hash || result7 || libp) ;
06134 }
06135 
06136 static int G__G__TMVA3_482_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06137 {
06138       G__letdouble(result7, 100, (double) ((TMVA::CCTreeWrapper*) G__getstructoffset())->TestTreeQuality((TMVA::CCTreeWrapper::EventList*) G__int(libp->para[0])));
06139    return(1 || funcname || hash || result7 || libp) ;
06140 }
06141 
06142 static int G__G__TMVA3_482_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06143 {
06144       G__letdouble(result7, 100, (double) ((TMVA::CCTreeWrapper*) G__getstructoffset())->TestTreeQuality((TMVA::DataSet*) G__int(libp->para[0])));
06145    return(1 || funcname || hash || result7 || libp) ;
06146 }
06147 
06148 static int G__G__TMVA3_482_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06149 {
06150       ((TMVA::CCTreeWrapper*) G__getstructoffset())->PruneNode((TMVA::CCTreeWrapper::CCTreeNode*) G__int(libp->para[0]));
06151       G__setnull(result7);
06152    return(1 || funcname || hash || result7 || libp) ;
06153 }
06154 
06155 static int G__G__TMVA3_482_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06156 {
06157       ((TMVA::CCTreeWrapper*) G__getstructoffset())->InitTree((TMVA::CCTreeWrapper::CCTreeNode*) G__int(libp->para[0]));
06158       G__setnull(result7);
06159    return(1 || funcname || hash || result7 || libp) ;
06160 }
06161 
06162 static int G__G__TMVA3_482_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06163 {
06164       G__letint(result7, 85, (long) ((TMVA::CCTreeWrapper*) G__getstructoffset())->GetRoot());
06165    return(1 || funcname || hash || result7 || libp) ;
06166 }
06167 
06168 // automatic copy constructor
06169 static int G__G__TMVA3_482_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06170 
06171 {
06172    TMVA::CCTreeWrapper* p;
06173    void* tmp = (void*) G__int(libp->para[0]);
06174    p = new TMVA::CCTreeWrapper(*(TMVA::CCTreeWrapper*) tmp);
06175    result7->obj.i = (long) p;
06176    result7->ref = (long) p;
06177    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrapper));
06178    return(1 || funcname || hash || result7 || libp) ;
06179 }
06180 
06181 // automatic destructor
06182 typedef TMVA::CCTreeWrapper G__TTMVAcLcLCCTreeWrapper;
06183 static int G__G__TMVA3_482_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06184 {
06185    char* gvp = (char*) G__getgvp();
06186    long soff = G__getstructoffset();
06187    int n = G__getaryconstruct();
06188    //
06189    //has_a_delete: 0
06190    //has_own_delete1arg: 0
06191    //has_own_delete2arg: 0
06192    //
06193    if (!soff) {
06194      return(1);
06195    }
06196    if (n) {
06197      if (gvp == (char*)G__PVOID) {
06198        delete[] (TMVA::CCTreeWrapper*) soff;
06199      } else {
06200        G__setgvp((long) G__PVOID);
06201        for (int i = n - 1; i >= 0; --i) {
06202          ((TMVA::CCTreeWrapper*) (soff+(sizeof(TMVA::CCTreeWrapper)*i)))->~G__TTMVAcLcLCCTreeWrapper();
06203        }
06204        G__setgvp((long)gvp);
06205      }
06206    } else {
06207      if (gvp == (char*)G__PVOID) {
06208        delete (TMVA::CCTreeWrapper*) soff;
06209      } else {
06210        G__setgvp((long) G__PVOID);
06211        ((TMVA::CCTreeWrapper*) (soff))->~G__TTMVAcLcLCCTreeWrapper();
06212        G__setgvp((long)gvp);
06213      }
06214    }
06215    G__setnull(result7);
06216    return(1 || funcname || hash || result7 || libp) ;
06217 }
06218 
06219 // automatic assignment operator
06220 static int G__G__TMVA3_482_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06221 {
06222    TMVA::CCTreeWrapper* dest = (TMVA::CCTreeWrapper*) G__getstructoffset();
06223    *dest = *(TMVA::CCTreeWrapper*) libp->para[0].ref;
06224    const TMVA::CCTreeWrapper& obj = *dest;
06225    result7->ref = (long) (&obj);
06226    result7->obj.i = (long) (&obj);
06227    return(1 || funcname || hash || result7 || libp) ;
06228 }
06229 
06230 
06231 /* TMVA::CCPruner */
06232 static int G__G__TMVA3_484_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06233 {
06234    TMVA::CCPruner* p = NULL;
06235    char* gvp = (char*) G__getgvp();
06236    switch (libp->paran) {
06237    case 3:
06238      //m: 3
06239      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06240        p = new TMVA::CCPruner(
06241 (TMVA::DecisionTree*) G__int(libp->para[0]), (TMVA::CCPruner::EventList*) G__int(libp->para[1])
06242 , (TMVA::SeparationBase*) G__int(libp->para[2]));
06243      } else {
06244        p = new((void*) gvp) TMVA::CCPruner(
06245 (TMVA::DecisionTree*) G__int(libp->para[0]), (TMVA::CCPruner::EventList*) G__int(libp->para[1])
06246 , (TMVA::SeparationBase*) G__int(libp->para[2]));
06247      }
06248      break;
06249    case 2:
06250      //m: 2
06251      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06252        p = new TMVA::CCPruner((TMVA::DecisionTree*) G__int(libp->para[0]), (TMVA::CCPruner::EventList*) G__int(libp->para[1]));
06253      } else {
06254        p = new((void*) gvp) TMVA::CCPruner((TMVA::DecisionTree*) G__int(libp->para[0]), (TMVA::CCPruner::EventList*) G__int(libp->para[1]));
06255      }
06256      break;
06257    }
06258    result7->obj.i = (long) p;
06259    result7->ref = (long) p;
06260    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCPruner));
06261    return(1 || funcname || hash || result7 || libp) ;
06262 }
06263 
06264 static int G__G__TMVA3_484_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06265 {
06266    TMVA::CCPruner* p = NULL;
06267    char* gvp = (char*) G__getgvp();
06268    switch (libp->paran) {
06269    case 3:
06270      //m: 3
06271      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06272        p = new TMVA::CCPruner(
06273 (TMVA::DecisionTree*) G__int(libp->para[0]), (TMVA::DataSet*) G__int(libp->para[1])
06274 , (TMVA::SeparationBase*) G__int(libp->para[2]));
06275      } else {
06276        p = new((void*) gvp) TMVA::CCPruner(
06277 (TMVA::DecisionTree*) G__int(libp->para[0]), (TMVA::DataSet*) G__int(libp->para[1])
06278 , (TMVA::SeparationBase*) G__int(libp->para[2]));
06279      }
06280      break;
06281    case 2:
06282      //m: 2
06283      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06284        p = new TMVA::CCPruner((TMVA::DecisionTree*) G__int(libp->para[0]), (TMVA::DataSet*) G__int(libp->para[1]));
06285      } else {
06286        p = new((void*) gvp) TMVA::CCPruner((TMVA::DecisionTree*) G__int(libp->para[0]), (TMVA::DataSet*) G__int(libp->para[1]));
06287      }
06288      break;
06289    }
06290    result7->obj.i = (long) p;
06291    result7->ref = (long) p;
06292    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCPruner));
06293    return(1 || funcname || hash || result7 || libp) ;
06294 }
06295 
06296 static int G__G__TMVA3_484_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06297 {
06298    switch (libp->paran) {
06299    case 1:
06300       ((TMVA::CCPruner*) G__getstructoffset())->SetPruneStrength((Float_t) G__double(libp->para[0]));
06301       G__setnull(result7);
06302       break;
06303    case 0:
06304       ((TMVA::CCPruner*) G__getstructoffset())->SetPruneStrength();
06305       G__setnull(result7);
06306       break;
06307    }
06308    return(1 || funcname || hash || result7 || libp) ;
06309 }
06310 
06311 static int G__G__TMVA3_484_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06312 {
06313       ((TMVA::CCPruner*) G__getstructoffset())->Optimize();
06314       G__setnull(result7);
06315    return(1 || funcname || hash || result7 || libp) ;
06316 }
06317 
06318 static int G__G__TMVA3_484_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06319 {
06320       {
06321          const vector<TMVA::DecisionTreeNode*>* pobj;
06322          const vector<TMVA::DecisionTreeNode*> xobj = ((const TMVA::CCPruner*) G__getstructoffset())->GetOptimalPruneSequence();
06323          pobj = new vector<TMVA::DecisionTreeNode*>(xobj);
06324          result7->obj.i = (long) ((void*) pobj);
06325          result7->ref = result7->obj.i;
06326          G__store_tempobject(*result7);
06327       }
06328    return(1 || funcname || hash || result7 || libp) ;
06329 }
06330 
06331 static int G__G__TMVA3_484_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06332 {
06333       G__letdouble(result7, 102, (double) ((const TMVA::CCPruner*) G__getstructoffset())->GetOptimalQualityIndex());
06334    return(1 || funcname || hash || result7 || libp) ;
06335 }
06336 
06337 static int G__G__TMVA3_484_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06338 {
06339       G__letdouble(result7, 102, (double) ((const TMVA::CCPruner*) G__getstructoffset())->GetOptimalPruneStrength());
06340    return(1 || funcname || hash || result7 || libp) ;
06341 }
06342 
06343 // automatic copy constructor
06344 static int G__G__TMVA3_484_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06345 
06346 {
06347    TMVA::CCPruner* p;
06348    void* tmp = (void*) G__int(libp->para[0]);
06349    p = new TMVA::CCPruner(*(TMVA::CCPruner*) tmp);
06350    result7->obj.i = (long) p;
06351    result7->ref = (long) p;
06352    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCPruner));
06353    return(1 || funcname || hash || result7 || libp) ;
06354 }
06355 
06356 // automatic destructor
06357 typedef TMVA::CCPruner G__TTMVAcLcLCCPruner;
06358 static int G__G__TMVA3_484_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06359 {
06360    char* gvp = (char*) G__getgvp();
06361    long soff = G__getstructoffset();
06362    int n = G__getaryconstruct();
06363    //
06364    //has_a_delete: 0
06365    //has_own_delete1arg: 0
06366    //has_own_delete2arg: 0
06367    //
06368    if (!soff) {
06369      return(1);
06370    }
06371    if (n) {
06372      if (gvp == (char*)G__PVOID) {
06373        delete[] (TMVA::CCPruner*) soff;
06374      } else {
06375        G__setgvp((long) G__PVOID);
06376        for (int i = n - 1; i >= 0; --i) {
06377          ((TMVA::CCPruner*) (soff+(sizeof(TMVA::CCPruner)*i)))->~G__TTMVAcLcLCCPruner();
06378        }
06379        G__setgvp((long)gvp);
06380      }
06381    } else {
06382      if (gvp == (char*)G__PVOID) {
06383        delete (TMVA::CCPruner*) soff;
06384      } else {
06385        G__setgvp((long) G__PVOID);
06386        ((TMVA::CCPruner*) (soff))->~G__TTMVAcLcLCCPruner();
06387        G__setgvp((long)gvp);
06388      }
06389    }
06390    G__setnull(result7);
06391    return(1 || funcname || hash || result7 || libp) ;
06392 }
06393 
06394 
06395 /* TMVA::CostComplexityPruneTool */
06396 static int G__G__TMVA3_492_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06397 {
06398    TMVA::CostComplexityPruneTool* p = NULL;
06399    char* gvp = (char*) G__getgvp();
06400    switch (libp->paran) {
06401    case 1:
06402      //m: 1
06403      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06404        p = new TMVA::CostComplexityPruneTool((TMVA::SeparationBase*) G__int(libp->para[0]));
06405      } else {
06406        p = new((void*) gvp) TMVA::CostComplexityPruneTool((TMVA::SeparationBase*) G__int(libp->para[0]));
06407      }
06408      break;
06409    case 0:
06410      int n = G__getaryconstruct();
06411      if (n) {
06412        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06413          p = new TMVA::CostComplexityPruneTool[n];
06414        } else {
06415          p = new((void*) gvp) TMVA::CostComplexityPruneTool[n];
06416        }
06417      } else {
06418        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06419          p = new TMVA::CostComplexityPruneTool;
06420        } else {
06421          p = new((void*) gvp) TMVA::CostComplexityPruneTool;
06422        }
06423      }
06424      break;
06425    }
06426    result7->obj.i = (long) p;
06427    result7->ref = (long) p;
06428    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool));
06429    return(1 || funcname || hash || result7 || libp) ;
06430 }
06431 
06432 // automatic copy constructor
06433 static int G__G__TMVA3_492_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06434 
06435 {
06436    TMVA::CostComplexityPruneTool* p;
06437    void* tmp = (void*) G__int(libp->para[0]);
06438    p = new TMVA::CostComplexityPruneTool(*(TMVA::CostComplexityPruneTool*) tmp);
06439    result7->obj.i = (long) p;
06440    result7->ref = (long) p;
06441    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool));
06442    return(1 || funcname || hash || result7 || libp) ;
06443 }
06444 
06445 // automatic destructor
06446 typedef TMVA::CostComplexityPruneTool G__TTMVAcLcLCostComplexityPruneTool;
06447 static int G__G__TMVA3_492_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06448 {
06449    char* gvp = (char*) G__getgvp();
06450    long soff = G__getstructoffset();
06451    int n = G__getaryconstruct();
06452    //
06453    //has_a_delete: 0
06454    //has_own_delete1arg: 0
06455    //has_own_delete2arg: 0
06456    //
06457    if (!soff) {
06458      return(1);
06459    }
06460    if (n) {
06461      if (gvp == (char*)G__PVOID) {
06462        delete[] (TMVA::CostComplexityPruneTool*) soff;
06463      } else {
06464        G__setgvp((long) G__PVOID);
06465        for (int i = n - 1; i >= 0; --i) {
06466          ((TMVA::CostComplexityPruneTool*) (soff+(sizeof(TMVA::CostComplexityPruneTool)*i)))->~G__TTMVAcLcLCostComplexityPruneTool();
06467        }
06468        G__setgvp((long)gvp);
06469      }
06470    } else {
06471      if (gvp == (char*)G__PVOID) {
06472        delete (TMVA::CostComplexityPruneTool*) soff;
06473      } else {
06474        G__setgvp((long) G__PVOID);
06475        ((TMVA::CostComplexityPruneTool*) (soff))->~G__TTMVAcLcLCostComplexityPruneTool();
06476        G__setgvp((long)gvp);
06477      }
06478    }
06479    G__setnull(result7);
06480    return(1 || funcname || hash || result7 || libp) ;
06481 }
06482 
06483 // automatic assignment operator
06484 static int G__G__TMVA3_492_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06485 {
06486    TMVA::CostComplexityPruneTool* dest = (TMVA::CostComplexityPruneTool*) G__getstructoffset();
06487    *dest = *(TMVA::CostComplexityPruneTool*) libp->para[0].ref;
06488    const TMVA::CostComplexityPruneTool& obj = *dest;
06489    result7->ref = (long) (&obj);
06490    result7->obj.i = (long) (&obj);
06491    return(1 || funcname || hash || result7 || libp) ;
06492 }
06493 
06494 
06495 /* TMVA::SVEvent */
06496 static int G__G__TMVA3_493_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06497 {
06498    TMVA::SVEvent* p = NULL;
06499    char* gvp = (char*) G__getgvp();
06500    int n = G__getaryconstruct();
06501    if (n) {
06502      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06503        p = new TMVA::SVEvent[n];
06504      } else {
06505        p = new((void*) gvp) TMVA::SVEvent[n];
06506      }
06507    } else {
06508      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06509        p = new TMVA::SVEvent;
06510      } else {
06511        p = new((void*) gvp) TMVA::SVEvent;
06512      }
06513    }
06514    result7->obj.i = (long) p;
06515    result7->ref = (long) p;
06516    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent));
06517    return(1 || funcname || hash || result7 || libp) ;
06518 }
06519 
06520 static int G__G__TMVA3_493_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06521 {
06522    TMVA::SVEvent* p = NULL;
06523    char* gvp = (char*) G__getgvp();
06524    //m: 2
06525    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06526      p = new TMVA::SVEvent((TMVA::Event*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1]));
06527    } else {
06528      p = new((void*) gvp) TMVA::SVEvent((TMVA::Event*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1]));
06529    }
06530    result7->obj.i = (long) p;
06531    result7->ref = (long) p;
06532    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent));
06533    return(1 || funcname || hash || result7 || libp) ;
06534 }
06535 
06536 static int G__G__TMVA3_493_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06537 {
06538    TMVA::SVEvent* p = NULL;
06539    char* gvp = (char*) G__getgvp();
06540    //m: 4
06541    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06542      p = new TMVA::SVEvent(
06543 (vector<Float_t>*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
06544 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
06545    } else {
06546      p = new((void*) gvp) TMVA::SVEvent(
06547 (vector<Float_t>*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
06548 , (Int_t) G__int(libp->para[2]), (UInt_t) G__int(libp->para[3]));
06549    }
06550    result7->obj.i = (long) p;
06551    result7->ref = (long) p;
06552    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent));
06553    return(1 || funcname || hash || result7 || libp) ;
06554 }
06555 
06556 static int G__G__TMVA3_493_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06557 {
06558    TMVA::SVEvent* p = NULL;
06559    char* gvp = (char*) G__getgvp();
06560    //m: 4
06561    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06562      p = new TMVA::SVEvent(
06563 (vector<Float_t>*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
06564 , (Float_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3]));
06565    } else {
06566      p = new((void*) gvp) TMVA::SVEvent(
06567 (vector<Float_t>*) G__int(libp->para[0]), (Float_t) G__double(libp->para[1])
06568 , (Float_t) G__double(libp->para[2]), (Int_t) G__int(libp->para[3]));
06569    }
06570    result7->obj.i = (long) p;
06571    result7->ref = (long) p;
06572    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent));
06573    return(1 || funcname || hash || result7 || libp) ;
06574 }
06575 
06576 static int G__G__TMVA3_493_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06577 {
06578       ((TMVA::SVEvent*) G__getstructoffset())->SetAlpha((Float_t) G__double(libp->para[0]));
06579       G__setnull(result7);
06580    return(1 || funcname || hash || result7 || libp) ;
06581 }
06582 
06583 static int G__G__TMVA3_493_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06584 {
06585       ((TMVA::SVEvent*) G__getstructoffset())->SetAlpha_p((Float_t) G__double(libp->para[0]));
06586       G__setnull(result7);
06587    return(1 || funcname || hash || result7 || libp) ;
06588 }
06589 
06590 static int G__G__TMVA3_493_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06591 {
06592       ((TMVA::SVEvent*) G__getstructoffset())->SetErrorCache((Float_t) G__double(libp->para[0]));
06593       G__setnull(result7);
06594    return(1 || funcname || hash || result7 || libp) ;
06595 }
06596 
06597 static int G__G__TMVA3_493_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06598 {
06599       ((TMVA::SVEvent*) G__getstructoffset())->SetIsShrinked((Int_t) G__int(libp->para[0]));
06600       G__setnull(result7);
06601    return(1 || funcname || hash || result7 || libp) ;
06602 }
06603 
06604 static int G__G__TMVA3_493_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06605 {
06606       ((TMVA::SVEvent*) G__getstructoffset())->SetLine((Float_t*) G__int(libp->para[0]));
06607       G__setnull(result7);
06608    return(1 || funcname || hash || result7 || libp) ;
06609 }
06610 
06611 static int G__G__TMVA3_493_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06612 {
06613       ((TMVA::SVEvent*) G__getstructoffset())->SetIdx((Int_t) G__int(libp->para[0]));
06614       G__setnull(result7);
06615    return(1 || funcname || hash || result7 || libp) ;
06616 }
06617 
06618 static int G__G__TMVA3_493_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06619 {
06620       ((TMVA::SVEvent*) G__getstructoffset())->SetNs((UInt_t) G__int(libp->para[0]));
06621       G__setnull(result7);
06622    return(1 || funcname || hash || result7 || libp) ;
06623 }
06624 
06625 static int G__G__TMVA3_493_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06626 {
06627       ((TMVA::SVEvent*) G__getstructoffset())->UpdateErrorCache((Float_t) G__double(libp->para[0]));
06628       G__setnull(result7);
06629    return(1 || funcname || hash || result7 || libp) ;
06630 }
06631 
06632 static int G__G__TMVA3_493_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06633 {
06634       G__letint(result7, 85, (long) ((TMVA::SVEvent*) G__getstructoffset())->GetDataVector());
06635    return(1 || funcname || hash || result7 || libp) ;
06636 }
06637 
06638 static int G__G__TMVA3_493_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06639 {
06640       G__letdouble(result7, 102, (double) ((const TMVA::SVEvent*) G__getstructoffset())->GetAlpha());
06641    return(1 || funcname || hash || result7 || libp) ;
06642 }
06643 
06644 static int G__G__TMVA3_493_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06645 {
06646       G__letdouble(result7, 102, (double) ((const TMVA::SVEvent*) G__getstructoffset())->GetAlpha_p());
06647    return(1 || funcname || hash || result7 || libp) ;
06648 }
06649 
06650 static int G__G__TMVA3_493_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06651 {
06652       G__letdouble(result7, 102, (double) ((const TMVA::SVEvent*) G__getstructoffset())->GetDeltaAlpha());
06653    return(1 || funcname || hash || result7 || libp) ;
06654 }
06655 
06656 static int G__G__TMVA3_493_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06657 {
06658       G__letdouble(result7, 102, (double) ((const TMVA::SVEvent*) G__getstructoffset())->GetErrorCache());
06659    return(1 || funcname || hash || result7 || libp) ;
06660 }
06661 
06662 static int G__G__TMVA3_493_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06663 {
06664       G__letint(result7, 105, (long) ((const TMVA::SVEvent*) G__getstructoffset())->GetTypeFlag());
06665    return(1 || funcname || hash || result7 || libp) ;
06666 }
06667 
06668 static int G__G__TMVA3_493_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06669 {
06670       G__letint(result7, 105, (long) ((const TMVA::SVEvent*) G__getstructoffset())->GetNVar());
06671    return(1 || funcname || hash || result7 || libp) ;
06672 }
06673 
06674 static int G__G__TMVA3_493_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06675 {
06676       G__letint(result7, 105, (long) ((const TMVA::SVEvent*) G__getstructoffset())->GetIdx());
06677    return(1 || funcname || hash || result7 || libp) ;
06678 }
06679 
06680 static int G__G__TMVA3_493_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06681 {
06682       G__letint(result7, 70, (long) ((const TMVA::SVEvent*) G__getstructoffset())->GetLine());
06683    return(1 || funcname || hash || result7 || libp) ;
06684 }
06685 
06686 static int G__G__TMVA3_493_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06687 {
06688       G__letint(result7, 104, (long) ((const TMVA::SVEvent*) G__getstructoffset())->GetNs());
06689    return(1 || funcname || hash || result7 || libp) ;
06690 }
06691 
06692 static int G__G__TMVA3_493_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06693 {
06694       G__letdouble(result7, 102, (double) ((const TMVA::SVEvent*) G__getstructoffset())->GetCweight());
06695    return(1 || funcname || hash || result7 || libp) ;
06696 }
06697 
06698 static int G__G__TMVA3_493_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06699 {
06700       G__letdouble(result7, 102, (double) ((const TMVA::SVEvent*) G__getstructoffset())->GetTarget());
06701    return(1 || funcname || hash || result7 || libp) ;
06702 }
06703 
06704 static int G__G__TMVA3_493_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06705 {
06706       G__letint(result7, 103, (long) ((const TMVA::SVEvent*) G__getstructoffset())->IsInI0a());
06707    return(1 || funcname || hash || result7 || libp) ;
06708 }
06709 
06710 static int G__G__TMVA3_493_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06711 {
06712       G__letint(result7, 103, (long) ((const TMVA::SVEvent*) G__getstructoffset())->IsInI0b());
06713    return(1 || funcname || hash || result7 || libp) ;
06714 }
06715 
06716 static int G__G__TMVA3_493_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06717 {
06718       G__letint(result7, 103, (long) ((const TMVA::SVEvent*) G__getstructoffset())->IsInI0());
06719    return(1 || funcname || hash || result7 || libp) ;
06720 }
06721 
06722 static int G__G__TMVA3_493_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06723 {
06724       G__letint(result7, 103, (long) ((const TMVA::SVEvent*) G__getstructoffset())->IsInI1());
06725    return(1 || funcname || hash || result7 || libp) ;
06726 }
06727 
06728 static int G__G__TMVA3_493_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06729 {
06730       G__letint(result7, 103, (long) ((const TMVA::SVEvent*) G__getstructoffset())->IsInI2());
06731    return(1 || funcname || hash || result7 || libp) ;
06732 }
06733 
06734 static int G__G__TMVA3_493_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06735 {
06736       G__letint(result7, 103, (long) ((const TMVA::SVEvent*) G__getstructoffset())->IsInI3());
06737    return(1 || funcname || hash || result7 || libp) ;
06738 }
06739 
06740 static int G__G__TMVA3_493_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06741 {
06742       ((const TMVA::SVEvent*) G__getstructoffset())->Print(*(ostream*) libp->para[0].ref);
06743       G__setnull(result7);
06744    return(1 || funcname || hash || result7 || libp) ;
06745 }
06746 
06747 static int G__G__TMVA3_493_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06748 {
06749       ((TMVA::SVEvent*) G__getstructoffset())->PrintData();
06750       G__setnull(result7);
06751    return(1 || funcname || hash || result7 || libp) ;
06752 }
06753 
06754 static int G__G__TMVA3_493_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06755 {
06756       G__letint(result7, 85, (long) TMVA::SVEvent::Class());
06757    return(1 || funcname || hash || result7 || libp) ;
06758 }
06759 
06760 static int G__G__TMVA3_493_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06761 {
06762       G__letint(result7, 67, (long) TMVA::SVEvent::Class_Name());
06763    return(1 || funcname || hash || result7 || libp) ;
06764 }
06765 
06766 static int G__G__TMVA3_493_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06767 {
06768       G__letint(result7, 115, (long) TMVA::SVEvent::Class_Version());
06769    return(1 || funcname || hash || result7 || libp) ;
06770 }
06771 
06772 static int G__G__TMVA3_493_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06773 {
06774       TMVA::SVEvent::Dictionary();
06775       G__setnull(result7);
06776    return(1 || funcname || hash || result7 || libp) ;
06777 }
06778 
06779 static int G__G__TMVA3_493_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06780 {
06781       G__letint(result7, 85, (long) ((const TMVA::SVEvent*) G__getstructoffset())->IsA());
06782    return(1 || funcname || hash || result7 || libp) ;
06783 }
06784 
06785 static int G__G__TMVA3_493_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06786 {
06787       ((TMVA::SVEvent*) G__getstructoffset())->ShowMembers(*(TMemberInspector*) libp->para[0].ref);
06788       G__setnull(result7);
06789    return(1 || funcname || hash || result7 || libp) ;
06790 }
06791 
06792 static int G__G__TMVA3_493_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06793 {
06794       ((TMVA::SVEvent*) G__getstructoffset())->Streamer(*(TBuffer*) libp->para[0].ref);
06795       G__setnull(result7);
06796    return(1 || funcname || hash || result7 || libp) ;
06797 }
06798 
06799 static int G__G__TMVA3_493_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06800 {
06801       ((TMVA::SVEvent*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06802       G__setnull(result7);
06803    return(1 || funcname || hash || result7 || libp) ;
06804 }
06805 
06806 static int G__G__TMVA3_493_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06807 {
06808       G__letint(result7, 67, (long) TMVA::SVEvent::DeclFileName());
06809    return(1 || funcname || hash || result7 || libp) ;
06810 }
06811 
06812 static int G__G__TMVA3_493_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06813 {
06814       G__letint(result7, 105, (long) TMVA::SVEvent::ImplFileLine());
06815    return(1 || funcname || hash || result7 || libp) ;
06816 }
06817 
06818 static int G__G__TMVA3_493_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06819 {
06820       G__letint(result7, 67, (long) TMVA::SVEvent::ImplFileName());
06821    return(1 || funcname || hash || result7 || libp) ;
06822 }
06823 
06824 static int G__G__TMVA3_493_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06825 {
06826       G__letint(result7, 105, (long) TMVA::SVEvent::DeclFileLine());
06827    return(1 || funcname || hash || result7 || libp) ;
06828 }
06829 
06830 // automatic copy constructor
06831 static int G__G__TMVA3_493_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06832 
06833 {
06834    TMVA::SVEvent* p;
06835    void* tmp = (void*) G__int(libp->para[0]);
06836    p = new TMVA::SVEvent(*(TMVA::SVEvent*) tmp);
06837    result7->obj.i = (long) p;
06838    result7->ref = (long) p;
06839    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent));
06840    return(1 || funcname || hash || result7 || libp) ;
06841 }
06842 
06843 // automatic destructor
06844 typedef TMVA::SVEvent G__TTMVAcLcLSVEvent;
06845 static int G__G__TMVA3_493_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06846 {
06847    char* gvp = (char*) G__getgvp();
06848    long soff = G__getstructoffset();
06849    int n = G__getaryconstruct();
06850    //
06851    //has_a_delete: 0
06852    //has_own_delete1arg: 0
06853    //has_own_delete2arg: 0
06854    //
06855    if (!soff) {
06856      return(1);
06857    }
06858    if (n) {
06859      if (gvp == (char*)G__PVOID) {
06860        delete[] (TMVA::SVEvent*) soff;
06861      } else {
06862        G__setgvp((long) G__PVOID);
06863        for (int i = n - 1; i >= 0; --i) {
06864          ((TMVA::SVEvent*) (soff+(sizeof(TMVA::SVEvent)*i)))->~G__TTMVAcLcLSVEvent();
06865        }
06866        G__setgvp((long)gvp);
06867      }
06868    } else {
06869      if (gvp == (char*)G__PVOID) {
06870        delete (TMVA::SVEvent*) soff;
06871      } else {
06872        G__setgvp((long) G__PVOID);
06873        ((TMVA::SVEvent*) (soff))->~G__TTMVAcLcLSVEvent();
06874        G__setgvp((long)gvp);
06875      }
06876    }
06877    G__setnull(result7);
06878    return(1 || funcname || hash || result7 || libp) ;
06879 }
06880 
06881 
06882 /* TMVA::OptimizeConfigParameters */
06883 static int G__G__TMVA3_548_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06884 {
06885    TMVA::OptimizeConfigParameters* p = NULL;
06886    char* gvp = (char*) G__getgvp();
06887    switch (libp->paran) {
06888    case 4:
06889      //m: 4
06890      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06891        p = new TMVA::OptimizeConfigParameters(
06892 (TMVA::MethodBase*) G__int(libp->para[0]), *((map<TString,TMVA::Interval>*) G__int(libp->para[1]))
06893 , *((TString*) G__int(libp->para[2])), *((TString*) G__int(libp->para[3])));
06894      } else {
06895        p = new((void*) gvp) TMVA::OptimizeConfigParameters(
06896 (TMVA::MethodBase*) G__int(libp->para[0]), *((map<TString,TMVA::Interval>*) G__int(libp->para[1]))
06897 , *((TString*) G__int(libp->para[2])), *((TString*) G__int(libp->para[3])));
06898      }
06899      break;
06900    case 3:
06901      //m: 3
06902      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06903        p = new TMVA::OptimizeConfigParameters(
06904 (TMVA::MethodBase*) G__int(libp->para[0]), *((map<TString,TMVA::Interval>*) G__int(libp->para[1]))
06905 , *((TString*) G__int(libp->para[2])));
06906      } else {
06907        p = new((void*) gvp) TMVA::OptimizeConfigParameters(
06908 (TMVA::MethodBase*) G__int(libp->para[0]), *((map<TString,TMVA::Interval>*) G__int(libp->para[1]))
06909 , *((TString*) G__int(libp->para[2])));
06910      }
06911      break;
06912    case 2:
06913      //m: 2
06914      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
06915        p = new TMVA::OptimizeConfigParameters((TMVA::MethodBase*) G__int(libp->para[0]), *((map<TString,TMVA::Interval>*) G__int(libp->para[1])));
06916      } else {
06917        p = new((void*) gvp) TMVA::OptimizeConfigParameters((TMVA::MethodBase*) G__int(libp->para[0]), *((map<TString,TMVA::Interval>*) G__int(libp->para[1])));
06918      }
06919      break;
06920    }
06921    result7->obj.i = (long) p;
06922    result7->ref = (long) p;
06923    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters));
06924    return(1 || funcname || hash || result7 || libp) ;
06925 }
06926 
06927 static int G__G__TMVA3_548_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06928 {
06929       {
06930          map<TString,Double_t>* pobj;
06931          map<TString,Double_t> xobj = ((TMVA::OptimizeConfigParameters*) G__getstructoffset())->optimize();
06932          pobj = new map<TString,Double_t>(xobj);
06933          result7->obj.i = (long) ((void*) pobj);
06934          result7->ref = result7->obj.i;
06935          G__store_tempobject(*result7);
06936       }
06937    return(1 || funcname || hash || result7 || libp) ;
06938 }
06939 
06940 static int G__G__TMVA3_548_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06941 {
06942       G__letint(result7, 85, (long) TMVA::OptimizeConfigParameters::Class());
06943    return(1 || funcname || hash || result7 || libp) ;
06944 }
06945 
06946 static int G__G__TMVA3_548_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06947 {
06948       G__letint(result7, 67, (long) TMVA::OptimizeConfigParameters::Class_Name());
06949    return(1 || funcname || hash || result7 || libp) ;
06950 }
06951 
06952 static int G__G__TMVA3_548_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06953 {
06954       G__letint(result7, 115, (long) TMVA::OptimizeConfigParameters::Class_Version());
06955    return(1 || funcname || hash || result7 || libp) ;
06956 }
06957 
06958 static int G__G__TMVA3_548_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06959 {
06960       TMVA::OptimizeConfigParameters::Dictionary();
06961       G__setnull(result7);
06962    return(1 || funcname || hash || result7 || libp) ;
06963 }
06964 
06965 static int G__G__TMVA3_548_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06966 {
06967       ((TMVA::OptimizeConfigParameters*) G__getstructoffset())->StreamerNVirtual(*(TBuffer*) libp->para[0].ref);
06968       G__setnull(result7);
06969    return(1 || funcname || hash || result7 || libp) ;
06970 }
06971 
06972 static int G__G__TMVA3_548_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06973 {
06974       G__letint(result7, 67, (long) TMVA::OptimizeConfigParameters::DeclFileName());
06975    return(1 || funcname || hash || result7 || libp) ;
06976 }
06977 
06978 static int G__G__TMVA3_548_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06979 {
06980       G__letint(result7, 105, (long) TMVA::OptimizeConfigParameters::ImplFileLine());
06981    return(1 || funcname || hash || result7 || libp) ;
06982 }
06983 
06984 static int G__G__TMVA3_548_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06985 {
06986       G__letint(result7, 67, (long) TMVA::OptimizeConfigParameters::ImplFileName());
06987    return(1 || funcname || hash || result7 || libp) ;
06988 }
06989 
06990 static int G__G__TMVA3_548_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06991 {
06992       G__letint(result7, 105, (long) TMVA::OptimizeConfigParameters::DeclFileLine());
06993    return(1 || funcname || hash || result7 || libp) ;
06994 }
06995 
06996 // automatic copy constructor
06997 static int G__G__TMVA3_548_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
06998 
06999 {
07000    TMVA::OptimizeConfigParameters* p;
07001    void* tmp = (void*) G__int(libp->para[0]);
07002    p = new TMVA::OptimizeConfigParameters(*(TMVA::OptimizeConfigParameters*) tmp);
07003    result7->obj.i = (long) p;
07004    result7->ref = (long) p;
07005    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters));
07006    return(1 || funcname || hash || result7 || libp) ;
07007 }
07008 
07009 // automatic destructor
07010 typedef TMVA::OptimizeConfigParameters G__TTMVAcLcLOptimizeConfigParameters;
07011 static int G__G__TMVA3_548_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
07012 {
07013    char* gvp = (char*) G__getgvp();
07014    long soff = G__getstructoffset();
07015    int n = G__getaryconstruct();
07016    //
07017    //has_a_delete: 0
07018    //has_own_delete1arg: 0
07019    //has_own_delete2arg: 0
07020    //
07021    if (!soff) {
07022      return(1);
07023    }
07024    if (n) {
07025      if (gvp == (char*)G__PVOID) {
07026        delete[] (TMVA::OptimizeConfigParameters*) soff;
07027      } else {
07028        G__setgvp((long) G__PVOID);
07029        for (int i = n - 1; i >= 0; --i) {
07030          ((TMVA::OptimizeConfigParameters*) (soff+(sizeof(TMVA::OptimizeConfigParameters)*i)))->~G__TTMVAcLcLOptimizeConfigParameters();
07031        }
07032        G__setgvp((long)gvp);
07033      }
07034    } else {
07035      if (gvp == (char*)G__PVOID) {
07036        delete (TMVA::OptimizeConfigParameters*) soff;
07037      } else {
07038        G__setgvp((long) G__PVOID);
07039        ((TMVA::OptimizeConfigParameters*) (soff))->~G__TTMVAcLcLOptimizeConfigParameters();
07040        G__setgvp((long)gvp);
07041      }
07042    }
07043    G__setnull(result7);
07044    return(1 || funcname || hash || result7 || libp) ;
07045 }
07046 
07047 
07048 /* Setting up global function */
07049 
07050 /*********************************************************
07051 * Member function Stub
07052 *********************************************************/
07053 
07054 /* TMVA */
07055 
07056 /* TMVA::Config */
07057 
07058 /* TMVA::Config::VariablePlotting */
07059 
07060 /* TMVA::Config::IONames */
07061 
07062 /* TMVA::KDEKernel */
07063 
07064 /* TMVA::Interval */
07065 
07066 /* TMVA::IFitterTarget */
07067 
07068 /* TMVA::FitterBase */
07069 
07070 /* TMVA::MCFitter */
07071 
07072 /* TMVA::GeneticFitter */
07073 
07074 /* TMVA::SimulatedAnnealingFitter */
07075 
07076 /* TMVA::MinuitWrapper */
07077 
07078 /* TMVA::MinuitFitter */
07079 
07080 /* TMVA::PDEFoamCell */
07081 
07082 /* TMVA::PDEFoamVect */
07083 
07084 /* TMVA::PDEFoamDistr */
07085 
07086 /* TMVA::PDEFoam */
07087 
07088 /* TMVA::BDTEventWrapper */
07089 
07090 /* TMVA::CCTreeWrapper */
07091 
07092 /* TMVA::CCPruner */
07093 
07094 /* TMVA::CostComplexityPruneTool */
07095 
07096 /* TMVA::SVEvent */
07097 
07098 /* TMVA::OptimizeConfigParameters */
07099 
07100 /*********************************************************
07101 * Global function Stub
07102 *********************************************************/
07103 
07104 /*********************************************************
07105 * Get size of pointer to member function
07106 *********************************************************/
07107 class G__Sizep2memfuncG__TMVA3 {
07108  public:
07109   G__Sizep2memfuncG__TMVA3(): p(&G__Sizep2memfuncG__TMVA3::sizep2memfunc) {}
07110     size_t sizep2memfunc() { return(sizeof(p)); }
07111   private:
07112     size_t (G__Sizep2memfuncG__TMVA3::*p)();
07113 };
07114 
07115 size_t G__get_sizep2memfuncG__TMVA3()
07116 {
07117   G__Sizep2memfuncG__TMVA3 a;
07118   G__setsizep2memfunc((int)a.sizep2memfunc());
07119   return((size_t)a.sizep2memfunc());
07120 }
07121 
07122 
07123 /*********************************************************
07124 * virtual base class offset calculation interface
07125 *********************************************************/
07126 
07127    /* Setting up class inheritance */
07128 
07129 /*********************************************************
07130 * Inheritance information setup/
07131 *********************************************************/
07132 extern "C" void G__cpp_setup_inheritanceG__TMVA3() {
07133 
07134    /* Setting up class inheritance */
07135    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLFitterBase))) {
07136      TMVA::FitterBase *G__Lderived;
07137      G__Lderived=(TMVA::FitterBase*)0x1000;
07138      {
07139        TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
07140        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLFitterBase),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,1);
07141      }
07142      {
07143        TObject *G__Lpbase=(TObject*)G__Lderived;
07144        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLFitterBase),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07145      }
07146    }
07147    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMCFitter))) {
07148      TMVA::MCFitter *G__Lderived;
07149      G__Lderived=(TMVA::MCFitter*)0x1000;
07150      {
07151        TMVA::FitterBase *G__Lpbase=(TMVA::FitterBase*)G__Lderived;
07152        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMCFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLFitterBase),(long)G__Lpbase-(long)G__Lderived,1,1);
07153      }
07154      {
07155        TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
07156        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMCFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
07157      }
07158      {
07159        TObject *G__Lpbase=(TObject*)G__Lderived;
07160        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMCFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07161      }
07162    }
07163    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLGeneticFitter))) {
07164      TMVA::GeneticFitter *G__Lderived;
07165      G__Lderived=(TMVA::GeneticFitter*)0x1000;
07166      {
07167        TMVA::FitterBase *G__Lpbase=(TMVA::FitterBase*)G__Lderived;
07168        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLGeneticFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLFitterBase),(long)G__Lpbase-(long)G__Lderived,1,1);
07169      }
07170      {
07171        TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
07172        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLGeneticFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
07173      }
07174      {
07175        TObject *G__Lpbase=(TObject*)G__Lderived;
07176        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLGeneticFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07177      }
07178    }
07179    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter))) {
07180      TMVA::SimulatedAnnealingFitter *G__Lderived;
07181      G__Lderived=(TMVA::SimulatedAnnealingFitter*)0x1000;
07182      {
07183        TMVA::FitterBase *G__Lpbase=(TMVA::FitterBase*)G__Lderived;
07184        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLFitterBase),(long)G__Lpbase-(long)G__Lderived,1,1);
07185      }
07186      {
07187        TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
07188        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
07189      }
07190      {
07191        TObject *G__Lpbase=(TObject*)G__Lderived;
07192        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07193      }
07194    }
07195    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitWrapper))) {
07196      TMVA::MinuitWrapper *G__Lderived;
07197      G__Lderived=(TMVA::MinuitWrapper*)0x1000;
07198      {
07199        TMinuit *G__Lpbase=(TMinuit*)G__Lderived;
07200        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitWrapper),G__get_linked_tagnum(&G__G__TMVA3LN_TMinuit),(long)G__Lpbase-(long)G__Lderived,1,1);
07201      }
07202      {
07203        TNamed *G__Lpbase=(TNamed*)G__Lderived;
07204        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitWrapper),G__get_linked_tagnum(&G__G__TMVA3LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
07205      }
07206      {
07207        TObject *G__Lpbase=(TObject*)G__Lderived;
07208        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitWrapper),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07209      }
07210    }
07211    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitFitter))) {
07212      TMVA::MinuitFitter *G__Lderived;
07213      G__Lderived=(TMVA::MinuitFitter*)0x1000;
07214      {
07215        TMVA::FitterBase *G__Lpbase=(TMVA::FitterBase*)G__Lderived;
07216        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLFitterBase),(long)G__Lpbase-(long)G__Lderived,1,1);
07217      }
07218      {
07219        TMVA::Configurable *G__Lpbase=(TMVA::Configurable*)G__Lderived;
07220        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigurable),(long)G__Lpbase-(long)G__Lderived,1,0);
07221      }
07222      {
07223        TObject *G__Lpbase=(TObject*)G__Lderived;
07224        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07225      }
07226      {
07227        TMVA::IFitterTarget *G__Lpbase=(TMVA::IFitterTarget*)G__Lderived;
07228        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitFitter),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLIFitterTarget),(long)G__Lpbase-(long)G__Lderived,1,1);
07229      }
07230    }
07231    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMinuit))) {
07232      TMinuit *G__Lderived;
07233      G__Lderived=(TMinuit*)0x1000;
07234      {
07235        TNamed *G__Lpbase=(TNamed*)G__Lderived;
07236        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMinuit),G__get_linked_tagnum(&G__G__TMVA3LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,1);
07237      }
07238      {
07239        TObject *G__Lpbase=(TObject*)G__Lderived;
07240        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMinuit),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
07241      }
07242    }
07243    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell))) {
07244      TMVA::PDEFoamCell *G__Lderived;
07245      G__Lderived=(TMVA::PDEFoamCell*)0x1000;
07246      {
07247        TObject *G__Lpbase=(TObject*)G__Lderived;
07248        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
07249      }
07250    }
07251    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect))) {
07252      TMVA::PDEFoamVect *G__Lderived;
07253      G__Lderived=(TMVA::PDEFoamVect*)0x1000;
07254      {
07255        TObject *G__Lpbase=(TObject*)G__Lderived;
07256        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
07257      }
07258    }
07259    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDistr))) {
07260      TMVA::PDEFoamDistr *G__Lderived;
07261      G__Lderived=(TMVA::PDEFoamDistr*)0x1000;
07262      {
07263        TObject *G__Lpbase=(TObject*)G__Lderived;
07264        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDistr),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
07265      }
07266    }
07267    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam))) {
07268      TMVA::PDEFoam *G__Lderived;
07269      G__Lderived=(TMVA::PDEFoam*)0x1000;
07270      {
07271        TObject *G__Lpbase=(TObject*)G__Lderived;
07272        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam),G__get_linked_tagnum(&G__G__TMVA3LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,1);
07273      }
07274    }
07275    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool))) {
07276      TMVA::CostComplexityPruneTool *G__Lderived;
07277      G__Lderived=(TMVA::CostComplexityPruneTool*)0x1000;
07278      {
07279        TMVA::IPruneTool *G__Lpbase=(TMVA::IPruneTool*)G__Lderived;
07280        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLIPruneTool),(long)G__Lpbase-(long)G__Lderived,1,1);
07281      }
07282    }
07283    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters))) {
07284      TMVA::OptimizeConfigParameters *G__Lderived;
07285      G__Lderived=(TMVA::OptimizeConfigParameters*)0x1000;
07286      {
07287        TMVA::IFitterTarget *G__Lpbase=(TMVA::IFitterTarget*)G__Lderived;
07288        G__inheritance_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters),G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLIFitterTarget),(long)G__Lpbase-(long)G__Lderived,1,1);
07289      }
07290    }
07291 }
07292 
07293 /*********************************************************
07294 * typedef information setup/
07295 *********************************************************/
07296 extern "C" void G__cpp_setup_typetableG__TMVA3() {
07297 
07298    /* Setting up typedef entry */
07299    G__search_typename2("Int_t",105,-1,0,-1);
07300    G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
07301    G__search_typename2("UInt_t",104,-1,0,-1);
07302    G__setnewtype(-1,"Unsigned integer 4 bytes (unsigned int)",0);
07303    G__search_typename2("Long_t",108,-1,0,-1);
07304    G__setnewtype(-1,"Signed long integer 4 bytes (long)",0);
07305    G__search_typename2("Float_t",102,-1,0,-1);
07306    G__setnewtype(-1,"Float 4 bytes (float)",0);
07307    G__search_typename2("Double_t",100,-1,0,-1);
07308    G__setnewtype(-1,"Double 8 bytes",0);
07309    G__search_typename2("Bool_t",103,-1,0,-1);
07310    G__setnewtype(-1,"Boolean (0=false, 1=true) (bool)",0);
07311    G__search_typename2("Version_t",115,-1,0,-1);
07312    G__setnewtype(-1,"Class version identifier (short)",0);
07313    G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
07314    G__setnewtype(-1,NULL,0);
07315    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
07316    G__setnewtype(-1,NULL,0);
07317    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
07318    G__setnewtype(-1,NULL,0);
07319    G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
07320    G__setnewtype(-1,NULL,0);
07321    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
07322    G__setnewtype(-1,NULL,0);
07323    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
07324    G__setnewtype(-1,NULL,0);
07325    G__search_typename2("iterator<std::bidirectional_iterator_tag,TObject*,std::ptrdiff_t,const TObject**,const TObject*&>",117,G__get_linked_tagnum(&G__G__TMVA3LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
07326    G__setnewtype(-1,NULL,0);
07327    G__search_typename2("iterator<bidirectional_iterator_tag,TObject*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
07328    G__setnewtype(-1,NULL,0);
07329    G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long>",117,G__get_linked_tagnum(&G__G__TMVA3LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
07330    G__setnewtype(-1,NULL,0);
07331    G__search_typename2("iterator<bidirectional_iterator_tag,TObject*,long,const TObject**>",117,G__get_linked_tagnum(&G__G__TMVA3LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR),0,-1);
07332    G__setnewtype(-1,NULL,0);
07333    G__search_typename2("TMVAVersion_t",104,-1,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVA));
07334    G__setnewtype(-1,NULL,0);
07335    G__search_typename2("map<TString,TMVA::Types::EMVA>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR),0,-1);
07336    G__setnewtype(-1,NULL,0);
07337    G__search_typename2("map<TString,TMVA::Types::EMVA,less<TString> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR),0,-1);
07338    G__setnewtype(-1,NULL,0);
07339    G__search_typename2("map<EMsgType,std::string>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR),0,-1);
07340    G__setnewtype(-1,NULL,0);
07341    G__search_typename2("map<TMVA::EMsgType,string>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR),0,-1);
07342    G__setnewtype(-1,NULL,0);
07343    G__search_typename2("map<TMVA::EMsgType,string,less<TMVA::EMsgType> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR),0,-1);
07344    G__setnewtype(-1,NULL,0);
07345    G__search_typename2("Option<Bool_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptionlEboolgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVA));
07346    G__setnewtype(-1,NULL,0);
07347    G__search_typename2("vector<bool>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEboolcOallocatorlEboolgRsPgR),0,-1);
07348    G__setnewtype(-1,NULL,0);
07349    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEboolcOallocatorlEboolgRsPgR));
07350    G__setnewtype(-1,NULL,0);
07351    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEboolcOallocatorlEboolgRsPgR));
07352    G__setnewtype(-1,NULL,0);
07353    G__search_typename2("Option<Bool_t*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptionlEboolmUgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVA));
07354    G__setnewtype(-1,NULL,0);
07355    G__search_typename2("vector<TString>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETStringcOallocatorlETStringgRsPgR),0,-1);
07356    G__setnewtype(-1,NULL,0);
07357    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETStringcOallocatorlETStringgRsPgR));
07358    G__setnewtype(-1,NULL,0);
07359    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETStringcOallocatorlETStringgRsPgR));
07360    G__setnewtype(-1,NULL,0);
07361    G__search_typename2("Option<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptionlEfloatgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVA));
07362    G__setnewtype(-1,NULL,0);
07363    G__search_typename2("vector<float>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
07364    G__setnewtype(-1,NULL,0);
07365    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR));
07366    G__setnewtype(-1,NULL,0);
07367    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR));
07368    G__setnewtype(-1,NULL,0);
07369    G__search_typename2("vector<TMVA::Interval*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR),0,-1);
07370    G__setnewtype(-1,NULL,0);
07371    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR));
07372    G__setnewtype(-1,NULL,0);
07373    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR));
07374    G__setnewtype(-1,NULL,0);
07375    G__search_typename2("vector<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
07376    G__setnewtype(-1,NULL,0);
07377    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR));
07378    G__setnewtype(-1,NULL,0);
07379    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR));
07380    G__setnewtype(-1,NULL,0);
07381    G__search_typename2("vector<double>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
07382    G__setnewtype(-1,NULL,0);
07383    G__search_typename2("TVectorT<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TVectorTlEfloatgR),0,-1);
07384    G__setnewtype(-1,NULL,0);
07385    G__search_typename2("TVectorT<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TVectorTlEdoublegR),0,-1);
07386    G__setnewtype(-1,NULL,0);
07387    G__search_typename2("TMatrixTBase<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTBaselEfloatgR),0,-1);
07388    G__setnewtype(-1,NULL,0);
07389    G__search_typename2("TMatrixTBase<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTBaselEdoublegR),0,-1);
07390    G__setnewtype(-1,NULL,0);
07391    G__search_typename2("vector<Float_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR),0,-1);
07392    G__setnewtype(-1,NULL,0);
07393    G__search_typename2("vector<const TMVA::BinarySearchTreeNode*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR),0,-1);
07394    G__setnewtype(-1,NULL,0);
07395    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR));
07396    G__setnewtype(-1,NULL,0);
07397    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR));
07398    G__setnewtype(-1,NULL,0);
07399    G__search_typename2("vector<TMVA::Event*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),0,-1);
07400    G__setnewtype(-1,NULL,0);
07401    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR));
07402    G__setnewtype(-1,NULL,0);
07403    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR));
07404    G__setnewtype(-1,NULL,0);
07405    G__search_typename2("vector<Int_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
07406    G__setnewtype(-1,NULL,0);
07407    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEintcOallocatorlEintgRsPgR));
07408    G__setnewtype(-1,NULL,0);
07409    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEintcOallocatorlEintgRsPgR));
07410    G__setnewtype(-1,NULL,0);
07411    G__search_typename2("vector<int>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEintcOallocatorlEintgRsPgR),0,-1);
07412    G__setnewtype(-1,NULL,0);
07413    G__search_typename2("pair<Double_t,const TMVA::Event*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR),0,-1);
07414    G__setnewtype(-1,NULL,0);
07415    G__search_typename2("vector<std::pair<Double_t,const TMVA::Event*> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR),0,-1);
07416    G__setnewtype(-1,NULL,0);
07417    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR));
07418    G__setnewtype(-1,NULL,0);
07419    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR));
07420    G__setnewtype(-1,NULL,0);
07421    G__search_typename2("vector<pair<double,const TMVA::Event*> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR),0,-1);
07422    G__setnewtype(-1,NULL,0);
07423    G__search_typename2("vector<Float_t*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR),0,-1);
07424    G__setnewtype(-1,NULL,0);
07425    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR));
07426    G__setnewtype(-1,NULL,0);
07427    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR));
07428    G__setnewtype(-1,NULL,0);
07429    G__search_typename2("vector<float*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR),0,-1);
07430    G__setnewtype(-1,NULL,0);
07431    G__search_typename2("vector<UInt_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
07432    G__setnewtype(-1,NULL,0);
07433    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
07434    G__setnewtype(-1,NULL,0);
07435    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
07436    G__setnewtype(-1,NULL,0);
07437    G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
07438    G__setnewtype(-1,NULL,0);
07439    G__search_typename2("vector<TH1F*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR),0,-1);
07440    G__setnewtype(-1,NULL,0);
07441    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR));
07442    G__setnewtype(-1,NULL,0);
07443    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR));
07444    G__setnewtype(-1,NULL,0);
07445    G__search_typename2("vector<TMVA::PDEFoamCell*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR),0,-1);
07446    G__setnewtype(-1,NULL,0);
07447    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR));
07448    G__setnewtype(-1,NULL,0);
07449    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR));
07450    G__setnewtype(-1,NULL,0);
07451    G__search_typename2("vector<PDEFoamCell*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam));
07452    G__setnewtype(-1,NULL,0);
07453    G__search_typename2("map<std::string,TObjArray*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
07454    G__setnewtype(-1,NULL,0);
07455    G__search_typename2("map<string,TObjArray*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
07456    G__setnewtype(-1,NULL,0);
07457    G__search_typename2("map<string,TObjArray*,less<string> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR),0,-1);
07458    G__setnewtype(-1,NULL,0);
07459    G__search_typename2("TMatrixT<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTlEdoublegR),0,-1);
07460    G__setnewtype(-1,NULL,0);
07461    G__search_typename2("TMatrixTRow_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTRow_constlEdoublegR),0,-1);
07462    G__setnewtype(-1,NULL,0);
07463    G__search_typename2("TMatrixTColumn_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTColumn_constlEdoublegR),0,-1);
07464    G__setnewtype(-1,NULL,0);
07465    G__search_typename2("TMatrixTDiag_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTDiag_constlEdoublegR),0,-1);
07466    G__setnewtype(-1,NULL,0);
07467    G__search_typename2("TMatrixTFlat_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTFlat_constlEdoublegR),0,-1);
07468    G__setnewtype(-1,NULL,0);
07469    G__search_typename2("TMatrixTSub_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTSub_constlEdoublegR),0,-1);
07470    G__setnewtype(-1,NULL,0);
07471    G__search_typename2("TMatrixTSparseRow_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTSparseRow_constlEdoublegR),0,-1);
07472    G__setnewtype(-1,NULL,0);
07473    G__search_typename2("TMatrixTSparseDiag_const<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTSparseDiag_constlEdoublegR),0,-1);
07474    G__setnewtype(-1,NULL,0);
07475    G__search_typename2("TMatrixTRow<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTRowlEdoublegR),0,-1);
07476    G__setnewtype(-1,NULL,0);
07477    G__search_typename2("TMatrixTColumn<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTColumnlEdoublegR),0,-1);
07478    G__setnewtype(-1,NULL,0);
07479    G__search_typename2("TMatrixTDiag<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTDiaglEdoublegR),0,-1);
07480    G__setnewtype(-1,NULL,0);
07481    G__search_typename2("TMatrixTFlat<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTFlatlEdoublegR),0,-1);
07482    G__setnewtype(-1,NULL,0);
07483    G__search_typename2("TMatrixTSub<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTSublEdoublegR),0,-1);
07484    G__setnewtype(-1,NULL,0);
07485    G__search_typename2("TMatrixTSparseRow<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTSparseRowlEdoublegR),0,-1);
07486    G__setnewtype(-1,NULL,0);
07487    G__search_typename2("TMatrixTSparseDiag<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTSparseDiaglEdoublegR),0,-1);
07488    G__setnewtype(-1,NULL,0);
07489    G__search_typename2("TElementActionT<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TElementActionTlEdoublegR),0,-1);
07490    G__setnewtype(-1,NULL,0);
07491    G__search_typename2("TElementPosActionT<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TElementPosActionTlEdoublegR),0,-1);
07492    G__setnewtype(-1,NULL,0);
07493    G__search_typename2("TMatrixTSym<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTSymlEdoublegR),0,-1);
07494    G__setnewtype(-1,NULL,0);
07495    G__search_typename2("TMatrixTSparse<Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_TMatrixTSparselEdoublegR),0,-1);
07496    G__setnewtype(-1,NULL,0);
07497    G__search_typename2("vector<std::vector<Event*>*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR),0,-1);
07498    G__setnewtype(-1,NULL,0);
07499    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR));
07500    G__setnewtype(-1,NULL,0);
07501    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR));
07502    G__setnewtype(-1,NULL,0);
07503    G__search_typename2("vector<vector<TMVA::Event*,allocator<TMVA::Event*> >*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR),0,-1);
07504    G__setnewtype(-1,NULL,0);
07505    G__search_typename2("map<TString,Results*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgR),0,-1);
07506    G__setnewtype(-1,NULL,0);
07507    G__search_typename2("map<TString,TMVA::Results*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgR),0,-1);
07508    G__setnewtype(-1,NULL,0);
07509    G__search_typename2("map<TString,TMVA::Results*,less<TString> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgR),0,-1);
07510    G__setnewtype(-1,NULL,0);
07511    G__search_typename2("vector<std::map<TString,Results*> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR),0,-1);
07512    G__setnewtype(-1,NULL,0);
07513    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR));
07514    G__setnewtype(-1,NULL,0);
07515    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR));
07516    G__setnewtype(-1,NULL,0);
07517    G__search_typename2("vector<map<TString,TMVA::Results*,less<TString>,allocator<pair<const TString,TMVA::Results*> > > >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR),0,-1);
07518    G__setnewtype(-1,NULL,0);
07519    G__search_typename2("vector<Char_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEcharcOallocatorlEchargRsPgR),0,-1);
07520    G__setnewtype(-1,NULL,0);
07521    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEcharcOallocatorlEchargRsPgR));
07522    G__setnewtype(-1,NULL,0);
07523    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEcharcOallocatorlEchargRsPgR));
07524    G__setnewtype(-1,NULL,0);
07525    G__search_typename2("vector<char>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEcharcOallocatorlEchargRsPgR),0,-1);
07526    G__setnewtype(-1,NULL,0);
07527    G__search_typename2("pair<Float_t,Long64_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_pairlEfloatcOlongsPlonggR),0,-1);
07528    G__setnewtype(-1,NULL,0);
07529    G__search_typename2("vector<std::pair<Float_t,Long64_t>*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR),0,-1);
07530    G__setnewtype(-1,NULL,0);
07531    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR));
07532    G__setnewtype(-1,NULL,0);
07533    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR));
07534    G__setnewtype(-1,NULL,0);
07535    G__search_typename2("vector<pair<float,long long>*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR),0,-1);
07536    G__setnewtype(-1,NULL,0);
07537    G__search_typename2("vector<std::vector<std::pair<Float_t,Long64_t>*> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR),0,-1);
07538    G__setnewtype(-1,NULL,0);
07539    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR));
07540    G__setnewtype(-1,NULL,0);
07541    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR));
07542    G__setnewtype(-1,NULL,0);
07543    G__search_typename2("vector<vector<pair<float,long long>*,allocator<pair<float,long long>*> > >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR),0,-1);
07544    G__setnewtype(-1,NULL,0);
07545    G__search_typename2("vector<Long64_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR),0,-1);
07546    G__setnewtype(-1,NULL,0);
07547    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR));
07548    G__setnewtype(-1,NULL,0);
07549    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR));
07550    G__setnewtype(-1,NULL,0);
07551    G__search_typename2("vector<long long>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR),0,-1);
07552    G__setnewtype(-1,NULL,0);
07553    G__search_typename2("vector<std::vector<Long64_t> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR),0,-1);
07554    G__setnewtype(-1,NULL,0);
07555    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR));
07556    G__setnewtype(-1,NULL,0);
07557    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR));
07558    G__setnewtype(-1,NULL,0);
07559    G__search_typename2("vector<vector<long long,allocator<long long> > >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR),0,-1);
07560    G__setnewtype(-1,NULL,0);
07561    G__search_typename2("vector<Event*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrapper));
07562    G__setnewtype(-1,NULL,0);
07563    G__search_typename2("EventList",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrapper));
07564    G__setnewtype(-1,NULL,0);
07565    G__search_typename2("vector<Event*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCPruner));
07566    G__setnewtype(-1,NULL,0);
07567    G__search_typename2("EventList",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCPruner));
07568    G__setnewtype(-1,NULL,0);
07569    G__search_typename2("vector<TMVA::DecisionTreeNode*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgR),0,-1);
07570    G__setnewtype(-1,NULL,0);
07571    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgR));
07572    G__setnewtype(-1,NULL,0);
07573    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgR));
07574    G__setnewtype(-1,NULL,0);
07575    G__search_typename2("vector<Event*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLIPruneTool));
07576    G__setnewtype(-1,NULL,0);
07577    G__search_typename2("vector<DecisionTreeNode*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool));
07578    G__setnewtype(-1,NULL,0);
07579    G__search_typename2("vector<VariableInfo>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR),0,-1);
07580    G__setnewtype(-1,NULL,0);
07581    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR));
07582    G__setnewtype(-1,NULL,0);
07583    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR));
07584    G__setnewtype(-1,NULL,0);
07585    G__search_typename2("vector<TMVA::VariableInfo>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR),0,-1);
07586    G__setnewtype(-1,NULL,0);
07587    G__search_typename2("vector<ClassInfo*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR),0,-1);
07588    G__setnewtype(-1,NULL,0);
07589    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR));
07590    G__setnewtype(-1,NULL,0);
07591    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR));
07592    G__setnewtype(-1,NULL,0);
07593    G__search_typename2("vector<TMVA::ClassInfo*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR),0,-1);
07594    G__setnewtype(-1,NULL,0);
07595    G__search_typename2("vector<TMVA::TransformationHandler::VariableStat>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgR),0,-1);
07596    G__setnewtype(-1,NULL,0);
07597    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgR));
07598    G__setnewtype(-1,NULL,0);
07599    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgR));
07600    G__setnewtype(-1,NULL,0);
07601    G__search_typename2("vector<std::vector<TMVA::TransformationHandler::VariableStat> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR),0,-1);
07602    G__setnewtype(-1,NULL,0);
07603    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR));
07604    G__setnewtype(-1,NULL,0);
07605    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR));
07606    G__setnewtype(-1,NULL,0);
07607    G__search_typename2("vector<vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> > >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR),0,-1);
07608    G__setnewtype(-1,NULL,0);
07609    G__search_typename2("vector<Ranking*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR),0,-1);
07610    G__setnewtype(-1,NULL,0);
07611    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR));
07612    G__setnewtype(-1,NULL,0);
07613    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR));
07614    G__setnewtype(-1,NULL,0);
07615    G__search_typename2("vector<TMVA::Ranking*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR),0,-1);
07616    G__setnewtype(-1,NULL,0);
07617    G__search_typename2("map<TString,Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR),0,-1);
07618    G__setnewtype(-1,NULL,0);
07619    G__search_typename2("map<TString,double>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR),0,-1);
07620    G__setnewtype(-1,NULL,0);
07621    G__search_typename2("map<TString,double,less<TString> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR),0,-1);
07622    G__setnewtype(-1,NULL,0);
07623    G__search_typename2("vector<std::vector<Float_t> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),0,-1);
07624    G__setnewtype(-1,NULL,0);
07625    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR));
07626    G__setnewtype(-1,NULL,0);
07627    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR));
07628    G__setnewtype(-1,NULL,0);
07629    G__search_typename2("vector<vector<float,allocator<float> > >",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR),0,-1);
07630    G__setnewtype(-1,NULL,0);
07631    G__search_typename2("vector<const std::vector<TMVA::Event*>*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR),0,-1);
07632    G__setnewtype(-1,NULL,0);
07633    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR));
07634    G__setnewtype(-1,NULL,0);
07635    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR));
07636    G__setnewtype(-1,NULL,0);
07637    G__search_typename2("vector<const vector<TMVA::Event*,allocator<TMVA::Event*> >*>",117,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR),0,-1);
07638    G__setnewtype(-1,NULL,0);
07639    G__search_typename2("map<TString,TMVA::Interval>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOTMVAcLcLIntervalcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIntervalgRsPgRsPgR),0,-1);
07640    G__setnewtype(-1,NULL,0);
07641    G__search_typename2("map<TString,TMVA::Interval,less<TString> >",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOTMVAcLcLIntervalcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIntervalgRsPgRsPgR),0,-1);
07642    G__setnewtype(-1,NULL,0);
07643    G__search_typename2("map<std::vector<Double_t>,Double_t>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR),0,-1);
07644    G__setnewtype(-1,NULL,0);
07645    G__search_typename2("map<vector<double,allocator<double> >,double>",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR),0,-1);
07646    G__setnewtype(-1,NULL,0);
07647    G__search_typename2("map<vector<double,allocator<double> >,double,less<vector<double,allocator<double> > > >",117,G__get_linked_tagnum(&G__G__TMVA3LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR),0,-1);
07648    G__setnewtype(-1,NULL,0);
07649 }
07650 
07651 /*********************************************************
07652 * Data Member information setup/
07653 *********************************************************/
07654 
07655    /* Setting up class,struct,union tag member variable */
07656 
07657    /* TMVA */
07658 static void G__setup_memvarTMVA(void) {
07659    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVA));
07660    {
07661    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kDEBUG=%lldLL",(long long)TMVA::kDEBUG).data(),0,(char*)NULL);
07662    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kVERBOSE=%lldLL",(long long)TMVA::kVERBOSE).data(),0,(char*)NULL);
07663    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kINFO=%lldLL",(long long)TMVA::kINFO).data(),0,(char*)NULL);
07664    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kWARNING=%lldLL",(long long)TMVA::kWARNING).data(),0,(char*)NULL);
07665    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kERROR=%lldLL",(long long)TMVA::kERROR).data(),0,(char*)NULL);
07666    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kFATAL=%lldLL",(long long)TMVA::kFATAL).data(),0,(char*)NULL);
07667    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEMsgType),-1,-2,1,G__FastAllocString(2048).Format("kSILENT=%lldLL",(long long)TMVA::kSILENT).data(),0,(char*)NULL);
07668    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEFoamType),-1,-2,1,G__FastAllocString(2048).Format("kSeparate=%lldLL",(long long)TMVA::kSeparate).data(),0,(char*)NULL);
07669    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEFoamType),-1,-2,1,G__FastAllocString(2048).Format("kDiscr=%lldLL",(long long)TMVA::kDiscr).data(),0,(char*)NULL);
07670    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEFoamType),-1,-2,1,G__FastAllocString(2048).Format("kMonoTarget=%lldLL",(long long)TMVA::kMonoTarget).data(),0,(char*)NULL);
07671    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEFoamType),-1,-2,1,G__FastAllocString(2048).Format("kMultiTarget=%lldLL",(long long)TMVA::kMultiTarget).data(),0,(char*)NULL);
07672    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLTDensityCalc),-1,-2,1,G__FastAllocString(2048).Format("kEVENT_DENSITY=%lldLL",(long long)TMVA::kEVENT_DENSITY).data(),0,(char*)NULL);
07673    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLTDensityCalc),-1,-2,1,G__FastAllocString(2048).Format("kDISCRIMINATOR=%lldLL",(long long)TMVA::kDISCRIMINATOR).data(),0,(char*)NULL);
07674    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLTDensityCalc),-1,-2,1,G__FastAllocString(2048).Format("kTARGET=%lldLL",(long long)TMVA::kTARGET).data(),0,(char*)NULL);
07675    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEKernel),-1,-2,1,G__FastAllocString(2048).Format("kNone=%lldLL",(long long)TMVA::kNone).data(),0,(char*)NULL);
07676    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEKernel),-1,-2,1,G__FastAllocString(2048).Format("kGaus=%lldLL",(long long)TMVA::kGaus).data(),0,(char*)NULL);
07677    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEKernel),-1,-2,1,G__FastAllocString(2048).Format("kLinN=%lldLL",(long long)TMVA::kLinN).data(),0,(char*)NULL);
07678    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLETargetSelection),-1,-2,1,G__FastAllocString(2048).Format("kMean=%lldLL",(long long)TMVA::kMean).data(),0,(char*)NULL);
07679    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLETargetSelection),-1,-2,1,G__FastAllocString(2048).Format("kMpv=%lldLL",(long long)TMVA::kMpv).data(),0,(char*)NULL);
07680    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLECellType),-1,-2,1,G__FastAllocString(2048).Format("kAll=%lldLL",(long long)TMVA::kAll).data(),0,(char*)NULL);
07681    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLECellType),-1,-2,1,G__FastAllocString(2048).Format("kActive=%lldLL",(long long)TMVA::kActive).data(),0,(char*)NULL);
07682    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLECellType),-1,-2,1,G__FastAllocString(2048).Format("kInActive=%lldLL",(long long)TMVA::kInActive).data(),0,(char*)NULL);
07683    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kNev=%lldLL",(long long)TMVA::kNev).data(),0,(char*)NULL);
07684    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kDiscriminator=%lldLL",(long long)TMVA::kDiscriminator).data(),0,(char*)NULL);
07685    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kDiscriminatorError=%lldLL",(long long)TMVA::kDiscriminatorError).data(),0,(char*)NULL);
07686    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kTarget0=%lldLL",(long long)TMVA::kTarget0).data(),0,(char*)NULL);
07687    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kTarget0Error=%lldLL",(long long)TMVA::kTarget0Error).data(),0,(char*)NULL);
07688    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kMeanValue=%lldLL",(long long)TMVA::kMeanValue).data(),0,(char*)NULL);
07689    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kRms=%lldLL",(long long)TMVA::kRms).data(),0,(char*)NULL);
07690    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kRmsOvMean=%lldLL",(long long)TMVA::kRmsOvMean).data(),0,(char*)NULL);
07691    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLECellValue),-1,-2,1,G__FastAllocString(2048).Format("kDensity=%lldLL",(long long)TMVA::kDensity).data(),0,(char*)NULL);
07692    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEDTSeparation),-1,-2,1,G__FastAllocString(2048).Format("kFoam=%lldLL",(long long)TMVA::kFoam).data(),0,(char*)NULL);
07693    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEDTSeparation),-1,-2,1,G__FastAllocString(2048).Format("kGiniIndex=%lldLL",(long long)TMVA::kGiniIndex).data(),0,(char*)NULL);
07694    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEDTSeparation),-1,-2,1,G__FastAllocString(2048).Format("kMisClassificationError=%lldLL",(long long)TMVA::kMisClassificationError).data(),0,(char*)NULL);
07695    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEDTSeparation),-1,-2,1,G__FastAllocString(2048).Format("kCrossEntropy=%lldLL",(long long)TMVA::kCrossEntropy).data(),0,(char*)NULL);
07696    }
07697    G__tag_memvar_reset();
07698 }
07699 
07700 
07701    /* TMVA::Config */
07702 static void G__setup_memvarTMVAcLcLConfig(void) {
07703    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfig));
07704    { TMVA::Config *p; p=(TMVA::Config*)0x1000; if (p) { }
07705    G__memvar_setup((void*)((long)(&p->fVariablePlotting)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting),-1,-1,1,"fVariablePlotting=",0,"Customisable plotting properties");
07706    G__memvar_setup((void*)((long)(&p->fIONames)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames),-1,-1,1,"fIONames=",0,"Customisable weight file properties");
07707    G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
07708    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfig),-1,-2,4,"fgConfigPtr=",0,(char*)NULL);
07709    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseColoredConsole=",0,"coloured standard output");
07710    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fSilent=",0,"no output at all");
07711    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fWriteOptionsReference=",0,"if set true: Configurable objects write file with option reference");
07712    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDrawProgressBar=",0,"draw progress bar to indicate training evolution");
07713    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"message logger");
07714    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07715    }
07716    G__tag_memvar_reset();
07717 }
07718 
07719 
07720    /* TMVA::Config::VariablePlotting */
07721 static void G__setup_memvarTMVAcLcLConfigcLcLVariablePlotting(void) {
07722    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting));
07723    { TMVA::Config::VariablePlotting *p; p=(TMVA::Config::VariablePlotting*)0x1000; if (p) { }
07724    G__memvar_setup((void*)((long)(&p->fTimesRMS)-(long)(p)),102,0,0,-1,G__defined_typename("Float_t"),-1,1,"fTimesRMS=",0,(char*)NULL);
07725    G__memvar_setup((void*)((long)(&p->fNbins1D)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fNbins1D=",0,(char*)NULL);
07726    G__memvar_setup((void*)((long)(&p->fNbins2D)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fNbins2D=",0,(char*)NULL);
07727    G__memvar_setup((void*)((long)(&p->fMaxNumOfAllowedVariablesForScatterPlots)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fMaxNumOfAllowedVariablesForScatterPlots=",0,(char*)NULL);
07728    G__memvar_setup((void*)((long)(&p->fNbinsXOfROCCurve)-(long)(p)),105,0,0,-1,G__defined_typename("Int_t"),-1,1,"fNbinsXOfROCCurve=",0,(char*)NULL);
07729    }
07730    G__tag_memvar_reset();
07731 }
07732 
07733 
07734    /* TMVA::Config::IONames */
07735 static void G__setup_memvarTMVAcLcLConfigcLcLIONames(void) {
07736    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames));
07737    { TMVA::Config::IONames *p; p=(TMVA::Config::IONames*)0x1000; if (p) { }
07738    G__memvar_setup((void*)((long)(&p->fWeightFileDir)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TString),-1,-1,1,"fWeightFileDir=",0,(char*)NULL);
07739    G__memvar_setup((void*)((long)(&p->fWeightFileExtension)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TString),-1,-1,1,"fWeightFileExtension=",0,(char*)NULL);
07740    G__memvar_setup((void*)((long)(&p->fOptionsReferenceFileDir)-(long)(p)),117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TString),-1,-1,1,"fOptionsReferenceFileDir=",0,(char*)NULL);
07741    }
07742    G__tag_memvar_reset();
07743 }
07744 
07745 
07746    /* TMVA::KDEKernel */
07747 static void G__setup_memvarTMVAcLcLKDEKernel(void) {
07748    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernel));
07749    { TMVA::KDEKernel *p; p=(TMVA::KDEKernel*)0x1000; if (p) { }
07750    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelType),-1,-2,1,G__FastAllocString(2048).Format("kNone=%lldLL",(long long)TMVA::KDEKernel::kNone).data(),0,(char*)NULL);
07751    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelType),-1,-2,1,G__FastAllocString(2048).Format("kGauss=%lldLL",(long long)TMVA::KDEKernel::kGauss).data(),0,(char*)NULL);
07752    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelIter),-1,-2,1,G__FastAllocString(2048).Format("kNonadaptiveKDE=%lldLL",(long long)TMVA::KDEKernel::kNonadaptiveKDE).data(),0,(char*)NULL);
07753    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelIter),-1,-2,1,G__FastAllocString(2048).Format("kAdaptiveKDE=%lldLL",(long long)TMVA::KDEKernel::kAdaptiveKDE).data(),0,(char*)NULL);
07754    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelBorder),-1,-2,1,G__FastAllocString(2048).Format("kNoTreatment=%lldLL",(long long)TMVA::KDEKernel::kNoTreatment).data(),0,(char*)NULL);
07755    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelBorder),-1,-2,1,G__FastAllocString(2048).Format("kKernelRenorm=%lldLL",(long long)TMVA::KDEKernel::kKernelRenorm).data(),0,(char*)NULL);
07756    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelBorder),-1,-2,1,G__FastAllocString(2048).Format("kSampleMirror=%lldLL",(long long)TMVA::KDEKernel::kSampleMirror).data(),0,(char*)NULL);
07757    G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
07758    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fSigma=",0,"Width of the Kernel function");
07759    G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelIter),-1,-1,4,"fIter=",0,"iteration number");
07760    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fLowerEdge=",0,"the lower edge of the PDF");
07761    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fUpperEdge=",0,"the upper edge of the PDF");
07762    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fFineFactor=",0,"fine tuning factor for Adaptive KDE: factor to multiply the \"width\" of the Kernel function");
07763    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TF1),-1,-1,4,"fKernel_integ=",0,"the integral of the Kernel function");
07764    G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelBorder),-1,-1,4,"fKDEborder=",0,"The method to take care about \"border\" effects");
07765    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TH1F),-1,-1,4,"fHist=",0,"copy of input histogram");
07766    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TH1F),-1,-1,4,"fFirstIterHist=",0,"histogram to be filled in the hidden iteration");
07767    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TH1F),-1,-1,4,"fSigmaHist=",0,"contains the Sigmas Widths for adaptive KDE ");
07768    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fHiddenIteration=",0,"Defines if whats currently running is the ");
07769    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"message logger");
07770    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07771    }
07772    G__tag_memvar_reset();
07773 }
07774 
07775 
07776    /* TMVA::Interval */
07777 static void G__setup_memvarTMVAcLcLInterval(void) {
07778    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLInterval));
07779    { TMVA::Interval *p; p=(TMVA::Interval*)0x1000; if (p) { }
07780    G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
07781    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMin=",0,(char*)NULL);
07782    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMax=",0,"the constraints of the Interval");
07783    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNbins=",0,"when >0 : number of bins (discrete interval); when =0 continuous interval");
07784    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger),-1,-2,4,"fgLogger=",0,"message logger");
07785    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07786    }
07787    G__tag_memvar_reset();
07788 }
07789 
07790 
07791    /* TMVA::IFitterTarget */
07792 static void G__setup_memvarTMVAcLcLIFitterTarget(void) {
07793    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLIFitterTarget));
07794    { TMVA::IFitterTarget *p; p=(TMVA::IFitterTarget*)0x1000; if (p) { }
07795    G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
07796    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07797    }
07798    G__tag_memvar_reset();
07799 }
07800 
07801 
07802    /* TMVA::FitterBase */
07803 static void G__setup_memvarTMVAcLcLFitterBase(void) {
07804    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLFitterBase));
07805    { TMVA::FitterBase *p; p=(TMVA::FitterBase*)0x1000; if (p) { }
07806    G__memvar_setup((void*)0,117,1,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLIFitterTarget),-1,-1,2,"fFitterTarget=",0,"pointer to target of fitting procedure");
07807    G__memvar_setup((void*)0,117,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR),G__defined_typename("vector<TMVA::Interval*>"),-1,2,"fRanges=",0,"allowed intervals");
07808    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNpars=",0,"number of parameters");
07809    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger),-1,-1,2,"fLogger=",0,"message logger");
07810    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TString),-1,-1,2,"fClassName=",0,"remove TMVA:: from TObject name");
07811    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07812    }
07813    G__tag_memvar_reset();
07814 }
07815 
07816 
07817    /* TMVA::MCFitter */
07818 static void G__setup_memvarTMVAcLcLMCFitter(void) {
07819    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMCFitter));
07820    { TMVA::MCFitter *p; p=(TMVA::MCFitter*)0x1000; if (p) { }
07821    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSamples=",0,"number of MC samples");
07822    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSigma=",0,"new samples are generated randomly with a gaussian probability with fSigma around the current best value");
07823    G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fSeed=",0,"Seed for the random generator (0 takes random seeds)");
07824    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07825    }
07826    G__tag_memvar_reset();
07827 }
07828 
07829 
07830    /* TMVA::GeneticFitter */
07831 static void G__setup_memvarTMVAcLcLGeneticFitter(void) {
07832    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLGeneticFitter));
07833    { TMVA::GeneticFitter *p; p=(TMVA::GeneticFitter*)0x1000; if (p) { }
07834    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fCycles=",0,"number of (nearly) independent calculation cycles");
07835    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNsteps=",0,"convergence criteria: if no improvements > fConvCrit was achieved within the last fNsteps: cycle has \"converged\"");
07836    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPopSize=",0,"number of individuals to start with");
07837    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSC_steps=",0,"regulates how strong the mutations for the coordinates are: if within fSC_steps there were more than...");
07838    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSC_rate=",0,"... fSC_rate improvements, than multiply the sigma of the gaussion which defines how the random numbers are generated ...");
07839    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSC_factor=",0,"... with fSC_factor; if there were less improvements: divide by that factor; if there were exactly fSC_rate improvements, dont change anything");
07840    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fConvCrit=",0,"improvements bigger than fConvCrit are counted as \"improvement\"");
07841    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSaveBestFromGeneration=",0,"store the best individuals from one generation (these are included as \"hints\" in the last cycle of GA calculation)");
07842    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSaveBestFromCycle=",0,"store the best individuals from one cycle (these are included as \"hints\" in the last cycle of GA calculation)");
07843    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fTrim=",0,"take care, that the number of individuals is less fPopSize (trimming is done after the fitness of the individuals is assessed)");
07844    G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fSeed=",0,"Seed for the random generator (0 takes random seeds)");
07845    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07846    }
07847    G__tag_memvar_reset();
07848 }
07849 
07850 
07851    /* TMVA::SimulatedAnnealingFitter */
07852 static void G__setup_memvarTMVAcLcLSimulatedAnnealingFitter(void) {
07853    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter));
07854    { TMVA::SimulatedAnnealingFitter *p; p=(TMVA::SimulatedAnnealingFitter*)0x1000; if (p) { }
07855    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMaxCalls=",0,"max number of FCN calls");
07856    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fInitialTemperature=",0,"initial temperature (depends on FCN)");
07857    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fMinTemperature=",0,"minimum temperature before SA quit");
07858    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fEps=",0,"relative required FCN accuracy at minimum");
07859    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TString),-1,-1,4,"fKernelTemperatureS=",0,"string just to set fKernelTemperature");
07860    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTemperatureScale=",0,"how fast temperature change");
07861    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fAdaptiveSpeed=",0,"how fast temperature change in adaptive (in adaptive two variables describe");
07862    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTemperatureAdaptiveStep=",0,"used to calculate InitialTemperature if fUseDefaultTemperature");
07863    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseDefaultScale=",0,"if TRUE, SA calculates its own TemperatureScale");
07864    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseDefaultTemperature=",0,"if TRUE, SA calculates its own InitialTemperature (MinTemperautre)");
07865    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07866    }
07867    G__tag_memvar_reset();
07868 }
07869 
07870 
07871    /* TMVA::MinuitWrapper */
07872 static void G__setup_memvarTMVAcLcLMinuitWrapper(void) {
07873    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitWrapper));
07874    { TMVA::MinuitWrapper *p; p=(TMVA::MinuitWrapper*)0x1000; if (p) { }
07875    G__memvar_setup((void*)0,117,1,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLIFitterTarget),-1,-1,4,"fFitterTarget=",0,"fitter Target");
07876    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fParameters=",0,"vector holding the current parameters ");
07877    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fNumPar=",0,"number of parameters");
07878    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07879    }
07880    G__tag_memvar_reset();
07881 }
07882 
07883 
07884    /* TMVA::MinuitFitter */
07885 static void G__setup_memvarTMVAcLcLMinuitFitter(void) {
07886    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitFitter));
07887    { TMVA::MinuitFitter *p; p=(TMVA::MinuitFitter*)0x1000; if (p) { }
07888    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitWrapper),-1,-1,2,"fMinWrap=",0,"holds a wrapper around TMinuit");
07889    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fErrorLevel=",0,"minuit error level");
07890    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fPrintLevel=",0,"minuit printout level");
07891    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fFitStrategy=",0,"minuit strategy level");
07892    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fPrintWarnings=",0,"minuit warnings level");
07893    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseImprove=",0,"flag for 'IMPROVE' use");
07894    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fUseMinos=",0,"flag for 'MINOS' use");
07895    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fBatch=",0,"batch mode");
07896    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fMaxCalls=",0,"(approximate) maximum number of function calls");
07897    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fTolerance=",0,"tolerance to the function value at the minimum");
07898    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07899    }
07900    G__tag_memvar_reset();
07901 }
07902 
07903 
07904    /* TMVA::PDEFoamCell */
07905 static void G__setup_memvarTMVAcLcLPDEFoamCell(void) {
07906    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell));
07907    { TMVA::PDEFoamCell *p; p=(TMVA::PDEFoamCell*)0x1000; if (p) { }
07908    G__memvar_setup((void*)0,115,0,0,-1,G__defined_typename("Short_t"),-1,4,"fDim=",0,"Dimension of the vector space");
07909    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fSerial=",0,"Serial number");
07910    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fStatus=",0,"Status (active, inactive)");
07911    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TRef),-1,-1,4,"fParent=",0,"Pointer to parent cell");
07912    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TRef),-1,-1,4,"fDaught0=",0,"Pointer to daughter 1");
07913    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TRef),-1,-1,4,"fDaught1=",0,"Pointer to daughter 2");
07914    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fXdiv=",0,"Factor for division");
07915    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fBest=",0,"Best Edge for division");
07916    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fVolume=",0,"Cartesian Volume of cell");
07917    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fIntegral=",0,"Integral over cell (estimate from exploration)");
07918    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fDrive=",0,"Driver  integral, only for cell build-up");
07919    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TObject),-1,-1,4,"fElement=",0,"may set by the user to save some data in this cell");
07920    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07921    }
07922    G__tag_memvar_reset();
07923 }
07924 
07925 
07926    /* TMVA::PDEFoamVect */
07927 static void G__setup_memvarTMVAcLcLPDEFoamVect(void) {
07928    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect));
07929    { TMVA::PDEFoamVect *p; p=(TMVA::PDEFoamVect*)0x1000; if (p) { }
07930    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fDim=",0,"Dimension");
07931    G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,4,"fCoords=",0,"[fDim] Coordinates");
07932    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07933    }
07934    G__tag_memvar_reset();
07935 }
07936 
07937 
07938    /* TMVA::PDEFoamDistr */
07939 static void G__setup_memvarTMVAcLcLPDEFoamDistr(void) {
07940    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDistr));
07941    { TMVA::PDEFoamDistr *p; p=(TMVA::PDEFoamDistr*)0x1000; if (p) { }
07942    G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam),-1,-1,4,"fPDEFoam=",0,"PDEFoam to refer to");
07943    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLBinarySearchTree),-1,-1,4,"fBst=",0,"Binary tree to find events within a volume");
07944    G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLTDensityCalc),-1,-1,4,"fDensityCalc=",0,"method of density calculation");
07945    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger),-1,-1,2,"fLogger=",0,"! message logger");
07946    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07947    }
07948    G__tag_memvar_reset();
07949 }
07950 
07951 
07952    /* TMVA::PDEFoam */
07953 static void G__setup_memvarTMVAcLcLPDEFoam(void) {
07954    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam));
07955    { TMVA::PDEFoam *p; p=(TMVA::PDEFoam*)0x1000; if (p) { }
07956    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TString),-1,-1,2,"fName=",0,"Name of a given instance of the FOAM class");
07957    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fDim=",0,"Dimension of the integration/simulation space");
07958    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNCells=",0,"Maximum number of cells");
07959    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNBin=",0,"No. of bins in the edge histogram for cell MC exploration");
07960    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNSampl=",0,"No. of MC events, when dividing (exploring) cell");
07961    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fEvPerBin=",0,"Maximum number of effective (wt=1) events per bin");
07962    G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fMaskDiv=",0,"! [fDim] Dynamic Mask for cell division");
07963    G__memvar_setup((void*)0,73,0,0,-1,G__defined_typename("Int_t"),-1,2,"fInhiDiv=",0,"! [fDim] Flags for inhibiting cell division");
07964    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fNoAct=",0,"Number of active cells");
07965    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,2,"fLastCe=",0,"Index of the last cell");
07966    G__memvar_setup((void*)0,85,2,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell),-1,-1,2,"fCells=",0,"[fNCells] Array of ALL cells");
07967    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TObjArray),-1,-1,2,"fHistEdg=",0,"Histograms of wt, one for each cell edge");
07968    G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fRvec=",0,"[fDim] random number vector from r.n. generator fDim+1 maximum elements");
07969    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TRandom3),-1,-1,2,"fPseRan=",0,"Pointer to user-defined generator of pseudorandom numbers");
07970    G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fAlpha=",0,"[fDim] Internal parameters of the hyperrectangle");
07971    G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEFoamType),-1,-1,2,"fFoamType=",0,"type of foam");
07972    G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXmin=",0,"[fDim] minimum for variable transform");
07973    G__memvar_setup((void*)0,68,0,0,-1,G__defined_typename("Double_t"),-1,2,"fXmax=",0,"[fDim] maximum for variable transform");
07974    G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fNElements=",0,"number of variables in every cell");
07975    G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fNmin=",0,"minimal number of events in cell to split cell");
07976    G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,2,"fMaxDepth=",0,"maximum depth of cell tree");
07977    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,2,"fVolFrac=",0,"volume fraction (with respect to total phase space");
07978    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fFillFoamWithOrigWeights=",0,"fill the foam with boost or orig. weights");
07979    G__memvar_setup((void*)0,105,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEDTSeparation),-1,-1,2,"fDTSeparation=",0,"split cells according to decision tree logic");
07980    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,2,"fPeekMax=",0,"peek up cell with max. driver integral for split");
07981    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDistr),-1,-1,2,"fDistr=",0,"! distribution of training events");
07982    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLTimer),-1,-1,2,"fTimer=",0,"timer for graphical output");
07983    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TObjArray),-1,-1,2,"fVariableNames=",0,"collection of all variable names");
07984    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger),-1,-1,2,"fLogger=",0,"! message logger");
07985    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
07986    }
07987    G__tag_memvar_reset();
07988 }
07989 
07990 
07991    /* TMVA::BDTEventWrapper */
07992 static void G__setup_memvarTMVAcLcLBDTEventWrapper(void) {
07993    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLBDTEventWrapper));
07994    { TMVA::BDTEventWrapper *p; p=(TMVA::BDTEventWrapper*)0x1000; if (p) { }
07995    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-2,4,"fVarIndex=",0,"index of the variable to sort on");
07996    G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEvent),-1,-1,4,"fEvent=",0,"pointer to the event");
07997    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fBkgWeight=",0,"cumulative background weight for splitting");
07998    G__memvar_setup((void*)0,100,0,0,-1,G__defined_typename("Double_t"),-1,4,"fSigWeight=",0,"same for the signal weights");
07999    }
08000    G__tag_memvar_reset();
08001 }
08002 
08003 
08004    /* TMVA::CCTreeWrapper */
08005 static void G__setup_memvarTMVAcLcLCCTreeWrapper(void) {
08006    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrapper));
08007    { TMVA::CCTreeWrapper *p; p=(TMVA::CCTreeWrapper*)0x1000; if (p) { }
08008    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSeparationBase),-1,-1,4,"fQualityIndex=",0,"! pointer to the used quality index calculator");
08009    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLDecisionTree),-1,-1,4,"fDTParent=",0,"! pointer to underlying DecisionTree");
08010    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrappercLcLCCTreeNode),-1,-1,4,"fRoot=",0,"! the root node of the (wrapped) decision Tree");
08011    }
08012    G__tag_memvar_reset();
08013 }
08014 
08015 
08016    /* TMVA::CCPruner */
08017 static void G__setup_memvarTMVAcLcLCCPruner(void) {
08018    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCPruner));
08019    { TMVA::CCPruner *p; p=(TMVA::CCPruner*)0x1000; if (p) { }
08020    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fAlpha=",0,"! regularization parameter in CC pruning");
08021    G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR),G__defined_typename("EventList"),-1,4,"fValidationSample=",0,"! the event sample to select the optimally-pruned tree");
08022    G__memvar_setup((void*)0,85,0,1,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLDataSet),-1,-1,4,"fValidationDataSet=",0,"! the event sample to select the optimally-pruned tree");
08023    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSeparationBase),-1,-1,4,"fQualityIndex=",0,"! the quality index used to calculate R(t), R(T) = sum[t in ~T]{ R(t) }");
08024    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fOwnQIndex=",0,"! flag indicates if fQualityIndex is owned by this");
08025    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLDecisionTree),-1,-1,4,"fTree=",0,"! (pruned) decision tree");
08026    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgR),G__defined_typename("vector<TMVA::DecisionTreeNode*>"),-1,4,"fPruneSequence=",0,"! map of weakest links (i.e., branches to prune) -> pruning index");
08027    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fPruneStrengthList=",0,"! map of alpha -> pruning index");
08028    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fQualityIndexList=",0,"! map of R(T) -> pruning index");
08029    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOptimalK=",0,"! index of the optimal tree in the pruned tree sequence");
08030    G__memvar_setup((void*)0,103,0,0,-1,G__defined_typename("Bool_t"),-1,4,"fDebug=",0,"! debug flag");
08031    }
08032    G__tag_memvar_reset();
08033 }
08034 
08035 
08036    /* TMVA::CostComplexityPruneTool */
08037 static void G__setup_memvarTMVAcLcLCostComplexityPruneTool(void) {
08038    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool));
08039    { TMVA::CostComplexityPruneTool *p; p=(TMVA::CostComplexityPruneTool*)0x1000; if (p) { }
08040    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSeparationBase),-1,-1,4,"fQualityIndexTool=",0,"! the quality index used to calculate R(t), R(T) = sum[t in ~T]{ R(t) }");
08041    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgR),-1,-1,4,"fPruneSequence=",0,"! map of weakest links (i.e., branches to prune) -> pruning index");
08042    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fPruneStrengthList=",0,"! map of alpha -> pruning index");
08043    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<Double_t>"),-1,4,"fQualityIndexList=",0,"! map of R(T) -> pruning index");
08044    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fOptimalK=",0,"! the optimal index of the prune sequence");
08045    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"! output stream to save logging information");
08046    }
08047    G__tag_memvar_reset();
08048 }
08049 
08050 
08051    /* TMVA::SVEvent */
08052 static void G__setup_memvarTMVAcLcLSVEvent(void) {
08053    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent));
08054    { TMVA::SVEvent *p; p=(TMVA::SVEvent*)0x1000; if (p) { }
08055    G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
08056    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fDataVector=",0,(char*)NULL);
08057    G__memvar_setup((void*)0,102,0,1,-1,G__defined_typename("Float_t"),-1,4,"fCweight=",0,"svm cost weight");
08058    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fAlpha=",0,"lagrange multiplier");
08059    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fAlpha_p=",0,"lagrange multiplier");
08060    G__memvar_setup((void*)0,102,0,0,-1,G__defined_typename("Float_t"),-1,4,"fErrorCache=",0,"optimization parameter");
08061    G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNVar=",0,"number of variables");
08062    G__memvar_setup((void*)0,105,0,1,-1,G__defined_typename("Int_t"),-1,4,"fTypeFlag=",0,"is sig or bkg - svm requieres 1 for sig and -1 for bkg");
08063    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIdx=",0,"index flag");
08064    G__memvar_setup((void*)0,104,0,0,-1,G__defined_typename("UInt_t"),-1,4,"fNs=",0,"documentation");
08065    G__memvar_setup((void*)0,105,0,0,-1,G__defined_typename("Int_t"),-1,4,"fIsShrinked=",0,"shrinking flag, see documentation");
08066    G__memvar_setup((void*)0,70,0,0,-1,G__defined_typename("Float_t"),-1,4,"fLine=",0,"pointer to column of kerenl matrix ");
08067    G__memvar_setup((void*)0,102,0,1,-1,G__defined_typename("Float_t"),-1,4,"fTarget=",0,"regression target");
08068    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08069    }
08070    G__tag_memvar_reset();
08071 }
08072 
08073 
08074    /* TMVA::OptimizeConfigParameters */
08075 static void G__setup_memvarTMVAcLcLOptimizeConfigParameters(void) {
08076    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters));
08077    { TMVA::OptimizeConfigParameters *p; p=(TMVA::OptimizeConfigParameters*)0x1000; if (p) { }
08078    G__memvar_setup((void*)0,85,0,4,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMethodBase),-1,-1,4,"fMethod=",0,"The MVA method to be evaluated");
08079    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR),G__defined_typename("vector<Float_t>"),-1,4,"fFOMvsIter=",0,"graph showing the develompment of the Figure Of Merit values during the fit");
08080    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOTMVAcLcLIntervalcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIntervalgRsPgRsPgR),G__defined_typename("map<TString,TMVA::Interval>"),-1,4,"fTuneParameters=",0,"parameters included in the tuning");
08081    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR),G__defined_typename("map<TString,Double_t>"),-1,4,"fTunedParameters=",0,"parameters included in the tuning");
08082    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR),G__defined_typename("map<std::vector<Double_t>,Double_t>"),-1,4,"fAlreadyTrainedParCombination=",0,"save parameters for which the FOM is already known (GA seems to evaluate the same parameters several times)");
08083    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TString),-1,-1,4,"fFOMType=",0,"the FOM type (Separation, ROC integra.. whaeter you implemented..");
08084    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TString),-1,-1,4,"fOptimizationFitType=",0,"which type of optimisation procedure to be used ");
08085    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TH1D),-1,-1,4,"fMvaSig=",0,"MVA distrituion for signal events, used for spline fit");
08086    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TH1D),-1,-1,4,"fMvaBkg=",0,"MVA distrituion for bakgr. events, used for spline fit");
08087    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TH1D),-1,-1,4,"fMvaSigFineBin=",0,"MVA distrituion for signal events");
08088    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TH1D),-1,-1,4,"fMvaBkgFineBin=",0,"MVA distrituion for bakgr. events");
08089    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger),-1,-1,4,"fLogger=",0,"message logger");
08090    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__TMVA3LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
08091    }
08092    G__tag_memvar_reset();
08093 }
08094 
08095 extern "C" void G__cpp_setup_memvarG__TMVA3() {
08096 }
08097 /***********************************************************
08098 ************************************************************
08099 ************************************************************
08100 ************************************************************
08101 ************************************************************
08102 ************************************************************
08103 ************************************************************
08104 ***********************************************************/
08105 
08106 /*********************************************************
08107 * Member function information setup for each class
08108 *********************************************************/
08109 static void G__setup_memfuncTMVA(void) {
08110    /* TMVA */
08111    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVA));
08112    G__memfunc_setup("gConfig",701,G__G__TMVA3_110_0_1, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfig), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) G__func2void( (TMVA::Config& (*)())(&TMVA::gConfig) ), 0);
08113    G__memfunc_setup("operator<<",996,G__G__TMVA3_110_0_2, 117, G__get_linked_tagnum(&G__G__TMVA3LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, 
08114 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os u 'TMVA::Node' - 11 - node", (char*)NULL, (void*) G__func2void( (ostream& (*)(ostream&, const TMVA::Node&))(&TMVA::operator<<) ), 0);
08115    G__memfunc_setup("operator<<",996,G__G__TMVA3_110_0_3, 117, G__get_linked_tagnum(&G__G__TMVA3LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, 
08116 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os U 'TMVA::Node' - 10 - node", (char*)NULL, (void*) G__func2void( (ostream& (*)(ostream&, const TMVA::Node*))(&TMVA::operator<<) ), 0);
08117    G__memfunc_setup("operator<<",996,G__G__TMVA3_110_0_4, 117, G__get_linked_tagnum(&G__G__TMVA3LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, 
08118 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os u 'TMVA::BinaryTree' - 11 - tree", (char*)NULL, (void*) G__func2void( (ostream& (*)(ostream&, const TMVA::BinaryTree&))(&TMVA::operator<<) ), 0);
08119    G__memfunc_setup("operator>>",1000,G__G__TMVA3_110_0_5, 117, G__get_linked_tagnum(&G__G__TMVA3LN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, 
08120 "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr u 'TMVA::BinaryTree' - 1 - tree", (char*)NULL, (void*) G__func2void( (istream& (*)(istream&, TMVA::BinaryTree&))(&TMVA::operator>>) ), 0);
08121    G__memfunc_setup("operator<<",996,G__G__TMVA3_110_0_6, 117, G__get_linked_tagnum(&G__G__TMVA3LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, 
08122 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os u 'TMVA::Event' - 11 - event", (char*)NULL, (void*) G__func2void( (ostream& (*)(ostream&, const TMVA::Event&))(&TMVA::operator<<) ), 0);
08123    G__memfunc_setup("operator<<",996,G__G__TMVA3_110_0_7, 117, G__get_linked_tagnum(&G__G__TMVA3LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("ostream"), 1, 2, 1, 1, 0, 
08124 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os u 'TMVA::PDEFoam' - 11 - pdefoam", (char*)NULL, (void*) G__func2void( (ostream& (*)(ostream&, const TMVA::PDEFoam&))(&TMVA::operator<<) ), 0);
08125    G__memfunc_setup("operator>>",1000,G__G__TMVA3_110_0_8, 117, G__get_linked_tagnum(&G__G__TMVA3LN_basic_istreamlEcharcOchar_traitslEchargRsPgR), G__defined_typename("istream"), 1, 2, 1, 1, 0, 
08126 "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - istr u 'TMVA::PDEFoam' - 1 - pdefoam", (char*)NULL, (void*) G__func2void( (istream& (*)(istream&, TMVA::PDEFoam&))(&TMVA::operator>>) ), 0);
08127    G__tag_memfunc_reset();
08128 }
08129 
08130 static void G__setup_memfuncTMVAcLcLConfig(void) {
08131    /* TMVA::Config */
08132    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfig));
08133    G__memfunc_setup("Instance",821,G__G__TMVA3_112_0_1, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfig), -1, 1, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TMVA::Config& (*)())(&TMVA::Config::Instance) ), 0);
08134    G__memfunc_setup("DestroyInstance",1567,G__G__TMVA3_112_0_2, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::Config::DestroyInstance) ), 0);
08135    G__memfunc_setup("UseColor",812,G__G__TMVA3_112_0_3, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08136    G__memfunc_setup("SetUseColor",1112,G__G__TMVA3_112_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - uc", (char*)NULL, (void*) NULL, 0);
08137    G__memfunc_setup("IsSilent",811,G__G__TMVA3_112_0_5, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08138    G__memfunc_setup("SetSilent",923,G__G__TMVA3_112_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - s", (char*)NULL, (void*) NULL, 0);
08139    G__memfunc_setup("WriteOptionsReference",2182,G__G__TMVA3_112_0_7, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08140    G__memfunc_setup("SetWriteOptionsReference",2482,G__G__TMVA3_112_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - w", (char*)NULL, (void*) NULL, 0);
08141    G__memfunc_setup("DrawProgressBar",1528,G__G__TMVA3_112_0_9, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08142    G__memfunc_setup("SetDrawProgressBar",1828,G__G__TMVA3_112_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - d", (char*)NULL, (void*) NULL, 0);
08143    G__memfunc_setup("GetVariablePlotting",1943,G__G__TMVA3_112_0_11, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08144    G__memfunc_setup("GetIONames",940,G__G__TMVA3_112_0_12, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08145    G__memfunc_setup("Config",598,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfig), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08146    G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
08147    G__memfunc_setup("Class",502,G__G__TMVA3_112_0_15, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::Config::Class) ), 0);
08148    G__memfunc_setup("Class_Name",982,G__G__TMVA3_112_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Config::Class_Name) ), 0);
08149    G__memfunc_setup("Class_Version",1339,G__G__TMVA3_112_0_17, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::Config::Class_Version) ), 0);
08150    G__memfunc_setup("Dictionary",1046,G__G__TMVA3_112_0_18, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::Config::Dictionary) ), 0);
08151    G__memfunc_setup("IsA",253,G__G__TMVA3_112_0_19, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08152    G__memfunc_setup("ShowMembers",1132,G__G__TMVA3_112_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
08153    G__memfunc_setup("Streamer",835,G__G__TMVA3_112_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
08154    G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_112_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08155    G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_112_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Config::DeclFileName) ), 0);
08156    G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_112_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Config::ImplFileLine) ), 0);
08157    G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_112_0_25, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Config::ImplFileName) ), 0);
08158    G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_112_0_26, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Config::DeclFileLine) ), 0);
08159    // automatic copy constructor
08160    G__memfunc_setup("Config", 598, G__G__TMVA3_112_0_27, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfig), -1, 0, 1, 1, 1, 0, "u 'TMVA::Config' - 11 - -", (char*) NULL, (void*) NULL, 0);
08161    // automatic assignment operator
08162    G__memfunc_setup("operator=", 937, G__G__TMVA3_112_0_28, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfig), -1, 1, 1, 1, 1, 0, "u 'TMVA::Config' - 11 - -", (char*) NULL, (void*) NULL, 0);
08163    G__tag_memfunc_reset();
08164 }
08165 
08166 static void G__setup_memfuncTMVAcLcLConfigcLcLVariablePlotting(void) {
08167    /* TMVA::Config::VariablePlotting */
08168    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting));
08169    // automatic default constructor
08170    G__memfunc_setup("VariablePlotting", 1655, G__G__TMVA3_113_0_1, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
08171    // automatic copy constructor
08172    G__memfunc_setup("VariablePlotting", 1655, G__G__TMVA3_113_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting), -1, 0, 1, 1, 1, 0, "u 'TMVA::Config::VariablePlotting' - 11 - -", (char*) NULL, (void*) NULL, 0);
08173    // automatic destructor
08174    G__memfunc_setup("~VariablePlotting", 1781, G__G__TMVA3_113_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
08175    // automatic assignment operator
08176    G__memfunc_setup("operator=", 937, G__G__TMVA3_113_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting), -1, 1, 1, 1, 1, 0, "u 'TMVA::Config::VariablePlotting' - 11 - -", (char*) NULL, (void*) NULL, 0);
08177    G__tag_memfunc_reset();
08178 }
08179 
08180 static void G__setup_memfuncTMVAcLcLConfigcLcLIONames(void) {
08181    /* TMVA::Config::IONames */
08182    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames));
08183    // automatic default constructor
08184    G__memfunc_setup("IONames", 652, G__G__TMVA3_114_0_1, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames), -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
08185    // automatic copy constructor
08186    G__memfunc_setup("IONames", 652, G__G__TMVA3_114_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames), -1, 0, 1, 1, 1, 0, "u 'TMVA::Config::IONames' - 11 - -", (char*) NULL, (void*) NULL, 0);
08187    // automatic destructor
08188    G__memfunc_setup("~IONames", 778, G__G__TMVA3_114_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
08189    // automatic assignment operator
08190    G__memfunc_setup("operator=", 937, G__G__TMVA3_114_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames), -1, 1, 1, 1, 1, 0, "u 'TMVA::Config::IONames' - 11 - -", (char*) NULL, (void*) NULL, 0);
08191    G__tag_memfunc_reset();
08192 }
08193 
08194 static void G__setup_memfuncTMVAcLcLKDEKernel(void) {
08195    /* TMVA::KDEKernel */
08196    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernel));
08197    G__memfunc_setup("KDEKernel",821,G__G__TMVA3_118_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernel), -1, 0, 6, 1, 1, 0, 
08198 "i 'TMVA::KDEKernel::EKernelIter' - 0 'kNonadaptiveKDE' kiter U 'TH1' - 10 '0' hist "
08199 "f - 'Float_t' 0 '0.' lower_edge f - 'Float_t' 0 '1.' upper_edge "
08200 "i 'TMVA::KDEKernel::EKernelBorder' - 0 'kNoTreatment' kborder f - 'Float_t' 0 '1.' FineFactor", (char*)NULL, (void*) NULL, 0);
08201    G__memfunc_setup("GetBinKernelIntegral",2000,G__G__TMVA3_118_0_2, 102, -1, G__defined_typename("Float_t"), 0, 4, 1, 1, 0, 
08202 "f - 'Float_t' 0 - lowr f - 'Float_t' 0 - highr "
08203 "f - 'Float_t' 0 - mean i - 'Int_t' 0 - binnum", (char*)NULL, (void*) NULL, 0);
08204    G__memfunc_setup("SetKernelType",1327,G__G__TMVA3_118_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TMVA::KDEKernel::EKernelType' - 0 'kGauss' ktype", (char*)NULL, (void*) NULL, 0);
08205    G__memfunc_setup("GetName",673,G__G__TMVA3_118_0_4, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
08206    G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
08207    G__memfunc_setup("Class",502,G__G__TMVA3_118_0_6, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::KDEKernel::Class) ), 0);
08208    G__memfunc_setup("Class_Name",982,G__G__TMVA3_118_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::KDEKernel::Class_Name) ), 0);
08209    G__memfunc_setup("Class_Version",1339,G__G__TMVA3_118_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::KDEKernel::Class_Version) ), 0);
08210    G__memfunc_setup("Dictionary",1046,G__G__TMVA3_118_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::KDEKernel::Dictionary) ), 0);
08211    G__memfunc_setup("IsA",253,G__G__TMVA3_118_0_10, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08212    G__memfunc_setup("ShowMembers",1132,G__G__TMVA3_118_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
08213    G__memfunc_setup("Streamer",835,G__G__TMVA3_118_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
08214    G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_118_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08215    G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_118_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::KDEKernel::DeclFileName) ), 0);
08216    G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_118_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::KDEKernel::ImplFileLine) ), 0);
08217    G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_118_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::KDEKernel::ImplFileName) ), 0);
08218    G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_118_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::KDEKernel::DeclFileLine) ), 0);
08219    // automatic copy constructor
08220    G__memfunc_setup("KDEKernel", 821, G__G__TMVA3_118_0_18, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernel), -1, 0, 1, 1, 1, 0, "u 'TMVA::KDEKernel' - 11 - -", (char*) NULL, (void*) NULL, 0);
08221    // automatic destructor
08222    G__memfunc_setup("~KDEKernel", 947, G__G__TMVA3_118_0_19, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08223    // automatic assignment operator
08224    G__memfunc_setup("operator=", 937, G__G__TMVA3_118_0_20, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLKDEKernel), -1, 1, 1, 1, 1, 0, "u 'TMVA::KDEKernel' - 11 - -", (char*) NULL, (void*) NULL, 0);
08225    G__tag_memfunc_reset();
08226 }
08227 
08228 static void G__setup_memfuncTMVAcLcLInterval(void) {
08229    /* TMVA::Interval */
08230    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLInterval));
08231    G__memfunc_setup("Interval",837,G__G__TMVA3_123_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLInterval), -1, 0, 3, 1, 1, 0, 
08232 "d - 'Double_t' 0 - min d - 'Double_t' 0 - max "
08233 "i - 'Int_t' 0 '0' nbins", (char*)NULL, (void*) NULL, 0);
08234    G__memfunc_setup("Interval",837,G__G__TMVA3_123_0_2, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLInterval), -1, 0, 1, 1, 1, 0, "u 'TMVA::Interval' - 11 - other", (char*)NULL, (void*) NULL, 0);
08235    G__memfunc_setup("GetMin",580,G__G__TMVA3_123_0_3, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08236    G__memfunc_setup("GetMax",582,G__G__TMVA3_123_0_4, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08237    G__memfunc_setup("GetWidth",800,G__G__TMVA3_123_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08238    G__memfunc_setup("GetNbins",794,G__G__TMVA3_123_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08239    G__memfunc_setup("GetMean",673,G__G__TMVA3_123_0_7, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08240    G__memfunc_setup("GetRndm",689,G__G__TMVA3_123_0_8, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "u 'TRandom3' - 1 - -", (char*)NULL, (void*) NULL, 0);
08241    G__memfunc_setup("GetElement",1002,G__G__TMVA3_123_0_9, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - position", (char*)NULL, (void*) NULL, 0);
08242    G__memfunc_setup("GetStepSize",1111,G__G__TMVA3_123_0_10, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08243    G__memfunc_setup("SetMax",594,G__G__TMVA3_123_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - m", (char*)NULL, (void*) NULL, 0);
08244    G__memfunc_setup("SetMin",592,G__G__TMVA3_123_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - m", (char*)NULL, (void*) NULL, 0);
08245    G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
08246    G__memfunc_setup("Class",502,G__G__TMVA3_123_0_14, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::Interval::Class) ), 0);
08247    G__memfunc_setup("Class_Name",982,G__G__TMVA3_123_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Interval::Class_Name) ), 0);
08248    G__memfunc_setup("Class_Version",1339,G__G__TMVA3_123_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::Interval::Class_Version) ), 0);
08249    G__memfunc_setup("Dictionary",1046,G__G__TMVA3_123_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::Interval::Dictionary) ), 0);
08250    G__memfunc_setup("IsA",253,G__G__TMVA3_123_0_18, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08251    G__memfunc_setup("ShowMembers",1132,G__G__TMVA3_123_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
08252    G__memfunc_setup("Streamer",835,G__G__TMVA3_123_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
08253    G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_123_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08254    G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_123_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Interval::DeclFileName) ), 0);
08255    G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_123_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Interval::ImplFileLine) ), 0);
08256    G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_123_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::Interval::ImplFileName) ), 0);
08257    G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_123_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::Interval::DeclFileLine) ), 0);
08258    // automatic destructor
08259    G__memfunc_setup("~Interval", 963, G__G__TMVA3_123_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08260    // automatic assignment operator
08261    G__memfunc_setup("operator=", 937, G__G__TMVA3_123_0_27, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLInterval), -1, 1, 1, 1, 1, 0, "u 'TMVA::Interval' - 11 - -", (char*) NULL, (void*) NULL, 0);
08262    G__tag_memfunc_reset();
08263 }
08264 
08265 static void G__setup_memfuncTMVAcLcLIFitterTarget(void) {
08266    /* TMVA::IFitterTarget */
08267    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLIFitterTarget));
08268    G__memfunc_setup("EstimatorFunction",1790,G__G__TMVA3_186_0_2, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - parameters", (char*)NULL, (void*) NULL, 3);
08269    G__memfunc_setup("ProgressNotifier",1685,G__G__TMVA3_186_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
08270 "u 'TString' - 0 - - u 'TString' - 0 - -", (char*)NULL, (void*) NULL, 1);
08271    G__memfunc_setup("Class",502,G__G__TMVA3_186_0_4, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::IFitterTarget::Class) ), 0);
08272    G__memfunc_setup("Class_Name",982,G__G__TMVA3_186_0_5, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::IFitterTarget::Class_Name) ), 0);
08273    G__memfunc_setup("Class_Version",1339,G__G__TMVA3_186_0_6, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::IFitterTarget::Class_Version) ), 0);
08274    G__memfunc_setup("Dictionary",1046,G__G__TMVA3_186_0_7, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::IFitterTarget::Dictionary) ), 0);
08275    G__memfunc_setup("IsA",253,G__G__TMVA3_186_0_8, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08276    G__memfunc_setup("ShowMembers",1132,G__G__TMVA3_186_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
08277    G__memfunc_setup("Streamer",835,G__G__TMVA3_186_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
08278    G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_186_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08279    G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_186_0_12, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::IFitterTarget::DeclFileName) ), 0);
08280    G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_186_0_13, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::IFitterTarget::ImplFileLine) ), 0);
08281    G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_186_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::IFitterTarget::ImplFileName) ), 0);
08282    G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_186_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::IFitterTarget::DeclFileLine) ), 0);
08283    // automatic destructor
08284    G__memfunc_setup("~IFitterTarget", 1436, G__G__TMVA3_186_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08285    // automatic assignment operator
08286    G__memfunc_setup("operator=", 937, G__G__TMVA3_186_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLIFitterTarget), -1, 1, 1, 1, 1, 0, "u 'TMVA::IFitterTarget' - 11 - -", (char*) NULL, (void*) NULL, 0);
08287    G__tag_memfunc_reset();
08288 }
08289 
08290 static void G__setup_memfuncTMVAcLcLFitterBase(void) {
08291    /* TMVA::FitterBase */
08292    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLFitterBase));
08293    G__memfunc_setup("Run",309,G__G__TMVA3_187_0_2, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08294    G__memfunc_setup("Run",309,G__G__TMVA3_187_0_3, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - pars", (char*)NULL, (void*) NULL, 3);
08295    G__memfunc_setup("EstimatorFunction",1790,G__G__TMVA3_187_0_4, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - parameters", (char*)NULL, (void*) NULL, 0);
08296    G__memfunc_setup("GetFitterTarget",1525,G__G__TMVA3_187_0_5, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLIFitterTarget), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08297    G__memfunc_setup("GetNpars",804,G__G__TMVA3_187_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08298    G__memfunc_setup("GetName",673,(G__InterfaceMethod) NULL,67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
08299    G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 3);
08300    G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
08301    G__memfunc_setup("Class",502,G__G__TMVA3_187_0_10, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::FitterBase::Class) ), 0);
08302    G__memfunc_setup("Class_Name",982,G__G__TMVA3_187_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::FitterBase::Class_Name) ), 0);
08303    G__memfunc_setup("Class_Version",1339,G__G__TMVA3_187_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::FitterBase::Class_Version) ), 0);
08304    G__memfunc_setup("Dictionary",1046,G__G__TMVA3_187_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::FitterBase::Dictionary) ), 0);
08305    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08306    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);
08307    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);
08308    G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_187_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08309    G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_187_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::FitterBase::DeclFileName) ), 0);
08310    G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_187_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::FitterBase::ImplFileLine) ), 0);
08311    G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_187_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::FitterBase::ImplFileName) ), 0);
08312    G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_187_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::FitterBase::DeclFileLine) ), 0);
08313    // automatic destructor
08314    G__memfunc_setup("~FitterBase", 1127, G__G__TMVA3_187_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08315    G__tag_memfunc_reset();
08316 }
08317 
08318 static void G__setup_memfuncTMVAcLcLMCFitter(void) {
08319    /* TMVA::MCFitter */
08320    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMCFitter));
08321    G__memfunc_setup("MCFitter",766,G__G__TMVA3_196_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMCFitter), -1, 0, 4, 1, 1, 0, 
08322 "u 'TMVA::IFitterTarget' - 1 - target u 'TString' - 11 - name "
08323 "u 'vector<TMVA::Interval*,allocator<TMVA::Interval*> >' 'vector<TMVA::Interval*>' 11 - ranges u 'TString' - 11 - theOption", (char*)NULL, (void*) NULL, 0);
08324    G__memfunc_setup("SetParameters",1344,G__G__TMVA3_196_0_2, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - cycles", (char*)NULL, (void*) NULL, 0);
08325    G__memfunc_setup("Run",309,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - pars", (char*)NULL, (void*) NULL, 1);
08326    G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
08327    G__memfunc_setup("Class",502,G__G__TMVA3_196_0_5, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MCFitter::Class) ), 0);
08328    G__memfunc_setup("Class_Name",982,G__G__TMVA3_196_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MCFitter::Class_Name) ), 0);
08329    G__memfunc_setup("Class_Version",1339,G__G__TMVA3_196_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MCFitter::Class_Version) ), 0);
08330    G__memfunc_setup("Dictionary",1046,G__G__TMVA3_196_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MCFitter::Dictionary) ), 0);
08331    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08332    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);
08333    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);
08334    G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_196_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08335    G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_196_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MCFitter::DeclFileName) ), 0);
08336    G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_196_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MCFitter::ImplFileLine) ), 0);
08337    G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_196_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MCFitter::ImplFileName) ), 0);
08338    G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_196_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MCFitter::DeclFileLine) ), 0);
08339    // automatic destructor
08340    G__memfunc_setup("~MCFitter", 892, G__G__TMVA3_196_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08341    G__tag_memfunc_reset();
08342 }
08343 
08344 static void G__setup_memfuncTMVAcLcLGeneticFitter(void) {
08345    /* TMVA::GeneticFitter */
08346    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLGeneticFitter));
08347    G__memfunc_setup("GeneticFitter",1325,G__G__TMVA3_197_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLGeneticFitter), -1, 0, 4, 1, 1, 0, 
08348 "u 'TMVA::IFitterTarget' - 1 - target u 'TString' - 11 - name "
08349 "u 'vector<TMVA::Interval*,allocator<TMVA::Interval*> >' 'vector<TMVA::Interval*>' 11 - ranges u 'TString' - 11 - theOption", (char*)NULL, (void*) NULL, 0);
08350    G__memfunc_setup("SetParameters",1344,G__G__TMVA3_197_0_2, 121, -1, -1, 0, 7, 1, 1, 0, 
08351 "i - 'Int_t' 0 - cycles i - 'Int_t' 0 - nsteps "
08352 "i - 'Int_t' 0 - popSize i - 'Int_t' 0 - SC_steps "
08353 "i - 'Int_t' 0 - SC_rate d - 'Double_t' 0 - SC_factor "
08354 "d - 'Double_t' 0 - convCrit", (char*)NULL, (void*) NULL, 0);
08355    G__memfunc_setup("Run",309,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - pars", (char*)NULL, (void*) NULL, 1);
08356    G__memfunc_setup("NewFitness",1030,G__G__TMVA3_197_0_4, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
08357 "d - 'Double_t' 0 - oldF d - 'Double_t' 0 - newF", (char*)NULL, (void*) NULL, 0);
08358    G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
08359    G__memfunc_setup("Class",502,G__G__TMVA3_197_0_6, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::GeneticFitter::Class) ), 0);
08360    G__memfunc_setup("Class_Name",982,G__G__TMVA3_197_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GeneticFitter::Class_Name) ), 0);
08361    G__memfunc_setup("Class_Version",1339,G__G__TMVA3_197_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::GeneticFitter::Class_Version) ), 0);
08362    G__memfunc_setup("Dictionary",1046,G__G__TMVA3_197_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::GeneticFitter::Dictionary) ), 0);
08363    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08364    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);
08365    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);
08366    G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_197_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08367    G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_197_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GeneticFitter::DeclFileName) ), 0);
08368    G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_197_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::GeneticFitter::ImplFileLine) ), 0);
08369    G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_197_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::GeneticFitter::ImplFileName) ), 0);
08370    G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_197_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::GeneticFitter::DeclFileLine) ), 0);
08371    // automatic destructor
08372    G__memfunc_setup("~GeneticFitter", 1451, G__G__TMVA3_197_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08373    G__tag_memfunc_reset();
08374 }
08375 
08376 static void G__setup_memfuncTMVAcLcLSimulatedAnnealingFitter(void) {
08377    /* TMVA::SimulatedAnnealingFitter */
08378    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter));
08379    G__memfunc_setup("SimulatedAnnealingFitter",2467,G__G__TMVA3_198_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter), -1, 0, 4, 1, 1, 0, 
08380 "u 'TMVA::IFitterTarget' - 1 - target u 'TString' - 11 - name "
08381 "u 'vector<TMVA::Interval*,allocator<TMVA::Interval*> >' 'vector<TMVA::Interval*>' 11 - ranges u 'TString' - 11 - theOption", (char*)NULL, (void*) NULL, 0);
08382    G__memfunc_setup("SetParameters",1344,G__G__TMVA3_198_0_2, 121, -1, -1, 0, 9, 1, 1, 0, 
08383 "i - 'Int_t' 0 - fMaxCalls d - 'Double_t' 0 - fInitialTemperature "
08384 "d - 'Double_t' 0 - fMinTemperature d - 'Double_t' 0 - fEps "
08385 "u 'TString' - 0 - fKernelTemperatureS d - 'Double_t' 0 - fTemperatureScale "
08386 "d - 'Double_t' 0 - fTemperatureAdaptiveStep g - 'Bool_t' 0 - fUseDefaultScale "
08387 "g - 'Bool_t' 0 - fUseDefaultTemperature", (char*)NULL, (void*) NULL, 0);
08388    G__memfunc_setup("Run",309,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - pars", (char*)NULL, (void*) NULL, 1);
08389    G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
08390    G__memfunc_setup("Class",502,G__G__TMVA3_198_0_5, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::SimulatedAnnealingFitter::Class) ), 0);
08391    G__memfunc_setup("Class_Name",982,G__G__TMVA3_198_0_6, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SimulatedAnnealingFitter::Class_Name) ), 0);
08392    G__memfunc_setup("Class_Version",1339,G__G__TMVA3_198_0_7, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::SimulatedAnnealingFitter::Class_Version) ), 0);
08393    G__memfunc_setup("Dictionary",1046,G__G__TMVA3_198_0_8, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::SimulatedAnnealingFitter::Dictionary) ), 0);
08394    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08395    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);
08396    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);
08397    G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_198_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08398    G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_198_0_13, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SimulatedAnnealingFitter::DeclFileName) ), 0);
08399    G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_198_0_14, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::SimulatedAnnealingFitter::ImplFileLine) ), 0);
08400    G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_198_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SimulatedAnnealingFitter::ImplFileName) ), 0);
08401    G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_198_0_16, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::SimulatedAnnealingFitter::DeclFileLine) ), 0);
08402    // automatic destructor
08403    G__memfunc_setup("~SimulatedAnnealingFitter", 2593, G__G__TMVA3_198_0_17, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08404    G__tag_memfunc_reset();
08405 }
08406 
08407 static void G__setup_memfuncTMVAcLcLMinuitWrapper(void) {
08408    /* TMVA::MinuitWrapper */
08409    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitWrapper));
08410    G__memfunc_setup("MinuitWrapper",1367,G__G__TMVA3_200_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitWrapper), -1, 0, 2, 1, 1, 0, 
08411 "u 'TMVA::IFitterTarget' - 1 - target i - 'Int_t' 0 - maxpar", (char*)NULL, (void*) NULL, 0);
08412    G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
08413 "i - 'Int_t' 0 - - D - 'Double_t' 0 - - "
08414 "d - 'Double_t' 1 - - D - 'Double_t' 0 - - "
08415 "i - 'Int_t' 0 - -", (char*)NULL, (void*) NULL, 1);
08416    G__memfunc_setup("SetFitterTarget",1537,G__G__TMVA3_200_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMVA::IFitterTarget' - 1 - target", (char*)NULL, (void*) NULL, 0);
08417    G__memfunc_setup("ExecuteCommand",1426,G__G__TMVA3_200_0_4, 105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
08418 "C - - 10 - command D - 'Double_t' 0 - args "
08419 "i - 'Int_t' 0 - nargs", (char*)NULL, (void*) NULL, 0);
08420    G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '0' -", (char*)NULL, (void*) NULL, 1);
08421    G__memfunc_setup("GetStats",815,G__G__TMVA3_200_0_6, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
08422 "d - 'Double_t' 1 - amin d - 'Double_t' 1 - edm "
08423 "d - 'Double_t' 1 - errdef i - 'Int_t' 1 - nvpar "
08424 "i - 'Int_t' 1 - nparx", (char*)NULL, (void*) NULL, 0);
08425    G__memfunc_setup("GetErrors",925,G__G__TMVA3_200_0_7, 105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 0, 
08426 "i - 'Int_t' 0 - ipar d - 'Double_t' 1 - eplus "
08427 "d - 'Double_t' 1 - eminus d - 'Double_t' 1 - eparab "
08428 "d - 'Double_t' 1 - globcc", (char*)NULL, (void*) NULL, 0);
08429    G__memfunc_setup("SetParameter",1229,G__G__TMVA3_200_0_8, 105, -1, G__defined_typename("Int_t"), 0, 6, 1, 1, 0, 
08430 "i - 'Int_t' 0 - ipar C - - 10 - parname "
08431 "d - 'Double_t' 0 - value d - 'Double_t' 0 - verr "
08432 "d - 'Double_t' 0 - vlow d - 'Double_t' 0 - vhigh", (char*)NULL, (void*) NULL, 0);
08433    G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TObject), -1, 0, 1, 1, 1, 8, "C - - 10 - -", (char*)NULL, (void*) NULL, 1);
08434    G__memfunc_setup("Class",502,G__G__TMVA3_200_0_10, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MinuitWrapper::Class) ), 0);
08435    G__memfunc_setup("Class_Name",982,G__G__TMVA3_200_0_11, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MinuitWrapper::Class_Name) ), 0);
08436    G__memfunc_setup("Class_Version",1339,G__G__TMVA3_200_0_12, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MinuitWrapper::Class_Version) ), 0);
08437    G__memfunc_setup("Dictionary",1046,G__G__TMVA3_200_0_13, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MinuitWrapper::Dictionary) ), 0);
08438    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08439    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);
08440    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);
08441    G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_200_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08442    G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_200_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MinuitWrapper::DeclFileName) ), 0);
08443    G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_200_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MinuitWrapper::ImplFileLine) ), 0);
08444    G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_200_0_20, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MinuitWrapper::ImplFileName) ), 0);
08445    G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_200_0_21, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MinuitWrapper::DeclFileLine) ), 0);
08446    // automatic destructor
08447    G__memfunc_setup("~MinuitWrapper", 1493, G__G__TMVA3_200_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08448    G__tag_memfunc_reset();
08449 }
08450 
08451 static void G__setup_memfuncTMVAcLcLMinuitFitter(void) {
08452    /* TMVA::MinuitFitter */
08453    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMinuitFitter));
08454    G__memfunc_setup("Init",404,G__G__TMVA3_201_0_2, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08455    G__memfunc_setup("Run",309,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - pars", (char*)NULL, (void*) NULL, 1);
08456    G__memfunc_setup("EstimatorFunction",1790,G__G__TMVA3_201_0_4, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - pars", (char*)NULL, (void*) NULL, 0);
08457    G__memfunc_setup("DeclareOptions",1436,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 1);
08458    G__memfunc_setup("Class",502,G__G__TMVA3_201_0_6, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::MinuitFitter::Class) ), 0);
08459    G__memfunc_setup("Class_Name",982,G__G__TMVA3_201_0_7, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MinuitFitter::Class_Name) ), 0);
08460    G__memfunc_setup("Class_Version",1339,G__G__TMVA3_201_0_8, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::MinuitFitter::Class_Version) ), 0);
08461    G__memfunc_setup("Dictionary",1046,G__G__TMVA3_201_0_9, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::MinuitFitter::Dictionary) ), 0);
08462    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08463    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);
08464    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);
08465    G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_201_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08466    G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_201_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MinuitFitter::DeclFileName) ), 0);
08467    G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_201_0_15, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MinuitFitter::ImplFileLine) ), 0);
08468    G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_201_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::MinuitFitter::ImplFileName) ), 0);
08469    G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_201_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::MinuitFitter::DeclFileLine) ), 0);
08470    // automatic destructor
08471    G__memfunc_setup("~MinuitFitter", 1378, G__G__TMVA3_201_0_18, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08472    G__tag_memfunc_reset();
08473 }
08474 
08475 static void G__setup_memfuncTMVAcLcLPDEFoamCell(void) {
08476    /* TMVA::PDEFoamCell */
08477    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell));
08478    G__memfunc_setup("PDEFoamCell",988,G__G__TMVA3_309_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell), -1, 0, 0, 1, 1, 0, "", "Default Constructor for ROOT streamers", (void*) NULL, 0);
08479    G__memfunc_setup("PDEFoamCell",988,G__G__TMVA3_309_0_2, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", "User Constructor", (void*) NULL, 0);
08480    G__memfunc_setup("PDEFoamCell",988,G__G__TMVA3_309_0_3, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell), -1, 0, 1, 1, 1, 0, "u 'TMVA::PDEFoamCell' - 11 - -", "Copy constructor", (void*) NULL, 0);
08481    G__memfunc_setup("Fill",391,G__G__TMVA3_309_0_4, 121, -1, -1, 0, 4, 1, 1, 0, 
08482 "i - 'Int_t' 0 - - U 'TMVA::PDEFoamCell' - 0 - - "
08483 "U 'TMVA::PDEFoamCell' - 0 - - U 'TMVA::PDEFoamCell' - 0 - -", "Assigns values of attributes", (void*) NULL, 0);
08484    G__memfunc_setup("GetXdiv",699,G__G__TMVA3_309_0_5, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "Pointer to Xdiv", (void*) NULL, 0);
08485    G__memfunc_setup("GetBest",686,G__G__TMVA3_309_0_6, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "Pointer to Best", (void*) NULL, 0);
08486    G__memfunc_setup("SetBest",698,G__G__TMVA3_309_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - Best", "Set Best edge candidate", (void*) NULL, 0);
08487    G__memfunc_setup("SetXdiv",711,G__G__TMVA3_309_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - Xdiv", "Set x-division for best edge cand.", (void*) NULL, 0);
08488    G__memfunc_setup("GetHcub",674,G__G__TMVA3_309_0_9, 121, -1, -1, 0, 2, 1, 1, 8, 
08489 "u 'TMVA::PDEFoamVect' - 1 - - u 'TMVA::PDEFoamVect' - 1 - -", "Get position and size vectors (h-cubical subspace)", (void*) NULL, 0);
08490    G__memfunc_setup("GetHSize",771,G__G__TMVA3_309_0_10, 121, -1, -1, 0, 1, 1, 1, 8, "u 'TMVA::PDEFoamVect' - 1 - -", "Get size only of cell vector  (h-cubical subspace)", (void*) NULL, 0);
08491    G__memfunc_setup("CalcVolume",1003,G__G__TMVA3_309_0_11, 121, -1, -1, 0, 0, 1, 1, 0, "", "Calculates volume of cell", (void*) NULL, 0);
08492    G__memfunc_setup("GetVolume",920,G__G__TMVA3_309_0_12, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "Volume of cell", (void*) NULL, 0);
08493    G__memfunc_setup("GetIntg",690,G__G__TMVA3_309_0_13, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "Get Integral", (void*) NULL, 0);
08494    G__memfunc_setup("GetDriv",693,G__G__TMVA3_309_0_14, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", "Get Drive", (void*) NULL, 0);
08495    G__memfunc_setup("SetIntg",702,G__G__TMVA3_309_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - Intg", "Set true integral", (void*) NULL, 0);
08496    G__memfunc_setup("SetDriv",705,G__G__TMVA3_309_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "d - 'Double_t' 0 - Driv", "Set driver integral", (void*) NULL, 0);
08497    G__memfunc_setup("GetStat",700,G__G__TMVA3_309_0_17, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "Get Status", (void*) NULL, 0);
08498    G__memfunc_setup("SetStat",712,G__G__TMVA3_309_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - Stat", "Set Status", (void*) NULL, 0);
08499    G__memfunc_setup("GetPare",680,G__G__TMVA3_309_0_19, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell), -1, 0, 0, 1, 1, 8, "", "Get Pointer to parent cell", (void*) NULL, 0);
08500    G__memfunc_setup("GetDau0",618,G__G__TMVA3_309_0_20, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell), -1, 0, 0, 1, 1, 8, "", "Get Pointer to 1-st daughter vertex", (void*) NULL, 0);
08501    G__memfunc_setup("GetDau1",619,G__G__TMVA3_309_0_21, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell), -1, 0, 0, 1, 1, 8, "", "Get Pointer to 2-nd daughter vertex", (void*) NULL, 0);
08502    G__memfunc_setup("SetDau0",630,G__G__TMVA3_309_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::PDEFoamCell' - 0 - Daug", "Set pointer to 1-st daughter", (void*) NULL, 0);
08503    G__memfunc_setup("SetDau1",631,G__G__TMVA3_309_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::PDEFoamCell' - 0 - Daug", "Set pointer to 2-nd daughter", (void*) NULL, 0);
08504    G__memfunc_setup("SetPare",692,G__G__TMVA3_309_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::PDEFoamCell' - 0 - Pare", "Set pointer to parent", (void*) NULL, 0);
08505    G__memfunc_setup("SetSerial",908,G__G__TMVA3_309_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - Serial", "Set serial number", (void*) NULL, 0);
08506    G__memfunc_setup("GetSerial",896,G__G__TMVA3_309_0_26, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "Get serial number", (void*) NULL, 0);
08507    G__memfunc_setup("GetDepth",789,G__G__TMVA3_309_0_27, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", "Get depth in binary tree", (void*) NULL, 0);
08508    G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 - option", "Prints cell content", (void*) NULL, 1);
08509    G__memfunc_setup("SetElement",1014,G__G__TMVA3_309_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObject' - 0 - fobj", "Set user variable", (void*) NULL, 0);
08510    G__memfunc_setup("GetElement",1002,G__G__TMVA3_309_0_30, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TObject), -1, 0, 0, 1, 1, 8, "", "Get pointer to user varibale", (void*) NULL, 0);
08511    G__memfunc_setup("Class",502,G__G__TMVA3_309_0_31, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoamCell::Class) ), 0);
08512    G__memfunc_setup("Class_Name",982,G__G__TMVA3_309_0_32, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamCell::Class_Name) ), 0);
08513    G__memfunc_setup("Class_Version",1339,G__G__TMVA3_309_0_33, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoamCell::Class_Version) ), 0);
08514    G__memfunc_setup("Dictionary",1046,G__G__TMVA3_309_0_34, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoamCell::Dictionary) ), 0);
08515    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08516    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);
08517    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);
08518    G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_309_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08519    G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_309_0_39, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamCell::DeclFileName) ), 0);
08520    G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_309_0_40, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamCell::ImplFileLine) ), 0);
08521    G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_309_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamCell::ImplFileName) ), 0);
08522    G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_309_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamCell::DeclFileLine) ), 0);
08523    // automatic destructor
08524    G__memfunc_setup("~PDEFoamCell", 1114, G__G__TMVA3_309_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08525    // automatic assignment operator
08526    G__memfunc_setup("operator=", 937, G__G__TMVA3_309_0_44, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamCell' - 11 - -", (char*) NULL, (void*) NULL, 0);
08527    G__tag_memfunc_reset();
08528 }
08529 
08530 static void G__setup_memfuncTMVAcLcLPDEFoamVect(void) {
08531    /* TMVA::PDEFoamVect */
08532    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect));
08533    G__memfunc_setup("PDEFoamVect",1006,G__G__TMVA3_310_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 0, 0, 1, 1, 0, "", "Constructor", (void*) NULL, 0);
08534    G__memfunc_setup("PDEFoamVect",1006,G__G__TMVA3_310_0_2, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", "USER Constructor", (void*) NULL, 0);
08535    G__memfunc_setup("PDEFoamVect",1006,G__G__TMVA3_310_0_3, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 0, 1, 1, 1, 0, "u 'TMVA::PDEFoamVect' - 11 - -", "Copy constructor", (void*) NULL, 0);
08536    G__memfunc_setup("operator=",937,G__G__TMVA3_310_0_4, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamVect' - 11 - -", "= operator; Substitution", (void*) NULL, 0);
08537    G__memfunc_setup("operator[]",1060,G__G__TMVA3_310_0_5, 100, -1, G__defined_typename("Double_t"), 1, 1, 1, 1, 0, "i - 'Int_t' 0 - -", "[] provides POINTER to coordinate", (void*) NULL, 0);
08538    G__memfunc_setup("operator=",937,G__G__TMVA3_310_0_6, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 1, 1, 1, 1, 0, "D - 'Double_t' 0 - -", "LOAD IN entire double vector", (void*) NULL, 0);
08539    G__memfunc_setup("operator=",937,G__G__TMVA3_310_0_7, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 1, 1, 1, 1, 0, "d - 'Double_t' 0 - -", "LOAD IN double number", (void*) NULL, 0);
08540    G__memfunc_setup("operator+=",980,G__G__TMVA3_310_0_8, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamVect' - 11 - -", "+=; add vector u+=v  (FAST)", (void*) NULL, 0);
08541    G__memfunc_setup("operator-=",982,G__G__TMVA3_310_0_9, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoamVect' - 11 - -", "+=; add vector u+=v  (FAST)", (void*) NULL, 0);
08542    G__memfunc_setup("operator*=",979,G__G__TMVA3_310_0_10, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 1, 1, 1, 1, 0, "d - 'Double_t' 11 - -", "*=; mult. by scalar v*=x (FAST)", (void*) NULL, 0);
08543    G__memfunc_setup("operator+",919,G__G__TMVA3_310_0_11, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 0, 1, 1, 1, 0, "u 'TMVA::PDEFoamVect' - 11 - -", "+;  u=v+s, NEVER USE IT, SLOW!!!", (void*) NULL, 0);
08544    G__memfunc_setup("operator-",921,G__G__TMVA3_310_0_12, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect), -1, 0, 1, 1, 1, 0, "u 'TMVA::PDEFoamVect' - 11 - -", "-;  u=v-s, NEVER USE IT, SLOW!!!", (void*) NULL, 0);
08545    G__memfunc_setup("Print",525,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 8, "C - 'Option_t' 10 - option", "Prints vector", (void*) NULL, 1);
08546    G__memfunc_setup("GetDim",570,G__G__TMVA3_310_0_14, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "Returns dimension", (void*) NULL, 0);
08547    G__memfunc_setup("GetCoord",791,G__G__TMVA3_310_0_15, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - i", "Returns coordinate", (void*) NULL, 0);
08548    G__memfunc_setup("Class",502,G__G__TMVA3_310_0_16, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoamVect::Class) ), 0);
08549    G__memfunc_setup("Class_Name",982,G__G__TMVA3_310_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamVect::Class_Name) ), 0);
08550    G__memfunc_setup("Class_Version",1339,G__G__TMVA3_310_0_18, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoamVect::Class_Version) ), 0);
08551    G__memfunc_setup("Dictionary",1046,G__G__TMVA3_310_0_19, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoamVect::Dictionary) ), 0);
08552    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08553    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);
08554    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);
08555    G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_310_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08556    G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_310_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamVect::DeclFileName) ), 0);
08557    G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_310_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamVect::ImplFileLine) ), 0);
08558    G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_310_0_26, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamVect::ImplFileName) ), 0);
08559    G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_310_0_27, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamVect::DeclFileLine) ), 0);
08560    // automatic destructor
08561    G__memfunc_setup("~PDEFoamVect", 1132, G__G__TMVA3_310_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08562    G__tag_memfunc_reset();
08563 }
08564 
08565 static void G__setup_memfuncTMVAcLcLPDEFoamDistr(void) {
08566    /* TMVA::PDEFoamDistr */
08567    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDistr));
08568    G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 2, 8, "", (char*)NULL, (void*) NULL, 0);
08569    G__memfunc_setup("PDEFoamDistr",1122,G__G__TMVA3_311_0_2, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDistr), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08570    G__memfunc_setup("PDEFoamDistr",1122,G__G__TMVA3_311_0_3, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDistr), -1, 0, 1, 1, 1, 0, "u 'TMVA::PDEFoamDistr' - 11 - -", (char*)NULL, (void*) NULL, 0);
08571    G__memfunc_setup("Initialize",1042,G__G__TMVA3_311_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", "create and initialize binary search tree", (void*) NULL, 0);
08572    G__memfunc_setup("FillBinarySearchTree",2002,G__G__TMVA3_311_0_5, 121, -1, -1, 0, 3, 1, 1, 0, 
08573 "U 'TMVA::Event' - 10 - ev i 'TMVA::EFoamType' - 0 - ft "
08574 "g - 'Bool_t' 0 'kFALSE' NoNegWeights", (char*)NULL, (void*) NULL, 0);
08575    G__memfunc_setup("Density",736,G__G__TMVA3_311_0_6, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
08576 "D - 'Double_t' 0 - Xarg d - 'Double_t' 1 - event_density", (char*)NULL, (void*) NULL, 0);
08577    G__memfunc_setup("FillHist",799,G__G__TMVA3_311_0_7, 121, -1, -1, 0, 5, 1, 1, 0, 
08578 "U 'TMVA::PDEFoamCell' - 0 - cell u 'vector<TH1F*,allocator<TH1F*> >' 'vector<TH1F*>' 1 - - "
08579 "u 'vector<TH1F*,allocator<TH1F*> >' 'vector<TH1F*>' 1 - - u 'vector<TH1F*,allocator<TH1F*> >' 'vector<TH1F*>' 1 - - "
08580 "u 'vector<TH1F*,allocator<TH1F*> >' 'vector<TH1F*>' 1 - -", (char*)NULL, (void*) NULL, 0);
08581    G__memfunc_setup("SetPDEFoam",904,G__G__TMVA3_311_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::PDEFoam' - 10 - foam", (char*)NULL, (void*) NULL, 0);
08582    G__memfunc_setup("GetPDEFoam",892,G__G__TMVA3_311_0_9, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
08583    G__memfunc_setup("SetDensityCalc",1407,G__G__TMVA3_311_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TMVA::TDensityCalc' - 0 - dc", (char*)NULL, (void*) NULL, 0);
08584    G__memfunc_setup("FillDiscriminator",1759,G__G__TMVA3_311_0_11, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08585    G__memfunc_setup("FillTarget0",1054,G__G__TMVA3_311_0_12, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08586    G__memfunc_setup("FillEventDensity",1641,G__G__TMVA3_311_0_13, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08587    G__memfunc_setup("Class",502,G__G__TMVA3_311_0_14, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoamDistr::Class) ), 0);
08588    G__memfunc_setup("Class_Name",982,G__G__TMVA3_311_0_15, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamDistr::Class_Name) ), 0);
08589    G__memfunc_setup("Class_Version",1339,G__G__TMVA3_311_0_16, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoamDistr::Class_Version) ), 0);
08590    G__memfunc_setup("Dictionary",1046,G__G__TMVA3_311_0_17, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoamDistr::Dictionary) ), 0);
08591    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08592    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);
08593    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);
08594    G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_311_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08595    G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_311_0_22, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamDistr::DeclFileName) ), 0);
08596    G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_311_0_23, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamDistr::ImplFileLine) ), 0);
08597    G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_311_0_24, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoamDistr::ImplFileName) ), 0);
08598    G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_311_0_25, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoamDistr::DeclFileLine) ), 0);
08599    // automatic destructor
08600    G__memfunc_setup("~PDEFoamDistr", 1248, G__G__TMVA3_311_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08601    G__tag_memfunc_reset();
08602 }
08603 
08604 static void G__setup_memfuncTMVAcLcLPDEFoam(void) {
08605    /* TMVA::PDEFoam */
08606    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam));
08607    G__memfunc_setup("GetDistr",806,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamDistr), -1, 0, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
08608    G__memfunc_setup("OutputGrow",1072,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "g - 'Bool_t' 0 'false' finished", "nice TMVA console output", (void*) NULL, 0);
08609    G__memfunc_setup("WeightGaus",1016,(G__InterfaceMethod) NULL, 102, -1, G__defined_typename("Float_t"), 0, 3, 1, 2, 0, 
08610 "U 'TMVA::PDEFoamCell' - 0 - - u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - - "
08611 "h - 'UInt_t' 0 '0' dim", (char*)NULL, (void*) NULL, 0);
08612    G__memfunc_setup("WeightLinNeighbors",1836,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 5, 1, 2, 0, 
08613 "u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - txvec i 'TMVA::ECellValue' - 0 - cv "
08614 "i - 'Int_t' 0 '-1' dim1 i - 'Int_t' 0 '-1' dim2 "
08615 "g - 'Bool_t' 0 'kFALSE' TreatEmptyCells", (char*)NULL, (void*) NULL, 0);
08616    G__memfunc_setup("InitCells",903,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Initialisation of all foam cells", (void*) NULL, 0);
08617    G__memfunc_setup("CellFill",775,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 2, 1, 2, 0, 
08618 "i - 'Int_t' 0 - - U 'TMVA::PDEFoamCell' - 0 - -", "Allocates new empty cell and return its index", (void*) NULL, 0);
08619    G__memfunc_setup("Explore",735,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TMVA::PDEFoamCell' - 0 - Cell", "Exploration of the new cell, determine <wt>, wtMax etc.", (void*) NULL, 0);
08620    G__memfunc_setup("DTExplore",887,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'TMVA::PDEFoamCell' - 0 - Cell", "Exploration of the new cell according to decision tree logic", (void*) NULL, 0);
08621    G__memfunc_setup("Varedu",615,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 4, 1, 2, 0, 
08622 "D - 'Double_t' 0 - - i - 'Int_t' 1 - - "
08623 "d - 'Double_t' 1 - - d - 'Double_t' 1 - -", "Determines the best edge, variace reduction", (void*) NULL, 0);
08624    G__memfunc_setup("MakeAlpha",868,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "Provides random point inside hyperrectangle", (void*) NULL, 0);
08625    G__memfunc_setup("Grow",415,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", "build up foam", (void*) NULL, 0);
08626    G__memfunc_setup("PeekMax",683,(G__InterfaceMethod) NULL, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 2, 0, "", "peek cell with max. driver integral", (void*) NULL, 0);
08627    G__memfunc_setup("PeekLast",793,(G__InterfaceMethod) NULL, 108, -1, G__defined_typename("Long_t"), 0, 0, 1, 2, 0, "", "peek last created cell", (void*) NULL, 0);
08628    G__memfunc_setup("Divide",597,(G__InterfaceMethod) NULL, 105, -1, G__defined_typename("Int_t"), 0, 1, 1, 2, 0, "U 'TMVA::PDEFoamCell' - 0 - -", "Divide iCell into two daughters; iCell retained, taged as inactive", (void*) NULL, 0);
08629    G__memfunc_setup("Eval",392,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 2, 0, 
08630 "D - 'Double_t' 0 - xRand d - 'Double_t' 1 - event_density", "evaluate distribution on point 'xRand'", (void*) NULL, 0);
08631    G__memfunc_setup("GetSeparation",1334,(G__InterfaceMethod) NULL, 102, -1, G__defined_typename("Float_t"), 0, 2, 1, 2, 0, 
08632 "f - 'Float_t' 0 - s f - 'Float_t' 0 - b", "calculate separation", (void*) NULL, 0);
08633    G__memfunc_setup("GetCellElement",1386,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 2, 0, 
08634 "U 'TMVA::PDEFoamCell' - 0 - cell h - 'UInt_t' 0 - i", "get Element 'i' in cell 'cell'", (void*) NULL, 0);
08635    G__memfunc_setup("SetCellElement",1398,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
08636 "U 'TMVA::PDEFoamCell' - 0 - cell h - 'UInt_t' 0 - i "
08637 "d - 'Double_t' 0 - value", "set Element 'i' in cell 'cell' to value 'value'", (void*) NULL, 0);
08638    G__memfunc_setup("GetCellValue",1181,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 2, 0, 
08639 "U 'TMVA::PDEFoamCell' - 0 - - i 'TMVA::ECellValue' - 0 - -", (char*)NULL, (void*) NULL, 0);
08640    G__memfunc_setup("CellValueIsUndefined",1995,(G__InterfaceMethod) NULL, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 2, 0, "U 'TMVA::PDEFoamCell' - 0 - -", (char*)NULL, (void*) NULL, 0);
08641    G__memfunc_setup("FindCell",769,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell), -1, 0, 1, 1, 2, 0, "u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - -", "!", (void*) NULL, 0);
08642    G__memfunc_setup("FindCells",884,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR), G__defined_typename("vector<TMVA::PDEFoamCell*>"), 0, 1, 1, 2, 0, "u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - -", "!", (void*) NULL, 0);
08643    G__memfunc_setup("FindCellsRecursive",1836,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
08644 "u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - - U 'TMVA::PDEFoamCell' - 0 - - "
08645 "u 'vector<TMVA::PDEFoamCell*,allocator<TMVA::PDEFoamCell*> >' - 1 - -", (char*)NULL, (void*) NULL, 0);
08646    G__memfunc_setup("GetCellTargets",1402,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 0, 2, 1, 2, 0, 
08647 "u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - tvals i 'TMVA::ETargetSelection' - 0 - ts", (char*)NULL, (void*) NULL, 0);
08648    G__memfunc_setup("GetBuildUpCellEvents",1994,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 2, 0, "U 'TMVA::PDEFoamCell' - 0 - cell", (char*)NULL, (void*) NULL, 0);
08649    G__memfunc_setup("PDEFoam",604,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam), -1, 0, 1, 1, 2, 0, "u 'TMVA::PDEFoam' - 11 - -", "Copy Constructor  NOT USED", (void*) NULL, 0);
08650    G__memfunc_setup("PDEFoam",604,G__G__TMVA3_312_0_27, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam), -1, 0, 0, 1, 1, 0, "", "Default constructor (used only by ROOT streamer)", (void*) NULL, 0);
08651    G__memfunc_setup("PDEFoam",604,G__G__TMVA3_312_0_28, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam), -1, 0, 1, 1, 1, 0, "u 'TString' - 11 - -", "Principal user-defined constructor", (void*) NULL, 0);
08652    G__memfunc_setup("Init",404,G__G__TMVA3_312_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", "initialize PDEFoamDistr", (void*) NULL, 0);
08653    G__memfunc_setup("FillBinarySearchTree",2002,G__G__TMVA3_312_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
08654 "U 'TMVA::Event' - 10 - ev g - 'Bool_t' 0 'kFALSE' NoNegWeights", (char*)NULL, (void*) NULL, 0);
08655    G__memfunc_setup("Create",596,G__G__TMVA3_312_0_31, 121, -1, -1, 0, 0, 1, 1, 0, "", "build-up foam", (void*) NULL, 0);
08656    G__memfunc_setup("FillFoamCells",1277,G__G__TMVA3_312_0_32, 121, -1, -1, 0, 2, 1, 1, 0, 
08657 "U 'TMVA::Event' - 10 - ev g - 'Bool_t' 0 'kFALSE' NoNegWeights", (char*)NULL, (void*) NULL, 0);
08658    G__memfunc_setup("CalcCellDiscr",1256,G__G__TMVA3_312_0_33, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08659    G__memfunc_setup("CalcCellTarget",1370,G__G__TMVA3_312_0_34, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08660    G__memfunc_setup("ResetCellElements",1728,G__G__TMVA3_312_0_35, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'false' allcells", (char*)NULL, (void*) NULL, 0);
08661    G__memfunc_setup("SetDim",582,G__G__TMVA3_312_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - kDim", "Sets dimension of cubical space", (void*) NULL, 0);
08662    G__memfunc_setup("SetnCells",909,G__G__TMVA3_312_0_37, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - nCells", "Sets maximum number of cells", (void*) NULL, 0);
08663    G__memfunc_setup("SetnSampl",919,G__G__TMVA3_312_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 - nSampl", "Sets no of MC events in cell exploration", (void*) NULL, 0);
08664    G__memfunc_setup("SetnBin",691,G__G__TMVA3_312_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - nBin", "Sets no of bins in histogs in cell exploration", (void*) NULL, 0);
08665    G__memfunc_setup("SetEvPerBin",1063,G__G__TMVA3_312_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - EvPerBin", "Sets max. no. of effective events per bin", (void*) NULL, 0);
08666    G__memfunc_setup("SetInhiDiv",983,G__G__TMVA3_312_0_41, 121, -1, -1, 0, 2, 1, 1, 0, 
08667 "i - 'Int_t' 0 - - i - 'Int_t' 0 - -", "Set inhibition of cell division along certain edge", (void*) NULL, 0);
08668    G__memfunc_setup("SetNElements",1207,G__G__TMVA3_312_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - numb", "init every cell element (TVectorD*)", (void*) NULL, 0);
08669    G__memfunc_setup("SetVolumeFraction",1754,G__G__TMVA3_312_0_43, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - vfr", "set VolFrac", (void*) NULL, 0);
08670    G__memfunc_setup("SetFoamType",1105,G__G__TMVA3_312_0_44, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TMVA::EFoamType' - 0 - ft", "set foam type", (void*) NULL, 0);
08671    G__memfunc_setup("SetFillFoamWithOrigWeights",2622,G__G__TMVA3_312_0_45, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - new_val", (char*)NULL, (void*) NULL, 0);
08672    G__memfunc_setup("SetDTSeparation",1498,G__G__TMVA3_312_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TMVA::EDTSeparation' - 0 - new_val", (char*)NULL, (void*) NULL, 0);
08673    G__memfunc_setup("SetPeekMax",983,G__G__TMVA3_312_0_47, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 - new_val", (char*)NULL, (void*) NULL, 0);
08674    G__memfunc_setup("GetTotDim",881,G__G__TMVA3_312_0_48, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", "Get total dimension", (void*) NULL, 0);
08675    G__memfunc_setup("GetFoamName",1060,G__G__TMVA3_312_0_49, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TString), -1, 0, 0, 1, 1, 8, "", "Get name of foam", (void*) NULL, 0);
08676    G__memfunc_setup("GetNElements",1195,G__G__TMVA3_312_0_50, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", "returns number of elements, saved on every cell", (void*) NULL, 0);
08677    G__memfunc_setup("GetVolumeFraction",1742,G__G__TMVA3_312_0_51, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", "get VolFrac from PDEFoam", (void*) NULL, 0);
08678    G__memfunc_setup("GetFoamType",1093,G__G__TMVA3_312_0_52, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEFoamType), -1, 0, 0, 1, 1, 8, "", "get foam type", (void*) NULL, 0);
08679    G__memfunc_setup("GetNActiveCells",1469,G__G__TMVA3_312_0_53, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", "returns number of active cells", (void*) NULL, 0);
08680    G__memfunc_setup("GetNInActiveCells",1652,G__G__TMVA3_312_0_54, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", "returns number of not active cells", (void*) NULL, 0);
08681    G__memfunc_setup("GetNCells",865,G__G__TMVA3_312_0_55, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", "returns number of cells", (void*) NULL, 0);
08682    G__memfunc_setup("GetRootCell",1092,G__G__TMVA3_312_0_56, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell), -1, 0, 0, 1, 1, 8, "", "get pointer to root cell", (void*) NULL, 0);
08683    G__memfunc_setup("SetNmin",702,G__G__TMVA3_312_0_57, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - val", (char*)NULL, (void*) NULL, 0);
08684    G__memfunc_setup("GetNmin",690,G__G__TMVA3_312_0_58, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08685    G__memfunc_setup("GetFillFoamWithOrigWeights",2610,G__G__TMVA3_312_0_59, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08686    G__memfunc_setup("SetMaxDepth",1095,G__G__TMVA3_312_0_60, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - maxdepth", (char*)NULL, (void*) NULL, 0);
08687    G__memfunc_setup("GetMaxDepth",1083,G__G__TMVA3_312_0_61, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08688    G__memfunc_setup("SetXmin",712,G__G__TMVA3_312_0_62, 121, -1, -1, 0, 2, 1, 1, 0, 
08689 "i - 'Int_t' 0 - idim d - 'Double_t' 0 - wmin", (char*)NULL, (void*) NULL, 0);
08690    G__memfunc_setup("SetXmax",714,G__G__TMVA3_312_0_63, 121, -1, -1, 0, 2, 1, 1, 0, 
08691 "i - 'Int_t' 0 - idim d - 'Double_t' 0 - wmax", (char*)NULL, (void*) NULL, 0);
08692    G__memfunc_setup("GetXmin",700,G__G__TMVA3_312_0_64, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idim", (char*)NULL, (void*) NULL, 0);
08693    G__memfunc_setup("GetXmax",702,G__G__TMVA3_312_0_65, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - idim", (char*)NULL, (void*) NULL, 0);
08694    G__memfunc_setup("AddVariableName",1456,G__G__TMVA3_312_0_66, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - s", (char*)NULL, (void*) NULL, 0);
08695    G__memfunc_setup("AddVariableName",1456,G__G__TMVA3_312_0_67, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TObjString' - 0 - s", (char*)NULL, (void*) NULL, 0);
08696    G__memfunc_setup("GetVariableName",1479,G__G__TMVA3_312_0_68, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TObjString), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
08697    G__memfunc_setup("DeleteBinarySearchTree",2206,G__G__TMVA3_312_0_69, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08698    G__memfunc_setup("VarTransform",1253,G__G__TMVA3_312_0_70, 102, -1, G__defined_typename("Float_t"), 0, 2, 1, 1, 8, 
08699 "i - 'Int_t' 0 - idim f - 'Float_t' 0 - x", "transform [xmin, xmax] --> [0, 1]", (void*) NULL, 0);
08700    G__memfunc_setup("VarTransform",1253,G__G__TMVA3_312_0_71, 117, G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 0, 1, 1, 1, 8, "u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - invec", (char*)NULL, (void*) NULL, 0);
08701    G__memfunc_setup("VarTransformInvers",1884,G__G__TMVA3_312_0_72, 102, -1, G__defined_typename("Float_t"), 0, 2, 1, 1, 8, 
08702 "i - 'Int_t' 0 - idim f - 'Float_t' 0 - x", "transform [0, 1] --> [xmin, xmax]", (void*) NULL, 0);
08703    G__memfunc_setup("VarTransformInvers",1884,G__G__TMVA3_312_0_73, 117, G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 0, 1, 1, 1, 8, "u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - invec", (char*)NULL, (void*) NULL, 0);
08704    G__memfunc_setup("CheckAll",759,G__G__TMVA3_312_0_74, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - -", "Checks correctness of the entire data structure in the FOAM object", (void*) NULL, 0);
08705    G__memfunc_setup("PrintCell",909,G__G__TMVA3_312_0_75, 121, -1, -1, 0, 1, 1, 1, 0, "l - 'Long_t' 0 '0' iCell", "Print content of cell", (void*) NULL, 0);
08706    G__memfunc_setup("PrintCells",1024,G__G__TMVA3_312_0_76, 121, -1, -1, 0, 0, 1, 1, 0, "", "Prints content of all cells", (void*) NULL, 0);
08707    G__memfunc_setup("CheckCells",977,G__G__TMVA3_312_0_77, 121, -1, -1, 0, 1, 1, 1, 0, "g - 'Bool_t' 0 'false' remove_empty_cells", "check all cells with respect to critical values", (void*) NULL, 0);
08708    G__memfunc_setup("RemoveEmptyCell",1533,G__G__TMVA3_312_0_78, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - iCell", "removes iCell if its volume is zero", (void*) NULL, 0);
08709    G__memfunc_setup("PrintCellElements",1738,G__G__TMVA3_312_0_79, 121, -1, -1, 0, 0, 1, 1, 0, "", "print all cells with its elements", (void*) NULL, 0);
08710    G__memfunc_setup("Log",290,G__G__TMVA3_312_0_80, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08711    G__memfunc_setup("ReadStream",1000,G__G__TMVA3_312_0_81, 121, -1, -1, 0, 1, 1, 1, 0, "u 'basic_istream<char,char_traits<char> >' 'istream' 1 - -", "read  foam from stream", (void*) NULL, 0);
08712    G__memfunc_setup("PrintStream",1145,G__G__TMVA3_312_0_82, 121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - -", "write foam from stream", (void*) NULL, 0);
08713    G__memfunc_setup("ReadXML",621,G__G__TMVA3_312_0_83, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - parent", "read  foam variables from xml", (void*) NULL, 0);
08714    G__memfunc_setup("AddXMLTo",701,G__G__TMVA3_312_0_84, 121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - parent", "write foam variables to xml", (void*) NULL, 0);
08715    G__memfunc_setup("Project2",777,G__G__TMVA3_312_0_85, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TH2D), -1, 0, 5, 1, 1, 0, 
08716 "i - 'Int_t' 0 - idim1 i - 'Int_t' 0 - idim2 "
08717 "C - - 10 '\"cell_value\"' opt C - - 10 '\"kNone\"' ker "
08718 "h - 'UInt_t' 0 '50' maxbins", (char*)NULL, (void*) NULL, 0);
08719    G__memfunc_setup("GetProjectionCellValue",2234,G__G__TMVA3_312_0_86, 100, -1, G__defined_typename("Double_t"), 0, 4, 1, 1, 0, 
08720 "U 'TMVA::PDEFoamCell' - 0 - cell i - 'Int_t' 0 - idim1 "
08721 "i - 'Int_t' 0 - idim2 i 'TMVA::ECellValue' - 0 - cv", (char*)NULL, (void*) NULL, 0);
08722    G__memfunc_setup("Draw1Dim",729,G__G__TMVA3_312_0_87, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TH1D), -1, 0, 2, 1, 1, 0, 
08723 "C - - 10 - opt i - 'Int_t' 0 - nbin", (char*)NULL, (void*) NULL, 0);
08724    G__memfunc_setup("RootPlot2dim",1199,G__G__TMVA3_312_0_88, 121, -1, -1, 0, 5, 1, 1, 0, 
08725 "u 'TString' - 11 - filename u 'TString' - 0 - opt "
08726 "g - 'Bool_t' 0 'kTRUE' CreateCanvas g - 'Bool_t' 0 'kTRUE' colors "
08727 "g - 'Bool_t' 0 'kFALSE' log_colors", (char*)NULL, (void*) NULL, 0);
08728    G__memfunc_setup("GetCellValue",1181,G__G__TMVA3_312_0_89, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
08729 "u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - - i 'TMVA::ECellValue' - 0 - -", (char*)NULL, (void*) NULL, 0);
08730    G__memfunc_setup("GetCellDiscr",1173,G__G__TMVA3_312_0_90, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
08731 "u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - xvec i 'TMVA::EKernel' - 0 'kNone' kernel", (char*)NULL, (void*) NULL, 0);
08732    G__memfunc_setup("GetCellDensity",1408,G__G__TMVA3_312_0_91, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
08733 "u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - xvec i 'TMVA::EKernel' - 0 'kNone' kernel", (char*)NULL, (void*) NULL, 0);
08734    G__memfunc_setup("GetAverageNeighborsValue",2425,G__G__TMVA3_312_0_92, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
08735 "u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - txvec i 'TMVA::ECellValue' - 0 - cv", (char*)NULL, (void*) NULL, 0);
08736    G__memfunc_setup("GetCellRegValue0",1515,G__G__TMVA3_312_0_93, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
08737 "u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - - i 'TMVA::EKernel' - 0 'kNone' kernel", (char*)NULL, (void*) NULL, 0);
08738    G__memfunc_setup("GetProjectedRegValue",2011,G__G__TMVA3_312_0_94, 117, G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 0, 3, 1, 1, 0, 
08739 "u 'vector<float,allocator<float> >' 'vector<Float_t>' 1 - vals i 'TMVA::EKernel' - 0 'kNone' kernel "
08740 "i 'TMVA::ETargetSelection' - 0 'kMean' ts", (char*)NULL, (void*) NULL, 0);
08741    G__memfunc_setup("Class",502,G__G__TMVA3_312_0_95, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::PDEFoam::Class) ), 0);
08742    G__memfunc_setup("Class_Name",982,G__G__TMVA3_312_0_96, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoam::Class_Name) ), 0);
08743    G__memfunc_setup("Class_Version",1339,G__G__TMVA3_312_0_97, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::PDEFoam::Class_Version) ), 0);
08744    G__memfunc_setup("Dictionary",1046,G__G__TMVA3_312_0_98, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::PDEFoam::Dictionary) ), 0);
08745    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08746    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);
08747    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);
08748    G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_312_0_102, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08749    G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_312_0_103, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoam::DeclFileName) ), 0);
08750    G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_312_0_104, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoam::ImplFileLine) ), 0);
08751    G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_312_0_105, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::PDEFoam::ImplFileName) ), 0);
08752    G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_312_0_106, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::PDEFoam::DeclFileLine) ), 0);
08753    // automatic destructor
08754    G__memfunc_setup("~PDEFoam", 730, G__G__TMVA3_312_0_107, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08755    // automatic assignment operator
08756    G__memfunc_setup("operator=", 937, G__G__TMVA3_312_0_108, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPDEFoam), -1, 1, 1, 1, 1, 0, "u 'TMVA::PDEFoam' - 11 - -", (char*) NULL, (void*) NULL, 0);
08757    G__tag_memfunc_reset();
08758 }
08759 
08760 static void G__setup_memfuncTMVAcLcLBDTEventWrapper(void) {
08761    /* TMVA::BDTEventWrapper */
08762    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLBDTEventWrapper));
08763    G__memfunc_setup("BDTEventWrapper",1469,G__G__TMVA3_387_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLBDTEventWrapper), -1, 0, 1, 1, 1, 0, "U 'TMVA::Event' - 10 - -", (char*)NULL, (void*) NULL, 0);
08764    G__memfunc_setup("operator<",936,G__G__TMVA3_387_0_2, 103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "u 'TMVA::BDTEventWrapper' - 11 - other", (char*)NULL, (void*) NULL, 0);
08765    G__memfunc_setup("SetCumulativeWeight",1971,G__G__TMVA3_387_0_3, 121, -1, -1, 0, 2, 1, 1, 0, 
08766 "g - 'Bool_t' 0 - type d - 'Double_t' 0 - weight", (char*)NULL, (void*) NULL, 0);
08767    G__memfunc_setup("GetCumulativeWeight",1959,G__G__TMVA3_387_0_4, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "g - 'Bool_t' 0 - type", (char*)NULL, (void*) NULL, 0);
08768    G__memfunc_setup("SetVarIndex",1101,G__G__TMVA3_387_0_5, 121, -1, -1, 0, 1, 3, 1, 0, "i - 'Int_t' 0 - iVar", (char*)NULL, (void*) G__func2void( (void (*)(Int_t))(&TMVA::BDTEventWrapper::SetVarIndex) ), 0);
08769    G__memfunc_setup("GetVal",579,G__G__TMVA3_387_0_6, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08770    G__memfunc_setup("operator*",918,G__G__TMVA3_387_0_7, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLEvent), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
08771    // automatic copy constructor
08772    G__memfunc_setup("BDTEventWrapper", 1469, G__G__TMVA3_387_0_8, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLBDTEventWrapper), -1, 0, 1, 1, 1, 0, "u 'TMVA::BDTEventWrapper' - 11 - -", (char*) NULL, (void*) NULL, 0);
08773    // automatic destructor
08774    G__memfunc_setup("~BDTEventWrapper", 1595, G__G__TMVA3_387_0_9, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
08775    G__tag_memfunc_reset();
08776 }
08777 
08778 static void G__setup_memfuncTMVAcLcLCCTreeWrapper(void) {
08779    /* TMVA::CCTreeWrapper */
08780    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrapper));
08781    G__memfunc_setup("CCTreeWrapper",1271,G__G__TMVA3_482_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrapper), -1, 0, 2, 1, 1, 0, 
08782 "U 'TMVA::DecisionTree' - 0 - T U 'TMVA::SeparationBase' - 0 - qualityIndex", (char*)NULL, (void*) NULL, 0);
08783    G__memfunc_setup("CheckEvent",992,G__G__TMVA3_482_0_2, 100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 0, 
08784 "u 'TMVA::Event' - 11 - e g - 'Bool_t' 0 'false' useYesNoLeaf", (char*)NULL, (void*) NULL, 0);
08785    G__memfunc_setup("TestTreeQuality",1561,G__G__TMVA3_482_0_3, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "U 'vector<TMVA::Event*,allocator<TMVA::Event*> >' 'TMVA::CCTreeWrapper::EventList' 10 - validationSample", (char*)NULL, (void*) NULL, 0);
08786    G__memfunc_setup("TestTreeQuality",1561,G__G__TMVA3_482_0_4, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "U 'TMVA::DataSet' - 10 - validationSample", (char*)NULL, (void*) NULL, 0);
08787    G__memfunc_setup("PruneNode",912,G__G__TMVA3_482_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::CCTreeWrapper::CCTreeNode' - 0 - t", (char*)NULL, (void*) NULL, 0);
08788    G__memfunc_setup("InitTree",804,G__G__TMVA3_482_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "U 'TMVA::CCTreeWrapper::CCTreeNode' - 0 - t", (char*)NULL, (void*) NULL, 0);
08789    G__memfunc_setup("GetRoot",708,G__G__TMVA3_482_0_7, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrappercLcLCCTreeNode), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08790    // automatic copy constructor
08791    G__memfunc_setup("CCTreeWrapper", 1271, G__G__TMVA3_482_0_8, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrapper), -1, 0, 1, 1, 1, 0, "u 'TMVA::CCTreeWrapper' - 11 - -", (char*) NULL, (void*) NULL, 0);
08792    // automatic destructor
08793    G__memfunc_setup("~CCTreeWrapper", 1397, G__G__TMVA3_482_0_9, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
08794    // automatic assignment operator
08795    G__memfunc_setup("operator=", 937, G__G__TMVA3_482_0_10, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCTreeWrapper), -1, 1, 1, 1, 1, 0, "u 'TMVA::CCTreeWrapper' - 11 - -", (char*) NULL, (void*) NULL, 0);
08796    G__tag_memfunc_reset();
08797 }
08798 
08799 static void G__setup_memfuncTMVAcLcLCCPruner(void) {
08800    /* TMVA::CCPruner */
08801    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCPruner));
08802    G__memfunc_setup("CCPruner",770,G__G__TMVA3_484_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCPruner), -1, 0, 3, 1, 1, 0, 
08803 "U 'TMVA::DecisionTree' - 0 - t_max U 'vector<TMVA::Event*,allocator<TMVA::Event*> >' 'TMVA::CCPruner::EventList' 10 - validationSample "
08804 "U 'TMVA::SeparationBase' - 0 'NULL' qualityIndex", (char*)NULL, (void*) NULL, 0);
08805    G__memfunc_setup("CCPruner",770,G__G__TMVA3_484_0_2, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCPruner), -1, 0, 3, 1, 1, 0, 
08806 "U 'TMVA::DecisionTree' - 0 - t_max U 'TMVA::DataSet' - 10 - validationSample "
08807 "U 'TMVA::SeparationBase' - 0 'NULL' qualityIndex", (char*)NULL, (void*) NULL, 0);
08808    G__memfunc_setup("SetPruneStrength",1669,G__G__TMVA3_484_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 '-1.0' alpha", (char*)NULL, (void*) NULL, 0);
08809    G__memfunc_setup("Optimize",849,G__G__TMVA3_484_0_4, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08810    G__memfunc_setup("GetOptimalPruneSequence",2361,G__G__TMVA3_484_0_5, 117, G__get_linked_tagnum(&G__G__TMVA3LN_vectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgR), G__defined_typename("vector<TMVA::DecisionTreeNode*>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08811    G__memfunc_setup("GetOptimalQualityIndex",2263,G__G__TMVA3_484_0_6, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08812    G__memfunc_setup("GetOptimalPruneStrength",2383,G__G__TMVA3_484_0_7, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08813    // automatic copy constructor
08814    G__memfunc_setup("CCPruner", 770, G__G__TMVA3_484_0_8, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCCPruner), -1, 0, 1, 1, 1, 0, "u 'TMVA::CCPruner' - 11 - -", (char*) NULL, (void*) NULL, 0);
08815    // automatic destructor
08816    G__memfunc_setup("~CCPruner", 896, G__G__TMVA3_484_0_9, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
08817    G__tag_memfunc_reset();
08818 }
08819 
08820 static void G__setup_memfuncTMVAcLcLCostComplexityPruneTool(void) {
08821    /* TMVA::CostComplexityPruneTool */
08822    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool));
08823    G__memfunc_setup("CostComplexityPruneTool",2415,G__G__TMVA3_492_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool), -1, 0, 1, 1, 1, 0, "U 'TMVA::SeparationBase' - 0 'NULL' qualityIndex", (char*)NULL, (void*) NULL, 0);
08824    G__memfunc_setup("CalculatePruningInfo",2045,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLPruningInfo), -1, 0, 3, 1, 1, 0, 
08825 "U 'TMVA::DecisionTree' - 0 - dt U 'vector<TMVA::Event*,allocator<TMVA::Event*> >' 'TMVA::IPruneTool::EventSample' 10 'NULL' testEvents "
08826 "g - 'Bool_t' 0 'kFALSE' isAutomatic", (char*)NULL, (void*) NULL, 1);
08827    G__memfunc_setup("InitTreePruningMetaData",2312,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 4, 0, "U 'TMVA::DecisionTreeNode' - 0 - n", (char*)NULL, (void*) NULL, 0);
08828    G__memfunc_setup("Optimize",849,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 1, 4, 0, 
08829 "U 'TMVA::DecisionTree' - 0 - dt d - 'Double_t' 0 - weights", (char*)NULL, (void*) NULL, 0);
08830    G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
08831    // automatic copy constructor
08832    G__memfunc_setup("CostComplexityPruneTool", 2415, G__G__TMVA3_492_0_6, (int) ('i'), 
08833 G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool), -1, 0, 1, 1, 1, 0, "u 'TMVA::CostComplexityPruneTool' - 11 - -", (char*) NULL, (void*) NULL, 0);
08834    // automatic destructor
08835    G__memfunc_setup("~CostComplexityPruneTool", 2541, G__G__TMVA3_492_0_7, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08836    // automatic assignment operator
08837    G__memfunc_setup("operator=", 937, G__G__TMVA3_492_0_8, (int) ('u'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool), -1, 1, 1, 1, 1, 0, "u 'TMVA::CostComplexityPruneTool' - 11 - -", (char*) NULL, (void*) NULL, 0);
08838    G__tag_memfunc_reset();
08839 }
08840 
08841 static void G__setup_memfuncTMVAcLcLSVEvent(void) {
08842    /* TMVA::SVEvent */
08843    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent));
08844    G__memfunc_setup("SVEvent",683,G__G__TMVA3_493_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08845    G__memfunc_setup("SVEvent",683,G__G__TMVA3_493_0_2, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent), -1, 0, 2, 1, 1, 0, 
08846 "U 'TMVA::Event' - 10 - - f - 'Float_t' 0 - -", (char*)NULL, (void*) NULL, 0);
08847    G__memfunc_setup("SVEvent",683,G__G__TMVA3_493_0_3, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent), -1, 0, 4, 1, 1, 0, 
08848 "U 'vector<float,allocator<float> >' 'vector<Float_t>' 10 - - f - 'Float_t' 0 - alpha "
08849 "i - 'Int_t' 0 - typeFlag h - 'UInt_t' 0 - ns", (char*)NULL, (void*) NULL, 0);
08850    G__memfunc_setup("SVEvent",683,G__G__TMVA3_493_0_4, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent), -1, 0, 4, 1, 1, 0, 
08851 "U 'vector<float,allocator<float> >' 'vector<Float_t>' 10 - svector f - 'Float_t' 0 - alpha "
08852 "f - 'Float_t' 0 - alpha_p i - 'Int_t' 0 - typeFlag", (char*)NULL, (void*) NULL, 0);
08853    G__memfunc_setup("SetAlpha",786,G__G__TMVA3_493_0_5, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - alpha", (char*)NULL, (void*) NULL, 0);
08854    G__memfunc_setup("SetAlpha_p",993,G__G__TMVA3_493_0_6, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - alpha", (char*)NULL, (void*) NULL, 0);
08855    G__memfunc_setup("SetErrorCache",1290,G__G__TMVA3_493_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - err_cache", (char*)NULL, (void*) NULL, 0);
08856    G__memfunc_setup("SetIsShrinked",1312,G__G__TMVA3_493_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - isshrinked", (char*)NULL, (void*) NULL, 0);
08857    G__memfunc_setup("SetLine",692,G__G__TMVA3_493_0_9, 121, -1, -1, 0, 1, 1, 1, 0, "F - 'Float_t' 0 - line", (char*)NULL, (void*) NULL, 0);
08858    G__memfunc_setup("SetIdx",593,G__G__TMVA3_493_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - idx", (char*)NULL, (void*) NULL, 0);
08859    G__memfunc_setup("SetNs",493,G__G__TMVA3_493_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'UInt_t' 0 - ns", (char*)NULL, (void*) NULL, 0);
08860    G__memfunc_setup("UpdateErrorCache",1601,G__G__TMVA3_493_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "f - 'Float_t' 0 - upercache", (char*)NULL, (void*) NULL, 0);
08861    G__memfunc_setup("GetDataVector",1293,G__G__TMVA3_493_0_13, 85, G__get_linked_tagnum(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR), G__defined_typename("vector<Float_t>"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08862    G__memfunc_setup("GetAlpha",774,G__G__TMVA3_493_0_14, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08863    G__memfunc_setup("GetAlpha_p",981,G__G__TMVA3_493_0_15, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08864    G__memfunc_setup("GetDeltaAlpha",1264,G__G__TMVA3_493_0_16, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08865    G__memfunc_setup("GetErrorCache",1278,G__G__TMVA3_493_0_17, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08866    G__memfunc_setup("GetTypeFlag",1084,G__G__TMVA3_493_0_18, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08867    G__memfunc_setup("GetNVar",663,G__G__TMVA3_493_0_19, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08868    G__memfunc_setup("GetIdx",581,G__G__TMVA3_493_0_20, 105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08869    G__memfunc_setup("GetLine",680,G__G__TMVA3_493_0_21, 70, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08870    G__memfunc_setup("GetNs",481,G__G__TMVA3_493_0_22, 104, -1, G__defined_typename("UInt_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08871    G__memfunc_setup("GetCweight",1003,G__G__TMVA3_493_0_23, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08872    G__memfunc_setup("GetTarget",903,G__G__TMVA3_493_0_24, 102, -1, G__defined_typename("Float_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08873    G__memfunc_setup("IsInI0a",589,G__G__TMVA3_493_0_25, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08874    G__memfunc_setup("IsInI0b",590,G__G__TMVA3_493_0_26, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08875    G__memfunc_setup("IsInI0",492,G__G__TMVA3_493_0_27, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08876    G__memfunc_setup("IsInI1",493,G__G__TMVA3_493_0_28, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08877    G__memfunc_setup("IsInI2",494,G__G__TMVA3_493_0_29, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08878    G__memfunc_setup("IsInI3",495,G__G__TMVA3_493_0_30, 103, -1, G__defined_typename("Bool_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
08879    G__memfunc_setup("Print",525,G__G__TMVA3_493_0_31, 121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os", (char*)NULL, (void*) NULL, 0);
08880    G__memfunc_setup("PrintData",903,G__G__TMVA3_493_0_32, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08881    G__memfunc_setup("Class",502,G__G__TMVA3_493_0_33, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::SVEvent::Class) ), 0);
08882    G__memfunc_setup("Class_Name",982,G__G__TMVA3_493_0_34, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SVEvent::Class_Name) ), 0);
08883    G__memfunc_setup("Class_Version",1339,G__G__TMVA3_493_0_35, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::SVEvent::Class_Version) ), 0);
08884    G__memfunc_setup("Dictionary",1046,G__G__TMVA3_493_0_36, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::SVEvent::Dictionary) ), 0);
08885    G__memfunc_setup("IsA",253,G__G__TMVA3_493_0_37, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08886    G__memfunc_setup("ShowMembers",1132,G__G__TMVA3_493_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
08887    G__memfunc_setup("Streamer",835,G__G__TMVA3_493_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
08888    G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_493_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08889    G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_493_0_41, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SVEvent::DeclFileName) ), 0);
08890    G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_493_0_42, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::SVEvent::ImplFileLine) ), 0);
08891    G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_493_0_43, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::SVEvent::ImplFileName) ), 0);
08892    G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_493_0_44, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::SVEvent::DeclFileLine) ), 0);
08893    // automatic copy constructor
08894    G__memfunc_setup("SVEvent", 683, G__G__TMVA3_493_0_45, (int) ('i'), G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLSVEvent), -1, 0, 1, 1, 1, 0, "u 'TMVA::SVEvent' - 11 - -", (char*) NULL, (void*) NULL, 0);
08895    // automatic destructor
08896    G__memfunc_setup("~SVEvent", 809, G__G__TMVA3_493_0_46, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08897    G__tag_memfunc_reset();
08898 }
08899 
08900 static void G__setup_memfuncTMVAcLcLOptimizeConfigParameters(void) {
08901    /* TMVA::OptimizeConfigParameters */
08902    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters));
08903    G__memfunc_setup("OptimizeConfigParameters",2491,G__G__TMVA3_548_0_1, 105, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters), -1, 0, 4, 1, 1, 0, 
08904 "U 'TMVA::MethodBase' - 40 - method u 'map<TString,TMVA::Interval,less<TString>,allocator<pair<const TString,TMVA::Interval> > >' 'map<TString,TMVA::Interval>' 0 - tuneParameters "
08905 "u 'TString' - 0 '\"Separation\"' fomType u 'TString' - 0 '\"GA\"' optimizationType", (char*)NULL, (void*) NULL, 0);
08906    G__memfunc_setup("optimize",881,G__G__TMVA3_548_0_2, 117, G__get_linked_tagnum(&G__G__TMVA3LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR), G__defined_typename("map<TString,Double_t>"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
08907    G__memfunc_setup("optimizeScan",1270,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08908    G__memfunc_setup("optimizeFit",1172,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08909    G__memfunc_setup("EstimatorFunction",1790,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "u 'vector<double,allocator<double> >' 'vector<Double_t>' 1 - -", (char*)NULL, (void*) NULL, 1);
08910    G__memfunc_setup("GetFOM",514,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08911    G__memfunc_setup("GetMethod",897,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMethodBase), -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08912    G__memfunc_setup("GetMVADists",1035,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08913    G__memfunc_setup("GetSeparation",1334,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08914    G__memfunc_setup("GetROCIntegral",1338,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 0, 1, 4, 0, "", (char*)NULL, (void*) NULL, 0);
08915    G__memfunc_setup("GetSigEffAt",1033,(G__InterfaceMethod) NULL, 100, -1, G__defined_typename("Double_t"), 0, 1, 1, 4, 0, "d - 'Double_t' 0 '0.1' bkgEff", (char*)NULL, (void*) NULL, 0);
08916    G__memfunc_setup("Log",290,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLMsgLogger), -1, 1, 0, 1, 4, 8, "", (char*)NULL, (void*) NULL, 0);
08917    G__memfunc_setup("Class",502,G__G__TMVA3_548_0_13, 85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TMVA::OptimizeConfigParameters::Class) ), 0);
08918    G__memfunc_setup("Class_Name",982,G__G__TMVA3_548_0_14, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::OptimizeConfigParameters::Class_Name) ), 0);
08919    G__memfunc_setup("Class_Version",1339,G__G__TMVA3_548_0_15, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TMVA::OptimizeConfigParameters::Class_Version) ), 0);
08920    G__memfunc_setup("Dictionary",1046,G__G__TMVA3_548_0_16, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TMVA::OptimizeConfigParameters::Dictionary) ), 0);
08921    G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__TMVA3LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
08922    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);
08923    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);
08924    G__memfunc_setup("StreamerNVirtual",1656,G__G__TMVA3_548_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
08925    G__memfunc_setup("DeclFileName",1145,G__G__TMVA3_548_0_21, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::OptimizeConfigParameters::DeclFileName) ), 0);
08926    G__memfunc_setup("ImplFileLine",1178,G__G__TMVA3_548_0_22, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::OptimizeConfigParameters::ImplFileLine) ), 0);
08927    G__memfunc_setup("ImplFileName",1171,G__G__TMVA3_548_0_23, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TMVA::OptimizeConfigParameters::ImplFileName) ), 0);
08928    G__memfunc_setup("DeclFileLine",1152,G__G__TMVA3_548_0_24, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TMVA::OptimizeConfigParameters::DeclFileLine) ), 0);
08929    // automatic copy constructor
08930    G__memfunc_setup("OptimizeConfigParameters", 2491, G__G__TMVA3_548_0_25, (int) ('i'), 
08931 G__get_linked_tagnum(&G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters), -1, 0, 1, 1, 1, 0, "u 'TMVA::OptimizeConfigParameters' - 11 - -", (char*) NULL, (void*) NULL, 0);
08932    // automatic destructor
08933    G__memfunc_setup("~OptimizeConfigParameters", 2617, G__G__TMVA3_548_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
08934    G__tag_memfunc_reset();
08935 }
08936 
08937 
08938 /*********************************************************
08939 * Member function information setup
08940 *********************************************************/
08941 extern "C" void G__cpp_setup_memfuncG__TMVA3() {
08942 }
08943 
08944 /*********************************************************
08945 * Global variable information setup for each class
08946 *********************************************************/
08947 static void G__cpp_setup_global0() {
08948 
08949    /* Setting up global variables */
08950    G__resetplocal();
08951 
08952 }
08953 
08954 static void G__cpp_setup_global1() {
08955 }
08956 
08957 static void G__cpp_setup_global2() {
08958 }
08959 
08960 static void G__cpp_setup_global3() {
08961 }
08962 
08963 static void G__cpp_setup_global4() {
08964 
08965    G__resetglobalenv();
08966 }
08967 extern "C" void G__cpp_setup_globalG__TMVA3() {
08968   G__cpp_setup_global0();
08969   G__cpp_setup_global1();
08970   G__cpp_setup_global2();
08971   G__cpp_setup_global3();
08972   G__cpp_setup_global4();
08973 }
08974 
08975 /*********************************************************
08976 * Global function information setup for each class
08977 *********************************************************/
08978 static void G__cpp_setup_func0() {
08979    G__lastifuncposition();
08980 
08981 }
08982 
08983 static void G__cpp_setup_func1() {
08984 }
08985 
08986 static void G__cpp_setup_func2() {
08987 }
08988 
08989 static void G__cpp_setup_func3() {
08990 }
08991 
08992 static void G__cpp_setup_func4() {
08993 }
08994 
08995 static void G__cpp_setup_func5() {
08996 }
08997 
08998 static void G__cpp_setup_func6() {
08999 }
09000 
09001 static void G__cpp_setup_func7() {
09002 }
09003 
09004 static void G__cpp_setup_func8() {
09005 }
09006 
09007 static void G__cpp_setup_func9() {
09008 }
09009 
09010 static void G__cpp_setup_func10() {
09011 }
09012 
09013 static void G__cpp_setup_func11() {
09014 }
09015 
09016 static void G__cpp_setup_func12() {
09017 }
09018 
09019 static void G__cpp_setup_func13() {
09020 }
09021 
09022 static void G__cpp_setup_func14() {
09023 }
09024 
09025 static void G__cpp_setup_func15() {
09026 }
09027 
09028 static void G__cpp_setup_func16() {
09029 }
09030 
09031 static void G__cpp_setup_func17() {
09032 }
09033 
09034 static void G__cpp_setup_func18() {
09035 }
09036 
09037 static void G__cpp_setup_func19() {
09038 }
09039 
09040 static void G__cpp_setup_func20() {
09041 }
09042 
09043 static void G__cpp_setup_func21() {
09044 }
09045 
09046 static void G__cpp_setup_func22() {
09047 }
09048 
09049 static void G__cpp_setup_func23() {
09050 
09051    G__resetifuncposition();
09052 }
09053 
09054 extern "C" void G__cpp_setup_funcG__TMVA3() {
09055   G__cpp_setup_func0();
09056   G__cpp_setup_func1();
09057   G__cpp_setup_func2();
09058   G__cpp_setup_func3();
09059   G__cpp_setup_func4();
09060   G__cpp_setup_func5();
09061   G__cpp_setup_func6();
09062   G__cpp_setup_func7();
09063   G__cpp_setup_func8();
09064   G__cpp_setup_func9();
09065   G__cpp_setup_func10();
09066   G__cpp_setup_func11();
09067   G__cpp_setup_func12();
09068   G__cpp_setup_func13();
09069   G__cpp_setup_func14();
09070   G__cpp_setup_func15();
09071   G__cpp_setup_func16();
09072   G__cpp_setup_func17();
09073   G__cpp_setup_func18();
09074   G__cpp_setup_func19();
09075   G__cpp_setup_func20();
09076   G__cpp_setup_func21();
09077   G__cpp_setup_func22();
09078   G__cpp_setup_func23();
09079 }
09080 
09081 /*********************************************************
09082 * Class,struct,union,enum tag information setup
09083 *********************************************************/
09084 /* Setup class/struct taginfo */
09085 G__linked_taginfo G__G__TMVA3LN_TClass = { "TClass" , 99 , -1 };
09086 G__linked_taginfo G__G__TMVA3LN_TBuffer = { "TBuffer" , 99 , -1 };
09087 G__linked_taginfo G__G__TMVA3LN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
09088 G__linked_taginfo G__G__TMVA3LN_TObject = { "TObject" , 99 , -1 };
09089 G__linked_taginfo G__G__TMVA3LN_TNamed = { "TNamed" , 99 , -1 };
09090 G__linked_taginfo G__G__TMVA3LN_TString = { "TString" , 99 , -1 };
09091 G__linked_taginfo G__G__TMVA3LN_basic_istreamlEcharcOchar_traitslEchargRsPgR = { "basic_istream<char,char_traits<char> >" , 99 , -1 };
09092 G__linked_taginfo G__G__TMVA3LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
09093 G__linked_taginfo G__G__TMVA3LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
09094 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
09095 G__linked_taginfo G__G__TMVA3LN_TObjArray = { "TObjArray" , 99 , -1 };
09096 G__linked_taginfo G__G__TMVA3LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
09097 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
09098 G__linked_taginfo G__G__TMVA3LN_TMVA = { "TMVA" , 110 , -1 };
09099 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLMsgLogger = { "TMVA::MsgLogger" , 99 , -1 };
09100 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLConfig = { "TMVA::Config" , 99 , -1 };
09101 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting = { "TMVA::Config::VariablePlotting" , 99 , -1 };
09102 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames = { "TMVA::Config::IONames" , 99 , -1 };
09103 G__linked_taginfo G__G__TMVA3LN_TH1 = { "TH1" , 99 , -1 };
09104 G__linked_taginfo G__G__TMVA3LN_TH1F = { "TH1F" , 99 , -1 };
09105 G__linked_taginfo G__G__TMVA3LN_TF1 = { "TF1" , 99 , -1 };
09106 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLKDEKernel = { "TMVA::KDEKernel" , 99 , -1 };
09107 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelType = { "TMVA::KDEKernel::EKernelType" , 101 , -1 };
09108 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelIter = { "TMVA::KDEKernel::EKernelIter" , 101 , -1 };
09109 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelBorder = { "TMVA::KDEKernel::EKernelBorder" , 101 , -1 };
09110 G__linked_taginfo G__G__TMVA3LN_TRandom3 = { "TRandom3" , 99 , -1 };
09111 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLInterval = { "TMVA::Interval" , 99 , -1 };
09112 G__linked_taginfo G__G__TMVA3LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR = { "iterator<bidirectional_iterator_tag,TObject*,long,const TObject**,const TObject*&>" , 115 , -1 };
09113 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLEMsgType = { "TMVA::EMsgType" , 101 , -1 };
09114 G__linked_taginfo G__G__TMVA3LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR = { "map<TString,TMVA::Types::EMVA,less<TString>,allocator<pair<const TString,TMVA::Types::EMVA> > >" , 99 , -1 };
09115 G__linked_taginfo G__G__TMVA3LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR = { "map<TMVA::EMsgType,string,less<TMVA::EMsgType>,allocator<pair<const TMVA::EMsgType,string> > >" , 99 , -1 };
09116 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLConfigurable = { "TMVA::Configurable" , 99 , -1 };
09117 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLOptionlEboolgR = { "TMVA::Option<bool>" , 99 , -1 };
09118 G__linked_taginfo G__G__TMVA3LN_vectorlEboolcOallocatorlEboolgRsPgR = { "vector<bool,allocator<bool> >" , 99 , -1 };
09119 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<bool,allocator<bool> >::iterator>" , 99 , -1 };
09120 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLOptionlEboolmUgR = { "TMVA::Option<bool*>" , 99 , -1 };
09121 G__linked_taginfo G__G__TMVA3LN_vectorlETStringcOallocatorlETStringgRsPgR = { "vector<TString,allocator<TString> >" , 99 , -1 };
09122 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TString,allocator<TString> >::iterator>" , 99 , -1 };
09123 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLOptionlEfloatgR = { "TMVA::Option<float>" , 99 , -1 };
09124 G__linked_taginfo G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR = { "vector<float,allocator<float> >" , 99 , -1 };
09125 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<float,allocator<float> >::iterator>" , 99 , -1 };
09126 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLIFitterTarget = { "TMVA::IFitterTarget" , 99 , -1 };
09127 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLFitterBase = { "TMVA::FitterBase" , 99 , -1 };
09128 G__linked_taginfo G__G__TMVA3LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR = { "vector<TMVA::Interval*,allocator<TMVA::Interval*> >" , 99 , -1 };
09129 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::Interval*,allocator<TMVA::Interval*> >::iterator>" , 99 , -1 };
09130 G__linked_taginfo G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
09131 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<double,allocator<double> >::iterator>" , 99 , -1 };
09132 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLMCFitter = { "TMVA::MCFitter" , 99 , -1 };
09133 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLGeneticFitter = { "TMVA::GeneticFitter" , 99 , -1 };
09134 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter = { "TMVA::SimulatedAnnealingFitter" , 99 , -1 };
09135 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLMinuitWrapper = { "TMVA::MinuitWrapper" , 99 , -1 };
09136 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLMinuitFitter = { "TMVA::MinuitFitter" , 99 , -1 };
09137 G__linked_taginfo G__G__TMVA3LN_TMinuit = { "TMinuit" , 99 , -1 };
09138 G__linked_taginfo G__G__TMVA3LN_TVectorTlEfloatgR = { "TVectorT<float>" , 99 , -1 };
09139 G__linked_taginfo G__G__TMVA3LN_TVectorTlEdoublegR = { "TVectorT<double>" , 99 , -1 };
09140 G__linked_taginfo G__G__TMVA3LN_TH1D = { "TH1D" , 99 , -1 };
09141 G__linked_taginfo G__G__TMVA3LN_TMatrixTBaselEfloatgR = { "TMatrixTBase<float>" , 99 , -1 };
09142 G__linked_taginfo G__G__TMVA3LN_TMatrixTBaselEdoublegR = { "TMatrixTBase<double>" , 99 , -1 };
09143 G__linked_taginfo G__G__TMVA3LN_TH2D = { "TH2D" , 99 , -1 };
09144 G__linked_taginfo G__G__TMVA3LN_TObjString = { "TObjString" , 99 , -1 };
09145 G__linked_taginfo G__G__TMVA3LN_TElementActionTlEdoublegR = { "TElementActionT<double>" , 99 , -1 };
09146 G__linked_taginfo G__G__TMVA3LN_TElementPosActionTlEdoublegR = { "TElementPosActionT<double>" , 99 , -1 };
09147 G__linked_taginfo G__G__TMVA3LN_TMatrixTRow_constlEdoublegR = { "TMatrixTRow_const<double>" , 99 , -1 };
09148 G__linked_taginfo G__G__TMVA3LN_TMatrixTlEdoublegR = { "TMatrixT<double>" , 99 , -1 };
09149 G__linked_taginfo G__G__TMVA3LN_TMatrixTSymlEdoublegR = { "TMatrixTSym<double>" , 99 , -1 };
09150 G__linked_taginfo G__G__TMVA3LN_TMatrixTRowlEdoublegR = { "TMatrixTRow<double>" , 99 , -1 };
09151 G__linked_taginfo G__G__TMVA3LN_TMatrixTSparselEdoublegR = { "TMatrixTSparse<double>" , 99 , -1 };
09152 G__linked_taginfo G__G__TMVA3LN_TMatrixTSparseRow_constlEdoublegR = { "TMatrixTSparseRow_const<double>" , 99 , -1 };
09153 G__linked_taginfo G__G__TMVA3LN_TMatrixTSparseRowlEdoublegR = { "TMatrixTSparseRow<double>" , 99 , -1 };
09154 G__linked_taginfo G__G__TMVA3LN_TMatrixTDiag_constlEdoublegR = { "TMatrixTDiag_const<double>" , 99 , -1 };
09155 G__linked_taginfo G__G__TMVA3LN_TMatrixTColumn_constlEdoublegR = { "TMatrixTColumn_const<double>" , 99 , -1 };
09156 G__linked_taginfo G__G__TMVA3LN_TMatrixTSparseDiag_constlEdoublegR = { "TMatrixTSparseDiag_const<double>" , 99 , -1 };
09157 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLTimer = { "TMVA::Timer" , 99 , -1 };
09158 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoamCell = { "TMVA::PDEFoamCell" , 99 , -1 };
09159 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoamVect = { "TMVA::PDEFoamVect" , 99 , -1 };
09160 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoamDistr = { "TMVA::PDEFoamDistr" , 99 , -1 };
09161 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPDEFoam = { "TMVA::PDEFoam" , 99 , -1 };
09162 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLEFoamType = { "TMVA::EFoamType" , 101 , -1 };
09163 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLNode = { "TMVA::Node" , 99 , -1 };
09164 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLEvent = { "TMVA::Event" , 99 , -1 };
09165 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLBinaryTree = { "TMVA::BinaryTree" , 99 , -1 };
09166 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLDataSet = { "TMVA::DataSet" , 99 , -1 };
09167 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLBinarySearchTree = { "TMVA::BinarySearchTree" , 99 , -1 };
09168 G__linked_taginfo G__G__TMVA3LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR = { "vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >" , 99 , -1 };
09169 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const TMVA::BinarySearchTreeNode*,allocator<const TMVA::BinarySearchTreeNode*> >::iterator>" , 99 , -1 };
09170 G__linked_taginfo G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR = { "vector<TMVA::Event*,allocator<TMVA::Event*> >" , 99 , -1 };
09171 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::Event*,allocator<TMVA::Event*> >::iterator>" , 99 , -1 };
09172 G__linked_taginfo G__G__TMVA3LN_vectorlEintcOallocatorlEintgRsPgR = { "vector<int,allocator<int> >" , 99 , -1 };
09173 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<int,allocator<int> >::iterator>" , 99 , -1 };
09174 G__linked_taginfo G__G__TMVA3LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR = { "pair<double,const TMVA::Event*>" , 115 , -1 };
09175 G__linked_taginfo G__G__TMVA3LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR = { "vector<pair<double,const TMVA::Event*>,allocator<pair<double,const TMVA::Event*> > >" , 99 , -1 };
09176 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<double,const TMVA::Event*>,allocator<pair<double,const TMVA::Event*> > >::iterator>" , 99 , -1 };
09177 G__linked_taginfo G__G__TMVA3LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR = { "vector<float*,allocator<float*> >" , 99 , -1 };
09178 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<float*,allocator<float*> >::iterator>" , 99 , -1 };
09179 G__linked_taginfo G__G__TMVA3LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
09180 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
09181 G__linked_taginfo G__G__TMVA3LN_TRef = { "TRef" , 99 , -1 };
09182 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLTDensityCalc = { "TMVA::TDensityCalc" , 101 , -1 };
09183 G__linked_taginfo G__G__TMVA3LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR = { "vector<TH1F*,allocator<TH1F*> >" , 99 , -1 };
09184 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TH1F*,allocator<TH1F*> >::iterator>" , 99 , -1 };
09185 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLEKernel = { "TMVA::EKernel" , 101 , -1 };
09186 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLETargetSelection = { "TMVA::ETargetSelection" , 101 , -1 };
09187 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLECellType = { "TMVA::ECellType" , 101 , -1 };
09188 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLECellValue = { "TMVA::ECellValue" , 101 , -1 };
09189 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLEDTSeparation = { "TMVA::EDTSeparation" , 101 , -1 };
09190 G__linked_taginfo G__G__TMVA3LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR = { "vector<TMVA::PDEFoamCell*,allocator<TMVA::PDEFoamCell*> >" , 99 , -1 };
09191 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::PDEFoamCell*,allocator<TMVA::PDEFoamCell*> >::iterator>" , 99 , -1 };
09192 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLBDTEventWrapper = { "TMVA::BDTEventWrapper" , 99 , -1 };
09193 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLSeparationBase = { "TMVA::SeparationBase" , 99 , -1 };
09194 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLDecisionTreeNode = { "TMVA::DecisionTreeNode" , 99 , -1 };
09195 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLDecisionTree = { "TMVA::DecisionTree" , 99 , -1 };
09196 G__linked_taginfo G__G__TMVA3LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR = { "map<string,TObjArray*,less<string>,allocator<pair<const string,TObjArray*> > >" , 99 , -1 };
09197 G__linked_taginfo G__G__TMVA3LN_TMatrixTFlat_constlEdoublegR = { "TMatrixTFlat_const<double>" , 99 , -1 };
09198 G__linked_taginfo G__G__TMVA3LN_TMatrixTSub_constlEdoublegR = { "TMatrixTSub_const<double>" , 99 , -1 };
09199 G__linked_taginfo G__G__TMVA3LN_TMatrixTColumnlEdoublegR = { "TMatrixTColumn<double>" , 99 , -1 };
09200 G__linked_taginfo G__G__TMVA3LN_TMatrixTDiaglEdoublegR = { "TMatrixTDiag<double>" , 99 , -1 };
09201 G__linked_taginfo G__G__TMVA3LN_TMatrixTFlatlEdoublegR = { "TMatrixTFlat<double>" , 99 , -1 };
09202 G__linked_taginfo G__G__TMVA3LN_TMatrixTSublEdoublegR = { "TMatrixTSub<double>" , 99 , -1 };
09203 G__linked_taginfo G__G__TMVA3LN_TMatrixTSparseDiaglEdoublegR = { "TMatrixTSparseDiag<double>" , 99 , -1 };
09204 G__linked_taginfo G__G__TMVA3LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR = { "vector<vector<TMVA::Event*,allocator<TMVA::Event*> >*,allocator<vector<TMVA::Event*,allocator<TMVA::Event*> >*> >" , 99 , -1 };
09205 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<TMVA::Event*,allocator<TMVA::Event*> >*,allocator<vector<TMVA::Event*,allocator<TMVA::Event*> >*> >::iterator>" , 99 , -1 };
09206 G__linked_taginfo G__G__TMVA3LN_maplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgR = { "map<TString,TMVA::Results*,less<TString>,allocator<pair<const TString,TMVA::Results*> > >" , 99 , -1 };
09207 G__linked_taginfo G__G__TMVA3LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR = { "vector<map<TString,TMVA::Results*,less<TString>,allocator<pair<const TString,TMVA::Results*> > >,allocator<map<TString,TMVA::Results*,less<TString>,allocator<pair<const TString,TMVA::Results*> > > > >" , 99 , -1 };
09208 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<map<TString,TMVA::Results*,less<TString>,allocator<pair<const TString,TMVA::Results*> > >,allocator<map<TString,TMVA::Results*,less<TString>,allocator<pair<const TString,TMVA::Results*> > > > >::iterator>" , 99 , -1 };
09209 G__linked_taginfo G__G__TMVA3LN_vectorlEcharcOallocatorlEchargRsPgR = { "vector<char,allocator<char> >" , 99 , -1 };
09210 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR = { "reverse_iterator<vector<char,allocator<char> >::iterator>" , 99 , -1 };
09211 G__linked_taginfo G__G__TMVA3LN_pairlEfloatcOlongsPlonggR = { "pair<float,long long>" , 115 , -1 };
09212 G__linked_taginfo G__G__TMVA3LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR = { "vector<pair<float,long long>*,allocator<pair<float,long long>*> >" , 99 , -1 };
09213 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<float,long long>*,allocator<pair<float,long long>*> >::iterator>" , 99 , -1 };
09214 G__linked_taginfo G__G__TMVA3LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR = { "vector<vector<pair<float,long long>*,allocator<pair<float,long long>*> >,allocator<vector<pair<float,long long>*,allocator<pair<float,long long>*> > > >" , 99 , -1 };
09215 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<pair<float,long long>*,allocator<pair<float,long long>*> >,allocator<vector<pair<float,long long>*,allocator<pair<float,long long>*> > > >::iterator>" , 99 , -1 };
09216 G__linked_taginfo G__G__TMVA3LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR = { "vector<long long,allocator<long long> >" , 99 , -1 };
09217 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcLcLiteratorgR = { "reverse_iterator<vector<long long,allocator<long long> >::iterator>" , 99 , -1 };
09218 G__linked_taginfo G__G__TMVA3LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR = { "vector<vector<long long,allocator<long long> >,allocator<vector<long long,allocator<long long> > > >" , 99 , -1 };
09219 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<long long,allocator<long long> >,allocator<vector<long long,allocator<long long> > > >::iterator>" , 99 , -1 };
09220 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLCCTreeWrapper = { "TMVA::CCTreeWrapper" , 99 , -1 };
09221 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLCCTreeWrappercLcLCCTreeNode = { "TMVA::CCTreeWrapper::CCTreeNode" , 99 , -1 };
09222 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLCCPruner = { "TMVA::CCPruner" , 99 , -1 };
09223 G__linked_taginfo G__G__TMVA3LN_vectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgR = { "vector<TMVA::DecisionTreeNode*,allocator<TMVA::DecisionTreeNode*> >" , 99 , -1 };
09224 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::DecisionTreeNode*,allocator<TMVA::DecisionTreeNode*> >::iterator>" , 99 , -1 };
09225 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLPruningInfo = { "TMVA::PruningInfo" , 99 , -1 };
09226 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLIPruneTool = { "TMVA::IPruneTool" , 99 , -1 };
09227 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool = { "TMVA::CostComplexityPruneTool" , 99 , -1 };
09228 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLSVEvent = { "TMVA::SVEvent" , 99 , -1 };
09229 G__linked_taginfo G__G__TMVA3LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR = { "vector<TMVA::VariableInfo,allocator<TMVA::VariableInfo> >" , 99 , -1 };
09230 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::VariableInfo,allocator<TMVA::VariableInfo> >::iterator>" , 99 , -1 };
09231 G__linked_taginfo G__G__TMVA3LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR = { "vector<TMVA::ClassInfo*,allocator<TMVA::ClassInfo*> >" , 99 , -1 };
09232 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::ClassInfo*,allocator<TMVA::ClassInfo*> >::iterator>" , 99 , -1 };
09233 G__linked_taginfo G__G__TMVA3LN_vectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgR = { "vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> >" , 99 , -1 };
09234 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> >::iterator>" , 99 , -1 };
09235 G__linked_taginfo G__G__TMVA3LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR = { "vector<vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> >,allocator<vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> > > >" , 99 , -1 };
09236 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> >,allocator<vector<TMVA::TransformationHandler::VariableStat,allocator<TMVA::TransformationHandler::VariableStat> > > >::iterator>" , 99 , -1 };
09237 G__linked_taginfo G__G__TMVA3LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR = { "vector<TMVA::Ranking*,allocator<TMVA::Ranking*> >" , 99 , -1 };
09238 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TMVA::Ranking*,allocator<TMVA::Ranking*> >::iterator>" , 99 , -1 };
09239 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLMethodBase = { "TMVA::MethodBase" , 99 , -1 };
09240 G__linked_taginfo G__G__TMVA3LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR = { "map<TString,double,less<TString>,allocator<pair<const TString,double> > >" , 99 , -1 };
09241 G__linked_taginfo G__G__TMVA3LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR = { "vector<vector<float,allocator<float> >,allocator<vector<float,allocator<float> > > >" , 99 , -1 };
09242 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<float,allocator<float> >,allocator<vector<float,allocator<float> > > >::iterator>" , 99 , -1 };
09243 G__linked_taginfo G__G__TMVA3LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR = { "vector<const vector<TMVA::Event*,allocator<TMVA::Event*> >*,allocator<const vector<TMVA::Event*,allocator<TMVA::Event*> >*> >" , 99 , -1 };
09244 G__linked_taginfo G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const vector<TMVA::Event*,allocator<TMVA::Event*> >*,allocator<const vector<TMVA::Event*,allocator<TMVA::Event*> >*> >::iterator>" , 99 , -1 };
09245 G__linked_taginfo G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters = { "TMVA::OptimizeConfigParameters" , 99 , -1 };
09246 G__linked_taginfo G__G__TMVA3LN_maplETStringcOTMVAcLcLIntervalcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIntervalgRsPgRsPgR = { "map<TString,TMVA::Interval,less<TString>,allocator<pair<const TString,TMVA::Interval> > >" , 99 , -1 };
09247 G__linked_taginfo G__G__TMVA3LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR = { "map<vector<double,allocator<double> >,double,less<vector<double,allocator<double> > >,allocator<pair<const vector<double,allocator<double> >,double> > >" , 99 , -1 };
09248 
09249 /* Reset class/struct taginfo */
09250 extern "C" void G__cpp_reset_tagtableG__TMVA3() {
09251   G__G__TMVA3LN_TClass.tagnum = -1 ;
09252   G__G__TMVA3LN_TBuffer.tagnum = -1 ;
09253   G__G__TMVA3LN_TMemberInspector.tagnum = -1 ;
09254   G__G__TMVA3LN_TObject.tagnum = -1 ;
09255   G__G__TMVA3LN_TNamed.tagnum = -1 ;
09256   G__G__TMVA3LN_TString.tagnum = -1 ;
09257   G__G__TMVA3LN_basic_istreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
09258   G__G__TMVA3LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
09259   G__G__TMVA3LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
09260   G__G__TMVA3LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
09261   G__G__TMVA3LN_TObjArray.tagnum = -1 ;
09262   G__G__TMVA3LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
09263   G__G__TMVA3LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
09264   G__G__TMVA3LN_TMVA.tagnum = -1 ;
09265   G__G__TMVA3LN_TMVAcLcLMsgLogger.tagnum = -1 ;
09266   G__G__TMVA3LN_TMVAcLcLConfig.tagnum = -1 ;
09267   G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting.tagnum = -1 ;
09268   G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames.tagnum = -1 ;
09269   G__G__TMVA3LN_TH1.tagnum = -1 ;
09270   G__G__TMVA3LN_TH1F.tagnum = -1 ;
09271   G__G__TMVA3LN_TF1.tagnum = -1 ;
09272   G__G__TMVA3LN_TMVAcLcLKDEKernel.tagnum = -1 ;
09273   G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelType.tagnum = -1 ;
09274   G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelIter.tagnum = -1 ;
09275   G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelBorder.tagnum = -1 ;
09276   G__G__TMVA3LN_TRandom3.tagnum = -1 ;
09277   G__G__TMVA3LN_TMVAcLcLInterval.tagnum = -1 ;
09278   G__G__TMVA3LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR.tagnum = -1 ;
09279   G__G__TMVA3LN_TMVAcLcLEMsgType.tagnum = -1 ;
09280   G__G__TMVA3LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR.tagnum = -1 ;
09281   G__G__TMVA3LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR.tagnum = -1 ;
09282   G__G__TMVA3LN_TMVAcLcLConfigurable.tagnum = -1 ;
09283   G__G__TMVA3LN_TMVAcLcLOptionlEboolgR.tagnum = -1 ;
09284   G__G__TMVA3LN_vectorlEboolcOallocatorlEboolgRsPgR.tagnum = -1 ;
09285   G__G__TMVA3LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR.tagnum = -1 ;
09286   G__G__TMVA3LN_TMVAcLcLOptionlEboolmUgR.tagnum = -1 ;
09287   G__G__TMVA3LN_vectorlETStringcOallocatorlETStringgRsPgR.tagnum = -1 ;
09288   G__G__TMVA3LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR.tagnum = -1 ;
09289   G__G__TMVA3LN_TMVAcLcLOptionlEfloatgR.tagnum = -1 ;
09290   G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR.tagnum = -1 ;
09291   G__G__TMVA3LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR.tagnum = -1 ;
09292   G__G__TMVA3LN_TMVAcLcLIFitterTarget.tagnum = -1 ;
09293   G__G__TMVA3LN_TMVAcLcLFitterBase.tagnum = -1 ;
09294   G__G__TMVA3LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR.tagnum = -1 ;
09295   G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
09296   G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
09297   G__G__TMVA3LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR.tagnum = -1 ;
09298   G__G__TMVA3LN_TMVAcLcLMCFitter.tagnum = -1 ;
09299   G__G__TMVA3LN_TMVAcLcLGeneticFitter.tagnum = -1 ;
09300   G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter.tagnum = -1 ;
09301   G__G__TMVA3LN_TMVAcLcLMinuitWrapper.tagnum = -1 ;
09302   G__G__TMVA3LN_TMVAcLcLMinuitFitter.tagnum = -1 ;
09303   G__G__TMVA3LN_TMinuit.tagnum = -1 ;
09304   G__G__TMVA3LN_TVectorTlEfloatgR.tagnum = -1 ;
09305   G__G__TMVA3LN_TVectorTlEdoublegR.tagnum = -1 ;
09306   G__G__TMVA3LN_TH1D.tagnum = -1 ;
09307   G__G__TMVA3LN_TMatrixTBaselEfloatgR.tagnum = -1 ;
09308   G__G__TMVA3LN_TMatrixTBaselEdoublegR.tagnum = -1 ;
09309   G__G__TMVA3LN_TH2D.tagnum = -1 ;
09310   G__G__TMVA3LN_TObjString.tagnum = -1 ;
09311   G__G__TMVA3LN_TElementActionTlEdoublegR.tagnum = -1 ;
09312   G__G__TMVA3LN_TElementPosActionTlEdoublegR.tagnum = -1 ;
09313   G__G__TMVA3LN_TMatrixTRow_constlEdoublegR.tagnum = -1 ;
09314   G__G__TMVA3LN_TMatrixTlEdoublegR.tagnum = -1 ;
09315   G__G__TMVA3LN_TMatrixTSymlEdoublegR.tagnum = -1 ;
09316   G__G__TMVA3LN_TMatrixTRowlEdoublegR.tagnum = -1 ;
09317   G__G__TMVA3LN_TMatrixTSparselEdoublegR.tagnum = -1 ;
09318   G__G__TMVA3LN_TMatrixTSparseRow_constlEdoublegR.tagnum = -1 ;
09319   G__G__TMVA3LN_TMatrixTSparseRowlEdoublegR.tagnum = -1 ;
09320   G__G__TMVA3LN_TMatrixTDiag_constlEdoublegR.tagnum = -1 ;
09321   G__G__TMVA3LN_TMatrixTColumn_constlEdoublegR.tagnum = -1 ;
09322   G__G__TMVA3LN_TMatrixTSparseDiag_constlEdoublegR.tagnum = -1 ;
09323   G__G__TMVA3LN_TMVAcLcLTimer.tagnum = -1 ;
09324   G__G__TMVA3LN_TMVAcLcLPDEFoamCell.tagnum = -1 ;
09325   G__G__TMVA3LN_TMVAcLcLPDEFoamVect.tagnum = -1 ;
09326   G__G__TMVA3LN_TMVAcLcLPDEFoamDistr.tagnum = -1 ;
09327   G__G__TMVA3LN_TMVAcLcLPDEFoam.tagnum = -1 ;
09328   G__G__TMVA3LN_TMVAcLcLEFoamType.tagnum = -1 ;
09329   G__G__TMVA3LN_TMVAcLcLNode.tagnum = -1 ;
09330   G__G__TMVA3LN_TMVAcLcLEvent.tagnum = -1 ;
09331   G__G__TMVA3LN_TMVAcLcLBinaryTree.tagnum = -1 ;
09332   G__G__TMVA3LN_TMVAcLcLDataSet.tagnum = -1 ;
09333   G__G__TMVA3LN_TMVAcLcLBinarySearchTree.tagnum = -1 ;
09334   G__G__TMVA3LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR.tagnum = -1 ;
09335   G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
09336   G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR.tagnum = -1 ;
09337   G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
09338   G__G__TMVA3LN_vectorlEintcOallocatorlEintgRsPgR.tagnum = -1 ;
09339   G__G__TMVA3LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR.tagnum = -1 ;
09340   G__G__TMVA3LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR.tagnum = -1 ;
09341   G__G__TMVA3LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR.tagnum = -1 ;
09342   G__G__TMVA3LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
09343   G__G__TMVA3LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR.tagnum = -1 ;
09344   G__G__TMVA3LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
09345   G__G__TMVA3LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
09346   G__G__TMVA3LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
09347   G__G__TMVA3LN_TRef.tagnum = -1 ;
09348   G__G__TMVA3LN_TMVAcLcLTDensityCalc.tagnum = -1 ;
09349   G__G__TMVA3LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR.tagnum = -1 ;
09350   G__G__TMVA3LN_reverse_iteratorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
09351   G__G__TMVA3LN_TMVAcLcLEKernel.tagnum = -1 ;
09352   G__G__TMVA3LN_TMVAcLcLETargetSelection.tagnum = -1 ;
09353   G__G__TMVA3LN_TMVAcLcLECellType.tagnum = -1 ;
09354   G__G__TMVA3LN_TMVAcLcLECellValue.tagnum = -1 ;
09355   G__G__TMVA3LN_TMVAcLcLEDTSeparation.tagnum = -1 ;
09356   G__G__TMVA3LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR.tagnum = -1 ;
09357   G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
09358   G__G__TMVA3LN_TMVAcLcLBDTEventWrapper.tagnum = -1 ;
09359   G__G__TMVA3LN_TMVAcLcLSeparationBase.tagnum = -1 ;
09360   G__G__TMVA3LN_TMVAcLcLDecisionTreeNode.tagnum = -1 ;
09361   G__G__TMVA3LN_TMVAcLcLDecisionTree.tagnum = -1 ;
09362   G__G__TMVA3LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR.tagnum = -1 ;
09363   G__G__TMVA3LN_TMatrixTFlat_constlEdoublegR.tagnum = -1 ;
09364   G__G__TMVA3LN_TMatrixTSub_constlEdoublegR.tagnum = -1 ;
09365   G__G__TMVA3LN_TMatrixTColumnlEdoublegR.tagnum = -1 ;
09366   G__G__TMVA3LN_TMatrixTDiaglEdoublegR.tagnum = -1 ;
09367   G__G__TMVA3LN_TMatrixTFlatlEdoublegR.tagnum = -1 ;
09368   G__G__TMVA3LN_TMatrixTSublEdoublegR.tagnum = -1 ;
09369   G__G__TMVA3LN_TMatrixTSparseDiaglEdoublegR.tagnum = -1 ;
09370   G__G__TMVA3LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR.tagnum = -1 ;
09371   G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
09372   G__G__TMVA3LN_maplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgR.tagnum = -1 ;
09373   G__G__TMVA3LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR.tagnum = -1 ;
09374   G__G__TMVA3LN_reverse_iteratorlEvectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
09375   G__G__TMVA3LN_vectorlEcharcOallocatorlEchargRsPgR.tagnum = -1 ;
09376   G__G__TMVA3LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR.tagnum = -1 ;
09377   G__G__TMVA3LN_pairlEfloatcOlongsPlonggR.tagnum = -1 ;
09378   G__G__TMVA3LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR.tagnum = -1 ;
09379   G__G__TMVA3LN_reverse_iteratorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
09380   G__G__TMVA3LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR.tagnum = -1 ;
09381   G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
09382   G__G__TMVA3LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR.tagnum = -1 ;
09383   G__G__TMVA3LN_reverse_iteratorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcLcLiteratorgR.tagnum = -1 ;
09384   G__G__TMVA3LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR.tagnum = -1 ;
09385   G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
09386   G__G__TMVA3LN_TMVAcLcLCCTreeWrapper.tagnum = -1 ;
09387   G__G__TMVA3LN_TMVAcLcLCCTreeWrappercLcLCCTreeNode.tagnum = -1 ;
09388   G__G__TMVA3LN_TMVAcLcLCCPruner.tagnum = -1 ;
09389   G__G__TMVA3LN_vectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgR.tagnum = -1 ;
09390   G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
09391   G__G__TMVA3LN_TMVAcLcLPruningInfo.tagnum = -1 ;
09392   G__G__TMVA3LN_TMVAcLcLIPruneTool.tagnum = -1 ;
09393   G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool.tagnum = -1 ;
09394   G__G__TMVA3LN_TMVAcLcLSVEvent.tagnum = -1 ;
09395   G__G__TMVA3LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR.tagnum = -1 ;
09396   G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR.tagnum = -1 ;
09397   G__G__TMVA3LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR.tagnum = -1 ;
09398   G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR.tagnum = -1 ;
09399   G__G__TMVA3LN_vectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgR.tagnum = -1 ;
09400   G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcLcLiteratorgR.tagnum = -1 ;
09401   G__G__TMVA3LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR.tagnum = -1 ;
09402   G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
09403   G__G__TMVA3LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR.tagnum = -1 ;
09404   G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
09405   G__G__TMVA3LN_TMVAcLcLMethodBase.tagnum = -1 ;
09406   G__G__TMVA3LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR.tagnum = -1 ;
09407   G__G__TMVA3LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR.tagnum = -1 ;
09408   G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
09409   G__G__TMVA3LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR.tagnum = -1 ;
09410   G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR.tagnum = -1 ;
09411   G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters.tagnum = -1 ;
09412   G__G__TMVA3LN_maplETStringcOTMVAcLcLIntervalcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIntervalgRsPgRsPgR.tagnum = -1 ;
09413   G__G__TMVA3LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR.tagnum = -1 ;
09414 }
09415 
09416 
09417 extern "C" void G__cpp_setup_tagtableG__TMVA3() {
09418 
09419    /* Setting up class,struct,union tag entry */
09420    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TClass);
09421    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TBuffer);
09422    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMemberInspector);
09423    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TObject);
09424    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TNamed);
09425    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TString);
09426    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_basic_istreamlEcharcOchar_traitslEchargRsPgR);
09427    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
09428    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
09429    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
09430    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TObjArray);
09431    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
09432    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
09433    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVA),0,-1,0,(char*)NULL,G__setup_memvarTMVA,G__setup_memfuncTMVA);
09434    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLMsgLogger);
09435    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLConfig),sizeof(TMVA::Config),-1,263424,"Singleton class for global configuration settings",G__setup_memvarTMVAcLcLConfig,G__setup_memfuncTMVAcLcLConfig);
09436    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLConfigcLcLVariablePlotting),sizeof(TMVA::Config::VariablePlotting),-1,262144,(char*)NULL,G__setup_memvarTMVAcLcLConfigcLcLVariablePlotting,G__setup_memfuncTMVAcLcLConfigcLcLVariablePlotting);
09437    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLConfigcLcLIONames),sizeof(TMVA::Config::IONames),-1,262144,(char*)NULL,G__setup_memvarTMVAcLcLConfigcLcLIONames,G__setup_memfuncTMVAcLcLConfigcLcLIONames);
09438    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TH1);
09439    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TH1F);
09440    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TF1);
09441    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLKDEKernel),sizeof(TMVA::KDEKernel),-1,263424,"Kernel density estimator for PDF smoothing",G__setup_memvarTMVAcLcLKDEKernel,G__setup_memfuncTMVAcLcLKDEKernel);
09442    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelType);
09443    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelIter);
09444    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLKDEKernelcLcLEKernelBorder);
09445    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TRandom3);
09446    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLInterval),sizeof(TMVA::Interval),-1,296448,"Interval definition, continous and discrete",G__setup_memvarTMVAcLcLInterval,G__setup_memfuncTMVAcLcLInterval);
09447    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_iteratorlEbidirectional_iterator_tagcOTObjectmUcOlongcOconstsPTObjectmUmUcOconstsPTObjectmUaNgR);
09448    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLEMsgType);
09449    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_maplETStringcOTMVAcLcLTypescLcLEMVAcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLTypescLcLEMVAgRsPgRsPgR);
09450    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_maplETMVAcLcLEMsgTypecOstringcOlesslETMVAcLcLEMsgTypegRcOallocatorlEpairlEconstsPTMVAcLcLEMsgTypecOstringgRsPgRsPgR);
09451    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLConfigurable);
09452    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLOptionlEboolgR);
09453    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEboolcOallocatorlEboolgRsPgR);
09454    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEboolcOallocatorlEboolgRsPgRcLcLiteratorgR);
09455    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLOptionlEboolmUgR);
09456    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETStringcOallocatorlETStringgRsPgR);
09457    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETStringcOallocatorlETStringgRsPgRcLcLiteratorgR);
09458    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLOptionlEfloatgR);
09459    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEfloatcOallocatorlEfloatgRsPgR);
09460    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEfloatcOallocatorlEfloatgRsPgRcLcLiteratorgR);
09461    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLIFitterTarget),sizeof(TMVA::IFitterTarget),-1,263425,"base class for a fitter \"target\"",G__setup_memvarTMVAcLcLIFitterTarget,G__setup_memfuncTMVAcLcLIFitterTarget);
09462    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLFitterBase),sizeof(TMVA::FitterBase),-1,324610,"Baseclass for fitters",G__setup_memvarTMVAcLcLFitterBase,G__setup_memfuncTMVAcLcLFitterBase);
09463    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgR);
09464    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLIntervalmUcOallocatorlETMVAcLcLIntervalmUgRsPgRcLcLiteratorgR);
09465    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEdoublecOallocatorlEdoublegRsPgR);
09466    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR);
09467    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLMCFitter),sizeof(TMVA::MCFitter),-1,324608,"Fitter using Monte Carlo sampling of parameters ",G__setup_memvarTMVAcLcLMCFitter,G__setup_memfuncTMVAcLcLMCFitter);
09468    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLGeneticFitter),sizeof(TMVA::GeneticFitter),-1,324608,"Fitter using a Genetic Algorithm",G__setup_memvarTMVAcLcLGeneticFitter,G__setup_memfuncTMVAcLcLGeneticFitter);
09469    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLSimulatedAnnealingFitter),sizeof(TMVA::SimulatedAnnealingFitter),-1,324608,"Fitter using a Simulated Annealing Algorithm",G__setup_memvarTMVAcLcLSimulatedAnnealingFitter,G__setup_memfuncTMVAcLcLSimulatedAnnealingFitter);
09470    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLMinuitWrapper),sizeof(TMVA::MinuitWrapper),-1,324608,"Wrapper around TMinuit",G__setup_memvarTMVAcLcLMinuitWrapper,G__setup_memfuncTMVAcLcLMinuitWrapper);
09471    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLMinuitFitter),sizeof(TMVA::MinuitFitter),-1,324609,"Fitter using a Genetic Algorithm",G__setup_memvarTMVAcLcLMinuitFitter,G__setup_memfuncTMVAcLcLMinuitFitter);
09472    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMinuit);
09473    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TVectorTlEfloatgR);
09474    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TVectorTlEdoublegR);
09475    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TH1D);
09476    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTBaselEfloatgR);
09477    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTBaselEdoublegR);
09478    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TH2D);
09479    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TObjString);
09480    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TElementActionTlEdoublegR);
09481    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TElementPosActionTlEdoublegR);
09482    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTRow_constlEdoublegR);
09483    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTlEdoublegR);
09484    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTSymlEdoublegR);
09485    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTRowlEdoublegR);
09486    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTSparselEdoublegR);
09487    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTSparseRow_constlEdoublegR);
09488    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTSparseRowlEdoublegR);
09489    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTDiag_constlEdoublegR);
09490    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTColumn_constlEdoublegR);
09491    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTSparseDiag_constlEdoublegR);
09492    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLTimer);
09493    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoamCell),sizeof(TMVA::PDEFoamCell),-1,325376,"Single cell of FOAM",G__setup_memvarTMVAcLcLPDEFoamCell,G__setup_memfuncTMVAcLcLPDEFoamCell);
09494    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoamVect),sizeof(TMVA::PDEFoamVect),-1,327424,"n-dimensional vector with dynamical allocation",G__setup_memvarTMVAcLcLPDEFoamVect,G__setup_memfuncTMVAcLcLPDEFoamVect);
09495    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoamDistr),sizeof(TMVA::PDEFoamDistr),-1,292608,"Class for Event density",G__setup_memvarTMVAcLcLPDEFoamDistr,G__setup_memfuncTMVAcLcLPDEFoamDistr);
09496    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPDEFoam),sizeof(TMVA::PDEFoam),-1,325376,"Tree of PDEFoamCells",G__setup_memvarTMVAcLcLPDEFoam,G__setup_memfuncTMVAcLcLPDEFoam);
09497    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLEFoamType);
09498    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLNode);
09499    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLEvent);
09500    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLBinaryTree);
09501    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLDataSet);
09502    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLBinarySearchTree);
09503    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgR);
09504    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPTMVAcLcLBinarySearchTreeNodemUcOallocatorlEconstsPTMVAcLcLBinarySearchTreeNodemUgRsPgRcLcLiteratorgR);
09505    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgR);
09506    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRcLcLiteratorgR);
09507    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEintcOallocatorlEintgRsPgR);
09508    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEintcOallocatorlEintgRsPgRcLcLiteratorgR);
09509    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_pairlEdoublecOconstsPTMVAcLcLEventmUgR);
09510    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgR);
09511    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRcOallocatorlEpairlEdoublecOconstsPTMVAcLcLEventmUgRsPgRsPgRcLcLiteratorgR);
09512    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEfloatmUcOallocatorlEfloatmUgRsPgR);
09513    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEfloatmUcOallocatorlEfloatmUgRsPgRcLcLiteratorgR);
09514    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
09515    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
09516    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TRef);
09517    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLTDensityCalc);
09518    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETH1FmUcOallocatorlETH1FmUgRsPgR);
09519    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETH1FmUcOallocatorlETH1FmUgRsPgRcLcLiteratorgR);
09520    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLEKernel);
09521    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLETargetSelection);
09522    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLECellType);
09523    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLECellValue);
09524    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLEDTSeparation);
09525    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgR);
09526    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLPDEFoamCellmUcOallocatorlETMVAcLcLPDEFoamCellmUgRsPgRcLcLiteratorgR);
09527    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLBDTEventWrapper),sizeof(TMVA::BDTEventWrapper),-1,295936,(char*)NULL,G__setup_memvarTMVAcLcLBDTEventWrapper,G__setup_memfuncTMVAcLcLBDTEventWrapper);
09528    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLSeparationBase);
09529    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLDecisionTreeNode);
09530    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLDecisionTree);
09531    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_maplEstringcOTObjArraymUcOlesslEstringgRcOallocatorlEpairlEconstsPstringcOTObjArraymUgRsPgRsPgR);
09532    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTFlat_constlEdoublegR);
09533    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTSub_constlEdoublegR);
09534    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTColumnlEdoublegR);
09535    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTDiaglEdoublegR);
09536    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTFlatlEdoublegR);
09537    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTSublEdoublegR);
09538    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMatrixTSparseDiaglEdoublegR);
09539    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR);
09540    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR);
09541    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_maplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgR);
09542    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgR);
09543    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRcOallocatorlEmaplETStringcOTMVAcLcLResultsmUcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLResultsmUgRsPgRsPgRsPgRsPgRcLcLiteratorgR);
09544    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEcharcOallocatorlEchargRsPgR);
09545    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEcharcOallocatorlEchargRsPgRcLcLiteratorgR);
09546    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_pairlEfloatcOlongsPlonggR);
09547    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgR);
09548    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcLcLiteratorgR);
09549    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgR);
09550    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRcOallocatorlEvectorlEpairlEfloatcOlongsPlonggRmUcOallocatorlEpairlEfloatcOlongsPlonggRmUgRsPgRsPgRsPgRcLcLiteratorgR);
09551    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlElongsPlongcOallocatorlElongsPlonggRsPgR);
09552    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcLcLiteratorgR);
09553    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgR);
09554    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRcOallocatorlEvectorlElongsPlongcOallocatorlElongsPlonggRsPgRsPgRsPgRcLcLiteratorgR);
09555    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLCCTreeWrapper),sizeof(TMVA::CCTreeWrapper),-1,295936,(char*)NULL,G__setup_memvarTMVAcLcLCCTreeWrapper,G__setup_memfuncTMVAcLcLCCTreeWrapper);
09556    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLCCTreeWrappercLcLCCTreeNode);
09557    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLCCPruner),sizeof(TMVA::CCPruner),-1,295936,(char*)NULL,G__setup_memvarTMVAcLcLCCPruner,G__setup_memfuncTMVAcLcLCCPruner);
09558    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgR);
09559    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLDecisionTreeNodemUcOallocatorlETMVAcLcLDecisionTreeNodemUgRsPgRcLcLiteratorgR);
09560    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLPruningInfo);
09561    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLIPruneTool);
09562    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLCostComplexityPruneTool),sizeof(TMVA::CostComplexityPruneTool),-1,263424,(char*)NULL,G__setup_memvarTMVAcLcLCostComplexityPruneTool,G__setup_memfuncTMVAcLcLCostComplexityPruneTool);
09563    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLSVEvent),sizeof(TMVA::SVEvent),-1,296192,"Event for SVM",G__setup_memvarTMVAcLcLSVEvent,G__setup_memfuncTMVAcLcLSVEvent);
09564    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgR);
09565    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLVariableInfocOallocatorlETMVAcLcLVariableInfogRsPgRcLcLiteratorgR);
09566    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgR);
09567    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLClassInfomUcOallocatorlETMVAcLcLClassInfomUgRsPgRcLcLiteratorgR);
09568    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgR);
09569    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcLcLiteratorgR);
09570    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgR);
09571    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRcOallocatorlEvectorlETMVAcLcLTransformationHandlercLcLVariableStatcOallocatorlETMVAcLcLTransformationHandlercLcLVariableStatgRsPgRsPgRsPgRcLcLiteratorgR);
09572    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgR);
09573    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlETMVAcLcLRankingmUcOallocatorlETMVAcLcLRankingmUgRsPgRcLcLiteratorgR);
09574    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLMethodBase);
09575    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_maplETStringcOdoublecOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOdoublegRsPgRsPgR);
09576    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgR);
09577    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEvectorlEfloatcOallocatorlEfloatgRsPgRcOallocatorlEvectorlEfloatcOallocatorlEfloatgRsPgRsPgRsPgRcLcLiteratorgR);
09578    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_vectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgR);
09579    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_reverse_iteratorlEvectorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUcOallocatorlEconstsPvectorlETMVAcLcLEventmUcOallocatorlETMVAcLcLEventmUgRsPgRmUgRsPgRcLcLiteratorgR);
09580    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__TMVA3LN_TMVAcLcLOptimizeConfigParameters),sizeof(TMVA::OptimizeConfigParameters),-1,295936,"Interface to different separation critiera used in training algorithms",G__setup_memvarTMVAcLcLOptimizeConfigParameters,G__setup_memfuncTMVAcLcLOptimizeConfigParameters);
09581    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_maplETStringcOTMVAcLcLIntervalcOlesslETStringgRcOallocatorlEpairlEconstsPTStringcOTMVAcLcLIntervalgRsPgRsPgR);
09582    G__get_linked_tagnum_fwd(&G__G__TMVA3LN_maplEvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublecOlesslEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRcOallocatorlEpairlEconstsPvectorlEdoublecOallocatorlEdoublegRsPgRcOdoublegRsPgRsPgR);
09583 }
09584 extern "C" void G__cpp_setupG__TMVA3(void) {
09585   G__check_setup_version(30051515,"G__cpp_setupG__TMVA3()");
09586   G__set_cpp_environmentG__TMVA3();
09587   G__cpp_setup_tagtableG__TMVA3();
09588 
09589   G__cpp_setup_inheritanceG__TMVA3();
09590 
09591   G__cpp_setup_typetableG__TMVA3();
09592 
09593   G__cpp_setup_memvarG__TMVA3();
09594 
09595   G__cpp_setup_memfuncG__TMVA3();
09596   G__cpp_setup_globalG__TMVA3();
09597   G__cpp_setup_funcG__TMVA3();
09598 
09599    if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__TMVA3();
09600   return;
09601 }
09602 class G__cpp_setup_initG__TMVA3 {
09603   public:
09604     G__cpp_setup_initG__TMVA3() { G__add_setup_func("G__TMVA3",(G__incsetup)(&G__cpp_setupG__TMVA3)); G__call_setup_funcs(); }
09605    ~G__cpp_setup_initG__TMVA3() { G__remove_setup_func("G__TMVA3"); }
09606 };
09607 G__cpp_setup_initG__TMVA3 G__cpp_setup_initializerG__TMVA3;
09608