G__Minuit2.cxx

Go to the documentation of this file.

//
// File generated by core/utils/src/rootcint_tmp at Wed Apr 20 13:56:48 2011

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

#define R__DICTIONARY_FILENAME mathdIminuit2dIsrcdIG__Minuit2
#include "RConfig.h" //rootcint 4834
#if !defined(R__ACCESS_IN_SYMBOL)
//Break the privacy of classes -- Disabled for the moment
#define private public
#define protected public
#endif

// Since CINT ignores the std namespace, we need to do so in this file.
namespace std {} using namespace std;
#include "G__Minuit2.h"

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

#ifndef G__ROOT
#define G__ROOT
#endif

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

// START OF SHADOWS

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

namespace ROOT {
   void ROOTcLcLMinuit2cLcLGenericFunction_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLGenericFunction_Dictionary();
   static void delete_ROOTcLcLMinuit2cLcLGenericFunction(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLGenericFunction(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLGenericFunction(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::GenericFunction*)
   {
      ::ROOT::Minuit2::GenericFunction *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::GenericFunction),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::GenericFunction", "include/Minuit2/GenericFunction.h", 35,
                  typeid(::ROOT::Minuit2::GenericFunction), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLGenericFunction_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::GenericFunction) );
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLGenericFunction);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLGenericFunction);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLGenericFunction);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::GenericFunction*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::GenericFunction*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::GenericFunction*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLGenericFunction_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::GenericFunction*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLFCNBase_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLFCNBase_Dictionary();
   static void delete_ROOTcLcLMinuit2cLcLFCNBase(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLFCNBase(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLFCNBase(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::FCNBase*)
   {
      ::ROOT::Minuit2::FCNBase *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::FCNBase),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::FCNBase", "include/Minuit2/FCNBase.h", 45,
                  typeid(::ROOT::Minuit2::FCNBase), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLFCNBase_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::FCNBase) );
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLFCNBase);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLFCNBase);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLFCNBase);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::FCNBase*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::FCNBase*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::FCNBase*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLFCNBase_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::FCNBase*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLFCNGradientBase_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLFCNGradientBase_Dictionary();
   static void delete_ROOTcLcLMinuit2cLcLFCNGradientBase(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLFCNGradientBase(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLFCNGradientBase(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::FCNGradientBase*)
   {
      ::ROOT::Minuit2::FCNGradientBase *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::FCNGradientBase),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::FCNGradientBase", "include/Minuit2/FCNGradientBase.h", 32,
                  typeid(::ROOT::Minuit2::FCNGradientBase), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLFCNGradientBase_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::FCNGradientBase) );
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLFCNGradientBase);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLFCNGradientBase);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLFCNGradientBase);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::FCNGradientBase*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::FCNGradientBase*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::FCNGradientBase*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLFCNGradientBase_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::FCNGradientBase*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TFcnAdapter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void delete_TFcnAdapter(void *p);
   static void deleteArray_TFcnAdapter(void *p);
   static void destruct_TFcnAdapter(void *p);
   static void streamer_TFcnAdapter(TBuffer &buf, void *obj);

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

namespace ROOT {
   void ROOTcLcLMinuit2cLcLMinuitParameter_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLMinuitParameter_Dictionary();
   static void delete_ROOTcLcLMinuit2cLcLMinuitParameter(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLMinuitParameter(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLMinuitParameter(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::MinuitParameter*)
   {
      ::ROOT::Minuit2::MinuitParameter *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::MinuitParameter),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::MinuitParameter", "include/Minuit2/MinuitParameter.h", 33,
                  typeid(::ROOT::Minuit2::MinuitParameter), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLMinuitParameter_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::MinuitParameter) );
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLMinuitParameter);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLMinuitParameter);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLMinuitParameter);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::MinuitParameter*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::MinuitParameter*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::MinuitParameter*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLMinuitParameter_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::MinuitParameter*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLMnUserParameters_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLMnUserParameters_Dictionary();
   static void *new_ROOTcLcLMinuit2cLcLMnUserParameters(void *p = 0);
   static void *newArray_ROOTcLcLMinuit2cLcLMnUserParameters(Long_t size, void *p);
   static void delete_ROOTcLcLMinuit2cLcLMnUserParameters(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLMnUserParameters(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLMnUserParameters(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::MnUserParameters*)
   {
      ::ROOT::Minuit2::MnUserParameters *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::MnUserParameters),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::MnUserParameters", "include/Minuit2/MnUserParameters.h", 37,
                  typeid(::ROOT::Minuit2::MnUserParameters), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLMnUserParameters_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::MnUserParameters) );
      instance.SetNew(&new_ROOTcLcLMinuit2cLcLMnUserParameters);
      instance.SetNewArray(&newArray_ROOTcLcLMinuit2cLcLMnUserParameters);
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLMnUserParameters);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLMnUserParameters);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLMnUserParameters);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::MnUserParameters*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::MnUserParameters*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnUserParameters*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLMnUserParameters_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnUserParameters*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLMnUserParameterState_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLMnUserParameterState_Dictionary();
   static void *new_ROOTcLcLMinuit2cLcLMnUserParameterState(void *p = 0);
   static void *newArray_ROOTcLcLMinuit2cLcLMnUserParameterState(Long_t size, void *p);
   static void delete_ROOTcLcLMinuit2cLcLMnUserParameterState(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLMnUserParameterState(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLMnUserParameterState(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::MnUserParameterState*)
   {
      ::ROOT::Minuit2::MnUserParameterState *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::MnUserParameterState),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::MnUserParameterState", "include/Minuit2/MnUserParameterState.h", 31,
                  typeid(::ROOT::Minuit2::MnUserParameterState), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLMnUserParameterState_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::MnUserParameterState) );
      instance.SetNew(&new_ROOTcLcLMinuit2cLcLMnUserParameterState);
      instance.SetNewArray(&newArray_ROOTcLcLMinuit2cLcLMnUserParameterState);
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLMnUserParameterState);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLMnUserParameterState);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLMnUserParameterState);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::MnUserParameterState*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::MnUserParameterState*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnUserParameterState*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLMnUserParameterState_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnUserParameterState*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLMinosError_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLMinosError_Dictionary();
   static void *new_ROOTcLcLMinuit2cLcLMinosError(void *p = 0);
   static void *newArray_ROOTcLcLMinuit2cLcLMinosError(Long_t size, void *p);
   static void delete_ROOTcLcLMinuit2cLcLMinosError(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLMinosError(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLMinosError(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::MinosError*)
   {
      ::ROOT::Minuit2::MinosError *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::MinosError),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::MinosError", "include/Minuit2/MinosError.h", 25,
                  typeid(::ROOT::Minuit2::MinosError), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLMinosError_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::MinosError) );
      instance.SetNew(&new_ROOTcLcLMinuit2cLcLMinosError);
      instance.SetNewArray(&newArray_ROOTcLcLMinuit2cLcLMinosError);
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLMinosError);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLMinosError);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLMinosError);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::MinosError*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::MinosError*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::MinosError*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLMinosError_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::MinosError*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLFunctionMinimum_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLFunctionMinimum_Dictionary();
   static void delete_ROOTcLcLMinuit2cLcLFunctionMinimum(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLFunctionMinimum(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLFunctionMinimum(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::FunctionMinimum*)
   {
      ::ROOT::Minuit2::FunctionMinimum *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::FunctionMinimum),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::FunctionMinimum", "include/Minuit2/FunctionMinimum.h", 30,
                  typeid(::ROOT::Minuit2::FunctionMinimum), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLFunctionMinimum_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::FunctionMinimum) );
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLFunctionMinimum);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLFunctionMinimum);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLFunctionMinimum);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::FunctionMinimum*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::FunctionMinimum*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::FunctionMinimum*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLFunctionMinimum_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::FunctionMinimum*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLFunctionMinimizer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLFunctionMinimizer_Dictionary();
   static void delete_ROOTcLcLMinuit2cLcLFunctionMinimizer(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLFunctionMinimizer(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLFunctionMinimizer(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::FunctionMinimizer*)
   {
      ::ROOT::Minuit2::FunctionMinimizer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::FunctionMinimizer),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::FunctionMinimizer", "include/Minuit2/FunctionMinimizer.h", 36,
                  typeid(::ROOT::Minuit2::FunctionMinimizer), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLFunctionMinimizer_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::FunctionMinimizer) );
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLFunctionMinimizer);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLFunctionMinimizer);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLFunctionMinimizer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::FunctionMinimizer*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::FunctionMinimizer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::FunctionMinimizer*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLFunctionMinimizer_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::FunctionMinimizer*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLMnStrategy_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLMnStrategy_Dictionary();
   static void *new_ROOTcLcLMinuit2cLcLMnStrategy(void *p = 0);
   static void *newArray_ROOTcLcLMinuit2cLcLMnStrategy(Long_t size, void *p);
   static void delete_ROOTcLcLMinuit2cLcLMnStrategy(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLMnStrategy(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLMnStrategy(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::MnStrategy*)
   {
      ::ROOT::Minuit2::MnStrategy *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::MnStrategy),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::MnStrategy", "include/Minuit2/MnStrategy.h", 27,
                  typeid(::ROOT::Minuit2::MnStrategy), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLMnStrategy_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::MnStrategy) );
      instance.SetNew(&new_ROOTcLcLMinuit2cLcLMnStrategy);
      instance.SetNewArray(&newArray_ROOTcLcLMinuit2cLcLMnStrategy);
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLMnStrategy);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLMnStrategy);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLMnStrategy);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::MnStrategy*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::MnStrategy*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnStrategy*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLMnStrategy_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnStrategy*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLFumiliFCNBase_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLFumiliFCNBase_Dictionary();
   static void delete_ROOTcLcLMinuit2cLcLFumiliFCNBase(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLFumiliFCNBase(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLFumiliFCNBase(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::FumiliFCNBase*)
   {
      ::ROOT::Minuit2::FumiliFCNBase *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::FumiliFCNBase),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::FumiliFCNBase", "include/Minuit2/FumiliFCNBase.h", 47,
                  typeid(::ROOT::Minuit2::FumiliFCNBase), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLFumiliFCNBase_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::FumiliFCNBase) );
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLFumiliFCNBase);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLFumiliFCNBase);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLFumiliFCNBase);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::FumiliFCNBase*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::FumiliFCNBase*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::FumiliFCNBase*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLFumiliFCNBase_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::FumiliFCNBase*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLModularFunctionMinimizer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLModularFunctionMinimizer_Dictionary();
   static void delete_ROOTcLcLMinuit2cLcLModularFunctionMinimizer(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLModularFunctionMinimizer(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLModularFunctionMinimizer(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::ModularFunctionMinimizer*)
   {
      ::ROOT::Minuit2::ModularFunctionMinimizer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::ModularFunctionMinimizer),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::ModularFunctionMinimizer", "include/Minuit2/ModularFunctionMinimizer.h", 47,
                  typeid(::ROOT::Minuit2::ModularFunctionMinimizer), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLModularFunctionMinimizer_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::ModularFunctionMinimizer) );
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLModularFunctionMinimizer);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLModularFunctionMinimizer);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLModularFunctionMinimizer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::ModularFunctionMinimizer*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::ModularFunctionMinimizer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::ModularFunctionMinimizer*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLModularFunctionMinimizer_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::ModularFunctionMinimizer*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLFumiliMinimizer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLFumiliMinimizer_Dictionary();
   static void *new_ROOTcLcLMinuit2cLcLFumiliMinimizer(void *p = 0);
   static void *newArray_ROOTcLcLMinuit2cLcLFumiliMinimizer(Long_t size, void *p);
   static void delete_ROOTcLcLMinuit2cLcLFumiliMinimizer(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLFumiliMinimizer(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLFumiliMinimizer(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::FumiliMinimizer*)
   {
      ::ROOT::Minuit2::FumiliMinimizer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::FumiliMinimizer),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::FumiliMinimizer", "include/Minuit2/FumiliMinimizer.h", 50,
                  typeid(::ROOT::Minuit2::FumiliMinimizer), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLFumiliMinimizer_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::FumiliMinimizer) );
      instance.SetNew(&new_ROOTcLcLMinuit2cLcLFumiliMinimizer);
      instance.SetNewArray(&newArray_ROOTcLcLMinuit2cLcLFumiliMinimizer);
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLFumiliMinimizer);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLFumiliMinimizer);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLFumiliMinimizer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::FumiliMinimizer*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::FumiliMinimizer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::FumiliMinimizer*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLFumiliMinimizer_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::FumiliMinimizer*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void TFitterMinuit_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TFitterMinuit(void *p = 0);
   static void *newArray_TFitterMinuit(Long_t size, void *p);
   static void delete_TFitterMinuit(void *p);
   static void deleteArray_TFitterMinuit(void *p);
   static void destruct_TFitterMinuit(void *p);
   static void streamer_TFitterMinuit(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TFitterMinuit*)
   {
      ::TFitterMinuit *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TFitterMinuit >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TFitterMinuit", ::TFitterMinuit::Class_Version(), "include/TFitterMinuit.h", 33,
                  typeid(::TFitterMinuit), DefineBehavior(ptr, ptr),
                  &::TFitterMinuit::Dictionary, isa_proxy, 0,
                  sizeof(::TFitterMinuit) );
      instance.SetNew(&new_TFitterMinuit);
      instance.SetNewArray(&newArray_TFitterMinuit);
      instance.SetDelete(&delete_TFitterMinuit);
      instance.SetDeleteArray(&deleteArray_TFitterMinuit);
      instance.SetDestructor(&destruct_TFitterMinuit);
      instance.SetStreamerFunc(&streamer_TFitterMinuit);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TFitterMinuit*)
   {
      return GenerateInitInstanceLocal((::TFitterMinuit*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TFitterMinuit*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void TFitterFumili_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void *new_TFitterFumili(void *p = 0);
   static void *newArray_TFitterFumili(Long_t size, void *p);
   static void delete_TFitterFumili(void *p);
   static void deleteArray_TFitterFumili(void *p);
   static void destruct_TFitterFumili(void *p);
   static void streamer_TFitterFumili(TBuffer &buf, void *obj);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::TFitterFumili*)
   {
      ::TFitterFumili *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TInstrumentedIsAProxy< ::TFitterFumili >(0);
      static ::ROOT::TGenericClassInfo 
         instance("TFitterFumili", ::TFitterFumili::Class_Version(), "include/TFitterFumili.h", 25,
                  typeid(::TFitterFumili), DefineBehavior(ptr, ptr),
                  &::TFitterFumili::Dictionary, isa_proxy, 0,
                  sizeof(::TFitterFumili) );
      instance.SetNew(&new_TFitterFumili);
      instance.SetNewArray(&newArray_TFitterFumili);
      instance.SetDelete(&delete_TFitterFumili);
      instance.SetDeleteArray(&deleteArray_TFitterFumili);
      instance.SetDestructor(&destruct_TFitterFumili);
      instance.SetStreamerFunc(&streamer_TFitterFumili);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::TFitterFumili*)
   {
      return GenerateInitInstanceLocal((::TFitterFumili*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::TFitterFumili*)0x0); R__UseDummy(_R__UNIQUE_(Init));
} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLVariableMetricMinimizer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLVariableMetricMinimizer_Dictionary();
   static void *new_ROOTcLcLMinuit2cLcLVariableMetricMinimizer(void *p = 0);
   static void *newArray_ROOTcLcLMinuit2cLcLVariableMetricMinimizer(Long_t size, void *p);
   static void delete_ROOTcLcLMinuit2cLcLVariableMetricMinimizer(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLVariableMetricMinimizer(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLVariableMetricMinimizer(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::VariableMetricMinimizer*)
   {
      ::ROOT::Minuit2::VariableMetricMinimizer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::VariableMetricMinimizer),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::VariableMetricMinimizer", "include/Minuit2/VariableMetricMinimizer.h", 30,
                  typeid(::ROOT::Minuit2::VariableMetricMinimizer), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLVariableMetricMinimizer_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::VariableMetricMinimizer) );
      instance.SetNew(&new_ROOTcLcLMinuit2cLcLVariableMetricMinimizer);
      instance.SetNewArray(&newArray_ROOTcLcLMinuit2cLcLVariableMetricMinimizer);
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLVariableMetricMinimizer);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLVariableMetricMinimizer);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLVariableMetricMinimizer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::VariableMetricMinimizer*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::VariableMetricMinimizer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::VariableMetricMinimizer*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLVariableMetricMinimizer_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::VariableMetricMinimizer*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLSimplexMinimizer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLSimplexMinimizer_Dictionary();
   static void *new_ROOTcLcLMinuit2cLcLSimplexMinimizer(void *p = 0);
   static void *newArray_ROOTcLcLMinuit2cLcLSimplexMinimizer(Long_t size, void *p);
   static void delete_ROOTcLcLMinuit2cLcLSimplexMinimizer(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLSimplexMinimizer(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLSimplexMinimizer(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::SimplexMinimizer*)
   {
      ::ROOT::Minuit2::SimplexMinimizer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::SimplexMinimizer),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::SimplexMinimizer", "include/Minuit2/SimplexMinimizer.h", 30,
                  typeid(::ROOT::Minuit2::SimplexMinimizer), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLSimplexMinimizer_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::SimplexMinimizer) );
      instance.SetNew(&new_ROOTcLcLMinuit2cLcLSimplexMinimizer);
      instance.SetNewArray(&newArray_ROOTcLcLMinuit2cLcLSimplexMinimizer);
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLSimplexMinimizer);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLSimplexMinimizer);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLSimplexMinimizer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::SimplexMinimizer*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::SimplexMinimizer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::SimplexMinimizer*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLSimplexMinimizer_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::SimplexMinimizer*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLCombinedMinimizer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLCombinedMinimizer_Dictionary();
   static void *new_ROOTcLcLMinuit2cLcLCombinedMinimizer(void *p = 0);
   static void *newArray_ROOTcLcLMinuit2cLcLCombinedMinimizer(Long_t size, void *p);
   static void delete_ROOTcLcLMinuit2cLcLCombinedMinimizer(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLCombinedMinimizer(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLCombinedMinimizer(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::CombinedMinimizer*)
   {
      ::ROOT::Minuit2::CombinedMinimizer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::CombinedMinimizer),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::CombinedMinimizer", "include/Minuit2/CombinedMinimizer.h", 30,
                  typeid(::ROOT::Minuit2::CombinedMinimizer), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLCombinedMinimizer_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::CombinedMinimizer) );
      instance.SetNew(&new_ROOTcLcLMinuit2cLcLCombinedMinimizer);
      instance.SetNewArray(&newArray_ROOTcLcLMinuit2cLcLCombinedMinimizer);
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLCombinedMinimizer);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLCombinedMinimizer);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLCombinedMinimizer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::CombinedMinimizer*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::CombinedMinimizer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::CombinedMinimizer*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLCombinedMinimizer_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::CombinedMinimizer*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLMinuit2Minimizer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLMinuit2Minimizer_Dictionary();
   static void *new_ROOTcLcLMinuit2cLcLMinuit2Minimizer(void *p = 0);
   static void *newArray_ROOTcLcLMinuit2cLcLMinuit2Minimizer(Long_t size, void *p);
   static void delete_ROOTcLcLMinuit2cLcLMinuit2Minimizer(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLMinuit2Minimizer(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLMinuit2Minimizer(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::Minuit2Minimizer*)
   {
      ::ROOT::Minuit2::Minuit2Minimizer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::Minuit2Minimizer),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::Minuit2Minimizer", "include/Minuit2/Minuit2Minimizer.h", 64,
                  typeid(::ROOT::Minuit2::Minuit2Minimizer), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLMinuit2Minimizer_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::Minuit2Minimizer) );
      instance.SetNew(&new_ROOTcLcLMinuit2cLcLMinuit2Minimizer);
      instance.SetNewArray(&newArray_ROOTcLcLMinuit2cLcLMinuit2Minimizer);
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLMinuit2Minimizer);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLMinuit2Minimizer);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLMinuit2Minimizer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::Minuit2Minimizer*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::Minuit2Minimizer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::Minuit2Minimizer*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLMinuit2Minimizer_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::Minuit2Minimizer*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLMnApplication_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLMnApplication_Dictionary();
   static void delete_ROOTcLcLMinuit2cLcLMnApplication(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLMnApplication(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLMnApplication(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::MnApplication*)
   {
      ::ROOT::Minuit2::MnApplication *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::MnApplication),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::MnApplication", "include/Minuit2/MnApplication.h", 37,
                  typeid(::ROOT::Minuit2::MnApplication), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLMnApplication_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::MnApplication) );
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLMnApplication);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLMnApplication);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLMnApplication);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::MnApplication*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::MnApplication*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnApplication*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLMnApplication_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnApplication*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLMnContours_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLMnContours_Dictionary();
   static void delete_ROOTcLcLMinuit2cLcLMnContours(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLMnContours(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLMnContours(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::MnContours*)
   {
      ::ROOT::Minuit2::MnContours *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::MnContours),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::MnContours", "include/Minuit2/MnContours.h", 37,
                  typeid(::ROOT::Minuit2::MnContours), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLMnContours_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::MnContours) );
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLMnContours);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLMnContours);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLMnContours);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::MnContours*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::MnContours*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnContours*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLMnContours_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnContours*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLMnFumiliMinimize_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLMnFumiliMinimize_Dictionary();
   static void delete_ROOTcLcLMinuit2cLcLMnFumiliMinimize(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLMnFumiliMinimize(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLMnFumiliMinimize(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::MnFumiliMinimize*)
   {
      ::ROOT::Minuit2::MnFumiliMinimize *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::MnFumiliMinimize),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::MnFumiliMinimize", "include/Minuit2/MnFumiliMinimize.h", 38,
                  typeid(::ROOT::Minuit2::MnFumiliMinimize), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLMnFumiliMinimize_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::MnFumiliMinimize) );
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLMnFumiliMinimize);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLMnFumiliMinimize);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLMnFumiliMinimize);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::MnFumiliMinimize*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::MnFumiliMinimize*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnFumiliMinimize*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLMnFumiliMinimize_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnFumiliMinimize*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLMnHesse_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLMnHesse_Dictionary();
   static void *new_ROOTcLcLMinuit2cLcLMnHesse(void *p = 0);
   static void *newArray_ROOTcLcLMinuit2cLcLMnHesse(Long_t size, void *p);
   static void delete_ROOTcLcLMinuit2cLcLMnHesse(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLMnHesse(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLMnHesse(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::MnHesse*)
   {
      ::ROOT::Minuit2::MnHesse *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::MnHesse),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::MnHesse", "include/Minuit2/MnHesse.h", 40,
                  typeid(::ROOT::Minuit2::MnHesse), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLMnHesse_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::MnHesse) );
      instance.SetNew(&new_ROOTcLcLMinuit2cLcLMnHesse);
      instance.SetNewArray(&newArray_ROOTcLcLMinuit2cLcLMnHesse);
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLMnHesse);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLMnHesse);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLMnHesse);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::MnHesse*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::MnHesse*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnHesse*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLMnHesse_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnHesse*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLMnMigrad_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLMnMigrad_Dictionary();
   static void delete_ROOTcLcLMinuit2cLcLMnMigrad(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLMnMigrad(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLMnMigrad(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::MnMigrad*)
   {
      ::ROOT::Minuit2::MnMigrad *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::MnMigrad),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::MnMigrad", "include/Minuit2/MnMigrad.h", 31,
                  typeid(::ROOT::Minuit2::MnMigrad), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLMnMigrad_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::MnMigrad) );
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLMnMigrad);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLMnMigrad);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLMnMigrad);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::MnMigrad*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::MnMigrad*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnMigrad*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLMnMigrad_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnMigrad*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLMnMinimize_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLMnMinimize_Dictionary();
   static void delete_ROOTcLcLMinuit2cLcLMnMinimize(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLMnMinimize(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLMnMinimize(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::MnMinimize*)
   {
      ::ROOT::Minuit2::MnMinimize *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::MnMinimize),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::MnMinimize", "include/Minuit2/MnMinimize.h", 29,
                  typeid(::ROOT::Minuit2::MnMinimize), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLMnMinimize_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::MnMinimize) );
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLMnMinimize);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLMnMinimize);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLMnMinimize);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::MnMinimize*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::MnMinimize*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnMinimize*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLMnMinimize_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnMinimize*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLMnMinos_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLMnMinos_Dictionary();
   static void delete_ROOTcLcLMinuit2cLcLMnMinos(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLMnMinos(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLMnMinos(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::MnMinos*)
   {
      ::ROOT::Minuit2::MnMinos *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::MnMinos),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::MnMinos", "include/Minuit2/MnMinos.h", 34,
                  typeid(::ROOT::Minuit2::MnMinos), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLMnMinos_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::MnMinos) );
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLMnMinos);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLMnMinos);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLMnMinos);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::MnMinos*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::MnMinos*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnMinos*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLMnMinos_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnMinos*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLMnPlot_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLMnPlot_Dictionary();
   static void *new_ROOTcLcLMinuit2cLcLMnPlot(void *p = 0);
   static void *newArray_ROOTcLcLMinuit2cLcLMnPlot(Long_t size, void *p);
   static void delete_ROOTcLcLMinuit2cLcLMnPlot(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLMnPlot(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLMnPlot(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::MnPlot*)
   {
      ::ROOT::Minuit2::MnPlot *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::MnPlot),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::MnPlot", "include/Minuit2/MnPlot.h", 26,
                  typeid(::ROOT::Minuit2::MnPlot), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLMnPlot_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::MnPlot) );
      instance.SetNew(&new_ROOTcLcLMinuit2cLcLMnPlot);
      instance.SetNewArray(&newArray_ROOTcLcLMinuit2cLcLMnPlot);
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLMnPlot);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLMnPlot);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLMnPlot);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::MnPlot*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::MnPlot*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnPlot*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLMnPlot_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnPlot*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLScanMinimizer_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLScanMinimizer_Dictionary();
   static void *new_ROOTcLcLMinuit2cLcLScanMinimizer(void *p = 0);
   static void *newArray_ROOTcLcLMinuit2cLcLScanMinimizer(Long_t size, void *p);
   static void delete_ROOTcLcLMinuit2cLcLScanMinimizer(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLScanMinimizer(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLScanMinimizer(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::ScanMinimizer*)
   {
      ::ROOT::Minuit2::ScanMinimizer *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::ScanMinimizer),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::ScanMinimizer", "include/Minuit2/ScanMinimizer.h", 30,
                  typeid(::ROOT::Minuit2::ScanMinimizer), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLScanMinimizer_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::ScanMinimizer) );
      instance.SetNew(&new_ROOTcLcLMinuit2cLcLScanMinimizer);
      instance.SetNewArray(&newArray_ROOTcLcLMinuit2cLcLScanMinimizer);
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLScanMinimizer);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLScanMinimizer);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLScanMinimizer);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::ScanMinimizer*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::ScanMinimizer*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::ScanMinimizer*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLScanMinimizer_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::ScanMinimizer*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLMnScan_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLMnScan_Dictionary();
   static void delete_ROOTcLcLMinuit2cLcLMnScan(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLMnScan(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLMnScan(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::MnScan*)
   {
      ::ROOT::Minuit2::MnScan *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::MnScan),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::MnScan", "include/Minuit2/MnScan.h", 31,
                  typeid(::ROOT::Minuit2::MnScan), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLMnScan_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::MnScan) );
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLMnScan);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLMnScan);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLMnScan);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::MnScan*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::MnScan*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnScan*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLMnScan_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnScan*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   void ROOTcLcLMinuit2cLcLMnSimplex_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void ROOTcLcLMinuit2cLcLMnSimplex_Dictionary();
   static void delete_ROOTcLcLMinuit2cLcLMnSimplex(void *p);
   static void deleteArray_ROOTcLcLMinuit2cLcLMnSimplex(void *p);
   static void destruct_ROOTcLcLMinuit2cLcLMnSimplex(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Minuit2::MnSimplex*)
   {
      ::ROOT::Minuit2::MnSimplex *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Minuit2::MnSimplex),0);
      static ::ROOT::TGenericClassInfo 
         instance("ROOT::Minuit2::MnSimplex", "include/Minuit2/MnSimplex.h", 34,
                  typeid(::ROOT::Minuit2::MnSimplex), DefineBehavior(ptr, ptr),
                  0, &ROOTcLcLMinuit2cLcLMnSimplex_Dictionary, isa_proxy, 0,
                  sizeof(::ROOT::Minuit2::MnSimplex) );
      instance.SetDelete(&delete_ROOTcLcLMinuit2cLcLMnSimplex);
      instance.SetDeleteArray(&deleteArray_ROOTcLcLMinuit2cLcLMnSimplex);
      instance.SetDestructor(&destruct_ROOTcLcLMinuit2cLcLMnSimplex);
      return &instance;
   }
   TGenericClassInfo *GenerateInitInstance(const ::ROOT::Minuit2::MnSimplex*)
   {
      return GenerateInitInstanceLocal((::ROOT::Minuit2::MnSimplex*)0);
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnSimplex*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void ROOTcLcLMinuit2cLcLMnSimplex_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Minuit2::MnSimplex*)0x0)->GetClass();
   }

} // end of namespace ROOT

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TVirtualFitter::Streamer(R__b);
      R__b >> fErrorDef;
      R__b >> fEDMVal;
      R__b >> fGradient;
      R__b.StreamObject(&(fState),typeid(ROOT::Minuit2::MnUserParameterState));
      {
         vector<ROOT::Minuit2::MinosError> &R__stl =  fMinosErrors;
         R__stl.clear();
         TClass *R__tcl1 = TBuffer::GetClass(typeid(ROOT::Minuit2::MinosError));
         if (R__tcl1==0) {
            Error("fMinosErrors streamer","Missing the TClass object for ROOT::Minuit2::MinosError!");
            return;
         }
         int R__i, R__n;
         R__b >> R__n;
         R__stl.reserve(R__n);
         for (R__i = 0; R__i < R__n; R__i++) {
            ROOT::Minuit2::MinosError R__t;
            R__b.StreamObject(&R__t,R__tcl1);
            R__stl.push_back(R__t);
         }
      }
      R__b >> fMinimizer;
      R__b >> fMinuitFCN;
      R__b >> fDebug;
      R__b >> fStrategy;
      R__b >> fMinTolerance;
      {
         vector<double> &R__stl =  fCovar;
         R__stl.clear();
         int R__i, R__n;
         R__b >> R__n;
         R__stl.reserve(R__n);
         for (R__i = 0; R__i < R__n; R__i++) {
            double R__t;
            R__b >> R__t;
            R__stl.push_back(R__t);
         }
      }
      R__b.CheckByteCount(R__s, R__c, TFitterMinuit::IsA());
   } else {
      R__c = R__b.WriteVersion(TFitterMinuit::IsA(), kTRUE);
      TVirtualFitter::Streamer(R__b);
      R__b << fErrorDef;
      R__b << fEDMVal;
      R__b << fGradient;
      R__b.StreamObject(&(fState),typeid(ROOT::Minuit2::MnUserParameterState));
      {
         vector<ROOT::Minuit2::MinosError> &R__stl =  fMinosErrors;
         int R__n=(&R__stl) ? int(R__stl.size()) : 0;
         R__b << R__n;
         if(R__n) {
         TClass *R__tcl1 = TBuffer::GetClass(typeid(ROOT::Minuit2::MinosError));
         if (R__tcl1==0) {
            Error("fMinosErrors streamer","Missing the TClass object for ROOT::Minuit2::MinosError!");
            return;
         }
            vector<ROOT::Minuit2::MinosError>::iterator R__k;
            for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
            R__b.StreamObject((ROOT::Minuit2::MinosError*)&(*R__k),R__tcl1);
            }
         }
      }
      R__b << fMinimizer;
      R__b << fMinuitFCN;
      R__b << fDebug;
      R__b << fStrategy;
      R__b << fMinTolerance;
      {
         vector<double> &R__stl =  fCovar;
         int R__n=(&R__stl) ? int(R__stl.size()) : 0;
         R__b << R__n;
         if(R__n) {
            vector<double>::iterator R__k;
            for (R__k = R__stl.begin(); R__k != R__stl.end(); ++R__k) {
            R__b << (*R__k);
            }
         }
      }
      R__b.SetByteCount(R__c, kTRUE);
   }
}

//______________________________________________________________________________
void TFitterMinuit::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TFitterMinuit.
      TClass *R__cl = ::TFitterMinuit::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrorDef", &fErrorDef);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fEDMVal", &fEDMVal);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGradient", &fGradient);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fState", (void*)&fState);
      R__insp.InspectMember("ROOT::Minuit2::MnUserParameterState", (void*)&fState, "fState.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinosErrors", (void*)&fMinosErrors);
      R__insp.InspectMember("vector<ROOT::Minuit2::MinosError>", (void*)&fMinosErrors, "fMinosErrors.", false);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMinimizer", &fMinimizer);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "*fMinuitFCN", &fMinuitFCN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fDebug", &fDebug);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fStrategy", &fStrategy);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinTolerance", &fMinTolerance);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fCovar", (void*)&fCovar);
      R__insp.InspectMember("vector<double>", (void*)&fCovar, "fCovar.", false);
      TVirtualFitter::ShowMembers(R__insp);
}

namespace ROOT {
   // Wrappers around operator new
   static void *new_TFitterMinuit(void *p) {
      return  p ? new(p) ::TFitterMinuit : new ::TFitterMinuit;
   }
   static void *newArray_TFitterMinuit(Long_t nElements, void *p) {
      return p ? new(p) ::TFitterMinuit[nElements] : new ::TFitterMinuit[nElements];
   }
   // Wrapper around operator delete
   static void delete_TFitterMinuit(void *p) {
      delete ((::TFitterMinuit*)p);
   }
   static void deleteArray_TFitterMinuit(void *p) {
      delete [] ((::TFitterMinuit*)p);
   }
   static void destruct_TFitterMinuit(void *p) {
      typedef ::TFitterMinuit current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TFitterMinuit(TBuffer &buf, void *obj) {
      ((::TFitterMinuit*)obj)->::TFitterMinuit::Streamer(buf);
   }
} // end of namespace ROOT for class ::TFitterMinuit

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

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TFitterMinuit::Streamer(R__b);
      R__b.CheckByteCount(R__s, R__c, TFitterFumili::IsA());
   } else {
      R__c = R__b.WriteVersion(TFitterFumili::IsA(), kTRUE);
      TFitterMinuit::Streamer(R__b);
      R__b.SetByteCount(R__c, kTRUE);
   }
}

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

namespace ROOT {
   // Wrappers around operator new
   static void *new_TFitterFumili(void *p) {
      return  p ? new(p) ::TFitterFumili : new ::TFitterFumili;
   }
   static void *newArray_TFitterFumili(Long_t nElements, void *p) {
      return p ? new(p) ::TFitterFumili[nElements] : new ::TFitterFumili[nElements];
   }
   // Wrapper around operator delete
   static void delete_TFitterFumili(void *p) {
      delete ((::TFitterFumili*)p);
   }
   static void deleteArray_TFitterFumili(void *p) {
      delete [] ((::TFitterFumili*)p);
   }
   static void destruct_TFitterFumili(void *p) {
      typedef ::TFitterFumili current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TFitterFumili(TBuffer &buf, void *obj) {
      ((::TFitterFumili*)obj)->::TFitterFumili::Streamer(buf);
   }
} // end of namespace ROOT for class ::TFitterFumili

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

   ::Error("TFcnAdapter::Streamer", "version id <=0 in ClassDef, dummy Streamer() called"); if (R__b.IsReading()) { }
}

//______________________________________________________________________________
void TFcnAdapter::ShowMembers(TMemberInspector &R__insp)
{
      // Inspect the data members of an object of class TFcnAdapter.
      TClass *R__cl = ::TFcnAdapter::IsA();
      if (R__cl || R__insp.IsA()) { }
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fFCN", &fFCN);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fUp", &fUp);
      R__insp.Inspect(R__cl, R__insp.GetParent(), "fGradCache", (void*)&fGradCache);
      R__insp.InspectMember("vector<double>", (void*)&fGradCache, "fGradCache.", false);
      R__insp.GenericShowMembers("ROOT::Minuit2::FCNGradientBase", ( ::ROOT::Minuit2::FCNGradientBase *) (this ), false);
}

namespace ROOT {
   // Wrapper around operator delete
   static void delete_TFcnAdapter(void *p) {
      delete ((::TFcnAdapter*)p);
   }
   static void deleteArray_TFcnAdapter(void *p) {
      delete [] ((::TFcnAdapter*)p);
   }
   static void destruct_TFcnAdapter(void *p) {
      typedef ::TFcnAdapter current_t;
      ((current_t*)p)->~current_t();
   }
   // Wrapper around a custom streamer member function.
   static void streamer_TFcnAdapter(TBuffer &buf, void *obj) {
      ((::TFcnAdapter*)obj)->::TFcnAdapter::Streamer(buf);
   }
} // end of namespace ROOT for class ::TFcnAdapter

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLGenericFunction(void *p) {
      delete ((::ROOT::Minuit2::GenericFunction*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLGenericFunction(void *p) {
      delete [] ((::ROOT::Minuit2::GenericFunction*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLGenericFunction(void *p) {
      typedef ::ROOT::Minuit2::GenericFunction current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::GenericFunction

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLFCNBase(void *p) {
      delete ((::ROOT::Minuit2::FCNBase*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLFCNBase(void *p) {
      delete [] ((::ROOT::Minuit2::FCNBase*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLFCNBase(void *p) {
      typedef ::ROOT::Minuit2::FCNBase current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::FCNBase

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLFCNGradientBase(void *p) {
      delete ((::ROOT::Minuit2::FCNGradientBase*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLFCNGradientBase(void *p) {
      delete [] ((::ROOT::Minuit2::FCNGradientBase*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLFCNGradientBase(void *p) {
      typedef ::ROOT::Minuit2::FCNGradientBase current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::FCNGradientBase

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLFumiliFCNBase(void *p) {
      delete ((::ROOT::Minuit2::FumiliFCNBase*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLFumiliFCNBase(void *p) {
      delete [] ((::ROOT::Minuit2::FumiliFCNBase*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLFumiliFCNBase(void *p) {
      typedef ::ROOT::Minuit2::FumiliFCNBase current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::FumiliFCNBase

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMinuit2cLcLMinuit2Minimizer(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::Minuit2Minimizer : new ::ROOT::Minuit2::Minuit2Minimizer;
   }
   static void *newArray_ROOTcLcLMinuit2cLcLMinuit2Minimizer(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::Minuit2Minimizer[nElements] : new ::ROOT::Minuit2::Minuit2Minimizer[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLMinuit2Minimizer(void *p) {
      delete ((::ROOT::Minuit2::Minuit2Minimizer*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLMinuit2Minimizer(void *p) {
      delete [] ((::ROOT::Minuit2::Minuit2Minimizer*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLMinuit2Minimizer(void *p) {
      typedef ::ROOT::Minuit2::Minuit2Minimizer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::Minuit2Minimizer

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLFunctionMinimum(void *p) {
      delete ((::ROOT::Minuit2::FunctionMinimum*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLFunctionMinimum(void *p) {
      delete [] ((::ROOT::Minuit2::FunctionMinimum*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLFunctionMinimum(void *p) {
      typedef ::ROOT::Minuit2::FunctionMinimum current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::FunctionMinimum

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLMinuitParameter(void *p) {
      delete ((::ROOT::Minuit2::MinuitParameter*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLMinuitParameter(void *p) {
      delete [] ((::ROOT::Minuit2::MinuitParameter*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLMinuitParameter(void *p) {
      typedef ::ROOT::Minuit2::MinuitParameter current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::MinuitParameter

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMinuit2cLcLMinosError(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::MinosError : new ::ROOT::Minuit2::MinosError;
   }
   static void *newArray_ROOTcLcLMinuit2cLcLMinosError(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::MinosError[nElements] : new ::ROOT::Minuit2::MinosError[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLMinosError(void *p) {
      delete ((::ROOT::Minuit2::MinosError*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLMinosError(void *p) {
      delete [] ((::ROOT::Minuit2::MinosError*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLMinosError(void *p) {
      typedef ::ROOT::Minuit2::MinosError current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::MinosError

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLMnApplication(void *p) {
      delete ((::ROOT::Minuit2::MnApplication*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLMnApplication(void *p) {
      delete [] ((::ROOT::Minuit2::MnApplication*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLMnApplication(void *p) {
      typedef ::ROOT::Minuit2::MnApplication current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::MnApplication

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLMnMigrad(void *p) {
      delete ((::ROOT::Minuit2::MnMigrad*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLMnMigrad(void *p) {
      delete [] ((::ROOT::Minuit2::MnMigrad*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLMnMigrad(void *p) {
      typedef ::ROOT::Minuit2::MnMigrad current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::MnMigrad

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLMnMinos(void *p) {
      delete ((::ROOT::Minuit2::MnMinos*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLMnMinos(void *p) {
      delete [] ((::ROOT::Minuit2::MnMinos*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLMnMinos(void *p) {
      typedef ::ROOT::Minuit2::MnMinos current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::MnMinos

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMinuit2cLcLMnHesse(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::MnHesse : new ::ROOT::Minuit2::MnHesse;
   }
   static void *newArray_ROOTcLcLMinuit2cLcLMnHesse(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::MnHesse[nElements] : new ::ROOT::Minuit2::MnHesse[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLMnHesse(void *p) {
      delete ((::ROOT::Minuit2::MnHesse*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLMnHesse(void *p) {
      delete [] ((::ROOT::Minuit2::MnHesse*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLMnHesse(void *p) {
      typedef ::ROOT::Minuit2::MnHesse current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::MnHesse

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLMnMinimize(void *p) {
      delete ((::ROOT::Minuit2::MnMinimize*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLMnMinimize(void *p) {
      delete [] ((::ROOT::Minuit2::MnMinimize*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLMnMinimize(void *p) {
      typedef ::ROOT::Minuit2::MnMinimize current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::MnMinimize

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLMnFumiliMinimize(void *p) {
      delete ((::ROOT::Minuit2::MnFumiliMinimize*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLMnFumiliMinimize(void *p) {
      delete [] ((::ROOT::Minuit2::MnFumiliMinimize*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLMnFumiliMinimize(void *p) {
      typedef ::ROOT::Minuit2::MnFumiliMinimize current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::MnFumiliMinimize

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLMnScan(void *p) {
      delete ((::ROOT::Minuit2::MnScan*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLMnScan(void *p) {
      delete [] ((::ROOT::Minuit2::MnScan*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLMnScan(void *p) {
      typedef ::ROOT::Minuit2::MnScan current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::MnScan

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLMnContours(void *p) {
      delete ((::ROOT::Minuit2::MnContours*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLMnContours(void *p) {
      delete [] ((::ROOT::Minuit2::MnContours*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLMnContours(void *p) {
      typedef ::ROOT::Minuit2::MnContours current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::MnContours

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLMnSimplex(void *p) {
      delete ((::ROOT::Minuit2::MnSimplex*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLMnSimplex(void *p) {
      delete [] ((::ROOT::Minuit2::MnSimplex*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLMnSimplex(void *p) {
      typedef ::ROOT::Minuit2::MnSimplex current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::MnSimplex

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMinuit2cLcLMnPlot(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::MnPlot : new ::ROOT::Minuit2::MnPlot;
   }
   static void *newArray_ROOTcLcLMinuit2cLcLMnPlot(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::MnPlot[nElements] : new ::ROOT::Minuit2::MnPlot[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLMnPlot(void *p) {
      delete ((::ROOT::Minuit2::MnPlot*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLMnPlot(void *p) {
      delete [] ((::ROOT::Minuit2::MnPlot*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLMnPlot(void *p) {
      typedef ::ROOT::Minuit2::MnPlot current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::MnPlot

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMinuit2cLcLMnUserParameterState(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::MnUserParameterState : new ::ROOT::Minuit2::MnUserParameterState;
   }
   static void *newArray_ROOTcLcLMinuit2cLcLMnUserParameterState(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::MnUserParameterState[nElements] : new ::ROOT::Minuit2::MnUserParameterState[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLMnUserParameterState(void *p) {
      delete ((::ROOT::Minuit2::MnUserParameterState*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLMnUserParameterState(void *p) {
      delete [] ((::ROOT::Minuit2::MnUserParameterState*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLMnUserParameterState(void *p) {
      typedef ::ROOT::Minuit2::MnUserParameterState current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::MnUserParameterState

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMinuit2cLcLMnUserParameters(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::MnUserParameters : new ::ROOT::Minuit2::MnUserParameters;
   }
   static void *newArray_ROOTcLcLMinuit2cLcLMnUserParameters(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::MnUserParameters[nElements] : new ::ROOT::Minuit2::MnUserParameters[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLMnUserParameters(void *p) {
      delete ((::ROOT::Minuit2::MnUserParameters*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLMnUserParameters(void *p) {
      delete [] ((::ROOT::Minuit2::MnUserParameters*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLMnUserParameters(void *p) {
      typedef ::ROOT::Minuit2::MnUserParameters current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::MnUserParameters

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMinuit2cLcLMnStrategy(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::MnStrategy : new ::ROOT::Minuit2::MnStrategy;
   }
   static void *newArray_ROOTcLcLMinuit2cLcLMnStrategy(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::MnStrategy[nElements] : new ::ROOT::Minuit2::MnStrategy[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLMnStrategy(void *p) {
      delete ((::ROOT::Minuit2::MnStrategy*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLMnStrategy(void *p) {
      delete [] ((::ROOT::Minuit2::MnStrategy*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLMnStrategy(void *p) {
      typedef ::ROOT::Minuit2::MnStrategy current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::MnStrategy

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLFunctionMinimizer(void *p) {
      delete ((::ROOT::Minuit2::FunctionMinimizer*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLFunctionMinimizer(void *p) {
      delete [] ((::ROOT::Minuit2::FunctionMinimizer*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLFunctionMinimizer(void *p) {
      typedef ::ROOT::Minuit2::FunctionMinimizer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::FunctionMinimizer

namespace ROOT {
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLModularFunctionMinimizer(void *p) {
      delete ((::ROOT::Minuit2::ModularFunctionMinimizer*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLModularFunctionMinimizer(void *p) {
      delete [] ((::ROOT::Minuit2::ModularFunctionMinimizer*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLModularFunctionMinimizer(void *p) {
      typedef ::ROOT::Minuit2::ModularFunctionMinimizer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::ModularFunctionMinimizer

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMinuit2cLcLVariableMetricMinimizer(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::VariableMetricMinimizer : new ::ROOT::Minuit2::VariableMetricMinimizer;
   }
   static void *newArray_ROOTcLcLMinuit2cLcLVariableMetricMinimizer(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::VariableMetricMinimizer[nElements] : new ::ROOT::Minuit2::VariableMetricMinimizer[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLVariableMetricMinimizer(void *p) {
      delete ((::ROOT::Minuit2::VariableMetricMinimizer*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLVariableMetricMinimizer(void *p) {
      delete [] ((::ROOT::Minuit2::VariableMetricMinimizer*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLVariableMetricMinimizer(void *p) {
      typedef ::ROOT::Minuit2::VariableMetricMinimizer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::VariableMetricMinimizer

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMinuit2cLcLSimplexMinimizer(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::SimplexMinimizer : new ::ROOT::Minuit2::SimplexMinimizer;
   }
   static void *newArray_ROOTcLcLMinuit2cLcLSimplexMinimizer(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::SimplexMinimizer[nElements] : new ::ROOT::Minuit2::SimplexMinimizer[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLSimplexMinimizer(void *p) {
      delete ((::ROOT::Minuit2::SimplexMinimizer*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLSimplexMinimizer(void *p) {
      delete [] ((::ROOT::Minuit2::SimplexMinimizer*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLSimplexMinimizer(void *p) {
      typedef ::ROOT::Minuit2::SimplexMinimizer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::SimplexMinimizer

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMinuit2cLcLCombinedMinimizer(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::CombinedMinimizer : new ::ROOT::Minuit2::CombinedMinimizer;
   }
   static void *newArray_ROOTcLcLMinuit2cLcLCombinedMinimizer(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::CombinedMinimizer[nElements] : new ::ROOT::Minuit2::CombinedMinimizer[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLCombinedMinimizer(void *p) {
      delete ((::ROOT::Minuit2::CombinedMinimizer*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLCombinedMinimizer(void *p) {
      delete [] ((::ROOT::Minuit2::CombinedMinimizer*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLCombinedMinimizer(void *p) {
      typedef ::ROOT::Minuit2::CombinedMinimizer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::CombinedMinimizer

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMinuit2cLcLScanMinimizer(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::ScanMinimizer : new ::ROOT::Minuit2::ScanMinimizer;
   }
   static void *newArray_ROOTcLcLMinuit2cLcLScanMinimizer(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::ScanMinimizer[nElements] : new ::ROOT::Minuit2::ScanMinimizer[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLScanMinimizer(void *p) {
      delete ((::ROOT::Minuit2::ScanMinimizer*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLScanMinimizer(void *p) {
      delete [] ((::ROOT::Minuit2::ScanMinimizer*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLScanMinimizer(void *p) {
      typedef ::ROOT::Minuit2::ScanMinimizer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::ScanMinimizer

namespace ROOT {
   // Wrappers around operator new
   static void *new_ROOTcLcLMinuit2cLcLFumiliMinimizer(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::FumiliMinimizer : new ::ROOT::Minuit2::FumiliMinimizer;
   }
   static void *newArray_ROOTcLcLMinuit2cLcLFumiliMinimizer(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Minuit2::FumiliMinimizer[nElements] : new ::ROOT::Minuit2::FumiliMinimizer[nElements];
   }
   // Wrapper around operator delete
   static void delete_ROOTcLcLMinuit2cLcLFumiliMinimizer(void *p) {
      delete ((::ROOT::Minuit2::FumiliMinimizer*)p);
   }
   static void deleteArray_ROOTcLcLMinuit2cLcLFumiliMinimizer(void *p) {
      delete [] ((::ROOT::Minuit2::FumiliMinimizer*)p);
   }
   static void destruct_ROOTcLcLMinuit2cLcLFumiliMinimizer(void *p) {
      typedef ::ROOT::Minuit2::FumiliMinimizer current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class ::ROOT::Minuit2::FumiliMinimizer

namespace ROOT {
   void vectorlEROOTcLcLMinuit2cLcLMinosErrorgR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEROOTcLcLMinuit2cLcLMinosErrorgR_Dictionary();
   static void *new_vectorlEROOTcLcLMinuit2cLcLMinosErrorgR(void *p = 0);
   static void *newArray_vectorlEROOTcLcLMinuit2cLcLMinosErrorgR(Long_t size, void *p);
   static void delete_vectorlEROOTcLcLMinuit2cLcLMinosErrorgR(void *p);
   static void deleteArray_vectorlEROOTcLcLMinuit2cLcLMinosErrorgR(void *p);
   static void destruct_vectorlEROOTcLcLMinuit2cLcLMinosErrorgR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<ROOT::Minuit2::MinosError>*)
   {
      vector<ROOT::Minuit2::MinosError> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<ROOT::Minuit2::MinosError>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<ROOT::Minuit2::MinosError>", -2, "prec_stl/vector", 49,
                  typeid(vector<ROOT::Minuit2::MinosError>), DefineBehavior(ptr, ptr),
                  0, &vectorlEROOTcLcLMinuit2cLcLMinosErrorgR_Dictionary, isa_proxy, 0,
                  sizeof(vector<ROOT::Minuit2::MinosError>) );
      instance.SetNew(&new_vectorlEROOTcLcLMinuit2cLcLMinosErrorgR);
      instance.SetNewArray(&newArray_vectorlEROOTcLcLMinuit2cLcLMinosErrorgR);
      instance.SetDelete(&delete_vectorlEROOTcLcLMinuit2cLcLMinosErrorgR);
      instance.SetDeleteArray(&deleteArray_vectorlEROOTcLcLMinuit2cLcLMinosErrorgR);
      instance.SetDestructor(&destruct_vectorlEROOTcLcLMinuit2cLcLMinosErrorgR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<ROOT::Minuit2::MinosError> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<ROOT::Minuit2::MinosError>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

   // Dictionary for non-ClassDef classes
   static void vectorlEROOTcLcLMinuit2cLcLMinosErrorgR_Dictionary() {
      ::ROOT::GenerateInitInstanceLocal((const vector<ROOT::Minuit2::MinosError>*)0x0)->GetClass();
   }

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEROOTcLcLMinuit2cLcLMinosErrorgR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<ROOT::Minuit2::MinosError> : new vector<ROOT::Minuit2::MinosError>;
   }
   static void *newArray_vectorlEROOTcLcLMinuit2cLcLMinosErrorgR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<ROOT::Minuit2::MinosError>[nElements] : new vector<ROOT::Minuit2::MinosError>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEROOTcLcLMinuit2cLcLMinosErrorgR(void *p) {
      delete ((vector<ROOT::Minuit2::MinosError>*)p);
   }
   static void deleteArray_vectorlEROOTcLcLMinuit2cLcLMinosErrorgR(void *p) {
      delete [] ((vector<ROOT::Minuit2::MinosError>*)p);
   }
   static void destruct_vectorlEROOTcLcLMinuit2cLcLMinosErrorgR(void *p) {
      typedef vector<ROOT::Minuit2::MinosError> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<ROOT::Minuit2::MinosError>

namespace ROOT {
   void vectorlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
   static void vectorlEdoublegR_Dictionary();
   static void *new_vectorlEdoublegR(void *p = 0);
   static void *newArray_vectorlEdoublegR(Long_t size, void *p);
   static void delete_vectorlEdoublegR(void *p);
   static void deleteArray_vectorlEdoublegR(void *p);
   static void destruct_vectorlEdoublegR(void *p);

   // Function generating the singleton type initializer
   static TGenericClassInfo *GenerateInitInstanceLocal(const vector<double>*)
   {
      vector<double> *ptr = 0;
      static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<double>),0);
      static ::ROOT::TGenericClassInfo 
         instance("vector<double>", -2, "prec_stl/vector", 49,
                  typeid(vector<double>), DefineBehavior(ptr, ptr),
                  0, &vectorlEdoublegR_Dictionary, isa_proxy, 0,
                  sizeof(vector<double>) );
      instance.SetNew(&new_vectorlEdoublegR);
      instance.SetNewArray(&newArray_vectorlEdoublegR);
      instance.SetDelete(&delete_vectorlEdoublegR);
      instance.SetDeleteArray(&deleteArray_vectorlEdoublegR);
      instance.SetDestructor(&destruct_vectorlEdoublegR);
      instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<double> >()));
      return &instance;
   }
   // Static variable to force the class initialization
   static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));

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

} // end of namespace ROOT

namespace ROOT {
   // Wrappers around operator new
   static void *new_vectorlEdoublegR(void *p) {
      return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double> : new vector<double>;
   }
   static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) {
      return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double>[nElements] : new vector<double>[nElements];
   }
   // Wrapper around operator delete
   static void delete_vectorlEdoublegR(void *p) {
      delete ((vector<double>*)p);
   }
   static void deleteArray_vectorlEdoublegR(void *p) {
      delete [] ((vector<double>*)p);
   }
   static void destruct_vectorlEdoublegR(void *p) {
      typedef vector<double> current_t;
      ((current_t*)p)->~current_t();
   }
} // end of namespace ROOT for class vector<double>

/********************************************************
* math/minuit2/src/G__Minuit2.cxx
* CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED
*          FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().
*          CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.
********************************************************/

#ifdef G__MEMTEST
#undef malloc
#undef free
#endif

#if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
#pragma GCC diagnostic ignored "-Wstrict-aliasing"
#endif

extern "C" void G__cpp_reset_tagtableG__Minuit2();

extern "C" void G__set_cpp_environmentG__Minuit2() {
  G__add_compiledheader("TObject.h");
  G__add_compiledheader("TMemberInspector.h");
  G__add_compiledheader("TBinLikelihoodFCN.h");
  G__add_compiledheader("TChi2ExtendedFCN.h");
  G__add_compiledheader("TChi2ExtendedFitData.h");
  G__add_compiledheader("TChi2FCN.h");
  G__add_compiledheader("TChi2FitData.h");
  G__add_compiledheader("TFcnAdapter.h");
  G__add_compiledheader("TFitterFumili.h");
  G__add_compiledheader("TFitterMinuit.h");
  G__add_compiledheader("TFumiliFCN.h");
  G__add_compiledheader("Minuit2/ABObj.h");
  G__add_compiledheader("Minuit2/ABProd.h");
  G__add_compiledheader("Minuit2/ABSum.h");
  G__add_compiledheader("Minuit2/ABTypes.h");
  G__add_compiledheader("Minuit2/AnalyticalGradientCalculator.h");
  G__add_compiledheader("Minuit2/BasicFunctionGradient.h");
  G__add_compiledheader("Minuit2/BasicFunctionMinimum.h");
  G__add_compiledheader("Minuit2/BasicMinimumError.h");
  G__add_compiledheader("Minuit2/BasicMinimumParameters.h");
  G__add_compiledheader("Minuit2/BasicMinimumSeed.h");
  G__add_compiledheader("Minuit2/BasicMinimumState.h");
  G__add_compiledheader("Minuit2/CombinedMinimizer.h");
  G__add_compiledheader("Minuit2/CombinedMinimumBuilder.h");
  G__add_compiledheader("Minuit2/ContoursError.h");
  G__add_compiledheader("Minuit2/DavidonErrorUpdator.h");
  G__add_compiledheader("Minuit2/FCNAdapter.h");
  G__add_compiledheader("Minuit2/FCNBase.h");
  G__add_compiledheader("Minuit2/FCNGradAdapter.h");
  G__add_compiledheader("Minuit2/FCNGradientBase.h");
  G__add_compiledheader("Minuit2/FumiliBuilder.h");
  G__add_compiledheader("Minuit2/FumiliChi2FCN.h");
  G__add_compiledheader("Minuit2/FumiliErrorUpdator.h");
  G__add_compiledheader("Minuit2/FumiliFCNAdapter.h");
  G__add_compiledheader("Minuit2/FumiliFCNBase.h");
  G__add_compiledheader("Minuit2/FumiliGradientCalculator.h");
  G__add_compiledheader("Minuit2/FumiliMaximumLikelihoodFCN.h");
  G__add_compiledheader("Minuit2/FumiliMinimizer.h");
  G__add_compiledheader("Minuit2/FumiliStandardChi2FCN.h");
  G__add_compiledheader("Minuit2/FumiliStandardMaximumLikelihoodFCN.h");
  G__add_compiledheader("Minuit2/FunctionGradient.h");
  G__add_compiledheader("Minuit2/FunctionMinimizer.h");
  G__add_compiledheader("Minuit2/FunctionMinimum.h");
  G__add_compiledheader("Minuit2/GenericFunction.h");
  G__add_compiledheader("Minuit2/GradientCalculator.h");
  G__add_compiledheader("Minuit2/HessianGradientCalculator.h");
  G__add_compiledheader("Minuit2/InitialGradientCalculator.h");
  G__add_compiledheader("Minuit2/LaInverse.h");
  G__add_compiledheader("Minuit2/LaOuterProduct.h");
  G__add_compiledheader("Minuit2/LaProd.h");
  G__add_compiledheader("Minuit2/LaSum.h");
  G__add_compiledheader("Minuit2/LASymMatrix.h");
  G__add_compiledheader("Minuit2/LAVector.h");
  G__add_compiledheader("Minuit2/MatrixInverse.h");
  G__add_compiledheader("Minuit2/MinimumBuilder.h");
  G__add_compiledheader("Minuit2/MinimumError.h");
  G__add_compiledheader("Minuit2/MinimumErrorUpdator.h");
  G__add_compiledheader("Minuit2/MinimumParameters.h");
  G__add_compiledheader("Minuit2/MinimumSeedGenerator.h");
  G__add_compiledheader("Minuit2/MinimumSeed.h");
  G__add_compiledheader("Minuit2/MinimumState.h");
  G__add_compiledheader("Minuit2/MinosError.h");
  G__add_compiledheader("Minuit2/Minuit2Minimizer.h");
  G__add_compiledheader("Minuit2/MinuitParameter.h");
  G__add_compiledheader("Minuit2/MnApplication.h");
  G__add_compiledheader("Minuit2/MnConfig.h");
  G__add_compiledheader("Minuit2/MnContours.h");
  G__add_compiledheader("Minuit2/MnCovarianceSqueeze.h");
  G__add_compiledheader("Minuit2/MnCross.h");
  G__add_compiledheader("Minuit2/MnEigen.h");
  G__add_compiledheader("Minuit2/MnFcn.h");
  G__add_compiledheader("Minuit2/MnFumiliMinimize.h");
  G__add_compiledheader("Minuit2/MnFunctionCross.h");
  G__add_compiledheader("Minuit2/MnGlobalCorrelationCoeff.h");
  G__add_compiledheader("Minuit2/MnHesse.h");
  G__add_compiledheader("Minuit2/MnLineSearch.h");
  G__add_compiledheader("Minuit2/MnMachinePrecision.h");
  G__add_compiledheader("Minuit2/MnMatrix.h");
  G__add_compiledheader("Minuit2/MnMigrad.h");
  G__add_compiledheader("Minuit2/MnMinimize.h");
  G__add_compiledheader("Minuit2/MnMinos.h");
  G__add_compiledheader("Minuit2/MnParabolaFactory.h");
  G__add_compiledheader("Minuit2/MnParabola.h");
  G__add_compiledheader("Minuit2/MnParabolaPoint.h");
  G__add_compiledheader("Minuit2/MnParameterScan.h");
  G__add_compiledheader("Minuit2/MnPlot.h");
  G__add_compiledheader("Minuit2/MnPosDef.h");
  G__add_compiledheader("Minuit2/MnPrint.h");
  G__add_compiledheader("Minuit2/MnRefCountedPointer.h");
  G__add_compiledheader("Minuit2/MnReferenceCounter.h");
  G__add_compiledheader("Minuit2/MnScan.h");
  G__add_compiledheader("Minuit2/MnSeedGenerator.h");
  G__add_compiledheader("Minuit2/MnSimplex.h");
  G__add_compiledheader("Minuit2/MnStrategy.h");
  G__add_compiledheader("Minuit2/MnTiny.h");
  G__add_compiledheader("Minuit2/MnUserCovariance.h");
  G__add_compiledheader("Minuit2/MnUserFcn.h");
  G__add_compiledheader("Minuit2/MnUserParameters.h");
  G__add_compiledheader("Minuit2/MnUserParameterState.h");
  G__add_compiledheader("Minuit2/MnUserTransformation.h");
  G__add_compiledheader("Minuit2/MnVectorTransform.h");
  G__add_compiledheader("Minuit2/ModularFunctionMinimizer.h");
  G__add_compiledheader("Minuit2/MPIProcess.h");
  G__add_compiledheader("Minuit2/NegativeG2LineSearch.h");
  G__add_compiledheader("Minuit2/Numerical2PGradientCalculator.h");
  G__add_compiledheader("Minuit2/ParametricFunction.h");
  G__add_compiledheader("Minuit2/ScanBuilder.h");
  G__add_compiledheader("Minuit2/ScanMinimizer.h");
  G__add_compiledheader("Minuit2/SimplexBuilder.h");
  G__add_compiledheader("Minuit2/SimplexMinimizer.h");
  G__add_compiledheader("Minuit2/SimplexParameters.h");
  G__add_compiledheader("Minuit2/SimplexSeedGenerator.h");
  G__add_compiledheader("Minuit2/SinParameterTransformation.h");
  G__add_compiledheader("Minuit2/SqrtLowParameterTransformation.h");
  G__add_compiledheader("Minuit2/SqrtUpParameterTransformation.h");
  G__add_compiledheader("Minuit2/StackAllocator.h");
  G__add_compiledheader("Minuit2/VariableMetricBuilder.h");
  G__add_compiledheader("Minuit2/VariableMetricEDMEstimator.h");
  G__add_compiledheader("Minuit2/VariableMetricMinimizer.h");
  G__add_compiledheader("Minuit2/VectorOuterProduct.h");
  G__cpp_reset_tagtableG__Minuit2();
}
#include <new>
extern "C" int G__cpp_dllrevG__Minuit2() { return(30051515); }

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

/* ROOT::Minuit2::GenericFunction */
static int G__G__Minuit2_100_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::GenericFunction*) G__getstructoffset())->operator()(*(vector<double>*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


/* ROOT::Minuit2::FCNBase */
static int G__G__Minuit2_105_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::FCNBase*) G__getstructoffset())->ErrorDef());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_105_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::FCNBase*) G__getstructoffset())->Up());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_105_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::FCNBase*) G__getstructoffset())->SetErrorDef((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


/* ROOT::Minuit2::FCNGradientBase */
static int G__G__Minuit2_121_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>* pobj;
         const vector<double> xobj = ((const ROOT::Minuit2::FCNGradientBase*) G__getstructoffset())->Gradient(*(vector<double>*) libp->para[0].ref);
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_121_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::FCNGradientBase*) G__getstructoffset())->CheckGradient());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

static int G__G__Minuit2_122_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::FCNBase& obj = ((const TFcnAdapter*) G__getstructoffset())->Base();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


/* ROOT::Minuit2::MinuitParameter */
static int G__G__Minuit2_173_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MinuitParameter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::MinuitParameter(
(unsigned int) G__int(libp->para[0]), *(string*) libp->para[1].ref
, (double) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) ROOT::Minuit2::MinuitParameter(
(unsigned int) G__int(libp->para[0]), *(string*) libp->para[1].ref
, (double) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuitParameter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MinuitParameter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::MinuitParameter(
(unsigned int) G__int(libp->para[0]), *(string*) libp->para[1].ref
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
   } else {
     p = new((void*) gvp) ROOT::Minuit2::MinuitParameter(
(unsigned int) G__int(libp->para[0]), *(string*) libp->para[1].ref
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuitParameter));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MinuitParameter* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 6
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::MinuitParameter(
(unsigned int) G__int(libp->para[0]), *(string*) libp->para[1].ref
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (double) G__double(libp->para[4]), (double) G__double(libp->para[5]));
   } else {
     p = new((void*) gvp) ROOT::Minuit2::MinuitParameter(
(unsigned int) G__int(libp->para[0]), *(string*) libp->para[1].ref
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (double) G__double(libp->para[4]), (double) G__double(libp->para[5]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuitParameter));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Minuit2_173_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MinuitParameter*) G__getstructoffset())->Number());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((const ROOT::Minuit2::MinuitParameter*) G__getstructoffset())->GetName();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const ROOT::Minuit2::MinuitParameter*) G__getstructoffset())->Name());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MinuitParameter*) G__getstructoffset())->Value());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MinuitParameter*) G__getstructoffset())->Error());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MinuitParameter*) G__getstructoffset())->SetValue((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MinuitParameter*) G__getstructoffset())->SetError((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MinuitParameter*) G__getstructoffset())->SetLimits((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MinuitParameter*) G__getstructoffset())->SetUpperLimit((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MinuitParameter*) G__getstructoffset())->SetLowerLimit((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MinuitParameter*) G__getstructoffset())->RemoveLimits();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MinuitParameter*) G__getstructoffset())->Fix();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MinuitParameter*) G__getstructoffset())->Release();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::MinuitParameter*) G__getstructoffset())->IsConst());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::MinuitParameter*) G__getstructoffset())->IsFixed());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::MinuitParameter*) G__getstructoffset())->HasLimits());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::MinuitParameter*) G__getstructoffset())->HasLowerLimit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::MinuitParameter*) G__getstructoffset())->HasUpperLimit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MinuitParameter*) G__getstructoffset())->LowerLimit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_173_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MinuitParameter*) G__getstructoffset())->UpperLimit());
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__G__Minuit2_188_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnUserParameters* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::MnUserParameters(*(vector<double>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) ROOT::Minuit2::MnUserParameters(*(vector<double>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameters));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Minuit2_188_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MnUserTransformation& obj = ((const ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->Trafo();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->VariableParameters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<ROOT::Minuit2::MinuitParameter>& obj = ((const ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->Parameters();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>* pobj;
         const vector<double> xobj = ((const ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->Params();
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>* pobj;
         const vector<double> xobj = ((const ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->Errors();
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MinuitParameter& obj = ((const ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->Parameter((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->Add(*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->Add(*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (double) G__double(libp->para[4])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->Add(*(string*) libp->para[0].ref, (double) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->Fix((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->Release((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->SetValue((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->SetError((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->SetLimits((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->SetUpperLimit((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->SetLowerLimit((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->RemoveLimits((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->Value((unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->Error((unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->Fix(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->Release(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->SetValue(*(string*) libp->para[0].ref, (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->SetError(*(string*) libp->para[0].ref, (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->SetLimits(*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->SetUpperLimit(*(string*) libp->para[0].ref, (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->SetLowerLimit(*(string*) libp->para[0].ref, (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->RemoveLimits(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->Value(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->Error(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->Index(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((const ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->GetName((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->Name((unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MnMachinePrecision& obj = ((const ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->Precision();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_188_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameters*) G__getstructoffset())->SetPrecision((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__G__Minuit2_191_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnUserParameterState* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::MnUserParameterState(*(vector<double>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) ROOT::Minuit2::MnUserParameterState(*(vector<double>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Minuit2_191_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnUserParameterState* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::MnUserParameterState(
*(vector<double>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) ROOT::Minuit2::MnUserParameterState(
*(vector<double>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnUserParameterState* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::MnUserParameterState(*(vector<double>*) libp->para[0].ref, *(ROOT::Minuit2::MnUserCovariance*) libp->para[1].ref);
   } else {
     p = new((void*) gvp) ROOT::Minuit2::MnUserParameterState(*(vector<double>*) libp->para[0].ref, *(ROOT::Minuit2::MnUserCovariance*) libp->para[1].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Minuit2_191_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnUserParameterState* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::MnUserParameterState(
*(ROOT::Minuit2::MinimumState*) libp->para[0].ref, (double) G__double(libp->para[1])
, *(ROOT::Minuit2::MnUserTransformation*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) ROOT::Minuit2::MnUserParameterState(
*(ROOT::Minuit2::MinimumState*) libp->para[0].ref, (double) G__double(libp->para[1])
, *(ROOT::Minuit2::MnUserTransformation*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Minuit2_191_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MnUserParameters& obj = ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Parameters();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MnUserCovariance& obj = ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Covariance();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MnGlobalCorrelationCoeff& obj = ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->GlobalCC();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>& obj = ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->IntParameters();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MnUserCovariance& obj = ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->IntCovariance();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MnUserTransformation& obj = ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Trafo();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->IsValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->HasCovariance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->HasGlobalCC());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Fval());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Edm());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->NFcn());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<ROOT::Minuit2::MinuitParameter>& obj = ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->MinuitParameters();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>* pobj;
         const vector<double> xobj = ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Params();
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>* pobj;
         const vector<double> xobj = ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Errors();
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MinuitParameter& obj = ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Parameter((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Add(*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Add(*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (double) G__double(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Add(*(string*) libp->para[0].ref, (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Fix((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Release((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->SetValue((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->SetError((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->SetLimits((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->SetUpperLimit((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->SetLowerLimit((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->RemoveLimits((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Value((unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Error((unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Fix(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Release(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->SetValue(*(string*) libp->para[0].ref, (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->SetError(*(string*) libp->para[0].ref, (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->SetLimits(*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->SetUpperLimit(*(string*) libp->para[0].ref, (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->SetLowerLimit(*(string*) libp->para[0].ref, (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_46(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->RemoveLimits(*(string*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_47(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Value(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Error(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_49(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Index(*(string*) libp->para[0].ref));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_50(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const string& obj = ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->GetName((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_51(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Name((unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_52(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Int2ext((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_53(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Ext2int((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_54(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->IntOfExt((unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_55(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->ExtOfInt((unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_56(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->VariableParameters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_57(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MnMachinePrecision& obj = ((const ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->Precision();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_191_0_58(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnUserParameterState*) G__getstructoffset())->SetPrecision((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__G__Minuit2_196_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MinosError* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::MinosError(
(unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])
, *(ROOT::Minuit2::MnCross*) libp->para[2].ref, *(ROOT::Minuit2::MnCross*) libp->para[3].ref);
   } else {
     p = new((void*) gvp) ROOT::Minuit2::MinosError(
(unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])
, *(ROOT::Minuit2::MnCross*) libp->para[2].ref, *(ROOT::Minuit2::MnCross*) libp->para[3].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinosError));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Minuit2_196_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const pair<double,double>* pobj;
         const pair<double,double> xobj = ((const ROOT::Minuit2::MinosError*) G__getstructoffset())->operator()();
         pobj = new pair<double,double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_196_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MinosError*) G__getstructoffset())->Lower());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_196_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MinosError*) G__getstructoffset())->Upper());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_196_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MinosError*) G__getstructoffset())->Parameter());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_196_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MnUserParameterState& obj = ((const ROOT::Minuit2::MinosError*) G__getstructoffset())->LowerState();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_196_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MnUserParameterState& obj = ((const ROOT::Minuit2::MinosError*) G__getstructoffset())->UpperState();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_196_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::MinosError*) G__getstructoffset())->IsValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_196_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::MinosError*) G__getstructoffset())->LowerValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_196_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::MinosError*) G__getstructoffset())->UpperValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_196_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::MinosError*) G__getstructoffset())->AtLowerLimit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_196_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::MinosError*) G__getstructoffset())->AtUpperLimit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_196_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::MinosError*) G__getstructoffset())->AtLowerMaxFcn());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_196_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::MinosError*) G__getstructoffset())->AtUpperMaxFcn());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_196_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::MinosError*) G__getstructoffset())->LowerNewMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_196_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::MinosError*) G__getstructoffset())->UpperNewMin());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_196_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MinosError*) G__getstructoffset())->NFcn());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_196_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MinosError*) G__getstructoffset())->Min());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


/* ROOT::Minuit2::FunctionMinimum */
static int G__G__Minuit2_198_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::FunctionMinimum* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 2
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::FunctionMinimum(*(ROOT::Minuit2::MinimumSeed*) libp->para[0].ref, (double) G__double(libp->para[1]));
   } else {
     p = new((void*) gvp) ROOT::Minuit2::FunctionMinimum(*(ROOT::Minuit2::MinimumSeed*) libp->para[0].ref, (double) G__double(libp->para[1]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::FunctionMinimum* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::FunctionMinimum(
*(ROOT::Minuit2::MinimumSeed*) libp->para[0].ref, *(vector<MinimumState>*) libp->para[1].ref
, (double) G__double(libp->para[2]));
   } else {
     p = new((void*) gvp) ROOT::Minuit2::FunctionMinimum(
*(ROOT::Minuit2::MinimumSeed*) libp->para[0].ref, *(vector<MinimumState>*) libp->para[1].ref
, (double) G__double(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::FunctionMinimum* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::FunctionMinimum(
*(ROOT::Minuit2::MinimumSeed*) libp->para[0].ref, *(vector<MinimumState>*) libp->para[1].ref
, (double) G__double(libp->para[2]), *((ROOT::Minuit2::FunctionMinimum::MnReachedCallLimit*) G__int(libp->para[3])));
   } else {
     p = new((void*) gvp) ROOT::Minuit2::FunctionMinimum(
*(ROOT::Minuit2::MinimumSeed*) libp->para[0].ref, *(vector<MinimumState>*) libp->para[1].ref
, (double) G__double(libp->para[2]), *((ROOT::Minuit2::FunctionMinimum::MnReachedCallLimit*) G__int(libp->para[3])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::FunctionMinimum* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 4
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::FunctionMinimum(
*(ROOT::Minuit2::MinimumSeed*) libp->para[0].ref, *(vector<MinimumState>*) libp->para[1].ref
, (double) G__double(libp->para[2]), *((ROOT::Minuit2::FunctionMinimum::MnAboveMaxEdm*) G__int(libp->para[3])));
   } else {
     p = new((void*) gvp) ROOT::Minuit2::FunctionMinimum(
*(ROOT::Minuit2::MinimumSeed*) libp->para[0].ref, *(vector<MinimumState>*) libp->para[1].ref
, (double) G__double(libp->para[2]), *((ROOT::Minuit2::FunctionMinimum::MnAboveMaxEdm*) G__int(libp->para[3])));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Minuit2_198_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->Add(*(ROOT::Minuit2::MinimumState*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MinimumSeed& obj = ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->Seed();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<ROOT::Minuit2::MinimumState>& obj = ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->States();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MnUserParameterState& obj = ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->UserState();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MnUserParameters& obj = ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->UserParameters();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MnUserCovariance& obj = ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->UserCovariance();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MinimumState& obj = ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->State();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MinimumParameters& obj = ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->Parameters();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MinimumError& obj = ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->Error();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::FunctionGradient& obj = ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->Grad();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->Fval());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->Edm());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->NFcn());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->Up());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->IsValid());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->HasValidParameters());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->HasValidCovariance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->HasAccurateCovar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->HasPosDefCovar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->HasMadePosDefCovar());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->HesseFailed());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->HasCovariance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->IsAboveMaxEdm());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->HasReachedCallLimit());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_198_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::FunctionMinimum*) G__getstructoffset())->SetErrorDef((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* ROOT::Minuit2::FunctionMinimizer */
static int G__G__Minuit2_199_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::FunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3])
, (unsigned int) G__int(libp->para[4]), (double) G__double(libp->para[5]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_199_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::FunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3])
, (unsigned int) G__int(libp->para[4]), (double) G__double(libp->para[5]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_199_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::FunctionMinimizer*) G__getstructoffset())->Minimize(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]), (unsigned int) G__int(libp->para[5])
, (double) G__double(libp->para[6]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_199_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::FunctionMinimizer*) G__getstructoffset())->Minimize(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]), (unsigned int) G__int(libp->para[5])
, (double) G__double(libp->para[6]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

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

static int G__G__Minuit2_205_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MnStrategy*) G__getstructoffset())->Strategy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_205_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MnStrategy*) G__getstructoffset())->GradientNCycles());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_205_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnStrategy*) G__getstructoffset())->GradientStepTolerance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_205_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnStrategy*) G__getstructoffset())->GradientTolerance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_205_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MnStrategy*) G__getstructoffset())->HessianNCycles());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_205_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnStrategy*) G__getstructoffset())->HessianStepTolerance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_205_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnStrategy*) G__getstructoffset())->HessianG2Tolerance());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_205_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MnStrategy*) G__getstructoffset())->HessianGradientNCycles());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_205_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::MnStrategy*) G__getstructoffset())->IsLow());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_205_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::MnStrategy*) G__getstructoffset())->IsMedium());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_205_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 103, (long) ((const ROOT::Minuit2::MnStrategy*) G__getstructoffset())->IsHigh());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_205_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnStrategy*) G__getstructoffset())->SetLowStrategy();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_205_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnStrategy*) G__getstructoffset())->SetMediumStrategy();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_205_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnStrategy*) G__getstructoffset())->SetHighStrategy();
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_205_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnStrategy*) G__getstructoffset())->SetGradientNCycles((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_205_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnStrategy*) G__getstructoffset())->SetGradientStepTolerance((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_205_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnStrategy*) G__getstructoffset())->SetGradientTolerance((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_205_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnStrategy*) G__getstructoffset())->SetHessianNCycles((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_205_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnStrategy*) G__getstructoffset())->SetHessianStepTolerance((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_205_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnStrategy*) G__getstructoffset())->SetHessianG2Tolerance((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_205_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnStrategy*) G__getstructoffset())->SetHessianGradientNCycles((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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


/* ROOT::Minuit2::FumiliFCNBase */
static int G__G__Minuit2_206_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::FumiliFCNBase*) G__getstructoffset())->EvaluateAll(*(vector<double>*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_206_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::FumiliFCNBase*) G__getstructoffset())->Value());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_206_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>& obj = ((const ROOT::Minuit2::FumiliFCNBase*) G__getstructoffset())->Gradient();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_206_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::FumiliFCNBase*) G__getstructoffset())->Hessian((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_206_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((ROOT::Minuit2::FumiliFCNBase*) G__getstructoffset())->Dimension());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


/* ROOT::Minuit2::ModularFunctionMinimizer */
static int G__G__Minuit2_207_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3])
, (unsigned int) G__int(libp->para[4]), (double) G__double(libp->para[5]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 5:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3])
, (unsigned int) G__int(libp->para[4]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref);
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_207_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3])
, (unsigned int) G__int(libp->para[4]), (double) G__double(libp->para[5]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 5:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3])
, (unsigned int) G__int(libp->para[4]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref);
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_207_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]), (unsigned int) G__int(libp->para[5])
, (double) G__double(libp->para[6]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 6:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]), (unsigned int) G__int(libp->para[5]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 5:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref);
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_207_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 7:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]), (unsigned int) G__int(libp->para[5])
, (double) G__double(libp->para[6]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 6:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]), (unsigned int) G__int(libp->para[5]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 5:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref);
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_207_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref, (unsigned int) G__int(libp->para[3])
, (double) G__double(libp->para[4]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_207_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref, (unsigned int) G__int(libp->para[3])
, (double) G__double(libp->para[4]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_207_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, *(ROOT::Minuit2::MnStrategy*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]), (double) G__double(libp->para[5]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 5:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, *(ROOT::Minuit2::MnStrategy*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, *(ROOT::Minuit2::MnStrategy*) libp->para[3].ref);
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_207_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 6:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, *(ROOT::Minuit2::MnStrategy*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]), (double) G__double(libp->para[5]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 5:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, *(ROOT::Minuit2::MnStrategy*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, *(ROOT::Minuit2::MnStrategy*) libp->para[3].ref);
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_207_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref, (unsigned int) G__int(libp->para[3])
, (double) G__double(libp->para[4]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_207_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref, (unsigned int) G__int(libp->para[3])
, (double) G__double(libp->para[4]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_207_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MinimumSeedGenerator& obj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->SeedGenerator();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_207_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MinimumBuilder& obj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Builder();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_207_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::FunctionMinimum* pobj;
         const ROOT::Minuit2::FunctionMinimum xobj = ((const ROOT::Minuit2::ModularFunctionMinimizer*) G__getstructoffset())->Minimize(*(ROOT::Minuit2::MnFcn*) libp->para[0].ref, *(ROOT::Minuit2::GradientCalculator*) libp->para[1].ref
, *(ROOT::Minuit2::MinimumSeed*) libp->para[2].ref, *(ROOT::Minuit2::MnStrategy*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]), (double) G__double(libp->para[5]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

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

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

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

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


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

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

static int G__G__Minuit2_252_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFitterMinuit*) G__getstructoffset())->SetMinuitFCN((ROOT::Minuit2::FCNBase*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_252_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MnUserParameterState& obj = ((const TFitterMinuit*) G__getstructoffset())->State();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Minuit2_252_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letint(result7, 105, (long) ((TFitterMinuit*) G__getstructoffset())->Minimize((int) G__int(libp->para[0]), (double) G__double(libp->para[1])));
      break;
   case 1:
      G__letint(result7, 105, (long) ((TFitterMinuit*) G__getstructoffset())->Minimize((int) G__int(libp->para[0])));
      break;
   case 0:
      G__letint(result7, 105, (long) ((TFitterMinuit*) G__getstructoffset())->Minimize());
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_252_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TFitterMinuit*) G__getstructoffset())->GetStrategy());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_252_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 105, (long) ((TFitterMinuit*) G__getstructoffset())->PrintLevel());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

static int G__G__Minuit2_252_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((TFitterMinuit*) G__getstructoffset())->SetMinimumTolerance((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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


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

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

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

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

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


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

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

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

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

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


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

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

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


/* ROOT::Minuit2::MnApplication */
static int G__G__Minuit2_308_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         ROOT::Minuit2::FunctionMinimum* pobj;
         ROOT::Minuit2::FunctionMinimum xobj = ((ROOT::Minuit2::MnApplication*) G__getstructoffset())->operator()((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         ROOT::Minuit2::FunctionMinimum* pobj;
         ROOT::Minuit2::FunctionMinimum xobj = ((ROOT::Minuit2::MnApplication*) G__getstructoffset())->operator()((unsigned int) G__int(libp->para[0]));
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 0:
      {
         ROOT::Minuit2::FunctionMinimum* pobj;
         ROOT::Minuit2::FunctionMinimum xobj = ((ROOT::Minuit2::MnApplication*) G__getstructoffset())->operator()();
         pobj = new ROOT::Minuit2::FunctionMinimum(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::ModularFunctionMinimizer& obj = ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->Minimizer();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MnMachinePrecision& obj = ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->Precision();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MnUserParameterState& obj = ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->State();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MnUserParameters& obj = ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->Parameters();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MnUserCovariance& obj = ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->Covariance();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::FCNBase& obj = ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->Fcnbase();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MnStrategy& obj = ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->Strategy();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->NumOfCalls());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<ROOT::Minuit2::MinuitParameter>& obj = ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->MinuitParameters();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>* pobj;
         const vector<double> xobj = ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->Params();
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const vector<double>* pobj;
         const vector<double> xobj = ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->Errors();
         pobj = new vector<double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MinuitParameter& obj = ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->Parameter((unsigned int) G__int(libp->para[0]));
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnApplication*) G__getstructoffset())->Add((const char*) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnApplication*) G__getstructoffset())->Add((const char*) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
, (double) G__double(libp->para[4]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnApplication*) G__getstructoffset())->Add((const char*) G__int(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnApplication*) G__getstructoffset())->Fix((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnApplication*) G__getstructoffset())->Release((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnApplication*) G__getstructoffset())->SetValue((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnApplication*) G__getstructoffset())->SetError((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnApplication*) G__getstructoffset())->SetLimits((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnApplication*) G__getstructoffset())->RemoveLimits((unsigned int) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->Value((unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->Error((unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnApplication*) G__getstructoffset())->Fix((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnApplication*) G__getstructoffset())->Release((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnApplication*) G__getstructoffset())->SetValue((const char*) G__int(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnApplication*) G__getstructoffset())->SetError((const char*) G__int(libp->para[0]), (double) G__double(libp->para[1]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnApplication*) G__getstructoffset())->SetLimits((const char*) G__int(libp->para[0]), (double) G__double(libp->para[1])
, (double) G__double(libp->para[2]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnApplication*) G__getstructoffset())->RemoveLimits((const char*) G__int(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((ROOT::Minuit2::MnApplication*) G__getstructoffset())->SetPrecision((double) G__double(libp->para[0]));
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->Value((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->Error((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->Index((const char*) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 67, (long) ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->Name((unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->Int2ext((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->Ext2int((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->IntOfExt((unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->ExtOfInt((unsigned int) G__int(libp->para[0])));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_308_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MnApplication*) G__getstructoffset())->VariableParameters());
   return(1 || funcname || hash || result7 || libp) ;
}

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


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

static int G__G__Minuit2_309_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnContours* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::MnContours(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::FunctionMinimum*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]));
   } else {
     p = new((void*) gvp) ROOT::Minuit2::MnContours(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::FunctionMinimum*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]));
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnContours));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_309_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnContours* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::MnContours(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::FunctionMinimum*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) ROOT::Minuit2::MnContours(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::FunctionMinimum*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnContours));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_309_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      {
         const vector<std::pair<double,double> >* pobj;
         const vector<std::pair<double,double> > xobj = ((const ROOT::Minuit2::MnContours*) G__getstructoffset())->operator()((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, (unsigned int) G__int(libp->para[2]));
         pobj = new vector<std::pair<double,double> >(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         const vector<std::pair<double,double> >* pobj;
         const vector<std::pair<double,double> > xobj = ((const ROOT::Minuit2::MnContours*) G__getstructoffset())->operator()((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
         pobj = new vector<std::pair<double,double> >(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_309_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      {
         const ROOT::Minuit2::ContoursError* pobj;
         const ROOT::Minuit2::ContoursError xobj = ((const ROOT::Minuit2::MnContours*) G__getstructoffset())->Contour((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, (unsigned int) G__int(libp->para[2]));
         pobj = new ROOT::Minuit2::ContoursError(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         const ROOT::Minuit2::ContoursError* pobj;
         const ROOT::Minuit2::ContoursError xobj = ((const ROOT::Minuit2::MnContours*) G__getstructoffset())->Contour((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
         pobj = new ROOT::Minuit2::ContoursError(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_309_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      {
         const ROOT::Minuit2::MnStrategy& obj = ((const ROOT::Minuit2::MnContours*) G__getstructoffset())->Strategy();
         result7->ref = (long) (&obj);
         result7->obj.i = (long) (&obj);
      }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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


/* ROOT::Minuit2::MnFumiliMinimize */
static int G__G__Minuit2_312_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnFumiliMinimize* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnFumiliMinimize(
*(ROOT::Minuit2::FumiliFCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnFumiliMinimize(
*(ROOT::Minuit2::FumiliFCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnFumiliMinimize(
*(ROOT::Minuit2::FumiliFCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnFumiliMinimize(
*(ROOT::Minuit2::FumiliFCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFumiliMinimize));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_312_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnFumiliMinimize* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnFumiliMinimize(
*(ROOT::Minuit2::FumiliFCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnFumiliMinimize(
*(ROOT::Minuit2::FumiliFCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnFumiliMinimize(
*(ROOT::Minuit2::FumiliFCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnFumiliMinimize(
*(ROOT::Minuit2::FumiliFCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFumiliMinimize));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_312_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnFumiliMinimize* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnFumiliMinimize(
*(ROOT::Minuit2::FumiliFCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnFumiliMinimize(
*(ROOT::Minuit2::FumiliFCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnFumiliMinimize(
*(ROOT::Minuit2::FumiliFCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnFumiliMinimize(
*(ROOT::Minuit2::FumiliFCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFumiliMinimize));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Minuit2_312_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnFumiliMinimize* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnFumiliMinimize(
*(ROOT::Minuit2::FumiliFCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnFumiliMinimize(
*(ROOT::Minuit2::FumiliFCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnFumiliMinimize(
*(ROOT::Minuit2::FumiliFCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnFumiliMinimize(
*(ROOT::Minuit2::FumiliFCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFumiliMinimize));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_312_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnFumiliMinimize* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::MnFumiliMinimize(
*(ROOT::Minuit2::FumiliFCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) ROOT::Minuit2::MnFumiliMinimize(
*(ROOT::Minuit2::FumiliFCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFumiliMinimize));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

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

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

static int G__G__Minuit2_314_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      {
         const ROOT::Minuit2::MnUserParameterState* pobj;
         const ROOT::Minuit2::MnUserParameterState xobj = ((const ROOT::Minuit2::MnHesse*) G__getstructoffset())->operator()(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
         pobj = new ROOT::Minuit2::MnUserParameterState(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         const ROOT::Minuit2::MnUserParameterState* pobj;
         const ROOT::Minuit2::MnUserParameterState xobj = ((const ROOT::Minuit2::MnHesse*) G__getstructoffset())->operator()(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref);
         pobj = new ROOT::Minuit2::MnUserParameterState(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_314_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 5:
      {
         const ROOT::Minuit2::MnUserParameterState* pobj;
         const ROOT::Minuit2::MnUserParameterState xobj = ((const ROOT::Minuit2::MnHesse*) G__getstructoffset())->operator()(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]));
         pobj = new ROOT::Minuit2::MnUserParameterState(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 4:
      {
         const ROOT::Minuit2::MnUserParameterState* pobj;
         const ROOT::Minuit2::MnUserParameterState xobj = ((const ROOT::Minuit2::MnHesse*) G__getstructoffset())->operator()(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref);
         pobj = new ROOT::Minuit2::MnUserParameterState(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_314_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      {
         const ROOT::Minuit2::MnUserParameterState* pobj;
         const ROOT::Minuit2::MnUserParameterState xobj = ((const ROOT::Minuit2::MnHesse*) G__getstructoffset())->operator()(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
         pobj = new ROOT::Minuit2::MnUserParameterState(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         const ROOT::Minuit2::MnUserParameterState* pobj;
         const ROOT::Minuit2::MnUserParameterState xobj = ((const ROOT::Minuit2::MnHesse*) G__getstructoffset())->operator()(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
         pobj = new ROOT::Minuit2::MnUserParameterState(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_314_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      {
         const ROOT::Minuit2::MnUserParameterState* pobj;
         const ROOT::Minuit2::MnUserParameterState xobj = ((const ROOT::Minuit2::MnHesse*) G__getstructoffset())->operator()(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]));
         pobj = new ROOT::Minuit2::MnUserParameterState(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         const ROOT::Minuit2::MnUserParameterState* pobj;
         const ROOT::Minuit2::MnUserParameterState xobj = ((const ROOT::Minuit2::MnHesse*) G__getstructoffset())->operator()(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref);
         pobj = new ROOT::Minuit2::MnUserParameterState(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_314_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      {
         const ROOT::Minuit2::MnUserParameterState* pobj;
         const ROOT::Minuit2::MnUserParameterState xobj = ((const ROOT::Minuit2::MnHesse*) G__getstructoffset())->operator()(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
         pobj = new ROOT::Minuit2::MnUserParameterState(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         const ROOT::Minuit2::MnUserParameterState* pobj;
         const ROOT::Minuit2::MnUserParameterState xobj = ((const ROOT::Minuit2::MnHesse*) G__getstructoffset())->operator()(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
         pobj = new ROOT::Minuit2::MnUserParameterState(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_314_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      {
         const ROOT::Minuit2::MnUserParameterState* pobj;
         const ROOT::Minuit2::MnUserParameterState xobj = ((const ROOT::Minuit2::MnHesse*) G__getstructoffset())->operator()(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]));
         pobj = new ROOT::Minuit2::MnUserParameterState(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         const ROOT::Minuit2::MnUserParameterState* pobj;
         const ROOT::Minuit2::MnUserParameterState xobj = ((const ROOT::Minuit2::MnHesse*) G__getstructoffset())->operator()(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref);
         pobj = new ROOT::Minuit2::MnUserParameterState(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_314_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 3:
      ((const ROOT::Minuit2::MnHesse*) G__getstructoffset())->operator()(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::FunctionMinimum*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]));
      G__setnull(result7);
      break;
   case 2:
      ((const ROOT::Minuit2::MnHesse*) G__getstructoffset())->operator()(*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::FunctionMinimum*) libp->para[1].ref);
      G__setnull(result7);
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_314_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      {
         const ROOT::Minuit2::MinimumState* pobj;
         const ROOT::Minuit2::MinimumState xobj = ((const ROOT::Minuit2::MnHesse*) G__getstructoffset())->operator()(*(ROOT::Minuit2::MnFcn*) libp->para[0].ref, *(ROOT::Minuit2::MinimumState*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserTransformation*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
         pobj = new ROOT::Minuit2::MinimumState(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         const ROOT::Minuit2::MinimumState* pobj;
         const ROOT::Minuit2::MinimumState xobj = ((const ROOT::Minuit2::MnHesse*) G__getstructoffset())->operator()(*(ROOT::Minuit2::MnFcn*) libp->para[0].ref, *(ROOT::Minuit2::MinimumState*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserTransformation*) libp->para[2].ref);
         pobj = new ROOT::Minuit2::MinimumState(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_314_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MnHesse*) G__getstructoffset())->Ncycles());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_314_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnHesse*) G__getstructoffset())->Tolerstp());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_314_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnHesse*) G__getstructoffset())->TolerG2());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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


/* ROOT::Minuit2::MnMigrad */
static int G__G__Minuit2_317_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMigrad* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_317_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMigrad* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_317_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMigrad* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Minuit2_317_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMigrad* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_317_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMigrad* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_317_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMigrad* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_317_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMigrad* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_317_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMigrad* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Minuit2_317_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMigrad* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_317_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMigrad* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) ROOT::Minuit2::MnMigrad(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


/* ROOT::Minuit2::MnMinimize */
static int G__G__Minuit2_318_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMinimize* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_318_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMinimize* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_318_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMinimize* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Minuit2_318_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMinimize* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_318_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMinimize* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_318_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMinimize* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_318_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMinimize* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_318_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMinimize* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Minuit2_318_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMinimize* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_318_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMinimize* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) ROOT::Minuit2::MnMinimize(
*(ROOT::Minuit2::FCNGradientBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


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

static int G__G__Minuit2_319_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnMinos* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::MnMinos(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::FunctionMinimum*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) ROOT::Minuit2::MnMinos(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::FunctionMinimum*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinos));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_319_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const pair<double,double>* pobj;
         const pair<double,double> xobj = ((const ROOT::Minuit2::MnMinos*) G__getstructoffset())->operator()((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
         pobj = new pair<double,double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         const pair<double,double>* pobj;
         const pair<double,double> xobj = ((const ROOT::Minuit2::MnMinos*) G__getstructoffset())->operator()((unsigned int) G__int(libp->para[0]));
         pobj = new pair<double,double>(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_319_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnMinos*) G__getstructoffset())->Lower((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnMinos*) G__getstructoffset())->Lower((unsigned int) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_319_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnMinos*) G__getstructoffset())->Upper((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])));
      break;
   case 1:
      G__letdouble(result7, 100, (double) ((const ROOT::Minuit2::MnMinos*) G__getstructoffset())->Upper((unsigned int) G__int(libp->para[0])));
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_319_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const ROOT::Minuit2::MnCross* pobj;
         const ROOT::Minuit2::MnCross xobj = ((const ROOT::Minuit2::MnMinos*) G__getstructoffset())->Loval((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
         pobj = new ROOT::Minuit2::MnCross(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         const ROOT::Minuit2::MnCross* pobj;
         const ROOT::Minuit2::MnCross xobj = ((const ROOT::Minuit2::MnMinos*) G__getstructoffset())->Loval((unsigned int) G__int(libp->para[0]));
         pobj = new ROOT::Minuit2::MnCross(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_319_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const ROOT::Minuit2::MnCross* pobj;
         const ROOT::Minuit2::MnCross xobj = ((const ROOT::Minuit2::MnMinos*) G__getstructoffset())->Upval((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
         pobj = new ROOT::Minuit2::MnCross(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         const ROOT::Minuit2::MnCross* pobj;
         const ROOT::Minuit2::MnCross xobj = ((const ROOT::Minuit2::MnMinos*) G__getstructoffset())->Upval((unsigned int) G__int(libp->para[0]));
         pobj = new ROOT::Minuit2::MnCross(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_319_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 2:
      {
         const ROOT::Minuit2::MinosError* pobj;
         const ROOT::Minuit2::MinosError xobj = ((const ROOT::Minuit2::MnMinos*) G__getstructoffset())->Minos((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
         pobj = new ROOT::Minuit2::MinosError(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         const ROOT::Minuit2::MinosError* pobj;
         const ROOT::Minuit2::MinosError xobj = ((const ROOT::Minuit2::MnMinos*) G__getstructoffset())->Minos((unsigned int) G__int(libp->para[0]));
         pobj = new ROOT::Minuit2::MinosError(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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


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

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

static int G__G__Minuit2_323_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const ROOT::Minuit2::MnPlot*) G__getstructoffset())->operator()(*(vector<std::pair<double,double> >*) libp->para[0].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_323_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      ((const ROOT::Minuit2::MnPlot*) G__getstructoffset())->operator()((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
, *(vector<std::pair<double,double> >*) libp->para[2].ref);
      G__setnull(result7);
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_323_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MnPlot*) G__getstructoffset())->Width());
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_323_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
      G__letint(result7, 104, (long) ((const ROOT::Minuit2::MnPlot*) G__getstructoffset())->Length());
   return(1 || funcname || hash || result7 || libp) ;
}

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

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

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

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


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

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

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

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

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


/* ROOT::Minuit2::MnScan */
static int G__G__Minuit2_327_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnScan* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnScan(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnScan(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnScan(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnScan(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnScan));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_327_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnScan* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnScan(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnScan(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnScan(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnScan(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnScan));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_327_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnScan* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnScan(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnScan(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnScan(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnScan(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnScan));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Minuit2_327_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnScan* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnScan(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnScan(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnScan(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnScan(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnScan));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_327_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnScan* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::MnScan(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) ROOT::Minuit2::MnScan(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnScan));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Minuit2_327_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   switch (libp->paran) {
   case 4:
      {
         vector<std::pair<double,double> >* pobj;
         vector<std::pair<double,double> > xobj = ((ROOT::Minuit2::MnScan*) G__getstructoffset())->Scan((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
         pobj = new vector<std::pair<double,double> >(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 3:
      {
         vector<std::pair<double,double> >* pobj;
         vector<std::pair<double,double> > xobj = ((ROOT::Minuit2::MnScan*) G__getstructoffset())->Scan((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
, (double) G__double(libp->para[2]));
         pobj = new vector<std::pair<double,double> >(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 2:
      {
         vector<std::pair<double,double> >* pobj;
         vector<std::pair<double,double> > xobj = ((ROOT::Minuit2::MnScan*) G__getstructoffset())->Scan((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
         pobj = new vector<std::pair<double,double> >(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   case 1:
      {
         vector<std::pair<double,double> >* pobj;
         vector<std::pair<double,double> > xobj = ((ROOT::Minuit2::MnScan*) G__getstructoffset())->Scan((unsigned int) G__int(libp->para[0]));
         pobj = new vector<std::pair<double,double> >(xobj);
         result7->obj.i = (long) ((void*) pobj);
         result7->ref = result7->obj.i;
         G__store_tempobject(*result7);
      }
      break;
   }
   return(1 || funcname || hash || result7 || libp) ;
}

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


/* ROOT::Minuit2::MnSimplex */
static int G__G__Minuit2_328_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnSimplex* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnSimplex(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnSimplex(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnSimplex(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnSimplex(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(vector<double>*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSimplex));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_328_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnSimplex* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 5:
     //m: 5
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnSimplex(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnSimplex(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref
, (unsigned int) G__int(libp->para[4]));
     }
     break;
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnSimplex(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnSimplex(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, (unsigned int) G__int(libp->para[2]), *(vector<double>*) libp->para[3].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSimplex));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_328_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnSimplex* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnSimplex(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnSimplex(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnSimplex(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnSimplex(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSimplex));
   return(1 || funcname || hash || result7 || libp) ;
}

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

static int G__G__Minuit2_328_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnSimplex* p = NULL;
   char* gvp = (char*) G__getgvp();
   switch (libp->paran) {
   case 4:
     //m: 4
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnSimplex(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnSimplex(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref, (unsigned int) G__int(libp->para[3]));
     }
     break;
   case 3:
     //m: 3
     if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
       p = new ROOT::Minuit2::MnSimplex(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     } else {
       p = new((void*) gvp) ROOT::Minuit2::MnSimplex(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameters*) libp->para[1].ref
, *(ROOT::Minuit2::MnUserCovariance*) libp->para[2].ref);
     }
     break;
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSimplex));
   return(1 || funcname || hash || result7 || libp) ;
}

static int G__G__Minuit2_328_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
{
   ROOT::Minuit2::MnSimplex* p = NULL;
   char* gvp = (char*) G__getgvp();
   //m: 3
   if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
     p = new ROOT::Minuit2::MnSimplex(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
   } else {
     p = new((void*) gvp) ROOT::Minuit2::MnSimplex(
*(ROOT::Minuit2::FCNBase*) libp->para[0].ref, *(ROOT::Minuit2::MnUserParameterState*) libp->para[1].ref
, *(ROOT::Minuit2::MnStrategy*) libp->para[2].ref);
   }
   result7->obj.i = (long) p;
   result7->ref = (long) p;
   G__set_tagnum(result7,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSimplex));
   return(1 || funcname || hash || result7 || libp) ;
}

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

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


/* Setting up global function */

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

/* ROOT::Minuit2::GenericFunction */

/* ROOT::Minuit2::FCNBase */

/* ROOT::Minuit2::FCNGradientBase */

/* TFcnAdapter */

/* ROOT::Minuit2::MinuitParameter */

/* ROOT::Minuit2::MnUserParameters */

/* ROOT::Minuit2::MnUserParameterState */

/* ROOT::Minuit2::MinosError */

/* ROOT::Minuit2::FunctionMinimum */

/* ROOT::Minuit2::FunctionMinimizer */

/* ROOT::Minuit2::MnStrategy */

/* ROOT::Minuit2::FumiliFCNBase */

/* ROOT::Minuit2::ModularFunctionMinimizer */

/* ROOT::Minuit2::FumiliMinimizer */

/* TFitterMinuit */

/* TFitterFumili */

/* ROOT::Minuit2::VariableMetricMinimizer */

/* ROOT::Minuit2::SimplexMinimizer */

/* ROOT::Minuit2::CombinedMinimizer */

/* ROOT::Minuit2::Minuit2Minimizer */

/* ROOT::Minuit2::MnApplication */

/* ROOT::Minuit2::MnContours */

/* ROOT::Minuit2::MnFumiliMinimize */

/* ROOT::Minuit2::MnHesse */

/* ROOT::Minuit2::MnMigrad */

/* ROOT::Minuit2::MnMinimize */

/* ROOT::Minuit2::MnMinos */

/* ROOT::Minuit2::MnPlot */

/* ROOT::Minuit2::ScanMinimizer */

/* ROOT::Minuit2::MnScan */

/* ROOT::Minuit2::MnSimplex */

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

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

size_t G__get_sizep2memfuncG__Minuit2()
{
  G__Sizep2memfuncG__Minuit2 a;
  G__setsizep2memfunc((int)a.sizep2memfunc());
  return((size_t)a.sizep2memfunc());
}


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

   /* Setting up class inheritance */

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

   /* Setting up class inheritance */
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNBase))) {
     ROOT::Minuit2::FCNBase *G__Lderived;
     G__Lderived=(ROOT::Minuit2::FCNBase*)0x1000;
     {
       ROOT::Minuit2::GenericFunction *G__Lpbase=(ROOT::Minuit2::GenericFunction*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNBase),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLGenericFunction),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNGradientBase))) {
     ROOT::Minuit2::FCNGradientBase *G__Lderived;
     G__Lderived=(ROOT::Minuit2::FCNGradientBase*)0x1000;
     {
       ROOT::Minuit2::FCNBase *G__Lpbase=(ROOT::Minuit2::FCNBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNGradientBase),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       ROOT::Minuit2::GenericFunction *G__Lpbase=(ROOT::Minuit2::GenericFunction*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNGradientBase),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLGenericFunction),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Minuit2LN_TFcnAdapter))) {
     TFcnAdapter *G__Lderived;
     G__Lderived=(TFcnAdapter*)0x1000;
     {
       ROOT::Minuit2::FCNGradientBase *G__Lpbase=(ROOT::Minuit2::FCNGradientBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_TFcnAdapter),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNGradientBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       ROOT::Minuit2::FCNBase *G__Lpbase=(ROOT::Minuit2::FCNBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_TFcnAdapter),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNBase),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       ROOT::Minuit2::GenericFunction *G__Lpbase=(ROOT::Minuit2::GenericFunction*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_TFcnAdapter),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLGenericFunction),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliFCNBase))) {
     ROOT::Minuit2::FumiliFCNBase *G__Lderived;
     G__Lderived=(ROOT::Minuit2::FumiliFCNBase*)0x1000;
     {
       ROOT::Minuit2::FCNBase *G__Lpbase=(ROOT::Minuit2::FCNBase*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliFCNBase),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNBase),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       ROOT::Minuit2::GenericFunction *G__Lpbase=(ROOT::Minuit2::GenericFunction*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliFCNBase),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLGenericFunction),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer))) {
     ROOT::Minuit2::ModularFunctionMinimizer *G__Lderived;
     G__Lderived=(ROOT::Minuit2::ModularFunctionMinimizer*)0x1000;
     {
       ROOT::Minuit2::FunctionMinimizer *G__Lpbase=(ROOT::Minuit2::FunctionMinimizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliMinimizer))) {
     ROOT::Minuit2::FumiliMinimizer *G__Lderived;
     G__Lderived=(ROOT::Minuit2::FumiliMinimizer*)0x1000;
     {
       ROOT::Minuit2::ModularFunctionMinimizer *G__Lpbase=(ROOT::Minuit2::ModularFunctionMinimizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliMinimizer),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       ROOT::Minuit2::FunctionMinimizer *G__Lpbase=(ROOT::Minuit2::FunctionMinimizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliMinimizer),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimizer),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Minuit2LN_TFitterMinuit))) {
     TFitterMinuit *G__Lderived;
     G__Lderived=(TFitterMinuit*)0x1000;
     {
       TVirtualFitter *G__Lpbase=(TVirtualFitter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_TFitterMinuit),G__get_linked_tagnum(&G__G__Minuit2LN_TVirtualFitter),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_TFitterMinuit),G__get_linked_tagnum(&G__G__Minuit2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_TFitterMinuit),G__get_linked_tagnum(&G__G__Minuit2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Minuit2LN_TFitterFumili))) {
     TFitterFumili *G__Lderived;
     G__Lderived=(TFitterFumili*)0x1000;
     {
       TFitterMinuit *G__Lpbase=(TFitterMinuit*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_TFitterFumili),G__get_linked_tagnum(&G__G__Minuit2LN_TFitterMinuit),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       TVirtualFitter *G__Lpbase=(TVirtualFitter*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_TFitterFumili),G__get_linked_tagnum(&G__G__Minuit2LN_TVirtualFitter),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TNamed *G__Lpbase=(TNamed*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_TFitterFumili),G__get_linked_tagnum(&G__G__Minuit2LN_TNamed),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
     {
       TObject *G__Lpbase=(TObject*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_TFitterFumili),G__get_linked_tagnum(&G__G__Minuit2LN_TObject),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLVariableMetricMinimizer))) {
     ROOT::Minuit2::VariableMetricMinimizer *G__Lderived;
     G__Lderived=(ROOT::Minuit2::VariableMetricMinimizer*)0x1000;
     {
       ROOT::Minuit2::ModularFunctionMinimizer *G__Lpbase=(ROOT::Minuit2::ModularFunctionMinimizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLVariableMetricMinimizer),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       ROOT::Minuit2::FunctionMinimizer *G__Lpbase=(ROOT::Minuit2::FunctionMinimizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLVariableMetricMinimizer),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimizer),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexMinimizer))) {
     ROOT::Minuit2::SimplexMinimizer *G__Lderived;
     G__Lderived=(ROOT::Minuit2::SimplexMinimizer*)0x1000;
     {
       ROOT::Minuit2::ModularFunctionMinimizer *G__Lpbase=(ROOT::Minuit2::ModularFunctionMinimizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexMinimizer),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       ROOT::Minuit2::FunctionMinimizer *G__Lpbase=(ROOT::Minuit2::FunctionMinimizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexMinimizer),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimizer),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLCombinedMinimizer))) {
     ROOT::Minuit2::CombinedMinimizer *G__Lderived;
     G__Lderived=(ROOT::Minuit2::CombinedMinimizer*)0x1000;
     {
       ROOT::Minuit2::ModularFunctionMinimizer *G__Lpbase=(ROOT::Minuit2::ModularFunctionMinimizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLCombinedMinimizer),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       ROOT::Minuit2::FunctionMinimizer *G__Lpbase=(ROOT::Minuit2::FunctionMinimizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLCombinedMinimizer),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimizer),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuit2Minimizer))) {
     ROOT::Minuit2::Minuit2Minimizer *G__Lderived;
     G__Lderived=(ROOT::Minuit2::Minuit2Minimizer*)0x1000;
     {
       ROOT::Math::Minimizer *G__Lpbase=(ROOT::Math::Minimizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuit2Minimizer),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMathcLcLMinimizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFumiliMinimize))) {
     ROOT::Minuit2::MnFumiliMinimize *G__Lderived;
     G__Lderived=(ROOT::Minuit2::MnFumiliMinimize*)0x1000;
     {
       ROOT::Minuit2::MnApplication *G__Lpbase=(ROOT::Minuit2::MnApplication*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFumiliMinimize),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnApplication),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad))) {
     ROOT::Minuit2::MnMigrad *G__Lderived;
     G__Lderived=(ROOT::Minuit2::MnMigrad*)0x1000;
     {
       ROOT::Minuit2::MnApplication *G__Lpbase=(ROOT::Minuit2::MnApplication*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnApplication),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize))) {
     ROOT::Minuit2::MnMinimize *G__Lderived;
     G__Lderived=(ROOT::Minuit2::MnMinimize*)0x1000;
     {
       ROOT::Minuit2::MnApplication *G__Lpbase=(ROOT::Minuit2::MnApplication*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnApplication),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLScanMinimizer))) {
     ROOT::Minuit2::ScanMinimizer *G__Lderived;
     G__Lderived=(ROOT::Minuit2::ScanMinimizer*)0x1000;
     {
       ROOT::Minuit2::ModularFunctionMinimizer *G__Lpbase=(ROOT::Minuit2::ModularFunctionMinimizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLScanMinimizer),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
     {
       ROOT::Minuit2::FunctionMinimizer *G__Lpbase=(ROOT::Minuit2::FunctionMinimizer*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLScanMinimizer),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimizer),(long)G__Lpbase-(long)G__Lderived,1,0);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnScan))) {
     ROOT::Minuit2::MnScan *G__Lderived;
     G__Lderived=(ROOT::Minuit2::MnScan*)0x1000;
     {
       ROOT::Minuit2::MnApplication *G__Lpbase=(ROOT::Minuit2::MnApplication*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnScan),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnApplication),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
   if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSimplex))) {
     ROOT::Minuit2::MnSimplex *G__Lderived;
     G__Lderived=(ROOT::Minuit2::MnSimplex*)0x1000;
     {
       ROOT::Minuit2::MnApplication *G__Lpbase=(ROOT::Minuit2::MnApplication*)G__Lderived;
       G__inheritance_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSimplex),G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnApplication),(long)G__Lpbase-(long)G__Lderived,1,1);
     }
   }
}

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

   /* Setting up typedef entry */
   G__search_typename2("Int_t",105,-1,0,-1);
   G__setnewtype(-1,"Signed integer 4 bytes (int)",0);
   G__search_typename2("Version_t",115,-1,0,-1);
   G__setnewtype(-1,"Class version identifier (short)",0);
   G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Minuit2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Minuit2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Minuit2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Minuit2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<double>",117,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Minuit2LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Minuit2LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<CoordData>",117,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Minuit2LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Minuit2LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<vector<double,allocator<double> > >",117,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("void (*)(int&, double*, double&, double*, int)",49,-1,0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("MatrixInverse<sym,ABObj<sym,LASymMatrix,double>,double>",117,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMatrixInverselEROOTcLcLMinuit2cLcLsymcOROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOdoublegR),0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ABObj<sym,MatrixInverse<sym,ABObj<sym,LASymMatrix,double>,double>,double>",117,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABObjlEROOTcLcLMinuit2cLcLsymcOROOTcLcLMinuit2cLcLMatrixInverselEROOTcLcLMinuit2cLcLsymcOROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOdoublegRcOdoublegR),0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("VectorOuterProduct<ABObj<vec,LAVector,double>,double>",117,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLVectorOuterProductlEROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRcOdoublegR),0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ABObj<sym,VectorOuterProduct<ABObj<vec,LAVector,double>,double>,double>",117,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABObjlEROOTcLcLMinuit2cLcLsymcOROOTcLcLMinuit2cLcLVectorOuterProductlEROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRcOdoublegRcOdoublegR),0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<MinuitParameter>",117,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinuitParametercOallocatorlEROOTcLcLMinuit2cLcLMinuitParametergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Minuit2LN_reverse_iteratorlEvectorlEROOTcLcLMinuit2cLcLMinuitParametercOallocatorlEROOTcLcLMinuit2cLcLMinuitParametergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinuitParametercOallocatorlEROOTcLcLMinuit2cLcLMinuitParametergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Minuit2LN_reverse_iteratorlEvectorlEROOTcLcLMinuit2cLcLMinuitParametercOallocatorlEROOTcLcLMinuit2cLcLMinuitParametergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinuitParametercOallocatorlEROOTcLcLMinuit2cLcLMinuitParametergRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<ROOT::Minuit2::MinuitParameter>",117,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinuitParametercOallocatorlEROOTcLcLMinuit2cLcLMinuitParametergRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Minuit2LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Minuit2LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ABSum<ABObj<vec,LAVector,double>,ABObj<vec,LAVector,double> >",117,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABSumlEROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRsPgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ABObj<vec,ABSum<ABObj<vec,LAVector,double>,ABObj<vec,LAVector,double> >,double>",117,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABObjlEROOTcLcLMinuit2cLcLveccOROOTcLcLMinuit2cLcLABSumlEROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRsPgRcOdoublegR),0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ABSum<ABObj<sym,LASymMatrix,double>,ABObj<sym,LASymMatrix,double> >",117,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABSumlEROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRsPgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ABObj<sym,ABSum<ABObj<sym,LASymMatrix,double>,ABObj<sym,LASymMatrix,double> >,double>",117,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABObjlEROOTcLcLMinuit2cLcLsymcOROOTcLcLMinuit2cLcLABSumlEROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRsPgRcOdoublegR),0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<MinimumState>",117,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinimumStatecOallocatorlEROOTcLcLMinuit2cLcLMinimumStategRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Minuit2LN_reverse_iteratorlEvectorlEROOTcLcLMinuit2cLcLMinimumStatecOallocatorlEROOTcLcLMinuit2cLcLMinimumStategRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinimumStatecOallocatorlEROOTcLcLMinuit2cLcLMinimumStategRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Minuit2LN_reverse_iteratorlEvectorlEROOTcLcLMinuit2cLcLMinimumStatecOallocatorlEROOTcLcLMinuit2cLcLMinimumStategRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinimumStatecOallocatorlEROOTcLcLMinuit2cLcLMinimumStategRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<ROOT::Minuit2::MinimumState>",117,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinimumStatecOallocatorlEROOTcLcLMinuit2cLcLMinimumStategRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("MnRefCountedPointer<BasicFunctionMinimum>",117,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnRefCountedPointerlEROOTcLcLMinuit2cLcLBasicFunctionMinimumgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<ROOT::Minuit2::MinosError>",117,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinosErrorcOallocatorlEROOTcLcLMinuit2cLcLMinosErrorgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Minuit2LN_reverse_iteratorlEvectorlEROOTcLcLMinuit2cLcLMinosErrorcOallocatorlEROOTcLcLMinuit2cLcLMinosErrorgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinosErrorcOallocatorlEROOTcLcLMinuit2cLcLMinosErrorgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Minuit2LN_reverse_iteratorlEvectorlEROOTcLcLMinuit2cLcLMinosErrorcOallocatorlEROOTcLcLMinuit2cLcLMinosErrorgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinosErrorcOallocatorlEROOTcLcLMinuit2cLcLMinosErrorgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::pair<double,double> >",117,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Minuit2LN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Minuit2LN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<double,double> >",117,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("BasicFitMethodFunction<ROOT::Math::IMultiGenFunction>",117,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMath));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("BasicFitMethodFunction<ROOT::Math::IMultiGradFunction>",117,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMath));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::vector<double> >",117,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ABProd<ABObj<sym,LASymMatrix,double>,ABObj<vec,LAVector,double> >",117,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABProdlEROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRsPgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("ABObj<AlgebraicProdType<sym,vec>::Type,ABProd<ABObj<sym,LASymMatrix,double>,ABObj<vec,LAVector,double> >,double>",117,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABObjlEROOTcLcLMinuit2cLcLveccOROOTcLcLMinuit2cLcLABProdlEROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRsPgRcOdoublegR),0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<std::pair<double,MnAlgebraicVector> >",117,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRcOallocatorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__Minuit2LN_reverse_iteratorlEvectorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRcOallocatorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRcOallocatorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__Minuit2LN_reverse_iteratorlEvectorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRcOallocatorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRcOallocatorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRsPgRsPgR));
   G__setnewtype(-1,NULL,0);
   G__search_typename2("vector<pair<double,ROOT::Minuit2::LAVector> >",117,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRcOallocatorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRsPgRsPgR),0,-1);
   G__setnewtype(-1,NULL,0);
}

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

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

   /* ROOT::Minuit2::GenericFunction */
static void G__setup_memvarROOTcLcLMinuit2cLcLGenericFunction(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLGenericFunction));
   { ROOT::Minuit2::GenericFunction *p; p=(ROOT::Minuit2::GenericFunction*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::FCNBase */
static void G__setup_memvarROOTcLcLMinuit2cLcLFCNBase(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNBase));
   { ROOT::Minuit2::FCNBase *p; p=(ROOT::Minuit2::FCNBase*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::FCNGradientBase */
static void G__setup_memvarROOTcLcLMinuit2cLcLFCNGradientBase(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNGradientBase));
   { ROOT::Minuit2::FCNGradientBase *p; p=(ROOT::Minuit2::FCNGradientBase*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* TFcnAdapter */
static void G__setup_memvarTFcnAdapter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_TFcnAdapter));
   { TFcnAdapter *p; p=(TFcnAdapter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,49,0,0,-1,G__defined_typename("void (*)(int&, double*, double&, double*, int)"),-1,4,"fFCN=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fUp=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fGradCache=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::MinuitParameter */
static void G__setup_memvarROOTcLcLMinuit2cLcLMinuitParameter(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuitParameter));
   { ROOT::Minuit2::MinuitParameter *p; p=(ROOT::Minuit2::MinuitParameter*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fNum=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fValue=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fError=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fConst=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fFix=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fLoLimit=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fUpLimit=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fLoLimValid=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fUpLimValid=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_string),-1,-1,4,"fName=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::MnUserParameters */
static void G__setup_memvarROOTcLcLMinuit2cLcLMnUserParameters(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameters));
   { ROOT::Minuit2::MnUserParameters *p; p=(ROOT::Minuit2::MnUserParameters*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserTransformation),-1,-1,4,"fTransformation=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::MnUserParameterState */
static void G__setup_memvarROOTcLcLMinuit2cLcLMnUserParameterState(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState));
   { ROOT::Minuit2::MnUserParameterState *p; p=(ROOT::Minuit2::MnUserParameterState*)0x1000; if (p) { }
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fValid=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fCovarianceValid=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fGCCValid=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fFVal=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fEDM=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fNFcn=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameters),-1,-1,4,"fParameters=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserCovariance),-1,-1,4,"fCovariance=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnGlobalCorrelationCoeff),-1,-1,4,"fGlobalCC=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fIntParameters=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserCovariance),-1,-1,4,"fIntCovariance=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::MinosError */
static void G__setup_memvarROOTcLcLMinuit2cLcLMinosError(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinosError));
   { ROOT::Minuit2::MinosError *p; p=(ROOT::Minuit2::MinosError*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fParameter=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fMinValue=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnCross),-1,-1,4,"fUpper=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnCross),-1,-1,4,"fLower=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::FunctionMinimum */
static void G__setup_memvarROOTcLcLMinuit2cLcLFunctionMinimum(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum));
   { ROOT::Minuit2::FunctionMinimum *p; p=(ROOT::Minuit2::FunctionMinimum*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnRefCountedPointerlEROOTcLcLMinuit2cLcLBasicFunctionMinimumgR),G__defined_typename("MnRefCountedPointer<BasicFunctionMinimum>"),-1,4,"fData=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::FunctionMinimizer */
static void G__setup_memvarROOTcLcLMinuit2cLcLFunctionMinimizer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimizer));
   { ROOT::Minuit2::FunctionMinimizer *p; p=(ROOT::Minuit2::FunctionMinimizer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::MnStrategy */
static void G__setup_memvarROOTcLcLMinuit2cLcLMnStrategy(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnStrategy));
   { ROOT::Minuit2::MnStrategy *p; p=(ROOT::Minuit2::MnStrategy*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fStrategy=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fGradNCyc=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fGradTlrStp=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fGradTlr=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fHessNCyc=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fHessTlrStp=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fHessTlrG2=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fHessGradNCyc=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::FumiliFCNBase */
static void G__setup_memvarROOTcLcLMinuit2cLcLFumiliFCNBase(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliFCNBase));
   { ROOT::Minuit2::FumiliFCNBase *p; p=(ROOT::Minuit2::FumiliFCNBase*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fNumberOfParameters=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fValue=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fGradient=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fHessian=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::ModularFunctionMinimizer */
static void G__setup_memvarROOTcLcLMinuit2cLcLModularFunctionMinimizer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer));
   { ROOT::Minuit2::ModularFunctionMinimizer *p; p=(ROOT::Minuit2::ModularFunctionMinimizer*)0x1000; if (p) { }
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::FumiliMinimizer */
static void G__setup_memvarROOTcLcLMinuit2cLcLFumiliMinimizer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliMinimizer));
   { ROOT::Minuit2::FumiliMinimizer *p; p=(ROOT::Minuit2::FumiliMinimizer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSeedGenerator),-1,-1,4,"fMinSeedGen=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliBuilder),-1,-1,4,"fMinBuilder=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFitterMinuit */
static void G__setup_memvarTFitterMinuit(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_TFitterMinuit));
   { TFitterMinuit *p; p=(TFitterMinuit*)0x1000; if (p) { }
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Minuit2LN_TFitterMinuitcLcLEMinimizerType),-1,-2,1,G__FastAllocString(2048).Format("kMigrad=%lldLL",(long long)TFitterMinuit::kMigrad).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Minuit2LN_TFitterMinuitcLcLEMinimizerType),-1,-2,1,G__FastAllocString(2048).Format("kSimplex=%lldLL",(long long)TFitterMinuit::kSimplex).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Minuit2LN_TFitterMinuitcLcLEMinimizerType),-1,-2,1,G__FastAllocString(2048).Format("kCombined=%lldLL",(long long)TFitterMinuit::kCombined).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Minuit2LN_TFitterMinuitcLcLEMinimizerType),-1,-2,1,G__FastAllocString(2048).Format("kScan=%lldLL",(long long)TFitterMinuit::kScan).data(),0,(char*)NULL);
   G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__Minuit2LN_TFitterMinuitcLcLEMinimizerType),-1,-2,1,G__FastAllocString(2048).Format("kFumili=%lldLL",(long long)TFitterMinuit::kFumili).data(),0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fErrorDef=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fEDMVal=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fGradient=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState),-1,-1,4,"fState=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinosErrorcOallocatorlEROOTcLcLMinuit2cLcLMinosErrorgRsPgR),G__defined_typename("vector<ROOT::Minuit2::MinosError>"),-1,4,"fMinosErrors=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer),-1,-1,4,"fMinimizer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNBase),-1,-1,4,"fMinuitFCN=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fDebug=",0,(char*)NULL);
   G__memvar_setup((void*)0,105,0,0,-1,-1,-1,4,"fStrategy=",0,(char*)NULL);
   G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fMinTolerance=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fCovar=",0,"cached covariance matrix (NxN)");
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* TFitterFumili */
static void G__setup_memvarTFitterFumili(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_TFitterFumili));
   { TFitterFumili *p; p=(TFitterFumili*)0x1000; if (p) { }
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_TClass),-1,-2,4,"fgIsA=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::VariableMetricMinimizer */
static void G__setup_memvarROOTcLcLMinuit2cLcLVariableMetricMinimizer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLVariableMetricMinimizer));
   { ROOT::Minuit2::VariableMetricMinimizer *p; p=(ROOT::Minuit2::VariableMetricMinimizer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSeedGenerator),-1,-1,4,"fMinSeedGen=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLVariableMetricBuilder),-1,-1,4,"fMinBuilder=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::SimplexMinimizer */
static void G__setup_memvarROOTcLcLMinuit2cLcLSimplexMinimizer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexMinimizer));
   { ROOT::Minuit2::SimplexMinimizer *p; p=(ROOT::Minuit2::SimplexMinimizer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexSeedGenerator),-1,-1,4,"fSeedGenerator=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexBuilder),-1,-1,4,"fBuilder=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::CombinedMinimizer */
static void G__setup_memvarROOTcLcLMinuit2cLcLCombinedMinimizer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLCombinedMinimizer));
   { ROOT::Minuit2::CombinedMinimizer *p; p=(ROOT::Minuit2::CombinedMinimizer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSeedGenerator),-1,-1,4,"fMinSeedGen=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLCombinedMinimumBuilder),-1,-1,4,"fMinBuilder=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::Minuit2Minimizer */
static void G__setup_memvarROOTcLcLMinuit2cLcLMinuit2Minimizer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuit2Minimizer));
   { ROOT::Minuit2::Minuit2Minimizer *p; p=(ROOT::Minuit2::Minuit2Minimizer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fDim=",0,"dimension of the function to be minimized ");
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fUseFumili=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState),-1,-1,4,"fState=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer),-1,-1,4,"fMinimizer=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNBase),-1,-1,4,"fMinuitFCN=",0,(char*)NULL);
   G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum),-1,-1,4,"fMinimum=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fValues=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fErrors=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::MnApplication */
static void G__setup_memvarROOTcLcLMinuit2cLcLMnApplication(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnApplication));
   { ROOT::Minuit2::MnApplication *p; p=(ROOT::Minuit2::MnApplication*)0x1000; if (p) { }
   G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,1,1,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNBase),-1,-1,2,"fFCN=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState),-1,-1,2,"fState=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnStrategy),-1,-1,2,"fStrategy=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fNumCall=",0,(char*)NULL);
   G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fUseGrad=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::MnContours */
static void G__setup_memvarROOTcLcLMinuit2cLcLMnContours(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnContours));
   { ROOT::Minuit2::MnContours *p; p=(ROOT::Minuit2::MnContours*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,1,1,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNBase),-1,-1,4,"fFCN=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,1,1,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum),-1,-1,4,"fMinimum=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnStrategy),-1,-1,4,"fStrategy=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::MnFumiliMinimize */
static void G__setup_memvarROOTcLcLMinuit2cLcLMnFumiliMinimize(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFumiliMinimize));
   { ROOT::Minuit2::MnFumiliMinimize *p; p=(ROOT::Minuit2::MnFumiliMinimize*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliMinimizer),-1,-1,4,"fMinimizer=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,1,1,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliFCNBase),-1,-1,4,"fFCN=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::MnHesse */
static void G__setup_memvarROOTcLcLMinuit2cLcLMnHesse(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnHesse));
   { ROOT::Minuit2::MnHesse *p; p=(ROOT::Minuit2::MnHesse*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnStrategy),-1,-1,4,"fStrategy=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::MnMigrad */
static void G__setup_memvarROOTcLcLMinuit2cLcLMnMigrad(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad));
   { ROOT::Minuit2::MnMigrad *p; p=(ROOT::Minuit2::MnMigrad*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLVariableMetricMinimizer),-1,-1,4,"fMinimizer=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::MnMinimize */
static void G__setup_memvarROOTcLcLMinuit2cLcLMnMinimize(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize));
   { ROOT::Minuit2::MnMinimize *p; p=(ROOT::Minuit2::MnMinimize*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLCombinedMinimizer),-1,-1,4,"fMinimizer=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::MnMinos */
static void G__setup_memvarROOTcLcLMinuit2cLcLMnMinos(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinos));
   { ROOT::Minuit2::MnMinos *p; p=(ROOT::Minuit2::MnMinos*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,1,1,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNBase),-1,-1,4,"fFCN=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,1,1,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum),-1,-1,4,"fMinimum=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnStrategy),-1,-1,4,"fStrategy=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::MnPlot */
static void G__setup_memvarROOTcLcLMinuit2cLcLMnPlot(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnPlot));
   { ROOT::Minuit2::MnPlot *p; p=(ROOT::Minuit2::MnPlot*)0x1000; if (p) { }
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fPageWidth=",0,(char*)NULL);
   G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fPageLength=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::ScanMinimizer */
static void G__setup_memvarROOTcLcLMinuit2cLcLScanMinimizer(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLScanMinimizer));
   { ROOT::Minuit2::ScanMinimizer *p; p=(ROOT::Minuit2::ScanMinimizer*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexSeedGenerator),-1,-1,4,"fSeedGenerator=",0,(char*)NULL);
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLScanBuilder),-1,-1,4,"fBuilder=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::MnScan */
static void G__setup_memvarROOTcLcLMinuit2cLcLMnScan(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnScan));
   { ROOT::Minuit2::MnScan *p; p=(ROOT::Minuit2::MnScan*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLScanMinimizer),-1,-1,4,"fMinimizer=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}


   /* ROOT::Minuit2::MnSimplex */
static void G__setup_memvarROOTcLcLMinuit2cLcLMnSimplex(void) {
   G__tag_memvar_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSimplex));
   { ROOT::Minuit2::MnSimplex *p; p=(ROOT::Minuit2::MnSimplex*)0x1000; if (p) { }
   G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexMinimizer),-1,-1,4,"fMinimizer=",0,(char*)NULL);
   }
   G__tag_memvar_reset();
}

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

/*********************************************************
* Member function information setup for each class
*********************************************************/
static void G__setup_memfuncROOTcLcLMinuit2cLcLGenericFunction(void) {
   /* ROOT::Minuit2::GenericFunction */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLGenericFunction));
   G__memfunc_setup("operator()",957,G__G__Minuit2_100_0_1, 100, -1, -1, 0, 1, 1, 1, 8, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - x", (char*)NULL, (void*) NULL, 3);
   // automatic destructor
   G__memfunc_setup("~GenericFunction", 1665, G__G__Minuit2_100_0_2, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Minuit2_100_0_3, (int) ('u'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLGenericFunction), -1, 1, 1, 1, 1, 0, "u 'ROOT::Minuit2::GenericFunction' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLFCNBase(void) {
   /* ROOT::Minuit2::FCNBase */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNBase));
   G__memfunc_setup("operator()",957,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 8, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - x", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("ErrorDef",793,G__G__Minuit2_105_0_2, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Up",197,G__G__Minuit2_105_0_3, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("SetErrorDef",1093,G__G__Minuit2_105_0_4, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - -", (char*)NULL, (void*) NULL, 1);
   // automatic destructor
   G__memfunc_setup("~FCNBase", 720, G__G__Minuit2_105_0_5, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Minuit2_105_0_6, (int) ('u'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNBase), -1, 1, 1, 1, 1, 0, "u 'ROOT::Minuit2::FCNBase' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLFCNGradientBase(void) {
   /* ROOT::Minuit2::FCNGradientBase */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNGradientBase));
   G__memfunc_setup("Gradient",814,G__G__Minuit2_121_0_1, 117, G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 1, 1, 1, 8, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - -", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("CheckGradient",1292,G__G__Minuit2_121_0_2, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   // automatic destructor
   G__memfunc_setup("~FCNGradientBase", 1534, G__G__Minuit2_121_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Minuit2_121_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNGradientBase), -1, 1, 1, 1, 1, 0, "u 'ROOT::Minuit2::FCNGradientBase' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFcnAdapter(void) {
   /* TFcnAdapter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_TFcnAdapter));
   G__memfunc_setup("TFcnAdapter",1068,G__G__Minuit2_122_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_TFcnAdapter), -1, 0, 1, 1, 1, 0, "1 - 'void (*)(int&, double*, double&, double*, int)' 0 - fcn", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Base",379,G__G__Minuit2_122_0_2, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNBase), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 8, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Up",197,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetErrorDef",1093,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - up", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Gradient",814,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 1, 1, 1, 8, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,G__G__Minuit2_122_0_7, 100, -1, -1, 0, 3, 1, 1, 8, 
"i - - 0 - npar D - - 0 - params "
"i - - 0 '4' iflag", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Class",502,G__G__Minuit2_122_0_8, 85, G__get_linked_tagnum(&G__G__Minuit2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFcnAdapter::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Minuit2_122_0_9, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFcnAdapter::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Minuit2_122_0_10, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFcnAdapter::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Minuit2_122_0_11, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFcnAdapter::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,G__G__Minuit2_122_0_12, 85, G__get_linked_tagnum(&G__G__Minuit2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,G__G__Minuit2_122_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,G__G__Minuit2_122_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Minuit2_122_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Minuit2_122_0_16, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFcnAdapter::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Minuit2_122_0_17, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFcnAdapter::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Minuit2_122_0_18, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFcnAdapter::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Minuit2_122_0_19, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFcnAdapter::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TFcnAdapter", 1068, G__G__Minuit2_122_0_20, (int) ('i'), G__get_linked_tagnum(&G__G__Minuit2LN_TFcnAdapter), -1, 0, 1, 1, 1, 0, "u 'TFcnAdapter' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TFcnAdapter", 1194, G__G__Minuit2_122_0_21, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Minuit2_122_0_22, (int) ('u'), G__get_linked_tagnum(&G__G__Minuit2LN_TFcnAdapter), -1, 1, 1, 1, 1, 0, "u 'TFcnAdapter' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLMinuitParameter(void) {
   /* ROOT::Minuit2::MinuitParameter */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuitParameter));
   G__memfunc_setup("MinuitParameter",1559,G__G__Minuit2_173_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuitParameter), -1, 0, 3, 1, 1, 0, 
"h - - 0 - num u 'string' - 11 - name "
"d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MinuitParameter",1559,G__G__Minuit2_173_0_2, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuitParameter), -1, 0, 4, 1, 1, 0, 
"h - - 0 - num u 'string' - 11 - name "
"d - - 0 - val d - - 0 - err", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MinuitParameter",1559,G__G__Minuit2_173_0_3, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuitParameter), -1, 0, 6, 1, 1, 0, 
"h - - 0 - num u 'string' - 11 - name "
"d - - 0 - val d - - 0 - err "
"d - - 0 - min d - - 0 - max", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MinuitParameter",1559,G__G__Minuit2_173_0_4, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuitParameter), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::MinuitParameter' - 11 - par", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Minuit2_173_0_5, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuitParameter), -1, 1, 1, 1, 1, 0, "u 'ROOT::Minuit2::MinuitParameter' - 11 - par", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Number",617,G__G__Minuit2_173_0_6, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,G__G__Minuit2_173_0_7, 117, G__get_linked_tagnum(&G__G__Minuit2LN_string), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Name",385,G__G__Minuit2_173_0_8, 67, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__G__Minuit2_173_0_9, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Error",522,G__G__Minuit2_173_0_10, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetValue",809,G__G__Minuit2_173_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetError",822,G__G__Minuit2_173_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - err", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLimits",926,G__G__Minuit2_173_0_13, 121, -1, -1, 0, 2, 1, 1, 0, 
"d - - 0 - low d - - 0 - up", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUpperLimit",1335,G__G__Minuit2_173_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - up", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLowerLimit",1332,G__G__Minuit2_173_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - low", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveLimits",1248,G__G__Minuit2_173_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fix",295,G__G__Minuit2_173_0_17, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Release",705,G__G__Minuit2_173_0_18, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsConst",707,G__G__Minuit2_173_0_19, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsFixed",684,G__G__Minuit2_173_0_20, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasLimits",910,G__G__Minuit2_173_0_21, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasLowerLimit",1316,G__G__Minuit2_173_0_22, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasUpperLimit",1319,G__G__Minuit2_173_0_23, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LowerLimit",1032,G__G__Minuit2_173_0_24, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpperLimit",1035,G__G__Minuit2_173_0_25, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MinuitParameter", 1685, G__G__Minuit2_173_0_26, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLMnUserParameters(void) {
   /* ROOT::Minuit2::MnUserParameters */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameters));
   G__memfunc_setup("MnUserParameters",1646,G__G__Minuit2_188_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameters), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnUserParameters",1646,G__G__Minuit2_188_0_2, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameters), -1, 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - - u 'vector<double,allocator<double> >' 'vector<double>' 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnUserParameters",1646,G__G__Minuit2_188_0_3, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameters), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::MnUserParameters' - 11 - par", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Minuit2_188_0_4, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameters), -1, 1, 1, 1, 1, 0, "u 'ROOT::Minuit2::MnUserParameters' - 11 - par", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Trafo",508,G__G__Minuit2_188_0_5, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserTransformation), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("VariableParameters",1850,G__G__Minuit2_188_0_6, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Parameters",1044,G__G__Minuit2_188_0_7, 117, G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinuitParametercOallocatorlEROOTcLcLMinuit2cLcLMinuitParametergRsPgR), G__defined_typename("vector<ROOT::Minuit2::MinuitParameter>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Params",612,G__G__Minuit2_188_0_8, 117, G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Errors",637,G__G__Minuit2_188_0_9, 117, G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Parameter",929,G__G__Minuit2_188_0_10, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuitParameter), -1, 1, 1, 1, 1, 9, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Minuit2_188_0_11, 103, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 11 - - d - - 0 - - "
"d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Minuit2_188_0_12, 103, -1, -1, 0, 5, 1, 1, 0, 
"u 'string' - 11 - - d - - 0 - - "
"d - - 0 - - d - - 0 - - "
"d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Minuit2_188_0_13, 103, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fix",295,G__G__Minuit2_188_0_14, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Release",705,G__G__Minuit2_188_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetValue",809,G__G__Minuit2_188_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetError",822,G__G__Minuit2_188_0_17, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLimits",926,G__G__Minuit2_188_0_18, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - d - - 0 - - "
"d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUpperLimit",1335,G__G__Minuit2_188_0_19, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLowerLimit",1332,G__G__Minuit2_188_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveLimits",1248,G__G__Minuit2_188_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__G__Minuit2_188_0_22, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Error",522,G__G__Minuit2_188_0_23, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fix",295,G__G__Minuit2_188_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Release",705,G__G__Minuit2_188_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetValue",809,G__G__Minuit2_188_0_26, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetError",822,G__G__Minuit2_188_0_27, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLimits",926,G__G__Minuit2_188_0_28, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 11 - - d - - 0 - - "
"d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUpperLimit",1335,G__G__Minuit2_188_0_29, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLowerLimit",1332,G__G__Minuit2_188_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveLimits",1248,G__G__Minuit2_188_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__G__Minuit2_188_0_32, 100, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Error",522,G__G__Minuit2_188_0_33, 100, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Index",504,G__G__Minuit2_188_0_34, 104, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,G__G__Minuit2_188_0_35, 117, G__get_linked_tagnum(&G__G__Minuit2LN_string), -1, 1, 1, 1, 1, 9, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Name",385,G__G__Minuit2_188_0_36, 67, -1, -1, 0, 1, 1, 1, 9, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Precision",940,G__G__Minuit2_188_0_37, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMachinePrecision), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPrecision",1240,G__G__Minuit2_188_0_38, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - eps", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MnUserParameters", 1772, G__G__Minuit2_188_0_39, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLMnUserParameterState(void) {
   /* ROOT::Minuit2::MnUserParameterState */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState));
   G__memfunc_setup("MnUserParameterState",2044,G__G__Minuit2_191_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnUserParameterState",2044,G__G__Minuit2_191_0_2, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - - u 'vector<double,allocator<double> >' 'vector<double>' 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnUserParameterState",2044,G__G__Minuit2_191_0_3, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::MnUserParameters' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnUserParameterState",2044,G__G__Minuit2_191_0_4, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 0, 3, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - - u 'vector<double,allocator<double> >' 'vector<double>' 11 - - "
"h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnUserParameterState",2044,G__G__Minuit2_191_0_5, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 0, 2, 1, 1, 0, 
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - - u 'ROOT::Minuit2::MnUserCovariance' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnUserParameterState",2044,G__G__Minuit2_191_0_6, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 0, 2, 1, 1, 0, 
"u 'ROOT::Minuit2::MnUserParameters' - 11 - - u 'ROOT::Minuit2::MnUserCovariance' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnUserParameterState",2044,G__G__Minuit2_191_0_7, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Minuit2::MinimumState' - 11 - - d - - 0 - - "
"u 'ROOT::Minuit2::MnUserTransformation' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnUserParameterState",2044,G__G__Minuit2_191_0_8, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::MnUserParameterState' - 11 - state", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Minuit2_191_0_9, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 1, 1, 1, 1, 0, "u 'ROOT::Minuit2::MnUserParameterState' - 11 - state", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Parameters",1044,G__G__Minuit2_191_0_10, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameters), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Covariance",1019,G__G__Minuit2_191_0_11, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserCovariance), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GlobalCC",727,G__G__Minuit2_191_0_12, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnGlobalCorrelationCoeff), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IntParameters",1343,G__G__Minuit2_191_0_13, 117, G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IntCovariance",1318,G__G__Minuit2_191_0_14, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserCovariance), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Trafo",508,G__G__Minuit2_191_0_15, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserTransformation), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__Minuit2_191_0_16, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasCovariance",1303,G__G__Minuit2_191_0_17, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasGlobalCC",1011,G__G__Minuit2_191_0_18, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fval",393,G__G__Minuit2_191_0_19, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Edm",278,G__G__Minuit2_191_0_20, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NFcn",357,G__G__Minuit2_191_0_21, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MinuitParameters",1674,G__G__Minuit2_191_0_22, 117, G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinuitParametercOallocatorlEROOTcLcLMinuit2cLcLMinuitParametergRsPgR), G__defined_typename("vector<ROOT::Minuit2::MinuitParameter>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Params",612,G__G__Minuit2_191_0_23, 117, G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Errors",637,G__G__Minuit2_191_0_24, 117, G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Parameter",929,G__G__Minuit2_191_0_25, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuitParameter), -1, 1, 1, 1, 1, 9, "h - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Minuit2_191_0_26, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 11 - name d - - 0 - val "
"d - - 0 - err", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Minuit2_191_0_27, 121, -1, -1, 0, 5, 1, 1, 0, 
"u 'string' - 11 - name d - - 0 - val "
"d - - 0 - err d - - 0 - - "
"d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Minuit2_191_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fix",295,G__G__Minuit2_191_0_29, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Release",705,G__G__Minuit2_191_0_30, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetValue",809,G__G__Minuit2_191_0_31, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetError",822,G__G__Minuit2_191_0_32, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLimits",926,G__G__Minuit2_191_0_33, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - d - - 0 - - "
"d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUpperLimit",1335,G__G__Minuit2_191_0_34, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLowerLimit",1332,G__G__Minuit2_191_0_35, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveLimits",1248,G__G__Minuit2_191_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__G__Minuit2_191_0_37, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Error",522,G__G__Minuit2_191_0_38, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fix",295,G__G__Minuit2_191_0_39, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Release",705,G__G__Minuit2_191_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetValue",809,G__G__Minuit2_191_0_41, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetError",822,G__G__Minuit2_191_0_42, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLimits",926,G__G__Minuit2_191_0_43, 121, -1, -1, 0, 3, 1, 1, 0, 
"u 'string' - 11 - - d - - 0 - - "
"d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetUpperLimit",1335,G__G__Minuit2_191_0_44, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLowerLimit",1332,G__G__Minuit2_191_0_45, 121, -1, -1, 0, 2, 1, 1, 0, 
"u 'string' - 11 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveLimits",1248,G__G__Minuit2_191_0_46, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__G__Minuit2_191_0_47, 100, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Error",522,G__G__Minuit2_191_0_48, 100, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Index",504,G__G__Minuit2_191_0_49, 104, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetName",673,G__G__Minuit2_191_0_50, 117, G__get_linked_tagnum(&G__G__Minuit2LN_string), -1, 1, 1, 1, 1, 9, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Name",385,G__G__Minuit2_191_0_51, 67, -1, -1, 0, 1, 1, 1, 9, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Int2ext",686,G__G__Minuit2_191_0_52, 100, -1, -1, 0, 2, 1, 1, 8, 
"h - - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Ext2int",686,G__G__Minuit2_191_0_53, 100, -1, -1, 0, 2, 1, 1, 8, 
"h - - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IntOfExt",785,G__G__Minuit2_191_0_54, 104, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExtOfInt",785,G__G__Minuit2_191_0_55, 104, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("VariableParameters",1850,G__G__Minuit2_191_0_56, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Precision",940,G__G__Minuit2_191_0_57, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMachinePrecision), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPrecision",1240,G__G__Minuit2_191_0_58, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - eps", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MnUserParameterState", 2170, G__G__Minuit2_191_0_59, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLMinosError(void) {
   /* ROOT::Minuit2::MinosError */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinosError));
   G__memfunc_setup("MinosError",1040,G__G__Minuit2_196_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinosError), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MinosError",1040,G__G__Minuit2_196_0_2, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinosError), -1, 0, 4, 1, 1, 0, 
"h - - 0 - par d - - 0 - min "
"u 'ROOT::Minuit2::MnCross' - 11 - low u 'ROOT::Minuit2::MnCross' - 11 - up", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MinosError",1040,G__G__Minuit2_196_0_3, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinosError), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::MinosError' - 11 - err", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Minuit2_196_0_4, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinosError), -1, 1, 1, 1, 1, 0, "u 'ROOT::Minuit2::MinosError' - 11 - err", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Minuit2_196_0_5, 117, G__get_linked_tagnum(&G__G__Minuit2LN_pairlEdoublecOdoublegR), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Lower",521,G__G__Minuit2_196_0_6, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Upper",524,G__G__Minuit2_196_0_7, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Parameter",929,G__G__Minuit2_196_0_8, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LowerState",1034,G__G__Minuit2_196_0_9, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpperState",1037,G__G__Minuit2_196_0_10, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__Minuit2_196_0_11, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LowerValid",1017,G__G__Minuit2_196_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpperValid",1020,G__G__Minuit2_196_0_13, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AtLowerLimit",1213,G__G__Minuit2_196_0_14, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AtUpperLimit",1216,G__G__Minuit2_196_0_15, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AtLowerMaxFcn",1275,G__G__Minuit2_196_0_16, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("AtUpperMaxFcn",1278,G__G__Minuit2_196_0_17, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("LowerNewMin",1111,G__G__Minuit2_196_0_18, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UpperNewMin",1114,G__G__Minuit2_196_0_19, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NFcn",357,G__G__Minuit2_196_0_20, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Min",292,G__G__Minuit2_196_0_21, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MinosError", 1166, G__G__Minuit2_196_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Minuit2_196_0_23, (int) ('u'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinosError), -1, 1, 1, 1, 1, 0, "u 'ROOT::Minuit2::MinosError' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLFunctionMinimum(void) {
   /* ROOT::Minuit2::FunctionMinimum */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum));
   G__memfunc_setup("FunctionMinimum",1570,G__G__Minuit2_198_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 2, 1, 1, 0, 
"u 'ROOT::Minuit2::MinimumSeed' - 11 - seed d - - 0 - up", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FunctionMinimum",1570,G__G__Minuit2_198_0_2, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Minuit2::MinimumSeed' - 11 - seed u 'vector<ROOT::Minuit2::MinimumState,allocator<ROOT::Minuit2::MinimumState> >' 'vector<MinimumState>' 11 - states "
"d - - 0 - up", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FunctionMinimum",1570,G__G__Minuit2_198_0_3, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::MinimumSeed' - 11 - seed u 'vector<ROOT::Minuit2::MinimumState,allocator<ROOT::Minuit2::MinimumState> >' 'vector<MinimumState>' 11 - states "
"d - - 0 - up u 'ROOT::Minuit2::FunctionMinimum::MnReachedCallLimit' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FunctionMinimum",1570,G__G__Minuit2_198_0_4, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::MinimumSeed' - 11 - seed u 'vector<ROOT::Minuit2::MinimumState,allocator<ROOT::Minuit2::MinimumState> >' 'vector<MinimumState>' 11 - states "
"d - - 0 - up u 'ROOT::Minuit2::FunctionMinimum::MnAboveMaxEdm' - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FunctionMinimum",1570,G__G__Minuit2_198_0_5, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::FunctionMinimum' - 11 - min", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,G__G__Minuit2_198_0_6, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 1, 1, 1, 1, 0, "u 'ROOT::Minuit2::FunctionMinimum' - 11 - min", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Minuit2_198_0_7, 121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::MinimumState' - 11 - state", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Seed",385,G__G__Minuit2_198_0_8, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumSeed), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("States",628,G__G__Minuit2_198_0_9, 117, G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinimumStatecOallocatorlEROOTcLcLMinuit2cLcLMinimumStategRsPgR), G__defined_typename("vector<ROOT::Minuit2::MinimumState>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UserState",928,G__G__Minuit2_198_0_10, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UserParameters",1459,G__G__Minuit2_198_0_11, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameters), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("UserCovariance",1434,G__G__Minuit2_198_0_12, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserCovariance), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("State",513,G__G__Minuit2_198_0_13, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumState), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Parameters",1044,G__G__Minuit2_198_0_14, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumParameters), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Error",522,G__G__Minuit2_198_0_15, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumError), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Grad",382,G__G__Minuit2_198_0_16, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionGradient), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fval",393,G__G__Minuit2_198_0_17, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Edm",278,G__G__Minuit2_198_0_18, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NFcn",357,G__G__Minuit2_198_0_19, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Up",197,G__G__Minuit2_198_0_20, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsValid",684,G__G__Minuit2_198_0_21, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasValidParameters",1824,G__G__Minuit2_198_0_22, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasValidCovariance",1799,G__G__Minuit2_198_0_23, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasAccurateCovar",1599,G__G__Minuit2_198_0_24, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasPosDefCovar",1368,G__G__Minuit2_198_0_25, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasMadePosDefCovar",1743,G__G__Minuit2_198_0_26, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HesseFailed",1085,G__G__Minuit2_198_0_27, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasCovariance",1303,G__G__Minuit2_198_0_28, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsAboveMaxEdm",1253,G__G__Minuit2_198_0_29, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HasReachedCallLimit",1859,G__G__Minuit2_198_0_30, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetErrorDef",1093,G__G__Minuit2_198_0_31, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - up", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~FunctionMinimum", 1696, G__G__Minuit2_198_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLFunctionMinimizer(void) {
   /* ROOT::Minuit2::FunctionMinimizer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimizer));
   G__memfunc_setup("Minimize",834,G__G__Minuit2_199_0_1, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 6, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNBase' - 11 - - u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - err h - - 0 - strategy "
"h - - 0 - maxfcn d - - 0 - toler", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Minimize",834,G__G__Minuit2_199_0_2, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 6, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - - u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - err h - - 0 - strategy "
"h - - 0 - maxfcn d - - 0 - toler", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Minimize",834,G__G__Minuit2_199_0_3, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 7, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNBase' - 11 - - u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"h - - 0 - nrow u 'vector<double,allocator<double> >' 'vector<double>' 11 - cov "
"h - - 0 - strategy h - - 0 - maxfcn "
"d - - 0 - toler", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Minimize",834,G__G__Minuit2_199_0_4, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 7, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - - u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"h - - 0 - nrow u 'vector<double,allocator<double> >' 'vector<double>' 11 - cov "
"h - - 0 - strategy h - - 0 - maxfcn "
"d - - 0 - toler", (char*)NULL, (void*) NULL, 3);
   // automatic destructor
   G__memfunc_setup("~FunctionMinimizer", 1912, G__G__Minuit2_199_0_5, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Minuit2_199_0_6, (int) ('u'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimizer), -1, 1, 1, 1, 1, 0, "u 'ROOT::Minuit2::FunctionMinimizer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLMnStrategy(void) {
   /* ROOT::Minuit2::MnStrategy */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnStrategy));
   G__memfunc_setup("MnStrategy",1038,G__G__Minuit2_205_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnStrategy), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnStrategy",1038,G__G__Minuit2_205_0_2, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnStrategy), -1, 0, 1, 5, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Strategy",851,G__G__Minuit2_205_0_3, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GradientNCycles",1503,G__G__Minuit2_205_0_4, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GradientStepTolerance",2151,G__G__Minuit2_205_0_5, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GradientTolerance",1739,G__G__Minuit2_205_0_6, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HessianNCycles",1404,G__G__Minuit2_205_0_7, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HessianStepTolerance",2052,G__G__Minuit2_205_0_8, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HessianG2Tolerance",1761,G__G__Minuit2_205_0_9, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("HessianGradientNCycles",2218,G__G__Minuit2_205_0_10, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsLow",494,G__G__Minuit2_205_0_11, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsMedium",797,G__G__Minuit2_205_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IsHigh",572,G__G__Minuit2_205_0_13, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLowStrategy",1457,G__G__Minuit2_205_0_14, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMediumStrategy",1760,G__G__Minuit2_205_0_15, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHighStrategy",1535,G__G__Minuit2_205_0_16, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGradientNCycles",1803,G__G__Minuit2_205_0_17, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGradientStepTolerance",2451,G__G__Minuit2_205_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - stp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetGradientTolerance",2039,G__G__Minuit2_205_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - toler", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHessianNCycles",1704,G__G__Minuit2_205_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - n", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHessianStepTolerance",2352,G__G__Minuit2_205_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - stp", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHessianG2Tolerance",2061,G__G__Minuit2_205_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - toler", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetHessianGradientNCycles",2518,G__G__Minuit2_205_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - n", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("MnStrategy", 1038, G__G__Minuit2_205_0_24, (int) ('i'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnStrategy), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::MnStrategy' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MnStrategy", 1164, G__G__Minuit2_205_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Minuit2_205_0_26, (int) ('u'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnStrategy), -1, 1, 1, 1, 1, 0, "u 'ROOT::Minuit2::MnStrategy' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLFumiliFCNBase(void) {
   /* ROOT::Minuit2::FumiliFCNBase */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliFCNBase));
   G__memfunc_setup("EvaluateAll",1104,G__G__Minuit2_206_0_3, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<double,allocator<double> >' 'vector<double>' 11 - par", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Value",509,G__G__Minuit2_206_0_4, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Gradient",814,G__G__Minuit2_206_0_5, 117, G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Hessian",715,G__G__Minuit2_206_0_6, 100, -1, -1, 0, 2, 1, 1, 8, 
"h - - 0 - row h - - 0 - col", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Dimension",934,G__G__Minuit2_206_0_7, 104, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("InitAndReset",1194,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "h - - 0 - npar", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFCNValue",1024,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "d - - 0 - value", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Gradient",814,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Hessian",715,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~FumiliFCNBase", 1334, G__G__Minuit2_206_0_12, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Minuit2_206_0_13, (int) ('u'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliFCNBase), -1, 1, 1, 1, 1, 0, "u 'ROOT::Minuit2::FumiliFCNBase' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLModularFunctionMinimizer(void) {
   /* ROOT::Minuit2::ModularFunctionMinimizer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer));
   G__memfunc_setup("Minimize",834,G__G__Minuit2_207_0_1, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 6, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNBase' - 11 - - u 'vector<double,allocator<double> >' 'vector<double>' 11 - - "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - - h - - 0 '1' stra "
"h - - 0 '0' maxfcn d - - 0 '0.1' toler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,G__G__Minuit2_207_0_2, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 6, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - - u 'vector<double,allocator<double> >' 'vector<double>' 11 - - "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - - h - - 0 '1' stra "
"h - - 0 '0' maxfcn d - - 0 '0.1' toler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,G__G__Minuit2_207_0_3, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 7, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNBase' - 11 - - u 'vector<double,allocator<double> >' 'vector<double>' 11 - - "
"h - - 0 - - u 'vector<double,allocator<double> >' 'vector<double>' 11 - - "
"h - - 0 '1' stra h - - 0 '0' maxfcn "
"d - - 0 '0.1' toler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,G__G__Minuit2_207_0_4, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 7, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - - u 'vector<double,allocator<double> >' 'vector<double>' 11 - - "
"h - - 0 - - u 'vector<double,allocator<double> >' 'vector<double>' 11 - - "
"h - - 0 '1' stra h - - 0 '0' maxfcn "
"d - - 0 '0.1' toler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,G__G__Minuit2_207_0_5, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 5, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNBase' - 11 - - u 'ROOT::Minuit2::MnUserParameters' - 11 - - "
"u 'ROOT::Minuit2::MnStrategy' - 11 - - h - - 0 '0' maxfcn "
"d - - 0 '0.1' toler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,G__G__Minuit2_207_0_6, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 5, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - - u 'ROOT::Minuit2::MnUserParameters' - 11 - - "
"u 'ROOT::Minuit2::MnStrategy' - 11 - - h - - 0 '0' maxfcn "
"d - - 0 '0.1' toler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,G__G__Minuit2_207_0_7, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 6, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNBase' - 11 - - u 'ROOT::Minuit2::MnUserParameters' - 11 - - "
"u 'ROOT::Minuit2::MnUserCovariance' - 11 - - u 'ROOT::Minuit2::MnStrategy' - 11 - - "
"h - - 0 '0' maxfcn d - - 0 '0.1' toler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,G__G__Minuit2_207_0_8, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 6, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - - u 'ROOT::Minuit2::MnUserParameters' - 11 - - "
"u 'ROOT::Minuit2::MnUserCovariance' - 11 - - u 'ROOT::Minuit2::MnStrategy' - 11 - - "
"h - - 0 '0' maxfcn d - - 0 '0.1' toler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,G__G__Minuit2_207_0_9, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 5, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNBase' - 11 - - u 'ROOT::Minuit2::MnUserParameterState' - 11 - - "
"u 'ROOT::Minuit2::MnStrategy' - 11 - - h - - 0 '0' maxfcn "
"d - - 0 '0.1' toler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,G__G__Minuit2_207_0_10, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 5, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - - u 'ROOT::Minuit2::MnUserParameterState' - 11 - - "
"u 'ROOT::Minuit2::MnStrategy' - 11 - - h - - 0 '0' maxfcn "
"d - - 0 '0.1' toler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SeedGenerator",1320,G__G__Minuit2_207_0_11, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumSeedGenerator), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Builder",711,G__G__Minuit2_207_0_12, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumBuilder), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Minimize",834,G__G__Minuit2_207_0_13, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 6, 1, 1, 8, 
"u 'ROOT::Minuit2::MnFcn' - 11 - - u 'ROOT::Minuit2::GradientCalculator' - 11 - - "
"u 'ROOT::Minuit2::MinimumSeed' - 11 - - u 'ROOT::Minuit2::MnStrategy' - 11 - - "
"h - - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 1);
   // automatic destructor
   G__memfunc_setup("~ModularFunctionMinimizer", 2636, G__G__Minuit2_207_0_14, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Minuit2_207_0_15, (int) ('u'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer), -1, 1, 1, 1, 1, 0, "u 'ROOT::Minuit2::ModularFunctionMinimizer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLFumiliMinimizer(void) {
   /* ROOT::Minuit2::FumiliMinimizer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliMinimizer));
   G__memfunc_setup("FumiliMinimizer",1562,G__G__Minuit2_251_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliMinimizer), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SeedGenerator",1320,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumSeedGenerator), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Builder",711,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliBuilder), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 5, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNBase' - 11 - - u 'ROOT::Minuit2::MnUserParameterState' - 11 - - "
"u 'ROOT::Minuit2::MnStrategy' - 11 - - h - - 0 '0' maxfcn "
"d - - 0 '0.1' toler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 5, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - - u 'ROOT::Minuit2::MnUserParameterState' - 11 - - "
"u 'ROOT::Minuit2::MnStrategy' - 11 - - h - - 0 '0' maxfcn "
"d - - 0 '0.1' toler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 6, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - err h - - 0 '1' stra "
"h - - 0 '0' maxfcn d - - 0 '0.1' toler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 6, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - err h - - 0 '1' stra "
"h - - 0 '0' maxfcn d - - 0 '0.1' toler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 7, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"h - - 0 - nrow u 'vector<double,allocator<double> >' 'vector<double>' 11 - cov "
"h - - 0 '1' stra h - - 0 '0' maxfcn "
"d - - 0 '0.1' toler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 7, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"h - - 0 - nrow u 'vector<double,allocator<double> >' 'vector<double>' 11 - cov "
"h - - 0 '1' stra h - - 0 '0' maxfcn "
"d - - 0 '0.1' toler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 5, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameters' - 11 - par "
"u 'ROOT::Minuit2::MnStrategy' - 11 - stra h - - 0 '0' maxfcn "
"d - - 0 '0.1' toler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 5, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameters' - 11 - par "
"u 'ROOT::Minuit2::MnStrategy' - 11 - stra h - - 0 '0' maxfcn "
"d - - 0 '0.1' toler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 6, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameters' - 11 - par "
"u 'ROOT::Minuit2::MnUserCovariance' - 11 - cov u 'ROOT::Minuit2::MnStrategy' - 11 - stra "
"h - - 0 '0' maxfcn d - - 0 '0.1' toler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 6, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameters' - 11 - par "
"u 'ROOT::Minuit2::MnUserCovariance' - 11 - cov u 'ROOT::Minuit2::MnStrategy' - 11 - stra "
"h - - 0 '0' maxfcn d - - 0 '0.1' toler", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 6, 1, 1, 8, 
"u 'ROOT::Minuit2::MnFcn' - 11 - mfcn u 'ROOT::Minuit2::GradientCalculator' - 11 - gc "
"u 'ROOT::Minuit2::MinimumSeed' - 11 - seed u 'ROOT::Minuit2::MnStrategy' - 11 - stra "
"h - - 0 - maxfcn d - - 0 - toler", (char*)NULL, (void*) NULL, 1);
   // automatic copy constructor
   G__memfunc_setup("FumiliMinimizer", 1562, G__G__Minuit2_251_0_15, (int) ('i'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliMinimizer), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::FumiliMinimizer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~FumiliMinimizer", 1688, G__G__Minuit2_251_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Minuit2_251_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliMinimizer), -1, 1, 1, 1, 1, 0, "u 'ROOT::Minuit2::FumiliMinimizer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFitterMinuit(void) {
   /* TFitterMinuit */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_TFitterMinuit));
   G__memfunc_setup("TFitterMinuit",1336,G__G__Minuit2_252_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_TFitterMinuit), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFitterMinuit",1336,G__G__Minuit2_252_0_2, 105, G__get_linked_tagnum(&G__G__Minuit2LN_TFitterMinuit), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - maxpar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Chisquare",933,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - npar D - 'Double_t' 0 - params", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - 'Option_t' 10 '\"\"' option", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExecuteCommand",1426,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 3, 1, 1, 0, 
"C - - 10 - command D - 'Double_t' 0 - args "
"i - 'Int_t' 0 - nargs", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("FixParameter",1224,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ipar", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCovarianceMatrix",1936,(G__InterfaceMethod) NULL,68, -1, G__defined_typename("Double_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetCovarianceMatrixElement",2650,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - i i - 'Int_t' 0 - j", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetErrors",925,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 8, 
"i - 'Int_t' 0 - ipar d - 'Double_t' 1 - eplus "
"d - 'Double_t' 1 - eminus d - 'Double_t' 1 - eparab "
"d - 'Double_t' 1 - globcc", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumberTotalParameters",2465,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetNumberFreeParameters",2335,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParError",1101,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - ipar", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParameter",1217,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - ipar", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParameter",1217,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 6, 1, 1, 8, 
"i - 'Int_t' 0 - ipar C - - 0 - name "
"d - 'Double_t' 1 - value d - 'Double_t' 1 - verr "
"d - 'Double_t' 1 - vlow d - 'Double_t' 1 - vhigh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetParName",964,(G__InterfaceMethod) NULL,67, -1, -1, 0, 1, 1, 1, 9, "i - 'Int_t' 0 - ipar", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStats",815,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 5, 1, 1, 8, 
"d - 'Double_t' 1 - amin d - 'Double_t' 1 - edm "
"d - 'Double_t' 1 - errdef i - 'Int_t' 1 - nvpar "
"i - 'Int_t' 1 - nparx", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetSumLog",887,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 1, 1, 1, 0, "i - 'Int_t' 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("IsFixed",684,(G__InterfaceMethod) NULL,103, -1, G__defined_typename("Bool_t"), 0, 1, 1, 1, 8, "i - 'Int_t' 0 - ipar", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintResults",1279,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - level d - 'Double_t' 0 - amin", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ReleaseParameter",1634,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - ipar", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFitMethod",1200,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetParameter",1229,(G__InterfaceMethod) NULL,105, -1, G__defined_typename("Int_t"), 0, 6, 1, 1, 0, 
"i - 'Int_t' 0 - ipar C - - 10 - parname "
"d - 'Double_t' 0 - value d - 'Double_t' 0 - verr "
"d - 'Double_t' 0 - vlow d - 'Double_t' 0 - vhigh", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFCN",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "1 - 'void (*)(Int_t&, Double_t*, Double_t&f, Double_t*, Int_t) ' 0 - fcn", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFCN",515,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "Y - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMinuitFCN",1145,G__G__Minuit2_252_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "U 'ROOT::Minuit2::FCNBase' - 0 - f", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("State",513,G__G__Minuit2_252_0_26, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinuitFCN",1133,G__G__Minuit2_252_0_27, 85, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNBase), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinimizer",1236,G__G__Minuit2_252_0_28, 85, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer), -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,G__G__Minuit2_252_0_29, 105, -1, -1, 0, 2, 1, 1, 0, 
"i - - 0 '0' nfcn d - - 0 '0.1' edmval", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetStrategy",1139,G__G__Minuit2_252_0_30, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("PrintLevel",1029,G__G__Minuit2_252_0_31, 105, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetStrategy",1151,G__G__Minuit2_252_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPrintLevel",1329,G__G__Minuit2_252_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "i - - 0 - level", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetMinimumTolerance",1957,G__G__Minuit2_252_0_34, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - mintol", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MinimumTolerance",1657,G__G__Minuit2_252_0_35, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("CreateMinimizer",1544,G__G__Minuit2_252_0_36, 121, -1, -1, 0, 1, 1, 1, 0, "i 'TFitterMinuit::EMinimizerType' - 0 'kMigrad' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("State",513,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 1, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMinimizer",1248,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'ROOT::Minuit2::ModularFunctionMinimizer' - 0 - m", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateChi2FCN",1137,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateChi2ExtendedFCN",1954,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateBinLikelihoodFCN",2120,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateUnbinLikelihoodFCN",2347,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("DoMinimization",1451,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 2, 1, 2, 0, 
"i - - 0 '0' nfcn d - - 0 '0.1' edmval", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExamineMinimum",1443,(G__InterfaceMethod) NULL, 105, -1, -1, 0, 1, 1, 2, 0, "u 'ROOT::Minuit2::FunctionMinimum' - 11 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Initialize",1042,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Minuit2_252_0_46, 85, G__get_linked_tagnum(&G__G__Minuit2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFitterMinuit::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Minuit2_252_0_47, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFitterMinuit::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Minuit2_252_0_48, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFitterMinuit::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Minuit2_252_0_49, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFitterMinuit::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Minuit2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Minuit2_252_0_53, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Minuit2_252_0_54, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFitterMinuit::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Minuit2_252_0_55, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFitterMinuit::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Minuit2_252_0_56, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFitterMinuit::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Minuit2_252_0_57, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFitterMinuit::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TFitterMinuit", 1336, G__G__Minuit2_252_0_58, (int) ('i'), G__get_linked_tagnum(&G__G__Minuit2LN_TFitterMinuit), -1, 0, 1, 1, 1, 0, "u 'TFitterMinuit' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TFitterMinuit", 1462, G__G__Minuit2_252_0_59, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncTFitterFumili(void) {
   /* TFitterFumili */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_TFitterFumili));
   G__memfunc_setup("TFitterFumili",1320,G__G__Minuit2_258_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_TFitterFumili), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TFitterFumili",1320,G__G__Minuit2_258_0_2, 105, G__get_linked_tagnum(&G__G__Minuit2LN_TFitterFumili), -1, 0, 1, 1, 1, 0, "i - 'Int_t' 0 - maxpar", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Chisquare",933,(G__InterfaceMethod) NULL,100, -1, G__defined_typename("Double_t"), 0, 2, 1, 1, 8, 
"i - 'Int_t' 0 - npar D - 'Double_t' 0 - params", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateMinimizer",1544,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i 'TFitterMinuit::EMinimizerType' - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateChi2FCN",1137,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateChi2ExtendedFCN",1954,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateUnbinLikelihoodFCN",2347,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CreateBinLikelihoodFCN",2120,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Class",502,G__G__Minuit2_258_0_9, 85, G__get_linked_tagnum(&G__G__Minuit2LN_TClass), -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (TClass* (*)())(&TFitterFumili::Class) ), 0);
   G__memfunc_setup("Class_Name",982,G__G__Minuit2_258_0_10, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFitterFumili::Class_Name) ), 0);
   G__memfunc_setup("Class_Version",1339,G__G__Minuit2_258_0_11, 115, -1, G__defined_typename("Version_t"), 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (Version_t (*)())(&TFitterFumili::Class_Version) ), 0);
   G__memfunc_setup("Dictionary",1046,G__G__Minuit2_258_0_12, 121, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (void (*)())(&TFitterFumili::Dictionary) ), 0);
   G__memfunc_setup("IsA",253,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__Minuit2LN_TClass), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ShowMembers",1132,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TMemberInspector' - 1 - insp", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Streamer",835,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("StreamerNVirtual",1656,G__G__Minuit2_258_0_16, 121, -1, -1, 0, 1, 1, 1, 0, "u 'TBuffer' - 1 - b", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("DeclFileName",1145,G__G__Minuit2_258_0_17, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFitterFumili::DeclFileName) ), 0);
   G__memfunc_setup("ImplFileLine",1178,G__G__Minuit2_258_0_18, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFitterFumili::ImplFileLine) ), 0);
   G__memfunc_setup("ImplFileName",1171,G__G__Minuit2_258_0_19, 67, -1, -1, 0, 0, 3, 1, 1, "", (char*)NULL, (void*) G__func2void( (const char* (*)())(&TFitterFumili::ImplFileName) ), 0);
   G__memfunc_setup("DeclFileLine",1152,G__G__Minuit2_258_0_20, 105, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (int (*)())(&TFitterFumili::DeclFileLine) ), 0);
   // automatic copy constructor
   G__memfunc_setup("TFitterFumili", 1320, G__G__Minuit2_258_0_21, (int) ('i'), G__get_linked_tagnum(&G__G__Minuit2LN_TFitterFumili), -1, 0, 1, 1, 1, 0, "u 'TFitterFumili' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~TFitterFumili", 1446, G__G__Minuit2_258_0_22, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLVariableMetricMinimizer(void) {
   /* ROOT::Minuit2::VariableMetricMinimizer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLVariableMetricMinimizer));
   G__memfunc_setup("VariableMetricMinimizer",2366,G__G__Minuit2_265_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLVariableMetricMinimizer), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SeedGenerator",1320,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumSeedGenerator), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Builder",711,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumBuilder), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   // automatic copy constructor
   G__memfunc_setup("VariableMetricMinimizer", 2366, G__G__Minuit2_265_0_4, (int) ('i'), 
G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLVariableMetricMinimizer), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::VariableMetricMinimizer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~VariableMetricMinimizer", 2492, G__G__Minuit2_265_0_5, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Minuit2_265_0_6, (int) ('u'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLVariableMetricMinimizer), -1, 1, 1, 1, 1, 0, "u 'ROOT::Minuit2::VariableMetricMinimizer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLSimplexMinimizer(void) {
   /* ROOT::Minuit2::SimplexMinimizer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexMinimizer));
   G__memfunc_setup("SimplexMinimizer",1686,G__G__Minuit2_268_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexMinimizer), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SeedGenerator",1320,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumSeedGenerator), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Builder",711,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumBuilder), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   // automatic copy constructor
   G__memfunc_setup("SimplexMinimizer", 1686, G__G__Minuit2_268_0_4, (int) ('i'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexMinimizer), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::SimplexMinimizer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~SimplexMinimizer", 1812, G__G__Minuit2_268_0_5, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Minuit2_268_0_6, (int) ('u'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexMinimizer), -1, 1, 1, 1, 1, 0, "u 'ROOT::Minuit2::SimplexMinimizer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLCombinedMinimizer(void) {
   /* ROOT::Minuit2::CombinedMinimizer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLCombinedMinimizer));
   G__memfunc_setup("CombinedMinimizer",1749,G__G__Minuit2_270_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLCombinedMinimizer), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SeedGenerator",1320,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumSeedGenerator), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Builder",711,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumBuilder), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   // automatic copy constructor
   G__memfunc_setup("CombinedMinimizer", 1749, G__G__Minuit2_270_0_4, (int) ('i'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLCombinedMinimizer), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::CombinedMinimizer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~CombinedMinimizer", 1875, G__G__Minuit2_270_0_5, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Minuit2_270_0_6, (int) ('u'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLCombinedMinimizer), -1, 1, 1, 1, 1, 0, "u 'ROOT::Minuit2::CombinedMinimizer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLMinuit2Minimizer(void) {
   /* ROOT::Minuit2::Minuit2Minimizer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuit2Minimizer));
   G__memfunc_setup("Minuit2Minimizer",1628,G__G__Minuit2_307_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuit2Minimizer), -1, 0, 1, 1, 1, 0, "i 'ROOT::Minuit2::EMinimizerType' - 0 'ROOT::Minuit2::kMigrad' type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Minuit2Minimizer",1628,G__G__Minuit2_307_0_2, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuit2Minimizer), -1, 0, 1, 1, 1, 0, "C - - 10 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Minuit2Minimizer",1628,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuit2Minimizer), -1, 0, 1, 1, 4, 0, "u 'ROOT::Minuit2::Minuit2Minimizer' - 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuit2Minimizer), -1, 1, 1, 1, 4, 0, "u 'ROOT::Minuit2::Minuit2Minimizer' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Clear",487,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFunction",1138,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::IBaseFunctionMultiDim' 'ROOT::Math::IMultiGenFunction' 11 - func", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFunction",1138,(G__InterfaceMethod) NULL,121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::IGradientFunctionMultiDim' 'ROOT::Math::IMultiGradFunction' 11 - func", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVariable",1106,(G__InterfaceMethod) NULL,103, -1, -1, 0, 4, 1, 1, 0, 
"h - - 0 - ivar u 'string' - 11 - name "
"d - - 0 - val d - - 0 - step", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLowerLimitedVariable",2339,(G__InterfaceMethod) NULL,103, -1, -1, 0, 5, 1, 1, 0, 
"h - - 0 - ivar u 'string' - 11 - name "
"d - - 0 - val d - - 0 - step "
"d - - 0 - lower", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetUpperLimitedVariable",2342,(G__InterfaceMethod) NULL,103, -1, -1, 0, 5, 1, 1, 0, 
"h - - 0 - ivar u 'string' - 11 - name "
"d - - 0 - val d - - 0 - step "
"d - - 0 - upper", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetLimitedVariable",1818,(G__InterfaceMethod) NULL,103, -1, -1, 0, 6, 1, 1, 0, 
"h - - 0 - ivar u 'string' - 11 - name "
"d - - 0 - val d - - 0 - step "
"d - - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetFixedVariable",1602,(G__InterfaceMethod) NULL,103, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - u 'string' - 11 - - "
"d - - 0 - -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVariableValue",1615,(G__InterfaceMethod) NULL,103, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - ivar d - - 0 - val", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetVariableValues",1730,(G__InterfaceMethod) NULL,103, -1, -1, 0, 1, 1, 1, 0, "D - - 10 - val", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("VariableName",1191,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_string), -1, 0, 1, 1, 1, 8, "h - - 0 - ivar", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("VariableIndex",1310,(G__InterfaceMethod) NULL,105, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimize",834,(G__InterfaceMethod) NULL,103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MinValue",801,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Edm",278,(G__InterfaceMethod) NULL,100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("X",88,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("MinGradient",1106,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", "not available in Minuit2 ", (void*) NULL, 1);
   G__memfunc_setup("NCalls",573,(G__InterfaceMethod) NULL,104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NDim",360,(G__InterfaceMethod) NULL,104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("NFree",464,(G__InterfaceMethod) NULL,104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ProvidesError",1366,(G__InterfaceMethod) NULL,103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Errors",637,(G__InterfaceMethod) NULL,68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CovMatrix",925,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 8, 
"h - - 0 - i h - - 0 - j", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("CovMatrixStatus",1569,(G__InterfaceMethod) NULL,105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Correlation",1154,(G__InterfaceMethod) NULL,100, -1, -1, 0, 2, 1, 1, 8, 
"h - - 0 - i h - - 0 - j", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GlobalCC",727,(G__InterfaceMethod) NULL,100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - i", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinosError",1328,(G__InterfaceMethod) NULL,103, -1, -1, 0, 4, 1, 1, 0, 
"h - - 0 - i d - - 1 - errLow "
"d - - 1 - errUp i - - 0 '0' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Scan",389,(G__InterfaceMethod) NULL,103, -1, -1, 0, 6, 1, 1, 0, 
"h - - 0 - i h - - 1 - nstep "
"D - - 0 - x D - - 0 - y "
"d - - 0 '0' xmin d - - 0 '0' xmax", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Contour",746,(G__InterfaceMethod) NULL,103, -1, -1, 0, 5, 1, 1, 0, 
"h - - 0 - i h - - 0 - j "
"h - - 1 - npoints D - - 0 - xi "
"D - - 0 - xj", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Hesse",504,(G__InterfaceMethod) NULL,103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("PrintResults",1279,(G__InterfaceMethod) NULL,121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("GetMinimizer",1236,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer), -1, 0, 0, 1, 2, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMinimizer",1248,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'ROOT::Minuit2::ModularFunctionMinimizer' - 0 - m", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("SetMinimizerType",1666,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "i 'ROOT::Minuit2::EMinimizerType' - 0 - type", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("GetFCN",503,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNBase), -1, 0, 0, 1, 2, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("ExamineMinimum",1443,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 1, 1, 2, 0, "u 'ROOT::Minuit2::FunctionMinimum' - 11 - min", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~Minuit2Minimizer", 1754, G__G__Minuit2_307_0_41, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLMnApplication(void) {
   /* ROOT::Minuit2::MnApplication */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnApplication));
   G__memfunc_setup("operator()",957,G__G__Minuit2_308_0_3, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 2, 1, 1, 0, 
"h - - 0 '0' maxfcn d - - 0 '0.1' tolerance", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Minimizer",948,G__G__Minuit2_308_0_4, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 3);
   G__memfunc_setup("Precision",940,G__G__Minuit2_308_0_5, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMachinePrecision), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("State",513,G__G__Minuit2_308_0_6, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Parameters",1044,G__G__Minuit2_308_0_7, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameters), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Covariance",1019,G__G__Minuit2_308_0_8, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserCovariance), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fcnbase",690,G__G__Minuit2_308_0_9, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNBase), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Strategy",851,G__G__Minuit2_308_0_10, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnStrategy), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("NumOfCalls",980,G__G__Minuit2_308_0_11, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MinuitParameters",1674,G__G__Minuit2_308_0_12, 117, G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinuitParametercOallocatorlEROOTcLcLMinuit2cLcLMinuitParametergRsPgR), G__defined_typename("vector<ROOT::Minuit2::MinuitParameter>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Params",612,G__G__Minuit2_308_0_13, 117, G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Errors",637,G__G__Minuit2_308_0_14, 117, G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Parameter",929,G__G__Minuit2_308_0_15, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuitParameter), -1, 1, 1, 1, 1, 9, "h - - 0 - i", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Minuit2_308_0_16, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - Name d - - 0 - val "
"d - - 0 - err", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Minuit2_308_0_17, 121, -1, -1, 0, 5, 1, 1, 0, 
"C - - 10 - Name d - - 0 - val "
"d - - 0 - err d - - 0 - - "
"d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Add",265,G__G__Minuit2_308_0_18, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fix",295,G__G__Minuit2_308_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Release",705,G__G__Minuit2_308_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetValue",809,G__G__Minuit2_308_0_21, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetError",822,G__G__Minuit2_308_0_22, 121, -1, -1, 0, 2, 1, 1, 0, 
"h - - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLimits",926,G__G__Minuit2_308_0_23, 121, -1, -1, 0, 3, 1, 1, 0, 
"h - - 0 - - d - - 0 - - "
"d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveLimits",1248,G__G__Minuit2_308_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__G__Minuit2_308_0_25, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Error",522,G__G__Minuit2_308_0_26, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Fix",295,G__G__Minuit2_308_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Release",705,G__G__Minuit2_308_0_28, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetValue",809,G__G__Minuit2_308_0_29, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetError",822,G__G__Minuit2_308_0_30, 121, -1, -1, 0, 2, 1, 1, 0, 
"C - - 10 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetLimits",926,G__G__Minuit2_308_0_31, 121, -1, -1, 0, 3, 1, 1, 0, 
"C - - 10 - - d - - 0 - - "
"d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("RemoveLimits",1248,G__G__Minuit2_308_0_32, 121, -1, -1, 0, 1, 1, 1, 0, "C - - 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SetPrecision",1240,G__G__Minuit2_308_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Value",509,G__G__Minuit2_308_0_34, 100, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Error",522,G__G__Minuit2_308_0_35, 100, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Index",504,G__G__Minuit2_308_0_36, 104, -1, -1, 0, 1, 1, 1, 8, "C - - 10 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Name",385,G__G__Minuit2_308_0_37, 67, -1, -1, 0, 1, 1, 1, 9, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Int2ext",686,G__G__Minuit2_308_0_38, 100, -1, -1, 0, 2, 1, 1, 8, 
"h - - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Ext2int",686,G__G__Minuit2_308_0_39, 100, -1, -1, 0, 2, 1, 1, 8, 
"h - - 0 - - d - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("IntOfExt",785,G__G__Minuit2_308_0_40, 104, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("ExtOfInt",785,G__G__Minuit2_308_0_41, 104, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("VariableParameters",1850,G__G__Minuit2_308_0_42, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MnApplication", 1453, G__G__Minuit2_308_0_43, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLMnContours(void) {
   /* ROOT::Minuit2::MnContours */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnContours));
   G__memfunc_setup("MnContours",1048,G__G__Minuit2_309_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnContours), -1, 0, 2, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'ROOT::Minuit2::FunctionMinimum' - 11 - min", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnContours",1048,G__G__Minuit2_309_0_2, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnContours), -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'ROOT::Minuit2::FunctionMinimum' - 11 - min "
"h - - 0 - stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnContours",1048,G__G__Minuit2_309_0_3, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnContours), -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'ROOT::Minuit2::FunctionMinimum' - 11 - min "
"u 'ROOT::Minuit2::MnStrategy' - 11 - stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Minuit2_309_0_4, 117, G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR), G__defined_typename("vector<std::pair<double,double> >"), 0, 3, 1, 1, 8, 
"h - - 0 - - h - - 0 - - "
"h - - 0 '20' npoints", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Contour",746,G__G__Minuit2_309_0_5, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLContoursError), -1, 0, 3, 1, 1, 8, 
"h - - 0 - - h - - 0 - - "
"h - - 0 '20' npoints", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Strategy",851,G__G__Minuit2_309_0_6, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnStrategy), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("MnContours", 1048, G__G__Minuit2_309_0_7, (int) ('i'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnContours), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::MnContours' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MnContours", 1174, G__G__Minuit2_309_0_8, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLMnFumiliMinimize(void) {
   /* ROOT::Minuit2::MnFumiliMinimize */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFumiliMinimize));
   G__memfunc_setup("MnFumiliMinimize",1635,G__G__Minuit2_312_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFumiliMinimize), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FumiliFCNBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - err h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnFumiliMinimize",1635,G__G__Minuit2_312_0_2, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFumiliMinimize), -1, 0, 5, 1, 1, 0, 
"u 'ROOT::Minuit2::FumiliFCNBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"h - - 0 - nrow u 'vector<double,allocator<double> >' 'vector<double>' 11 - cov "
"h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnFumiliMinimize",1635,G__G__Minuit2_312_0_3, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFumiliMinimize), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FumiliFCNBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"u 'ROOT::Minuit2::MnUserCovariance' - 11 - cov h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnFumiliMinimize",1635,G__G__Minuit2_312_0_4, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFumiliMinimize), -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Minuit2::FumiliFCNBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameters' - 11 - par "
"h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnFumiliMinimize",1635,G__G__Minuit2_312_0_5, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFumiliMinimize), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FumiliFCNBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameters' - 11 - par "
"u 'ROOT::Minuit2::MnUserCovariance' - 11 - cov h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnFumiliMinimize",1635,G__G__Minuit2_312_0_6, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFumiliMinimize), -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Minuit2::FumiliFCNBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameterState' - 11 - par "
"u 'ROOT::Minuit2::MnStrategy' - 11 - str", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnFumiliMinimize",1635,G__G__Minuit2_312_0_7, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFumiliMinimize), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::MnFumiliMinimize' - 11 - migr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Minimizer",948,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliMinimizer), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Fcnbase",690,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliFCNBase), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator()",957,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum), -1, 0, 2, 1, 1, 0, 
"h - - 0 '0' - d - - 0 '0.1' -", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFumiliMinimize), -1, 1, 1, 1, 4, 0, "u 'ROOT::Minuit2::MnFumiliMinimize' - 11 - -", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MnFumiliMinimize", 1761, G__G__Minuit2_312_0_12, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLMnHesse(void) {
   /* ROOT::Minuit2::MnHesse */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnHesse));
   G__memfunc_setup("MnHesse",691,G__G__Minuit2_314_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnHesse), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnHesse",691,G__G__Minuit2_314_0_2, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnHesse), -1, 0, 1, 1, 1, 0, "h - - 0 - stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnHesse",691,G__G__Minuit2_314_0_3, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnHesse), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::MnStrategy' - 11 - stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Minuit2_314_0_4, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 0, 4, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNBase' - 11 - - u 'vector<double,allocator<double> >' 'vector<double>' 11 - - "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - - h - - 0 '0' maxcalls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Minuit2_314_0_5, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 0, 5, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNBase' - 11 - - u 'vector<double,allocator<double> >' 'vector<double>' 11 - - "
"h - - 0 - nrow u 'vector<double,allocator<double> >' 'vector<double>' 11 - - "
"h - - 0 '0' maxcalls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Minuit2_314_0_6, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 0, 4, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNBase' - 11 - - u 'vector<double,allocator<double> >' 'vector<double>' 11 - - "
"u 'ROOT::Minuit2::MnUserCovariance' - 11 - - h - - 0 '0' maxcalls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Minuit2_314_0_7, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 0, 3, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNBase' - 11 - - u 'ROOT::Minuit2::MnUserParameters' - 11 - - "
"h - - 0 '0' maxcalls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Minuit2_314_0_8, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 0, 4, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNBase' - 11 - - u 'ROOT::Minuit2::MnUserParameters' - 11 - - "
"u 'ROOT::Minuit2::MnUserCovariance' - 11 - - h - - 0 '0' maxcalls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Minuit2_314_0_9, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState), -1, 0, 3, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNBase' - 11 - - u 'ROOT::Minuit2::MnUserParameterState' - 11 - - "
"h - - 0 '0' maxcalls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Minuit2_314_0_10, 121, -1, -1, 0, 3, 1, 1, 8, 
"u 'ROOT::Minuit2::FCNBase' - 11 - - u 'ROOT::Minuit2::FunctionMinimum' - 1 - - "
"h - - 0 '0' maxcalls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Minuit2_314_0_11, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumState), -1, 0, 4, 1, 1, 8, 
"u 'ROOT::Minuit2::MnFcn' - 11 - - u 'ROOT::Minuit2::MinimumState' - 11 - - "
"u 'ROOT::Minuit2::MnUserTransformation' - 11 - - h - - 0 '0' maxcalls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Ncycles",721,G__G__Minuit2_314_0_12, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Tolerstp",861,G__G__Minuit2_314_0_13, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("TolerG2",639,G__G__Minuit2_314_0_14, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("MnHesse", 691, G__G__Minuit2_314_0_15, (int) ('i'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnHesse), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::MnHesse' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MnHesse", 817, G__G__Minuit2_314_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Minuit2_314_0_17, (int) ('u'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnHesse), -1, 1, 1, 1, 1, 0, "u 'ROOT::Minuit2::MnHesse' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLMnMigrad(void) {
   /* ROOT::Minuit2::MnMigrad */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad));
   G__memfunc_setup("MnMigrad",783,G__G__Minuit2_317_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - err h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMigrad",783,G__G__Minuit2_317_0_2, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad), -1, 0, 5, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"h - - 0 - nrow u 'vector<double,allocator<double> >' 'vector<double>' 11 - cov "
"h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMigrad",783,G__G__Minuit2_317_0_3, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"u 'ROOT::Minuit2::MnUserCovariance' - 11 - cov h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMigrad",783,G__G__Minuit2_317_0_4, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad), -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameters' - 11 - par "
"h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMigrad",783,G__G__Minuit2_317_0_5, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameters' - 11 - par "
"u 'ROOT::Minuit2::MnUserCovariance' - 11 - cov h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMigrad",783,G__G__Minuit2_317_0_6, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad), -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameterState' - 11 - par "
"u 'ROOT::Minuit2::MnStrategy' - 11 - str", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMigrad",783,G__G__Minuit2_317_0_7, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - err h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMigrad",783,G__G__Minuit2_317_0_8, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad), -1, 0, 5, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"h - - 0 - nrow u 'vector<double,allocator<double> >' 'vector<double>' 11 - cov "
"h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMigrad",783,G__G__Minuit2_317_0_9, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"u 'ROOT::Minuit2::MnUserCovariance' - 11 - cov h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMigrad",783,G__G__Minuit2_317_0_10, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad), -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameters' - 11 - par "
"h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMigrad",783,G__G__Minuit2_317_0_11, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameters' - 11 - par "
"u 'ROOT::Minuit2::MnUserCovariance' - 11 - cov h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMigrad",783,G__G__Minuit2_317_0_12, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad), -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameterState' - 11 - par "
"u 'ROOT::Minuit2::MnStrategy' - 11 - str", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMigrad",783,G__G__Minuit2_317_0_13, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::MnMigrad' - 11 - migr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Minimizer",948,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad), -1, 1, 1, 1, 4, 0, "u 'ROOT::Minuit2::MnMigrad' - 11 - -", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MnMigrad", 909, G__G__Minuit2_317_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLMnMinimize(void) {
   /* ROOT::Minuit2::MnMinimize */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize));
   G__memfunc_setup("MnMinimize",1021,G__G__Minuit2_318_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - err h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMinimize",1021,G__G__Minuit2_318_0_2, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize), -1, 0, 5, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"h - - 0 - nrow u 'vector<double,allocator<double> >' 'vector<double>' 11 - cov "
"h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMinimize",1021,G__G__Minuit2_318_0_3, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"u 'ROOT::Minuit2::MnUserCovariance' - 11 - cov h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMinimize",1021,G__G__Minuit2_318_0_4, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize), -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameters' - 11 - par "
"h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMinimize",1021,G__G__Minuit2_318_0_5, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameters' - 11 - par "
"u 'ROOT::Minuit2::MnUserCovariance' - 11 - cov h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMinimize",1021,G__G__Minuit2_318_0_6, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize), -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameterState' - 11 - par "
"u 'ROOT::Minuit2::MnStrategy' - 11 - str", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMinimize",1021,G__G__Minuit2_318_0_7, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - err h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMinimize",1021,G__G__Minuit2_318_0_8, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize), -1, 0, 5, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"h - - 0 - nrow u 'vector<double,allocator<double> >' 'vector<double>' 11 - cov "
"h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMinimize",1021,G__G__Minuit2_318_0_9, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"u 'ROOT::Minuit2::MnUserCovariance' - 11 - cov h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMinimize",1021,G__G__Minuit2_318_0_10, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize), -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameters' - 11 - par "
"h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMinimize",1021,G__G__Minuit2_318_0_11, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameters' - 11 - par "
"u 'ROOT::Minuit2::MnUserCovariance' - 11 - cov h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMinimize",1021,G__G__Minuit2_318_0_12, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize), -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNGradientBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameterState' - 11 - par "
"u 'ROOT::Minuit2::MnStrategy' - 11 - str", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMinimize",1021,G__G__Minuit2_318_0_13, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::MnMinimize' - 11 - migr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Minimizer",948,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize), -1, 1, 1, 1, 4, 0, "u 'ROOT::Minuit2::MnMinimize' - 11 - -", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MnMinimize", 1147, G__G__Minuit2_318_0_16, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLMnMinos(void) {
   /* ROOT::Minuit2::MnMinos */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinos));
   G__memfunc_setup("MnMinos",705,G__G__Minuit2_319_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinos), -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'ROOT::Minuit2::FunctionMinimum' - 11 - min "
"h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnMinos",705,G__G__Minuit2_319_0_2, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinos), -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'ROOT::Minuit2::FunctionMinimum' - 11 - min "
"u 'ROOT::Minuit2::MnStrategy' - 11 - stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Minuit2_319_0_3, 117, G__get_linked_tagnum(&G__G__Minuit2LN_pairlEdoublecOdoublegR), -1, 0, 2, 1, 1, 8, 
"h - - 0 - - h - - 0 '0' maxcalls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Lower",521,G__G__Minuit2_319_0_4, 100, -1, -1, 0, 2, 1, 1, 8, 
"h - - 0 - - h - - 0 '0' maxcalls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Upper",524,G__G__Minuit2_319_0_5, 100, -1, -1, 0, 2, 1, 1, 8, 
"h - - 0 - - h - - 0 '0' maxcalls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Loval",510,G__G__Minuit2_319_0_6, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnCross), -1, 0, 2, 1, 1, 8, 
"h - - 0 - - h - - 0 '0' maxcalls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Upval",520,G__G__Minuit2_319_0_7, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnCross), -1, 0, 2, 1, 1, 8, 
"h - - 0 - - h - - 0 '0' maxcalls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Minos",518,G__G__Minuit2_319_0_8, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinosError), -1, 0, 2, 1, 1, 8, 
"h - - 0 - - h - - 0 '0' maxcalls", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("FindCrossValue",1416,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnCross), -1, 0, 3, 1, 2, 8, 
"i - - 0 - dir h - - 0 - - "
"h - - 0 '0' maxcalls", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("MnMinos", 705, G__G__Minuit2_319_0_10, (int) ('i'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinos), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::MnMinos' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MnMinos", 831, G__G__Minuit2_319_0_11, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLMnPlot(void) {
   /* ROOT::Minuit2::MnPlot */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnPlot));
   G__memfunc_setup("MnPlot",602,G__G__Minuit2_323_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnPlot), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnPlot",602,G__G__Minuit2_323_0_2, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnPlot), -1, 0, 2, 1, 1, 0, 
"h - - 0 - width h - - 0 - length", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Minuit2_323_0_3, 121, -1, -1, 0, 1, 1, 1, 8, "u 'vector<pair<double,double>,allocator<pair<double,double> > >' 'vector<std::pair<double,double> >' 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator()",957,G__G__Minuit2_323_0_4, 121, -1, -1, 0, 3, 1, 1, 8, 
"d - - 0 - - d - - 0 - - "
"u 'vector<pair<double,double>,allocator<pair<double,double> > >' 'vector<std::pair<double,double> >' 11 - -", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Width",512,G__G__Minuit2_323_0_5, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Length",610,G__G__Minuit2_323_0_6, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
   // automatic copy constructor
   G__memfunc_setup("MnPlot", 602, G__G__Minuit2_323_0_7, (int) ('i'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnPlot), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::MnPlot' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MnPlot", 728, G__G__Minuit2_323_0_8, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Minuit2_323_0_9, (int) ('u'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnPlot), -1, 1, 1, 1, 1, 0, "u 'ROOT::Minuit2::MnPlot' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLScanMinimizer(void) {
   /* ROOT::Minuit2::ScanMinimizer */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLScanMinimizer));
   G__memfunc_setup("ScanMinimizer",1337,G__G__Minuit2_326_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLScanMinimizer), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("SeedGenerator",1320,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumSeedGenerator), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Builder",711,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumBuilder), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   // automatic copy constructor
   G__memfunc_setup("ScanMinimizer", 1337, G__G__Minuit2_326_0_4, (int) ('i'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLScanMinimizer), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::ScanMinimizer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~ScanMinimizer", 1463, G__G__Minuit2_326_0_5, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   // automatic assignment operator
   G__memfunc_setup("operator=", 937, G__G__Minuit2_326_0_6, (int) ('u'), G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLScanMinimizer), -1, 1, 1, 1, 1, 0, "u 'ROOT::Minuit2::ScanMinimizer' - 11 - -", (char*) NULL, (void*) NULL, 0);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLMnScan(void) {
   /* ROOT::Minuit2::MnScan */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnScan));
   G__memfunc_setup("MnScan",576,G__G__Minuit2_327_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnScan), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - err h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnScan",576,G__G__Minuit2_327_0_2, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnScan), -1, 0, 5, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"h - - 0 - nrow u 'vector<double,allocator<double> >' 'vector<double>' 11 - cov "
"h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnScan",576,G__G__Minuit2_327_0_3, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnScan), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"u 'ROOT::Minuit2::MnUserCovariance' - 11 - cov h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnScan",576,G__G__Minuit2_327_0_4, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnScan), -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameters' - 11 - par "
"h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnScan",576,G__G__Minuit2_327_0_5, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnScan), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameters' - 11 - par "
"u 'ROOT::Minuit2::MnUserCovariance' - 11 - cov h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnScan",576,G__G__Minuit2_327_0_6, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnScan), -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameterState' - 11 - par "
"u 'ROOT::Minuit2::MnStrategy' - 11 - str", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnScan",576,G__G__Minuit2_327_0_7, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnScan), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::MnScan' - 11 - migr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Minimizer",948,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("Scan",389,G__G__Minuit2_327_0_9, 117, G__get_linked_tagnum(&G__G__Minuit2LN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR), G__defined_typename("vector<std::pair<double,double> >"), 0, 4, 1, 1, 0, 
"h - - 0 - par h - - 0 '41' maxsteps "
"d - - 0 '0.' low d - - 0 '0.' high", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnScan), -1, 1, 1, 1, 4, 0, "u 'ROOT::Minuit2::MnScan' - 11 - -", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MnScan", 702, G__G__Minuit2_327_0_11, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}

static void G__setup_memfuncROOTcLcLMinuit2cLcLMnSimplex(void) {
   /* ROOT::Minuit2::MnSimplex */
   G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSimplex));
   G__memfunc_setup("MnSimplex",925,G__G__Minuit2_328_0_1, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSimplex), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"u 'vector<double,allocator<double> >' 'vector<double>' 11 - err h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnSimplex",925,G__G__Minuit2_328_0_2, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSimplex), -1, 0, 5, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"h - - 0 - nrow u 'vector<double,allocator<double> >' 'vector<double>' 11 - cov "
"h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnSimplex",925,G__G__Minuit2_328_0_3, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSimplex), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'vector<double,allocator<double> >' 'vector<double>' 11 - par "
"u 'ROOT::Minuit2::MnUserCovariance' - 11 - cov h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnSimplex",925,G__G__Minuit2_328_0_4, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSimplex), -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameters' - 11 - par "
"h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnSimplex",925,G__G__Minuit2_328_0_5, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSimplex), -1, 0, 4, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameters' - 11 - par "
"u 'ROOT::Minuit2::MnUserCovariance' - 11 - cov h - - 0 '1' stra", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnSimplex",925,G__G__Minuit2_328_0_6, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSimplex), -1, 0, 3, 1, 1, 0, 
"u 'ROOT::Minuit2::FCNBase' - 11 - fcn u 'ROOT::Minuit2::MnUserParameterState' - 11 - par "
"u 'ROOT::Minuit2::MnStrategy' - 11 - str", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("MnSimplex",925,G__G__Minuit2_328_0_7, 105, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSimplex), -1, 0, 1, 1, 1, 0, "u 'ROOT::Minuit2::MnSimplex' - 11 - migr", (char*)NULL, (void*) NULL, 0);
   G__memfunc_setup("Minimizer",948,(G__InterfaceMethod) NULL,117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
   G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSimplex), -1, 1, 1, 1, 4, 0, "u 'ROOT::Minuit2::MnSimplex' - 11 - -", (char*)NULL, (void*) NULL, 0);
   // automatic destructor
   G__memfunc_setup("~MnSimplex", 1051, G__G__Minuit2_328_0_10, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
   G__tag_memfunc_reset();
}


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

/*********************************************************
* Global variable information setup for each class
*********************************************************/
static void G__cpp_setup_global0() {

   /* Setting up global variables */
   G__resetplocal();

}

static void G__cpp_setup_global1() {
}

static void G__cpp_setup_global2() {
}

static void G__cpp_setup_global3() {
   G__memvar_setup((void*)(&gMinuit2),85,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_TFitterMinuit),-1,-1,1,"gMinuit2=",0,(char*)NULL);
   G__memvar_setup((void*)(&gFumili2),85,0,0,G__get_linked_tagnum(&G__G__Minuit2LN_TFitterFumili),-1,-1,1,"gFumili2=",0,(char*)NULL);
}

static void G__cpp_setup_global4() {

   G__resetglobalenv();
}
extern "C" void G__cpp_setup_globalG__Minuit2() {
  G__cpp_setup_global0();
  G__cpp_setup_global1();
  G__cpp_setup_global2();
  G__cpp_setup_global3();
  G__cpp_setup_global4();
}

/*********************************************************
* Global function information setup for each class
*********************************************************/
static void G__cpp_setup_func0() {
   G__lastifuncposition();

}

static void G__cpp_setup_func1() {
}

static void G__cpp_setup_func2() {
}

static void G__cpp_setup_func3() {
}

static void G__cpp_setup_func4() {
}

static void G__cpp_setup_func5() {
}

static void G__cpp_setup_func6() {
}

static void G__cpp_setup_func7() {
}

static void G__cpp_setup_func8() {

   G__resetifuncposition();
}

extern "C" void G__cpp_setup_funcG__Minuit2() {
  G__cpp_setup_func0();
  G__cpp_setup_func1();
  G__cpp_setup_func2();
  G__cpp_setup_func3();
  G__cpp_setup_func4();
  G__cpp_setup_func5();
  G__cpp_setup_func6();
  G__cpp_setup_func7();
  G__cpp_setup_func8();
}

/*********************************************************
* Class,struct,union,enum tag information setup
*********************************************************/
/* Setup class/struct taginfo */
G__linked_taginfo G__G__Minuit2LN_TClass = { "TClass" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_TBuffer = { "TBuffer" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_TMemberInspector = { "TMemberInspector" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_TObject = { "TObject" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_TNamed = { "TNamed" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOT = { "ROOT" , 110 , -1 };
G__linked_taginfo G__G__Minuit2LN_string = { "string" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2 = { "ROOT::Minuit2" , 110 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLGenericFunction = { "ROOT::Minuit2::GenericFunction" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<double,allocator<double> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNBase = { "ROOT::Minuit2::FCNBase" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_TVirtualFitter = { "TVirtualFitter" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR = { "vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<double,allocator<double> >,allocator<vector<double,allocator<double> > > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNGradientBase = { "ROOT::Minuit2::FCNGradientBase" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_TFcnAdapter = { "TFcnAdapter" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLVectorOuterProductlEROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRcOdoublegR = { "ROOT::Minuit2::VectorOuterProduct<ROOT::Minuit2::ABObj<vec,LAVector,double>,double>" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABObjlEROOTcLcLMinuit2cLcLsymcOROOTcLcLMinuit2cLcLVectorOuterProductlEROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRcOdoublegRcOdoublegR = { "ROOT::Minuit2::ABObj<ROOT::Minuit2::sym,ROOT::Minuit2::VectorOuterProduct<ROOT::Minuit2::ABObj<vec,LAVector,double>,double>,double>" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMatrixInverselEROOTcLcLMinuit2cLcLsymcOROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOdoublegR = { "ROOT::Minuit2::MatrixInverse<ROOT::Minuit2::sym,ROOT::Minuit2::ABObj<sym,LASymMatrix,double>,double>" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABObjlEROOTcLcLMinuit2cLcLsymcOROOTcLcLMinuit2cLcLMatrixInverselEROOTcLcLMinuit2cLcLsymcOROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOdoublegRcOdoublegR = { "ROOT::Minuit2::ABObj<ROOT::Minuit2::sym,ROOT::Minuit2::MatrixInverse<ROOT::Minuit2::sym,ROOT::Minuit2::ABObj<sym,LASymMatrix,double>,double>,double>" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuitParameter = { "ROOT::Minuit2::MinuitParameter" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMachinePrecision = { "ROOT::Minuit2::MnMachinePrecision" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserCovariance = { "ROOT::Minuit2::MnUserCovariance" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserTransformation = { "ROOT::Minuit2::MnUserTransformation" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinuitParametercOallocatorlEROOTcLcLMinuit2cLcLMinuitParametergRsPgR = { "vector<ROOT::Minuit2::MinuitParameter,allocator<ROOT::Minuit2::MinuitParameter> >" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_reverse_iteratorlEvectorlEROOTcLcLMinuit2cLcLMinuitParametercOallocatorlEROOTcLcLMinuit2cLcLMinuitParametergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::Minuit2::MinuitParameter,allocator<ROOT::Minuit2::MinuitParameter> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameters = { "ROOT::Minuit2::MnUserParameters" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnGlobalCorrelationCoeff = { "ROOT::Minuit2::MnGlobalCorrelationCoeff" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumState = { "ROOT::Minuit2::MinimumState" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState = { "ROOT::Minuit2::MnUserParameterState" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnCross = { "ROOT::Minuit2::MnCross" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinosError = { "ROOT::Minuit2::MinosError" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_pairlEdoublecOdoublegR = { "pair<double,double>" , 115 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum = { "ROOT::Minuit2::FunctionMinimum" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimizer = { "ROOT::Minuit2::FunctionMinimizer" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumSeedGenerator = { "ROOT::Minuit2::MinimumSeedGenerator" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumBuilder = { "ROOT::Minuit2::MinimumBuilder" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumSeed = { "ROOT::Minuit2::MinimumSeed" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFcn = { "ROOT::Minuit2::MnFcn" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLGradientCalculator = { "ROOT::Minuit2::GradientCalculator" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnStrategy = { "ROOT::Minuit2::MnStrategy" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliFCNBase = { "ROOT::Minuit2::FumiliFCNBase" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer = { "ROOT::Minuit2::ModularFunctionMinimizer" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSeedGenerator = { "ROOT::Minuit2::MnSeedGenerator" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionGradient = { "ROOT::Minuit2::FunctionGradient" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumError = { "ROOT::Minuit2::MinimumError" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumParameters = { "ROOT::Minuit2::MinimumParameters" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABSumlEROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRsPgR = { "ROOT::Minuit2::ABSum<ROOT::Minuit2::ABObj<vec,LAVector,double>,ROOT::Minuit2::ABObj<vec,LAVector,double> >" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABObjlEROOTcLcLMinuit2cLcLveccOROOTcLcLMinuit2cLcLABSumlEROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRsPgRcOdoublegR = { "ROOT::Minuit2::ABObj<ROOT::Minuit2::vec,ROOT::Minuit2::ABSum<ROOT::Minuit2::ABObj<vec,LAVector,double>,ROOT::Minuit2::ABObj<vec,LAVector,double> >,double>" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABSumlEROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRsPgR = { "ROOT::Minuit2::ABSum<ROOT::Minuit2::ABObj<sym,LASymMatrix,double>,ROOT::Minuit2::ABObj<sym,LASymMatrix,double> >" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABObjlEROOTcLcLMinuit2cLcLsymcOROOTcLcLMinuit2cLcLABSumlEROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRsPgRcOdoublegR = { "ROOT::Minuit2::ABObj<ROOT::Minuit2::sym,ROOT::Minuit2::ABSum<ROOT::Minuit2::ABObj<sym,LASymMatrix,double>,ROOT::Minuit2::ABObj<sym,LASymMatrix,double> >,double>" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinimumStatecOallocatorlEROOTcLcLMinuit2cLcLMinimumStategRsPgR = { "vector<ROOT::Minuit2::MinimumState,allocator<ROOT::Minuit2::MinimumState> >" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_reverse_iteratorlEvectorlEROOTcLcLMinuit2cLcLMinimumStatecOallocatorlEROOTcLcLMinuit2cLcLMinimumStategRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::Minuit2::MinimumState,allocator<ROOT::Minuit2::MinimumState> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimumcLcLMnReachedCallLimit = { "ROOT::Minuit2::FunctionMinimum::MnReachedCallLimit" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimumcLcLMnAboveMaxEdm = { "ROOT::Minuit2::FunctionMinimum::MnAboveMaxEdm" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnRefCountedPointerlEROOTcLcLMinuit2cLcLBasicFunctionMinimumgR = { "ROOT::Minuit2::MnRefCountedPointer<ROOT::Minuit2::BasicFunctionMinimum>" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliBuilder = { "ROOT::Minuit2::FumiliBuilder" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliMinimizer = { "ROOT::Minuit2::FumiliMinimizer" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_TFitterMinuit = { "TFitterMinuit" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_TFitterMinuitcLcLEMinimizerType = { "TFitterMinuit::EMinimizerType" , 101 , -1 };
G__linked_taginfo G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinosErrorcOallocatorlEROOTcLcLMinuit2cLcLMinosErrorgRsPgR = { "vector<ROOT::Minuit2::MinosError,allocator<ROOT::Minuit2::MinosError> >" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_reverse_iteratorlEvectorlEROOTcLcLMinuit2cLcLMinosErrorcOallocatorlEROOTcLcLMinuit2cLcLMinosErrorgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::Minuit2::MinosError,allocator<ROOT::Minuit2::MinosError> >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_TFitterFumili = { "TFitterFumili" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLVariableMetricBuilder = { "ROOT::Minuit2::VariableMetricBuilder" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLVariableMetricMinimizer = { "ROOT::Minuit2::VariableMetricMinimizer" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexBuilder = { "ROOT::Minuit2::SimplexBuilder" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexSeedGenerator = { "ROOT::Minuit2::SimplexSeedGenerator" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexMinimizer = { "ROOT::Minuit2::SimplexMinimizer" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLCombinedMinimumBuilder = { "ROOT::Minuit2::CombinedMinimumBuilder" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLCombinedMinimizer = { "ROOT::Minuit2::CombinedMinimizer" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLContoursError = { "ROOT::Minuit2::ContoursError" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR = { "vector<pair<double,double>,allocator<pair<double,double> > >" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<double,double>,allocator<pair<double,double> > >::iterator>" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMath = { "ROOT::Math" , 110 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMathcLcLIBaseFunctionMultiDim = { "ROOT::Math::IBaseFunctionMultiDim" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMathcLcLIGradientFunctionMultiDim = { "ROOT::Math::IGradientFunctionMultiDim" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR = { "ROOT::Math::BasicFitMethodFunction<ROOT::Math::IBaseFunctionMultiDim>" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR = { "ROOT::Math::BasicFitMethodFunction<ROOT::Math::IGradientFunctionMultiDim>" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABProdlEROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRsPgR = { "ROOT::Minuit2::ABProd<ROOT::Minuit2::ABObj<sym,LASymMatrix,double>,ROOT::Minuit2::ABObj<vec,LAVector,double> >" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABObjlEROOTcLcLMinuit2cLcLveccOROOTcLcLMinuit2cLcLABProdlEROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRsPgRcOdoublegR = { "ROOT::Minuit2::ABObj<ROOT::Minuit2::vec,ROOT::Minuit2::ABProd<ROOT::Minuit2::ABObj<sym,LASymMatrix,double>,ROOT::Minuit2::ABObj<vec,LAVector,double> >,double>" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMathcLcLMinimizer = { "ROOT::Math::Minimizer" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLEMinimizerType = { "ROOT::Minuit2::EMinimizerType" , 101 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuit2Minimizer = { "ROOT::Minuit2::Minuit2Minimizer" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnApplication = { "ROOT::Minuit2::MnApplication" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnContours = { "ROOT::Minuit2::MnContours" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFumiliMinimize = { "ROOT::Minuit2::MnFumiliMinimize" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnHesse = { "ROOT::Minuit2::MnHesse" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad = { "ROOT::Minuit2::MnMigrad" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize = { "ROOT::Minuit2::MnMinimize" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinos = { "ROOT::Minuit2::MnMinos" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnPlot = { "ROOT::Minuit2::MnPlot" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLScanBuilder = { "ROOT::Minuit2::ScanBuilder" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLScanMinimizer = { "ROOT::Minuit2::ScanMinimizer" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnScan = { "ROOT::Minuit2::MnScan" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSimplex = { "ROOT::Minuit2::MnSimplex" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_vectorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRcOallocatorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRsPgRsPgR = { "vector<pair<double,ROOT::Minuit2::LAVector>,allocator<pair<double,ROOT::Minuit2::LAVector> > >" , 99 , -1 };
G__linked_taginfo G__G__Minuit2LN_reverse_iteratorlEvectorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRcOallocatorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<double,ROOT::Minuit2::LAVector>,allocator<pair<double,ROOT::Minuit2::LAVector> > >::iterator>" , 99 , -1 };

/* Reset class/struct taginfo */
extern "C" void G__cpp_reset_tagtableG__Minuit2() {
  G__G__Minuit2LN_TClass.tagnum = -1 ;
  G__G__Minuit2LN_TBuffer.tagnum = -1 ;
  G__G__Minuit2LN_TMemberInspector.tagnum = -1 ;
  G__G__Minuit2LN_TObject.tagnum = -1 ;
  G__G__Minuit2LN_TNamed.tagnum = -1 ;
  G__G__Minuit2LN_ROOT.tagnum = -1 ;
  G__G__Minuit2LN_string.tagnum = -1 ;
  G__G__Minuit2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
  G__G__Minuit2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Minuit2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
  G__G__Minuit2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLGenericFunction.tagnum = -1 ;
  G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
  G__G__Minuit2LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNBase.tagnum = -1 ;
  G__G__Minuit2LN_TVirtualFitter.tagnum = -1 ;
  G__G__Minuit2LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR.tagnum = -1 ;
  G__G__Minuit2LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNGradientBase.tagnum = -1 ;
  G__G__Minuit2LN_TFcnAdapter.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLVectorOuterProductlEROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRcOdoublegR.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABObjlEROOTcLcLMinuit2cLcLsymcOROOTcLcLMinuit2cLcLVectorOuterProductlEROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRcOdoublegRcOdoublegR.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMatrixInverselEROOTcLcLMinuit2cLcLsymcOROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOdoublegR.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABObjlEROOTcLcLMinuit2cLcLsymcOROOTcLcLMinuit2cLcLMatrixInverselEROOTcLcLMinuit2cLcLsymcOROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOdoublegRcOdoublegR.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuitParameter.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMachinePrecision.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserCovariance.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserTransformation.tagnum = -1 ;
  G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinuitParametercOallocatorlEROOTcLcLMinuit2cLcLMinuitParametergRsPgR.tagnum = -1 ;
  G__G__Minuit2LN_reverse_iteratorlEvectorlEROOTcLcLMinuit2cLcLMinuitParametercOallocatorlEROOTcLcLMinuit2cLcLMinuitParametergRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Minuit2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
  G__G__Minuit2LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameters.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnGlobalCorrelationCoeff.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumState.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnCross.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinosError.tagnum = -1 ;
  G__G__Minuit2LN_pairlEdoublecOdoublegR.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimizer.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumSeedGenerator.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumBuilder.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumSeed.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFcn.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLGradientCalculator.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnStrategy.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliFCNBase.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSeedGenerator.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionGradient.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumError.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumParameters.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABSumlEROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRsPgR.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABObjlEROOTcLcLMinuit2cLcLveccOROOTcLcLMinuit2cLcLABSumlEROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRsPgRcOdoublegR.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABSumlEROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRsPgR.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABObjlEROOTcLcLMinuit2cLcLsymcOROOTcLcLMinuit2cLcLABSumlEROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRsPgRcOdoublegR.tagnum = -1 ;
  G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinimumStatecOallocatorlEROOTcLcLMinuit2cLcLMinimumStategRsPgR.tagnum = -1 ;
  G__G__Minuit2LN_reverse_iteratorlEvectorlEROOTcLcLMinuit2cLcLMinimumStatecOallocatorlEROOTcLcLMinuit2cLcLMinimumStategRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimumcLcLMnReachedCallLimit.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimumcLcLMnAboveMaxEdm.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnRefCountedPointerlEROOTcLcLMinuit2cLcLBasicFunctionMinimumgR.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliBuilder.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliMinimizer.tagnum = -1 ;
  G__G__Minuit2LN_TFitterMinuit.tagnum = -1 ;
  G__G__Minuit2LN_TFitterMinuitcLcLEMinimizerType.tagnum = -1 ;
  G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinosErrorcOallocatorlEROOTcLcLMinuit2cLcLMinosErrorgRsPgR.tagnum = -1 ;
  G__G__Minuit2LN_reverse_iteratorlEvectorlEROOTcLcLMinuit2cLcLMinosErrorcOallocatorlEROOTcLcLMinuit2cLcLMinosErrorgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Minuit2LN_TFitterFumili.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLVariableMetricBuilder.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLVariableMetricMinimizer.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexBuilder.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexSeedGenerator.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexMinimizer.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLCombinedMinimumBuilder.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLCombinedMinimizer.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLContoursError.tagnum = -1 ;
  G__G__Minuit2LN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR.tagnum = -1 ;
  G__G__Minuit2LN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMath.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMathcLcLIBaseFunctionMultiDim.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMathcLcLIGradientFunctionMultiDim.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABProdlEROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRsPgR.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABObjlEROOTcLcLMinuit2cLcLveccOROOTcLcLMinuit2cLcLABProdlEROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRsPgRcOdoublegR.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMathcLcLMinimizer.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLEMinimizerType.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuit2Minimizer.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnApplication.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnContours.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFumiliMinimize.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnHesse.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinos.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnPlot.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLScanBuilder.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLScanMinimizer.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnScan.tagnum = -1 ;
  G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSimplex.tagnum = -1 ;
  G__G__Minuit2LN_vectorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRcOallocatorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRsPgRsPgR.tagnum = -1 ;
  G__G__Minuit2LN_reverse_iteratorlEvectorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRcOallocatorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
}


extern "C" void G__cpp_setup_tagtableG__Minuit2() {

   /* Setting up class,struct,union tag entry */
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_TClass);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_TBuffer);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_TMemberInspector);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_TObject);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_TNamed);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOT);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_string);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLGenericFunction),sizeof(ROOT::Minuit2::GenericFunction),-1,1025,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLGenericFunction,G__setup_memfuncROOTcLcLMinuit2cLcLGenericFunction);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_vectorlEdoublecOallocatorlEdoublegRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNBase),sizeof(ROOT::Minuit2::FCNBase),-1,1026,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLFCNBase,G__setup_memfuncROOTcLcLMinuit2cLcLFCNBase);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_TVirtualFitter);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_vectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_reverse_iteratorlEvectorlEvectorlEdoublecOallocatorlEdoublegRsPgRcOallocatorlEvectorlEdoublecOallocatorlEdoublegRsPgRsPgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFCNGradientBase),sizeof(ROOT::Minuit2::FCNGradientBase),-1,1027,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLFCNGradientBase,G__setup_memfuncROOTcLcLMinuit2cLcLFCNGradientBase);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_TFcnAdapter),sizeof(TFcnAdapter),-1,33792,"wrapper class implementing the Minuit2 interface for TMinuit2-like objective functions",G__setup_memvarTFcnAdapter,G__setup_memfuncTFcnAdapter);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLVectorOuterProductlEROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRcOdoublegR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABObjlEROOTcLcLMinuit2cLcLsymcOROOTcLcLMinuit2cLcLVectorOuterProductlEROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRcOdoublegRcOdoublegR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMatrixInverselEROOTcLcLMinuit2cLcLsymcOROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOdoublegR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABObjlEROOTcLcLMinuit2cLcLsymcOROOTcLcLMinuit2cLcLMatrixInverselEROOTcLcLMinuit2cLcLsymcOROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOdoublegRcOdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuitParameter),sizeof(ROOT::Minuit2::MinuitParameter),-1,36352,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLMinuitParameter,G__setup_memfuncROOTcLcLMinuit2cLcLMinuitParameter);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMachinePrecision);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserCovariance);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserTransformation);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinuitParametercOallocatorlEROOTcLcLMinuit2cLcLMinuitParametergRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_reverse_iteratorlEvectorlEROOTcLcLMinuit2cLcLMinuitParametercOallocatorlEROOTcLcLMinuit2cLcLMinuitParametergRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameters),sizeof(ROOT::Minuit2::MnUserParameters),-1,36608,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLMnUserParameters,G__setup_memfuncROOTcLcLMinuit2cLcLMnUserParameters);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnGlobalCorrelationCoeff);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumState);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnUserParameterState),sizeof(ROOT::Minuit2::MnUserParameterState),-1,36608,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLMnUserParameterState,G__setup_memfuncROOTcLcLMinuit2cLcLMnUserParameterState);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnCross);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinosError),sizeof(ROOT::Minuit2::MinosError),-1,34560,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLMinosError,G__setup_memfuncROOTcLcLMinuit2cLcLMinosError);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_pairlEdoublecOdoublegR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimum),sizeof(ROOT::Minuit2::FunctionMinimum),-1,36352,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLFunctionMinimum,G__setup_memfuncROOTcLcLMinuit2cLcLFunctionMinimum);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimizer),sizeof(ROOT::Minuit2::FunctionMinimizer),-1,1028,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLFunctionMinimizer,G__setup_memfuncROOTcLcLMinuit2cLcLFunctionMinimizer);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumSeedGenerator);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumBuilder);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumSeed);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFcn);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLGradientCalculator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnStrategy),sizeof(ROOT::Minuit2::MnStrategy),-1,34048,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLMnStrategy,G__setup_memfuncROOTcLcLMinuit2cLcLMnStrategy);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliFCNBase),sizeof(ROOT::Minuit2::FumiliFCNBase),-1,34051,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLFumiliFCNBase,G__setup_memfuncROOTcLcLMinuit2cLcLFumiliFCNBase);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLModularFunctionMinimizer),sizeof(ROOT::Minuit2::ModularFunctionMinimizer),-1,1026,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLModularFunctionMinimizer,G__setup_memfuncROOTcLcLMinuit2cLcLModularFunctionMinimizer);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSeedGenerator);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionGradient);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumError);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinimumParameters);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABSumlEROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABObjlEROOTcLcLMinuit2cLcLveccOROOTcLcLMinuit2cLcLABSumlEROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRsPgRcOdoublegR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABSumlEROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABObjlEROOTcLcLMinuit2cLcLsymcOROOTcLcLMinuit2cLcLABSumlEROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRsPgRcOdoublegR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinimumStatecOallocatorlEROOTcLcLMinuit2cLcLMinimumStategRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_reverse_iteratorlEvectorlEROOTcLcLMinuit2cLcLMinimumStatecOallocatorlEROOTcLcLMinuit2cLcLMinimumStategRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimumcLcLMnReachedCallLimit);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFunctionMinimumcLcLMnAboveMaxEdm);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnRefCountedPointerlEROOTcLcLMinuit2cLcLBasicFunctionMinimumgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliBuilder);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLFumiliMinimizer),sizeof(ROOT::Minuit2::FumiliMinimizer),-1,1280,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLFumiliMinimizer,G__setup_memfuncROOTcLcLMinuit2cLcLFumiliMinimizer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_TFitterMinuit),sizeof(TFitterMinuit),-1,62720,"The ROOT fitter based on new Minuit (Minuit2)",G__setup_memvarTFitterMinuit,G__setup_memfuncTFitterMinuit);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_TFitterMinuitcLcLEMinimizerType);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_vectorlEROOTcLcLMinuit2cLcLMinosErrorcOallocatorlEROOTcLcLMinuit2cLcLMinosErrorgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_reverse_iteratorlEvectorlEROOTcLcLMinuit2cLcLMinosErrorcOallocatorlEROOTcLcLMinuit2cLcLMinosErrorgRsPgRcLcLiteratorgR);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_TFitterFumili),sizeof(TFitterFumili),-1,62720,"Fitter based on new Fumili method (Fumili2)",G__setup_memvarTFitterFumili,G__setup_memfuncTFitterFumili);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLVariableMetricBuilder);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLVariableMetricMinimizer),sizeof(ROOT::Minuit2::VariableMetricMinimizer),-1,1280,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLVariableMetricMinimizer,G__setup_memfuncROOTcLcLMinuit2cLcLVariableMetricMinimizer);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexBuilder);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexSeedGenerator);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLSimplexMinimizer),sizeof(ROOT::Minuit2::SimplexMinimizer),-1,1280,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLSimplexMinimizer,G__setup_memfuncROOTcLcLMinuit2cLcLSimplexMinimizer);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLCombinedMinimumBuilder);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLCombinedMinimizer),sizeof(ROOT::Minuit2::CombinedMinimizer),-1,1280,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLCombinedMinimizer,G__setup_memfuncROOTcLcLMinuit2cLcLCombinedMinimizer);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLContoursError);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMath);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMathcLcLIBaseFunctionMultiDim);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMathcLcLIGradientFunctionMultiDim);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABProdlEROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLABObjlEROOTcLcLMinuit2cLcLveccOROOTcLcLMinuit2cLcLABProdlEROOTcLcLMinuit2cLcLABObjlEsymcOLASymMatrixcOdoublegRcOROOTcLcLMinuit2cLcLABObjlEveccOLAVectorcOdoublegRsPgRcOdoublegR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMathcLcLMinimizer);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLEMinimizerType);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMinuit2Minimizer),sizeof(ROOT::Minuit2::Minuit2Minimizer),-1,36608,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLMinuit2Minimizer,G__setup_memfuncROOTcLcLMinuit2cLcLMinuit2Minimizer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnApplication),sizeof(ROOT::Minuit2::MnApplication),-1,33793,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLMnApplication,G__setup_memfuncROOTcLcLMinuit2cLcLMnApplication);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnContours),sizeof(ROOT::Minuit2::MnContours),-1,33792,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLMnContours,G__setup_memfuncROOTcLcLMinuit2cLcLMnContours);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnFumiliMinimize),sizeof(ROOT::Minuit2::MnFumiliMinimize),-1,36352,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLMnFumiliMinimize,G__setup_memfuncROOTcLcLMinuit2cLcLMnFumiliMinimize);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnHesse),sizeof(ROOT::Minuit2::MnHesse),-1,34048,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLMnHesse,G__setup_memfuncROOTcLcLMinuit2cLcLMnHesse);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMigrad),sizeof(ROOT::Minuit2::MnMigrad),-1,36352,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLMnMigrad,G__setup_memfuncROOTcLcLMinuit2cLcLMnMigrad);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinimize),sizeof(ROOT::Minuit2::MnMinimize),-1,36352,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLMnMinimize,G__setup_memfuncROOTcLcLMinuit2cLcLMnMinimize);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnMinos),sizeof(ROOT::Minuit2::MnMinos),-1,33792,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLMnMinos,G__setup_memfuncROOTcLcLMinuit2cLcLMnMinos);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnPlot),sizeof(ROOT::Minuit2::MnPlot),-1,34048,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLMnPlot,G__setup_memfuncROOTcLcLMinuit2cLcLMnPlot);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLScanBuilder);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLScanMinimizer),sizeof(ROOT::Minuit2::ScanMinimizer),-1,1280,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLScanMinimizer,G__setup_memfuncROOTcLcLMinuit2cLcLScanMinimizer);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnScan),sizeof(ROOT::Minuit2::MnScan),-1,36352,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLMnScan,G__setup_memfuncROOTcLcLMinuit2cLcLMnScan);
   G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__Minuit2LN_ROOTcLcLMinuit2cLcLMnSimplex),sizeof(ROOT::Minuit2::MnSimplex),-1,36352,(char*)NULL,G__setup_memvarROOTcLcLMinuit2cLcLMnSimplex,G__setup_memfuncROOTcLcLMinuit2cLcLMnSimplex);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_vectorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRcOallocatorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRsPgRsPgR);
   G__get_linked_tagnum_fwd(&G__G__Minuit2LN_reverse_iteratorlEvectorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRcOallocatorlEpairlEdoublecOROOTcLcLMinuit2cLcLLAVectorgRsPgRsPgRcLcLiteratorgR);
}
extern "C" void G__cpp_setupG__Minuit2(void) {
  G__check_setup_version(30051515,"G__cpp_setupG__Minuit2()");
  G__set_cpp_environmentG__Minuit2();
  G__cpp_setup_tagtableG__Minuit2();

  G__cpp_setup_inheritanceG__Minuit2();

  G__cpp_setup_typetableG__Minuit2();

  G__cpp_setup_memvarG__Minuit2();

  G__cpp_setup_memfuncG__Minuit2();
  G__cpp_setup_globalG__Minuit2();
  G__cpp_setup_funcG__Minuit2();

   if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__Minuit2();
  return;
}
class G__cpp_setup_initG__Minuit2 {
  public:
    G__cpp_setup_initG__Minuit2() { G__add_setup_func("G__Minuit2",(G__incsetup)(&G__cpp_setupG__Minuit2)); G__call_setup_funcs(); }
   ~G__cpp_setup_initG__Minuit2() { G__remove_setup_func("G__Minuit2"); }
};
G__cpp_setup_initG__Minuit2 G__cpp_setup_initializerG__Minuit2;

---