ROOT_528-00b_version: math/mathcore/src/G_

00001 //
00002 // File generated by core/utils/src/rootcint_tmp at Wed Apr 20 13:32:01 2011
00003 
00004 // Do NOT change. Changes will be lost next time file is generated
00005 //
00006 
00007 #define R__DICTIONARY_FILENAME mathdImathcoredIsrcdIG__MathFit
00008 #include "RConfig.h" //rootcint 4834
00009 #if !defined(R__ACCESS_IN_SYMBOL)
00010 //Break the privacy of classes -- Disabled for the moment
00011 #define private public
00012 #define protected public
00013 #endif
00014 
00015 // Since CINT ignores the std namespace, we need to do so in this file.
00016 namespace std {} using namespace std;
00017 #include "G__MathFit.h"
00018 
00019 #include "TCollectionProxyInfo.h"
00020 #include "TClass.h"
00021 #include "TBuffer.h"
00022 #include "TMemberInspector.h"
00023 #include "TError.h"
00024 
00025 #ifndef G__ROOT
00026 #define G__ROOT
00027 #endif
00028 
00029 #include "RtypesImp.h"
00030 #include "TIsAProxy.h"
00031 
00032 // START OF SHADOWS
00033 
00034 namespace ROOT {
00035    namespace Shadow {
00036       namespace ROOT {
00037          namespace Fit {
00038 
00039       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00040       typedef ::ROOT::Fit::FitData FitData;
00041       #else
00042       class FitData  {
00043          public:
00044          //friend XX;
00045          // To force the creation of a virtual table, throw just in case.
00046          virtual ~FitData() throw() {};
00047          ::ROOT::Fit::DataOptions fOptions; //
00048          ::ROOT::Fit::DataRange fRange; //
00049       };
00050       #endif
00051       } } 
00052       namespace ROOT {
00053          namespace Fit {
00054 
00055       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00056       typedef ::ROOT::Fit::BinData BinData;
00057       #else
00058       class BinData  :  public ::ROOT::Fit::FitData {
00059          public:
00060          //friend XX;
00061          #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00062          typedef ::ROOT::Fit::BinData::ErrorType ErrorType;
00063          #else
00064          enum ErrorType  {
00065          };
00066          #endif
00067 
00068          // To force the creation of a virtual table, throw just in case.
00069          virtual ~BinData() throw() {};
00070          unsigned int fDim; //coordinate dimension
00071          unsigned int fPointSize; //total point size including value and errors (= fDim + 2 for error in only Y ) 
00072          unsigned int fNPoints; //number of contained points in the data set (can be different than size of vector)
00073          double fRefVolume; //reference bin volume - used to normalize the bins in case of variable bins data
00074          ::ROOT::Fit::DataVector* fDataVector; //pointer to the copied in data vector
00075          ::ROOT::Fit::DataWrapper* fDataWrapper; //pointer to the external data wrapper structure
00076          vector< double > fBinEdge; //vector containing the bin upper edge (coordinate will contain low edge) 
00077       };
00078       #endif
00079       } } 
00080       namespace ROOT {
00081          namespace Fit {
00082 
00083       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00084       typedef ::ROOT::Fit::UnBinData UnBinData;
00085       #else
00086       class UnBinData  :  public ::ROOT::Fit::FitData {
00087          public:
00088          //friend XX;
00089          // To force the creation of a virtual table, throw just in case.
00090          virtual ~UnBinData() throw() {};
00091          unsigned int fDim; //coordinate data dimension
00092          unsigned int fNPoints; //numer of fit points
00093          ::ROOT::Fit::DataVector* fDataVector; //pointer to internal data vector (null for external data)
00094          ::ROOT::Fit::DataWrapper* fDataWrapper; //pointer to structure wrapping external data (null when data are copied in)
00095       };
00096       #endif
00097       } } 
00098       namespace ROOT {
00099          namespace Fit {
00100 
00101       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00102       typedef ::ROOT::Fit::ParameterSettings ParameterSettings;
00103       #else
00104       class ParameterSettings  {
00105          public:
00106          //friend XX;
00107          double fValue; //parameter value
00108          double fStepSize; //parameter step size (used by minimizer)
00109          bool fFix; //flag to control if parameter is fixed 
00110          double fLowerLimit; //lower parameter limit
00111          double fUpperLimit; //upper parameter limit
00112          bool fHasLowerLimit; //flag to control lower parameter limit
00113          bool fHasUpperLimit; //flag to control upper parameter limit
00114          string fName; //parameter name
00115       };
00116       #endif
00117       } } 
00118       namespace ROOT {
00119          namespace Fit {
00120 
00121       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00122       typedef ::ROOT::Fit::FitConfig FitConfig;
00123       #else
00124       class FitConfig  {
00125          public:
00126          //friend XX;
00127          bool fNormErrors; //flag for error normalization
00128          bool fParabErrors; //get correct parabolic errors estimate (call Hesse after minimizing)  
00129          bool fMinosErrors; //do full error analysis using Minos
00130          vector< ::ROOT::Fit::ParameterSettings > fSettings; //vector with the parameter settings
00131          vector< unsigned int > fMinosParams; //vector with the parameter indeces for running Minos
00132          ::ROOT::Math::MinimizerOptions fMinimizerOpts; //minimizer control parameters including name and algo type
00133       };
00134       #endif
00135       } } 
00136       namespace ROOT {
00137          namespace Fit {
00138 
00139       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00140       typedef ::ROOT::Fit::FitResult FitResult;
00141       #else
00142       class FitResult  {
00143          public:
00144          //friend XX;
00145          #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00146          typedef ::ROOT::Fit::FitResult::Fitter Fitter;
00147          #else
00148          class Fitter  {
00149             public:
00150             //friend XX;
00151          };
00152          #endif
00153 
00154          typedef ::ROOT::Math::IParametricFunctionMultiDim IModelFunction;
00155          bool fValid; //flag for indicating valid fit
00156          bool fNormalized; //flag for indicating is errors are normalized
00157          unsigned int fNFree; //number of fit free parameters (total parameters are in size of parameter vector)  
00158          unsigned int fNdf; //number of degree of freedom
00159          unsigned int fNCalls; //number of function calls
00160          int fStatus; //minimizer status code
00161          int fCovStatus; //covariance matrix status code
00162          double fVal; //minimum function value
00163          double fEdm; //expected distance from mimimum
00164          double fChi2; //fit chi2 value (different than fval in case of chi2 fits)
00165          ::ROOT::Math::IParametricFunctionMultiDim* fFitFunc; //! model function resulting  from the fit. It is given by Fitter but it is managed by FitResult
00166          vector< unsigned int > fFixedParams; //list of fixed parameters
00167          vector< unsigned int > fBoundParams; //list of limited parameters
00168          vector< double > fParams; //parameter values. Size is total number of parameters
00169          vector< double > fErrors; //errors 
00170          vector< double > fCovMatrix; //covariance matrix (size is npar*(npar+1)/2) where npar is total parameters
00171          vector< double > fGlobalCC; //global Correlation coefficient
00172          map< unsigned int, pair< double, double >  > fMinosErrors; //map contains the two Minos errors
00173          string fMinimType; //string indicating type of minimizer
00174          vector< ::string > fParNames; //parameter names (only with FCN only fits, when fFitFunc=0)
00175       };
00176       #endif
00177       } } 
00178       namespace ROOT {
00179          namespace Fit {
00180 
00181       #if !(defined(R__ACCESS_IN_SYMBOL) || defined(R__USE_SHADOW_CLASS))
00182       typedef ::ROOT::Fit::SparseData SparseData;
00183       #else
00184       class SparseData  :  public ::ROOT::Fit::FitData {
00185          public:
00186          //friend XX;
00187          // To force the creation of a virtual table, throw just in case.
00188          virtual ~SparseData() throw() {};
00189          ::ROOT::Fit::ProxyListBox* fList; //
00190       };
00191       #endif
00192       } } 
00193    } // of namespace Shadow
00194 } // of namespace ROOT
00195 // END OF SHADOWS
00196 
00197 namespace ROOT {
00198 namespace Fit {
00199    namespace ROOT {
00200       inline ::ROOT::TGenericClassInfo *GenerateInitInstance();
00201       static void ROOTcLcLFit_Dictionary();
00202 
00203       // Function generating the singleton type initializer
00204       inline ::ROOT::TGenericClassInfo *GenerateInitInstance()
00205       {
00206          static ::ROOT::TGenericClassInfo 
00207             instance("ROOT::Fit", 0 /*version*/, "include/Fit/SparseData.h", 26,
00208                      ::ROOT::DefineBehavior((void*)0,(void*)0),
00209                      &ROOTcLcLFit_Dictionary, 0);
00210          return &instance;
00211       }
00212       // Insure that the inline function is _not_ optimized away by the compiler
00213       ::ROOT::TGenericClassInfo *(*_R__UNIQUE_(InitFunctionKeeper))() = &GenerateInitInstance;  
00214       // Static variable to force the class initialization
00215       static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstance(); R__UseDummy(_R__UNIQUE_(Init));
00216 
00217       // Dictionary for non-ClassDef classes
00218       static void ROOTcLcLFit_Dictionary() {
00219          GenerateInitInstance()->GetClass();
00220       }
00221 
00222    }
00223 }
00224 }
00225 
00226 namespace ROOT {
00227    void ROOTcLcLFitcLcLDataOptions_ShowMembers(void *obj, TMemberInspector &R__insp);
00228    static void ROOTcLcLFitcLcLDataOptions_Dictionary();
00229    static void *new_ROOTcLcLFitcLcLDataOptions(void *p = 0);
00230    static void *newArray_ROOTcLcLFitcLcLDataOptions(Long_t size, void *p);
00231    static void delete_ROOTcLcLFitcLcLDataOptions(void *p);
00232    static void deleteArray_ROOTcLcLFitcLcLDataOptions(void *p);
00233    static void destruct_ROOTcLcLFitcLcLDataOptions(void *p);
00234 
00235    // Function generating the singleton type initializer
00236    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Fit::DataOptions*)
00237    {
00238       ::ROOT::Fit::DataOptions *ptr = 0;
00239       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Fit::DataOptions),0);
00240       static ::ROOT::TGenericClassInfo 
00241          instance("ROOT::Fit::DataOptions", "include/Fit/DataOptions.h", 28,
00242                   typeid(::ROOT::Fit::DataOptions), DefineBehavior(ptr, ptr),
00243                   0, &ROOTcLcLFitcLcLDataOptions_Dictionary, isa_proxy, 0,
00244                   sizeof(::ROOT::Fit::DataOptions) );
00245       instance.SetNew(&new_ROOTcLcLFitcLcLDataOptions);
00246       instance.SetNewArray(&newArray_ROOTcLcLFitcLcLDataOptions);
00247       instance.SetDelete(&delete_ROOTcLcLFitcLcLDataOptions);
00248       instance.SetDeleteArray(&deleteArray_ROOTcLcLFitcLcLDataOptions);
00249       instance.SetDestructor(&destruct_ROOTcLcLFitcLcLDataOptions);
00250       return &instance;
00251    }
00252    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Fit::DataOptions*)
00253    {
00254       return GenerateInitInstanceLocal((::ROOT::Fit::DataOptions*)0);
00255    }
00256    // Static variable to force the class initialization
00257    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Fit::DataOptions*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00258 
00259    // Dictionary for non-ClassDef classes
00260    static void ROOTcLcLFitcLcLDataOptions_Dictionary() {
00261       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::DataOptions*)0x0)->GetClass();
00262    }
00263 
00264 } // end of namespace ROOT
00265 
00266 namespace ROOT {
00267    void ROOTcLcLFitcLcLDataRange_ShowMembers(void *obj, TMemberInspector &R__insp);
00268    static void ROOTcLcLFitcLcLDataRange_Dictionary();
00269    static void *new_ROOTcLcLFitcLcLDataRange(void *p = 0);
00270    static void *newArray_ROOTcLcLFitcLcLDataRange(Long_t size, void *p);
00271    static void delete_ROOTcLcLFitcLcLDataRange(void *p);
00272    static void deleteArray_ROOTcLcLFitcLcLDataRange(void *p);
00273    static void destruct_ROOTcLcLFitcLcLDataRange(void *p);
00274 
00275    // Function generating the singleton type initializer
00276    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Fit::DataRange*)
00277    {
00278       ::ROOT::Fit::DataRange *ptr = 0;
00279       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Fit::DataRange),0);
00280       static ::ROOT::TGenericClassInfo 
00281          instance("ROOT::Fit::DataRange", "include/Fit/DataRange.h", 34,
00282                   typeid(::ROOT::Fit::DataRange), DefineBehavior(ptr, ptr),
00283                   0, &ROOTcLcLFitcLcLDataRange_Dictionary, isa_proxy, 0,
00284                   sizeof(::ROOT::Fit::DataRange) );
00285       instance.SetNew(&new_ROOTcLcLFitcLcLDataRange);
00286       instance.SetNewArray(&newArray_ROOTcLcLFitcLcLDataRange);
00287       instance.SetDelete(&delete_ROOTcLcLFitcLcLDataRange);
00288       instance.SetDeleteArray(&deleteArray_ROOTcLcLFitcLcLDataRange);
00289       instance.SetDestructor(&destruct_ROOTcLcLFitcLcLDataRange);
00290       return &instance;
00291    }
00292    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Fit::DataRange*)
00293    {
00294       return GenerateInitInstanceLocal((::ROOT::Fit::DataRange*)0);
00295    }
00296    // Static variable to force the class initialization
00297    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Fit::DataRange*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00298 
00299    // Dictionary for non-ClassDef classes
00300    static void ROOTcLcLFitcLcLDataRange_Dictionary() {
00301       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::DataRange*)0x0)->GetClass();
00302    }
00303 
00304 } // end of namespace ROOT
00305 
00306 namespace ROOT {
00307    void ROOTcLcLFitcLcLFitData_ShowMembers(void *obj, TMemberInspector &R__insp);
00308    static void ROOTcLcLFitcLcLFitData_Dictionary();
00309    static void *new_ROOTcLcLFitcLcLFitData(void *p = 0);
00310    static void *newArray_ROOTcLcLFitcLcLFitData(Long_t size, void *p);
00311    static void delete_ROOTcLcLFitcLcLFitData(void *p);
00312    static void deleteArray_ROOTcLcLFitcLcLFitData(void *p);
00313    static void destruct_ROOTcLcLFitcLcLFitData(void *p);
00314 
00315    // Function generating the singleton type initializer
00316    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Fit::FitData*)
00317    {
00318       // Make sure the shadow class has the right sizeof
00319       R__ASSERT(sizeof(::ROOT::Fit::FitData) == sizeof(::ROOT::Shadow::ROOT::Fit::FitData));
00320       ::ROOT::Fit::FitData *ptr = 0;
00321       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Fit::FitData),0);
00322       static ::ROOT::TGenericClassInfo 
00323          instance("ROOT::Fit::FitData", "include/Fit/DataVector.h", 55,
00324                   typeid(::ROOT::Fit::FitData), DefineBehavior(ptr, ptr),
00325                   &ROOTcLcLFitcLcLFitData_ShowMembers, &ROOTcLcLFitcLcLFitData_Dictionary, isa_proxy, 4,
00326                   sizeof(::ROOT::Fit::FitData) );
00327       instance.SetNew(&new_ROOTcLcLFitcLcLFitData);
00328       instance.SetNewArray(&newArray_ROOTcLcLFitcLcLFitData);
00329       instance.SetDelete(&delete_ROOTcLcLFitcLcLFitData);
00330       instance.SetDeleteArray(&deleteArray_ROOTcLcLFitcLcLFitData);
00331       instance.SetDestructor(&destruct_ROOTcLcLFitcLcLFitData);
00332       return &instance;
00333    }
00334    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Fit::FitData*)
00335    {
00336       return GenerateInitInstanceLocal((::ROOT::Fit::FitData*)0);
00337    }
00338    // Static variable to force the class initialization
00339    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Fit::FitData*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00340 
00341    // Dictionary for non-ClassDef classes
00342    static void ROOTcLcLFitcLcLFitData_Dictionary() {
00343       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::FitData*)0x0)->GetClass();
00344    }
00345 
00346 } // end of namespace ROOT
00347 
00348 namespace ROOT {
00349    void ROOTcLcLFitcLcLBinData_ShowMembers(void *obj, TMemberInspector &R__insp);
00350    static void ROOTcLcLFitcLcLBinData_Dictionary();
00351    static void *new_ROOTcLcLFitcLcLBinData(void *p = 0);
00352    static void *newArray_ROOTcLcLFitcLcLBinData(Long_t size, void *p);
00353    static void delete_ROOTcLcLFitcLcLBinData(void *p);
00354    static void deleteArray_ROOTcLcLFitcLcLBinData(void *p);
00355    static void destruct_ROOTcLcLFitcLcLBinData(void *p);
00356 
00357    // Function generating the singleton type initializer
00358    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Fit::BinData*)
00359    {
00360       // Make sure the shadow class has the right sizeof
00361       R__ASSERT(sizeof(::ROOT::Fit::BinData) == sizeof(::ROOT::Shadow::ROOT::Fit::BinData));
00362       ::ROOT::Fit::BinData *ptr = 0;
00363       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Fit::BinData),0);
00364       static ::ROOT::TGenericClassInfo 
00365          instance("ROOT::Fit::BinData", "include/Fit/BinData.h", 61,
00366                   typeid(::ROOT::Fit::BinData), DefineBehavior(ptr, ptr),
00367                   &ROOTcLcLFitcLcLBinData_ShowMembers, &ROOTcLcLFitcLcLBinData_Dictionary, isa_proxy, 4,
00368                   sizeof(::ROOT::Fit::BinData) );
00369       instance.SetNew(&new_ROOTcLcLFitcLcLBinData);
00370       instance.SetNewArray(&newArray_ROOTcLcLFitcLcLBinData);
00371       instance.SetDelete(&delete_ROOTcLcLFitcLcLBinData);
00372       instance.SetDeleteArray(&deleteArray_ROOTcLcLFitcLcLBinData);
00373       instance.SetDestructor(&destruct_ROOTcLcLFitcLcLBinData);
00374       return &instance;
00375    }
00376    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Fit::BinData*)
00377    {
00378       return GenerateInitInstanceLocal((::ROOT::Fit::BinData*)0);
00379    }
00380    // Static variable to force the class initialization
00381    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Fit::BinData*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00382 
00383    // Dictionary for non-ClassDef classes
00384    static void ROOTcLcLFitcLcLBinData_Dictionary() {
00385       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::BinData*)0x0)->GetClass();
00386    }
00387 
00388 } // end of namespace ROOT
00389 
00390 namespace ROOT {
00391    void ROOTcLcLFitcLcLUnBinData_ShowMembers(void *obj, TMemberInspector &R__insp);
00392    static void ROOTcLcLFitcLcLUnBinData_Dictionary();
00393    static void *new_ROOTcLcLFitcLcLUnBinData(void *p = 0);
00394    static void *newArray_ROOTcLcLFitcLcLUnBinData(Long_t size, void *p);
00395    static void delete_ROOTcLcLFitcLcLUnBinData(void *p);
00396    static void deleteArray_ROOTcLcLFitcLcLUnBinData(void *p);
00397    static void destruct_ROOTcLcLFitcLcLUnBinData(void *p);
00398 
00399    // Function generating the singleton type initializer
00400    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Fit::UnBinData*)
00401    {
00402       // Make sure the shadow class has the right sizeof
00403       R__ASSERT(sizeof(::ROOT::Fit::UnBinData) == sizeof(::ROOT::Shadow::ROOT::Fit::UnBinData));
00404       ::ROOT::Fit::UnBinData *ptr = 0;
00405       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Fit::UnBinData),0);
00406       static ::ROOT::TGenericClassInfo 
00407          instance("ROOT::Fit::UnBinData", "include/Fit/UnBinData.h", 47,
00408                   typeid(::ROOT::Fit::UnBinData), DefineBehavior(ptr, ptr),
00409                   &ROOTcLcLFitcLcLUnBinData_ShowMembers, &ROOTcLcLFitcLcLUnBinData_Dictionary, isa_proxy, 4,
00410                   sizeof(::ROOT::Fit::UnBinData) );
00411       instance.SetNew(&new_ROOTcLcLFitcLcLUnBinData);
00412       instance.SetNewArray(&newArray_ROOTcLcLFitcLcLUnBinData);
00413       instance.SetDelete(&delete_ROOTcLcLFitcLcLUnBinData);
00414       instance.SetDeleteArray(&deleteArray_ROOTcLcLFitcLcLUnBinData);
00415       instance.SetDestructor(&destruct_ROOTcLcLFitcLcLUnBinData);
00416       return &instance;
00417    }
00418    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Fit::UnBinData*)
00419    {
00420       return GenerateInitInstanceLocal((::ROOT::Fit::UnBinData*)0);
00421    }
00422    // Static variable to force the class initialization
00423    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Fit::UnBinData*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00424 
00425    // Dictionary for non-ClassDef classes
00426    static void ROOTcLcLFitcLcLUnBinData_Dictionary() {
00427       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::UnBinData*)0x0)->GetClass();
00428    }
00429 
00430 } // end of namespace ROOT
00431 
00432 namespace ROOT {
00433    void ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR_ShowMembers(void *obj, TMemberInspector &R__insp);
00434    static void ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR_Dictionary();
00435    static void delete_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void *p);
00436    static void deleteArray_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void *p);
00437    static void destruct_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void *p);
00438 
00439    // Function generating the singleton type initializer
00440    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>*)
00441    {
00442       ::ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim> *ptr = 0;
00443       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>),0);
00444       static ::ROOT::TGenericClassInfo 
00445          instance("ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>", "include/Fit/Chi2FCN.h", 74,
00446                   typeid(::ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>), DefineBehavior(ptr, ptr),
00447                   0, &ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR_Dictionary, isa_proxy, 1,
00448                   sizeof(::ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>) );
00449       instance.SetDelete(&delete_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR);
00450       instance.SetDeleteArray(&deleteArray_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR);
00451       instance.SetDestructor(&destruct_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR);
00452       return &instance;
00453    }
00454    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>*)
00455    {
00456       return GenerateInitInstanceLocal((::ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>*)0);
00457    }
00458    // Static variable to force the class initialization
00459    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00460 
00461    // Dictionary for non-ClassDef classes
00462    static void ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR_Dictionary() {
00463       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>*)0x0)->GetClass();
00464    }
00465 
00466 } // end of namespace ROOT
00467 
00468 namespace ROOT {
00469    void ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR_ShowMembers(void *obj, TMemberInspector &R__insp);
00470    static void ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR_Dictionary();
00471    static void delete_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void *p);
00472    static void deleteArray_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void *p);
00473    static void destruct_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void *p);
00474 
00475    // Function generating the singleton type initializer
00476    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>*)
00477    {
00478       ::ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim> *ptr = 0;
00479       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>),0);
00480       static ::ROOT::TGenericClassInfo 
00481          instance("ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>", "include/Fit/Chi2FCN.h", 74,
00482                   typeid(::ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>), DefineBehavior(ptr, ptr),
00483                   0, &ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR_Dictionary, isa_proxy, 1,
00484                   sizeof(::ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>) );
00485       instance.SetDelete(&delete_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR);
00486       instance.SetDeleteArray(&deleteArray_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR);
00487       instance.SetDestructor(&destruct_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR);
00488       return &instance;
00489    }
00490    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>*)
00491    {
00492       return GenerateInitInstanceLocal((::ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>*)0);
00493    }
00494    // Static variable to force the class initialization
00495    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00496 
00497    // Dictionary for non-ClassDef classes
00498    static void ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR_Dictionary() {
00499       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>*)0x0)->GetClass();
00500    }
00501 
00502 } // end of namespace ROOT
00503 
00504 namespace ROOT {
00505    void ROOTcLcLFitcLcLParameterSettings_ShowMembers(void *obj, TMemberInspector &R__insp);
00506    static void ROOTcLcLFitcLcLParameterSettings_Dictionary();
00507    static void *new_ROOTcLcLFitcLcLParameterSettings(void *p = 0);
00508    static void *newArray_ROOTcLcLFitcLcLParameterSettings(Long_t size, void *p);
00509    static void delete_ROOTcLcLFitcLcLParameterSettings(void *p);
00510    static void deleteArray_ROOTcLcLFitcLcLParameterSettings(void *p);
00511    static void destruct_ROOTcLcLFitcLcLParameterSettings(void *p);
00512 
00513    // Function generating the singleton type initializer
00514    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Fit::ParameterSettings*)
00515    {
00516       // Make sure the shadow class has the right sizeof
00517       R__ASSERT(sizeof(::ROOT::Fit::ParameterSettings) == sizeof(::ROOT::Shadow::ROOT::Fit::ParameterSettings));
00518       ::ROOT::Fit::ParameterSettings *ptr = 0;
00519       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Fit::ParameterSettings),0);
00520       static ::ROOT::TGenericClassInfo 
00521          instance("ROOT::Fit::ParameterSettings", "include/Fit/ParameterSettings.h", 33,
00522                   typeid(::ROOT::Fit::ParameterSettings), DefineBehavior(ptr, ptr),
00523                   &ROOTcLcLFitcLcLParameterSettings_ShowMembers, &ROOTcLcLFitcLcLParameterSettings_Dictionary, isa_proxy, 4,
00524                   sizeof(::ROOT::Fit::ParameterSettings) );
00525       instance.SetNew(&new_ROOTcLcLFitcLcLParameterSettings);
00526       instance.SetNewArray(&newArray_ROOTcLcLFitcLcLParameterSettings);
00527       instance.SetDelete(&delete_ROOTcLcLFitcLcLParameterSettings);
00528       instance.SetDeleteArray(&deleteArray_ROOTcLcLFitcLcLParameterSettings);
00529       instance.SetDestructor(&destruct_ROOTcLcLFitcLcLParameterSettings);
00530       return &instance;
00531    }
00532    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Fit::ParameterSettings*)
00533    {
00534       return GenerateInitInstanceLocal((::ROOT::Fit::ParameterSettings*)0);
00535    }
00536    // Static variable to force the class initialization
00537    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Fit::ParameterSettings*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00538 
00539    // Dictionary for non-ClassDef classes
00540    static void ROOTcLcLFitcLcLParameterSettings_Dictionary() {
00541       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::ParameterSettings*)0x0)->GetClass();
00542    }
00543 
00544 } // end of namespace ROOT
00545 
00546 namespace ROOT {
00547    void ROOTcLcLFitcLcLFitConfig_ShowMembers(void *obj, TMemberInspector &R__insp);
00548    static void ROOTcLcLFitcLcLFitConfig_Dictionary();
00549    static void *new_ROOTcLcLFitcLcLFitConfig(void *p = 0);
00550    static void *newArray_ROOTcLcLFitcLcLFitConfig(Long_t size, void *p);
00551    static void delete_ROOTcLcLFitcLcLFitConfig(void *p);
00552    static void deleteArray_ROOTcLcLFitcLcLFitConfig(void *p);
00553    static void destruct_ROOTcLcLFitcLcLFitConfig(void *p);
00554 
00555    // Function generating the singleton type initializer
00556    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Fit::FitConfig*)
00557    {
00558       // Make sure the shadow class has the right sizeof
00559       R__ASSERT(sizeof(::ROOT::Fit::FitConfig) == sizeof(::ROOT::Shadow::ROOT::Fit::FitConfig));
00560       ::ROOT::Fit::FitConfig *ptr = 0;
00561       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Fit::FitConfig),0);
00562       static ::ROOT::TGenericClassInfo 
00563          instance("ROOT::Fit::FitConfig", "include/Fit/FitConfig.h", 49,
00564                   typeid(::ROOT::Fit::FitConfig), DefineBehavior(ptr, ptr),
00565                   &ROOTcLcLFitcLcLFitConfig_ShowMembers, &ROOTcLcLFitcLcLFitConfig_Dictionary, isa_proxy, 4,
00566                   sizeof(::ROOT::Fit::FitConfig) );
00567       instance.SetNew(&new_ROOTcLcLFitcLcLFitConfig);
00568       instance.SetNewArray(&newArray_ROOTcLcLFitcLcLFitConfig);
00569       instance.SetDelete(&delete_ROOTcLcLFitcLcLFitConfig);
00570       instance.SetDeleteArray(&deleteArray_ROOTcLcLFitcLcLFitConfig);
00571       instance.SetDestructor(&destruct_ROOTcLcLFitcLcLFitConfig);
00572       return &instance;
00573    }
00574    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Fit::FitConfig*)
00575    {
00576       return GenerateInitInstanceLocal((::ROOT::Fit::FitConfig*)0);
00577    }
00578    // Static variable to force the class initialization
00579    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Fit::FitConfig*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00580 
00581    // Dictionary for non-ClassDef classes
00582    static void ROOTcLcLFitcLcLFitConfig_Dictionary() {
00583       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::FitConfig*)0x0)->GetClass();
00584    }
00585 
00586 } // end of namespace ROOT
00587 
00588 namespace ROOT {
00589    void ROOTcLcLFitcLcLFitResult_ShowMembers(void *obj, TMemberInspector &R__insp);
00590    static void ROOTcLcLFitcLcLFitResult_Dictionary();
00591    static void *new_ROOTcLcLFitcLcLFitResult(void *p = 0);
00592    static void *newArray_ROOTcLcLFitcLcLFitResult(Long_t size, void *p);
00593    static void delete_ROOTcLcLFitcLcLFitResult(void *p);
00594    static void deleteArray_ROOTcLcLFitcLcLFitResult(void *p);
00595    static void destruct_ROOTcLcLFitcLcLFitResult(void *p);
00596 
00597    // Function generating the singleton type initializer
00598    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Fit::FitResult*)
00599    {
00600       // Make sure the shadow class has the right sizeof
00601       R__ASSERT(sizeof(::ROOT::Fit::FitResult) == sizeof(::ROOT::Shadow::ROOT::Fit::FitResult));
00602       ::ROOT::Fit::FitResult *ptr = 0;
00603       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Fit::FitResult),0);
00604       static ::ROOT::TGenericClassInfo 
00605          instance("ROOT::Fit::FitResult", "include/Fit/FitResult.h", 50,
00606                   typeid(::ROOT::Fit::FitResult), DefineBehavior(ptr, ptr),
00607                   &ROOTcLcLFitcLcLFitResult_ShowMembers, &ROOTcLcLFitcLcLFitResult_Dictionary, isa_proxy, 4,
00608                   sizeof(::ROOT::Fit::FitResult) );
00609       instance.SetNew(&new_ROOTcLcLFitcLcLFitResult);
00610       instance.SetNewArray(&newArray_ROOTcLcLFitcLcLFitResult);
00611       instance.SetDelete(&delete_ROOTcLcLFitcLcLFitResult);
00612       instance.SetDeleteArray(&deleteArray_ROOTcLcLFitcLcLFitResult);
00613       instance.SetDestructor(&destruct_ROOTcLcLFitcLcLFitResult);
00614       return &instance;
00615    }
00616    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Fit::FitResult*)
00617    {
00618       return GenerateInitInstanceLocal((::ROOT::Fit::FitResult*)0);
00619    }
00620    // Static variable to force the class initialization
00621    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Fit::FitResult*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00622 
00623    // Dictionary for non-ClassDef classes
00624    static void ROOTcLcLFitcLcLFitResult_Dictionary() {
00625       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::FitResult*)0x0)->GetClass();
00626    }
00627 
00628 } // end of namespace ROOT
00629 
00630 namespace ROOT {
00631    void ROOTcLcLFitcLcLFitter_ShowMembers(void *obj, TMemberInspector &R__insp);
00632    static void ROOTcLcLFitcLcLFitter_Dictionary();
00633    static void *new_ROOTcLcLFitcLcLFitter(void *p = 0);
00634    static void *newArray_ROOTcLcLFitcLcLFitter(Long_t size, void *p);
00635    static void delete_ROOTcLcLFitcLcLFitter(void *p);
00636    static void deleteArray_ROOTcLcLFitcLcLFitter(void *p);
00637    static void destruct_ROOTcLcLFitcLcLFitter(void *p);
00638 
00639    // Function generating the singleton type initializer
00640    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Fit::Fitter*)
00641    {
00642       ::ROOT::Fit::Fitter *ptr = 0;
00643       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Fit::Fitter),0);
00644       static ::ROOT::TGenericClassInfo 
00645          instance("ROOT::Fit::Fitter", "include/Fit/Fitter.h", 73,
00646                   typeid(::ROOT::Fit::Fitter), DefineBehavior(ptr, ptr),
00647                   0, &ROOTcLcLFitcLcLFitter_Dictionary, isa_proxy, 0,
00648                   sizeof(::ROOT::Fit::Fitter) );
00649       instance.SetNew(&new_ROOTcLcLFitcLcLFitter);
00650       instance.SetNewArray(&newArray_ROOTcLcLFitcLcLFitter);
00651       instance.SetDelete(&delete_ROOTcLcLFitcLcLFitter);
00652       instance.SetDeleteArray(&deleteArray_ROOTcLcLFitcLcLFitter);
00653       instance.SetDestructor(&destruct_ROOTcLcLFitcLcLFitter);
00654       return &instance;
00655    }
00656    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Fit::Fitter*)
00657    {
00658       return GenerateInitInstanceLocal((::ROOT::Fit::Fitter*)0);
00659    }
00660    // Static variable to force the class initialization
00661    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Fit::Fitter*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00662 
00663    // Dictionary for non-ClassDef classes
00664    static void ROOTcLcLFitcLcLFitter_Dictionary() {
00665       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::Fitter*)0x0)->GetClass();
00666    }
00667 
00668 } // end of namespace ROOT
00669 
00670 namespace ROOT {
00671    void ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR_ShowMembers(void *obj, TMemberInspector &R__insp);
00672    static void ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR_Dictionary();
00673    static void delete_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void *p);
00674    static void deleteArray_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void *p);
00675    static void destruct_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void *p);
00676 
00677    // Function generating the singleton type initializer
00678    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*)
00679    {
00680       ::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim> *ptr = 0;
00681       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>),0);
00682       static ::ROOT::TGenericClassInfo 
00683          instance("ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>", "include/Fit/LogLikelihoodFCN.h", 53,
00684                   typeid(::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>), DefineBehavior(ptr, ptr),
00685                   0, &ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR_Dictionary, isa_proxy, 1,
00686                   sizeof(::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>) );
00687       instance.SetDelete(&delete_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR);
00688       instance.SetDeleteArray(&deleteArray_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR);
00689       instance.SetDestructor(&destruct_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR);
00690       return &instance;
00691    }
00692    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*)
00693    {
00694       return GenerateInitInstanceLocal((::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*)0);
00695    }
00696    // Static variable to force the class initialization
00697    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00698 
00699    // Dictionary for non-ClassDef classes
00700    static void ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR_Dictionary() {
00701       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*)0x0)->GetClass();
00702    }
00703 
00704 } // end of namespace ROOT
00705 
00706 namespace ROOT {
00707    void ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR_ShowMembers(void *obj, TMemberInspector &R__insp);
00708    static void ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR_Dictionary();
00709    static void delete_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void *p);
00710    static void deleteArray_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void *p);
00711    static void destruct_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void *p);
00712 
00713    // Function generating the singleton type initializer
00714    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*)
00715    {
00716       ::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim> *ptr = 0;
00717       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>),0);
00718       static ::ROOT::TGenericClassInfo 
00719          instance("ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>", "include/Fit/LogLikelihoodFCN.h", 53,
00720                   typeid(::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>), DefineBehavior(ptr, ptr),
00721                   0, &ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR_Dictionary, isa_proxy, 1,
00722                   sizeof(::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>) );
00723       instance.SetDelete(&delete_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR);
00724       instance.SetDeleteArray(&deleteArray_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR);
00725       instance.SetDestructor(&destruct_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR);
00726       return &instance;
00727    }
00728    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*)
00729    {
00730       return GenerateInitInstanceLocal((::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*)0);
00731    }
00732    // Static variable to force the class initialization
00733    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00734 
00735    // Dictionary for non-ClassDef classes
00736    static void ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR_Dictionary() {
00737       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*)0x0)->GetClass();
00738    }
00739 
00740 } // end of namespace ROOT
00741 
00742 namespace ROOT {
00743    void ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR_ShowMembers(void *obj, TMemberInspector &R__insp);
00744    static void ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR_Dictionary();
00745    static void delete_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void *p);
00746    static void deleteArray_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void *p);
00747    static void destruct_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void *p);
00748 
00749    // Function generating the singleton type initializer
00750    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*)
00751    {
00752       ::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim> *ptr = 0;
00753       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>),0);
00754       static ::ROOT::TGenericClassInfo 
00755          instance("ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>", "include/Fit/PoissonLikelihoodFCN.h", 53,
00756                   typeid(::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>), DefineBehavior(ptr, ptr),
00757                   0, &ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR_Dictionary, isa_proxy, 1,
00758                   sizeof(::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>) );
00759       instance.SetDelete(&delete_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR);
00760       instance.SetDeleteArray(&deleteArray_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR);
00761       instance.SetDestructor(&destruct_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR);
00762       return &instance;
00763    }
00764    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*)
00765    {
00766       return GenerateInitInstanceLocal((::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*)0);
00767    }
00768    // Static variable to force the class initialization
00769    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00770 
00771    // Dictionary for non-ClassDef classes
00772    static void ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR_Dictionary() {
00773       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*)0x0)->GetClass();
00774    }
00775 
00776 } // end of namespace ROOT
00777 
00778 namespace ROOT {
00779    void ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR_ShowMembers(void *obj, TMemberInspector &R__insp);
00780    static void ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR_Dictionary();
00781    static void delete_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void *p);
00782    static void deleteArray_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void *p);
00783    static void destruct_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void *p);
00784 
00785    // Function generating the singleton type initializer
00786    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*)
00787    {
00788       ::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim> *ptr = 0;
00789       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>),0);
00790       static ::ROOT::TGenericClassInfo 
00791          instance("ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>", "include/Fit/PoissonLikelihoodFCN.h", 53,
00792                   typeid(::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>), DefineBehavior(ptr, ptr),
00793                   0, &ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR_Dictionary, isa_proxy, 1,
00794                   sizeof(::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>) );
00795       instance.SetDelete(&delete_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR);
00796       instance.SetDeleteArray(&deleteArray_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR);
00797       instance.SetDestructor(&destruct_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR);
00798       return &instance;
00799    }
00800    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*)
00801    {
00802       return GenerateInitInstanceLocal((::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*)0);
00803    }
00804    // Static variable to force the class initialization
00805    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00806 
00807    // Dictionary for non-ClassDef classes
00808    static void ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR_Dictionary() {
00809       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*)0x0)->GetClass();
00810    }
00811 
00812 } // end of namespace ROOT
00813 
00814 namespace ROOT {
00815    void ROOTcLcLFitcLcLSparseData_ShowMembers(void *obj, TMemberInspector &R__insp);
00816    static void ROOTcLcLFitcLcLSparseData_Dictionary();
00817    static void delete_ROOTcLcLFitcLcLSparseData(void *p);
00818    static void deleteArray_ROOTcLcLFitcLcLSparseData(void *p);
00819    static void destruct_ROOTcLcLFitcLcLSparseData(void *p);
00820 
00821    // Function generating the singleton type initializer
00822    static TGenericClassInfo *GenerateInitInstanceLocal(const ::ROOT::Fit::SparseData*)
00823    {
00824       // Make sure the shadow class has the right sizeof
00825       R__ASSERT(sizeof(::ROOT::Fit::SparseData) == sizeof(::ROOT::Shadow::ROOT::Fit::SparseData));
00826       ::ROOT::Fit::SparseData *ptr = 0;
00827       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(::ROOT::Fit::SparseData),0);
00828       static ::ROOT::TGenericClassInfo 
00829          instance("ROOT::Fit::SparseData", "include/Fit/SparseData.h", 31,
00830                   typeid(::ROOT::Fit::SparseData), DefineBehavior(ptr, ptr),
00831                   &ROOTcLcLFitcLcLSparseData_ShowMembers, &ROOTcLcLFitcLcLSparseData_Dictionary, isa_proxy, 4,
00832                   sizeof(::ROOT::Fit::SparseData) );
00833       instance.SetDelete(&delete_ROOTcLcLFitcLcLSparseData);
00834       instance.SetDeleteArray(&deleteArray_ROOTcLcLFitcLcLSparseData);
00835       instance.SetDestructor(&destruct_ROOTcLcLFitcLcLSparseData);
00836       return &instance;
00837    }
00838    TGenericClassInfo *GenerateInitInstance(const ::ROOT::Fit::SparseData*)
00839    {
00840       return GenerateInitInstanceLocal((::ROOT::Fit::SparseData*)0);
00841    }
00842    // Static variable to force the class initialization
00843    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const ::ROOT::Fit::SparseData*)0x0); R__UseDummy(_R__UNIQUE_(Init));
00844 
00845    // Dictionary for non-ClassDef classes
00846    static void ROOTcLcLFitcLcLSparseData_Dictionary() {
00847       ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::SparseData*)0x0)->GetClass();
00848    }
00849 
00850 } // end of namespace ROOT
00851 
00852 namespace ROOT {
00853    // Wrappers around operator new
00854    static void *new_ROOTcLcLFitcLcLDataRange(void *p) {
00855       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Fit::DataRange : new ::ROOT::Fit::DataRange;
00856    }
00857    static void *newArray_ROOTcLcLFitcLcLDataRange(Long_t nElements, void *p) {
00858       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Fit::DataRange[nElements] : new ::ROOT::Fit::DataRange[nElements];
00859    }
00860    // Wrapper around operator delete
00861    static void delete_ROOTcLcLFitcLcLDataRange(void *p) {
00862       delete ((::ROOT::Fit::DataRange*)p);
00863    }
00864    static void deleteArray_ROOTcLcLFitcLcLDataRange(void *p) {
00865       delete [] ((::ROOT::Fit::DataRange*)p);
00866    }
00867    static void destruct_ROOTcLcLFitcLcLDataRange(void *p) {
00868       typedef ::ROOT::Fit::DataRange current_t;
00869       ((current_t*)p)->~current_t();
00870    }
00871 } // end of namespace ROOT for class ::ROOT::Fit::DataRange
00872 
00873 namespace ROOT {
00874    // Wrappers around operator new
00875    static void *new_ROOTcLcLFitcLcLDataOptions(void *p) {
00876       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Fit::DataOptions : new ::ROOT::Fit::DataOptions;
00877    }
00878    static void *newArray_ROOTcLcLFitcLcLDataOptions(Long_t nElements, void *p) {
00879       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Fit::DataOptions[nElements] : new ::ROOT::Fit::DataOptions[nElements];
00880    }
00881    // Wrapper around operator delete
00882    static void delete_ROOTcLcLFitcLcLDataOptions(void *p) {
00883       delete ((::ROOT::Fit::DataOptions*)p);
00884    }
00885    static void deleteArray_ROOTcLcLFitcLcLDataOptions(void *p) {
00886       delete [] ((::ROOT::Fit::DataOptions*)p);
00887    }
00888    static void destruct_ROOTcLcLFitcLcLDataOptions(void *p) {
00889       typedef ::ROOT::Fit::DataOptions current_t;
00890       ((current_t*)p)->~current_t();
00891    }
00892 } // end of namespace ROOT for class ::ROOT::Fit::DataOptions
00893 
00894 namespace ROOT {
00895    // Wrappers around operator new
00896    static void *new_ROOTcLcLFitcLcLFitter(void *p) {
00897       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Fit::Fitter : new ::ROOT::Fit::Fitter;
00898    }
00899    static void *newArray_ROOTcLcLFitcLcLFitter(Long_t nElements, void *p) {
00900       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Fit::Fitter[nElements] : new ::ROOT::Fit::Fitter[nElements];
00901    }
00902    // Wrapper around operator delete
00903    static void delete_ROOTcLcLFitcLcLFitter(void *p) {
00904       delete ((::ROOT::Fit::Fitter*)p);
00905    }
00906    static void deleteArray_ROOTcLcLFitcLcLFitter(void *p) {
00907       delete [] ((::ROOT::Fit::Fitter*)p);
00908    }
00909    static void destruct_ROOTcLcLFitcLcLFitter(void *p) {
00910       typedef ::ROOT::Fit::Fitter current_t;
00911       ((current_t*)p)->~current_t();
00912    }
00913 } // end of namespace ROOT for class ::ROOT::Fit::Fitter
00914 
00915 //______________________________________________________________________________
00916 namespace ROOT {
00917    void ROOTcLcLFitcLcLFitConfig_ShowMembers(void *obj, TMemberInspector &R__insp)
00918    {
00919       // Inspect the data members of an object of class ROOT::Fit::FitConfig.
00920       typedef ::ROOT::Shadow::ROOT::Fit::FitConfig ShadowClass;
00921       ShadowClass *sobj = (ShadowClass*)obj;
00922       if (sobj) { } // Dummy usage just in case there is no datamember.
00923 
00924       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::FitConfig*)0x0)->GetClass();
00925       if (R__cl || R__insp.IsA()) { }
00926       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormErrors", &sobj->fNormErrors);
00927       R__insp.Inspect(R__cl, R__insp.GetParent(), "fParabErrors", &sobj->fParabErrors);
00928       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinosErrors", &sobj->fMinosErrors);
00929       R__insp.Inspect(R__cl, R__insp.GetParent(), "fSettings", (void*)&sobj->fSettings);
00930       R__insp.InspectMember("vector<ROOT::Fit::ParameterSettings>", (void*)&sobj->fSettings, "fSettings.", false);
00931       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinosParams", (void*)&sobj->fMinosParams);
00932       R__insp.InspectMember("vector<unsigned int>", (void*)&sobj->fMinosParams, "fMinosParams.", false);
00933       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimizerOpts", (void*)&sobj->fMinimizerOpts);
00934       R__insp.InspectMember("ROOT::Math::MinimizerOptions", (void*)&sobj->fMinimizerOpts, "fMinimizerOpts.", false);
00935    }
00936 
00937 }
00938 
00939 namespace ROOT {
00940    // Wrappers around operator new
00941    static void *new_ROOTcLcLFitcLcLFitConfig(void *p) {
00942       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Fit::FitConfig : new ::ROOT::Fit::FitConfig;
00943    }
00944    static void *newArray_ROOTcLcLFitcLcLFitConfig(Long_t nElements, void *p) {
00945       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Fit::FitConfig[nElements] : new ::ROOT::Fit::FitConfig[nElements];
00946    }
00947    // Wrapper around operator delete
00948    static void delete_ROOTcLcLFitcLcLFitConfig(void *p) {
00949       delete ((::ROOT::Fit::FitConfig*)p);
00950    }
00951    static void deleteArray_ROOTcLcLFitcLcLFitConfig(void *p) {
00952       delete [] ((::ROOT::Fit::FitConfig*)p);
00953    }
00954    static void destruct_ROOTcLcLFitcLcLFitConfig(void *p) {
00955       typedef ::ROOT::Fit::FitConfig current_t;
00956       ((current_t*)p)->~current_t();
00957    }
00958 } // end of namespace ROOT for class ::ROOT::Fit::FitConfig
00959 
00960 //______________________________________________________________________________
00961 namespace ROOT {
00962    void ROOTcLcLFitcLcLFitData_ShowMembers(void *obj, TMemberInspector &R__insp)
00963    {
00964       // Inspect the data members of an object of class ROOT::Fit::FitData.
00965       typedef ::ROOT::Shadow::ROOT::Fit::FitData ShadowClass;
00966       ShadowClass *sobj = (ShadowClass*)obj;
00967       if (sobj) { } // Dummy usage just in case there is no datamember.
00968 
00969       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::FitData*)0x0)->GetClass();
00970       if (R__cl || R__insp.IsA()) { }
00971       R__insp.Inspect(R__cl, R__insp.GetParent(), "fOptions", (void*)&sobj->fOptions);
00972       R__insp.InspectMember("ROOT::Fit::DataOptions", (void*)&sobj->fOptions, "fOptions.", false);
00973       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRange", (void*)&sobj->fRange);
00974       R__insp.InspectMember("ROOT::Fit::DataRange", (void*)&sobj->fRange, "fRange.", false);
00975    }
00976 
00977 }
00978 
00979 namespace ROOT {
00980    // Wrappers around operator new
00981    static void *new_ROOTcLcLFitcLcLFitData(void *p) {
00982       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Fit::FitData : new ::ROOT::Fit::FitData;
00983    }
00984    static void *newArray_ROOTcLcLFitcLcLFitData(Long_t nElements, void *p) {
00985       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Fit::FitData[nElements] : new ::ROOT::Fit::FitData[nElements];
00986    }
00987    // Wrapper around operator delete
00988    static void delete_ROOTcLcLFitcLcLFitData(void *p) {
00989       delete ((::ROOT::Fit::FitData*)p);
00990    }
00991    static void deleteArray_ROOTcLcLFitcLcLFitData(void *p) {
00992       delete [] ((::ROOT::Fit::FitData*)p);
00993    }
00994    static void destruct_ROOTcLcLFitcLcLFitData(void *p) {
00995       typedef ::ROOT::Fit::FitData current_t;
00996       ((current_t*)p)->~current_t();
00997    }
00998 } // end of namespace ROOT for class ::ROOT::Fit::FitData
00999 
01000 //______________________________________________________________________________
01001 namespace ROOT {
01002    void ROOTcLcLFitcLcLBinData_ShowMembers(void *obj, TMemberInspector &R__insp)
01003    {
01004       // Inspect the data members of an object of class ROOT::Fit::BinData.
01005       typedef ::ROOT::Shadow::ROOT::Fit::BinData ShadowClass;
01006       ShadowClass *sobj = (ShadowClass*)obj;
01007       if (sobj) { } // Dummy usage just in case there is no datamember.
01008 
01009       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::BinData*)0x0)->GetClass();
01010       if (R__cl || R__insp.IsA()) { }
01011       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDim", &sobj->fDim);
01012       R__insp.Inspect(R__cl, R__insp.GetParent(), "fPointSize", &sobj->fPointSize);
01013       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNPoints", &sobj->fNPoints);
01014       R__insp.Inspect(R__cl, R__insp.GetParent(), "fRefVolume", &sobj->fRefVolume);
01015       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataVector", &sobj->fDataVector);
01016       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataWrapper", &sobj->fDataWrapper);
01017       R__insp.Inspect(R__cl, R__insp.GetParent(), "fBinEdge", (void*)&sobj->fBinEdge);
01018       R__insp.InspectMember("vector<double>", (void*)&sobj->fBinEdge, "fBinEdge.", false);
01019       R__insp.GenericShowMembers("ROOT::Fit::FitData", ( ::ROOT::Fit::FitData * )( (::ROOT::Fit::BinData*) obj ), false);
01020    }
01021 
01022 }
01023 
01024 namespace ROOT {
01025    // Wrappers around operator new
01026    static void *new_ROOTcLcLFitcLcLBinData(void *p) {
01027       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Fit::BinData : new ::ROOT::Fit::BinData;
01028    }
01029    static void *newArray_ROOTcLcLFitcLcLBinData(Long_t nElements, void *p) {
01030       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Fit::BinData[nElements] : new ::ROOT::Fit::BinData[nElements];
01031    }
01032    // Wrapper around operator delete
01033    static void delete_ROOTcLcLFitcLcLBinData(void *p) {
01034       delete ((::ROOT::Fit::BinData*)p);
01035    }
01036    static void deleteArray_ROOTcLcLFitcLcLBinData(void *p) {
01037       delete [] ((::ROOT::Fit::BinData*)p);
01038    }
01039    static void destruct_ROOTcLcLFitcLcLBinData(void *p) {
01040       typedef ::ROOT::Fit::BinData current_t;
01041       ((current_t*)p)->~current_t();
01042    }
01043 } // end of namespace ROOT for class ::ROOT::Fit::BinData
01044 
01045 //______________________________________________________________________________
01046 namespace ROOT {
01047    void ROOTcLcLFitcLcLUnBinData_ShowMembers(void *obj, TMemberInspector &R__insp)
01048    {
01049       // Inspect the data members of an object of class ROOT::Fit::UnBinData.
01050       typedef ::ROOT::Shadow::ROOT::Fit::UnBinData ShadowClass;
01051       ShadowClass *sobj = (ShadowClass*)obj;
01052       if (sobj) { } // Dummy usage just in case there is no datamember.
01053 
01054       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::UnBinData*)0x0)->GetClass();
01055       if (R__cl || R__insp.IsA()) { }
01056       R__insp.Inspect(R__cl, R__insp.GetParent(), "fDim", &sobj->fDim);
01057       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNPoints", &sobj->fNPoints);
01058       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataVector", &sobj->fDataVector);
01059       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fDataWrapper", &sobj->fDataWrapper);
01060       R__insp.GenericShowMembers("ROOT::Fit::FitData", ( ::ROOT::Fit::FitData * )( (::ROOT::Fit::UnBinData*) obj ), false);
01061    }
01062 
01063 }
01064 
01065 namespace ROOT {
01066    // Wrappers around operator new
01067    static void *new_ROOTcLcLFitcLcLUnBinData(void *p) {
01068       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Fit::UnBinData : new ::ROOT::Fit::UnBinData;
01069    }
01070    static void *newArray_ROOTcLcLFitcLcLUnBinData(Long_t nElements, void *p) {
01071       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Fit::UnBinData[nElements] : new ::ROOT::Fit::UnBinData[nElements];
01072    }
01073    // Wrapper around operator delete
01074    static void delete_ROOTcLcLFitcLcLUnBinData(void *p) {
01075       delete ((::ROOT::Fit::UnBinData*)p);
01076    }
01077    static void deleteArray_ROOTcLcLFitcLcLUnBinData(void *p) {
01078       delete [] ((::ROOT::Fit::UnBinData*)p);
01079    }
01080    static void destruct_ROOTcLcLFitcLcLUnBinData(void *p) {
01081       typedef ::ROOT::Fit::UnBinData current_t;
01082       ((current_t*)p)->~current_t();
01083    }
01084 } // end of namespace ROOT for class ::ROOT::Fit::UnBinData
01085 
01086 //______________________________________________________________________________
01087 namespace ROOT {
01088    void ROOTcLcLFitcLcLSparseData_ShowMembers(void *obj, TMemberInspector &R__insp)
01089    {
01090       // Inspect the data members of an object of class ROOT::Fit::SparseData.
01091       typedef ::ROOT::Shadow::ROOT::Fit::SparseData ShadowClass;
01092       ShadowClass *sobj = (ShadowClass*)obj;
01093       if (sobj) { } // Dummy usage just in case there is no datamember.
01094 
01095       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::SparseData*)0x0)->GetClass();
01096       if (R__cl || R__insp.IsA()) { }
01097       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fList", &sobj->fList);
01098       R__insp.GenericShowMembers("ROOT::Fit::FitData", ( ::ROOT::Fit::FitData * )( (::ROOT::Fit::SparseData*) obj ), false);
01099    }
01100 
01101 }
01102 
01103 namespace ROOT {
01104    // Wrapper around operator delete
01105    static void delete_ROOTcLcLFitcLcLSparseData(void *p) {
01106       delete ((::ROOT::Fit::SparseData*)p);
01107    }
01108    static void deleteArray_ROOTcLcLFitcLcLSparseData(void *p) {
01109       delete [] ((::ROOT::Fit::SparseData*)p);
01110    }
01111    static void destruct_ROOTcLcLFitcLcLSparseData(void *p) {
01112       typedef ::ROOT::Fit::SparseData current_t;
01113       ((current_t*)p)->~current_t();
01114    }
01115 } // end of namespace ROOT for class ::ROOT::Fit::SparseData
01116 
01117 //______________________________________________________________________________
01118 namespace ROOT {
01119    void ROOTcLcLFitcLcLFitResult_ShowMembers(void *obj, TMemberInspector &R__insp)
01120    {
01121       // Inspect the data members of an object of class ROOT::Fit::FitResult.
01122       typedef ::ROOT::Shadow::ROOT::Fit::FitResult ShadowClass;
01123       ShadowClass *sobj = (ShadowClass*)obj;
01124       if (sobj) { } // Dummy usage just in case there is no datamember.
01125 
01126       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::FitResult*)0x0)->GetClass();
01127       if (R__cl || R__insp.IsA()) { }
01128       R__insp.Inspect(R__cl, R__insp.GetParent(), "fValid", &sobj->fValid);
01129       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNormalized", &sobj->fNormalized);
01130       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNFree", &sobj->fNFree);
01131       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNdf", &sobj->fNdf);
01132       R__insp.Inspect(R__cl, R__insp.GetParent(), "fNCalls", &sobj->fNCalls);
01133       R__insp.Inspect(R__cl, R__insp.GetParent(), "fStatus", &sobj->fStatus);
01134       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCovStatus", &sobj->fCovStatus);
01135       R__insp.Inspect(R__cl, R__insp.GetParent(), "fVal", &sobj->fVal);
01136       R__insp.Inspect(R__cl, R__insp.GetParent(), "fEdm", &sobj->fEdm);
01137       R__insp.Inspect(R__cl, R__insp.GetParent(), "fChi2", &sobj->fChi2);
01138       R__insp.Inspect(R__cl, R__insp.GetParent(), "*fFitFunc", &sobj->fFitFunc);
01139       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFixedParams", (void*)&sobj->fFixedParams);
01140       R__insp.InspectMember("vector<unsigned int>", (void*)&sobj->fFixedParams, "fFixedParams.", false);
01141       R__insp.Inspect(R__cl, R__insp.GetParent(), "fBoundParams", (void*)&sobj->fBoundParams);
01142       R__insp.InspectMember("vector<unsigned int>", (void*)&sobj->fBoundParams, "fBoundParams.", false);
01143       R__insp.Inspect(R__cl, R__insp.GetParent(), "fParams", (void*)&sobj->fParams);
01144       R__insp.InspectMember("vector<double>", (void*)&sobj->fParams, "fParams.", false);
01145       R__insp.Inspect(R__cl, R__insp.GetParent(), "fErrors", (void*)&sobj->fErrors);
01146       R__insp.InspectMember("vector<double>", (void*)&sobj->fErrors, "fErrors.", false);
01147       R__insp.Inspect(R__cl, R__insp.GetParent(), "fCovMatrix", (void*)&sobj->fCovMatrix);
01148       R__insp.InspectMember("vector<double>", (void*)&sobj->fCovMatrix, "fCovMatrix.", false);
01149       R__insp.Inspect(R__cl, R__insp.GetParent(), "fGlobalCC", (void*)&sobj->fGlobalCC);
01150       R__insp.InspectMember("vector<double>", (void*)&sobj->fGlobalCC, "fGlobalCC.", false);
01151       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinosErrors", (void*)&sobj->fMinosErrors);
01152       R__insp.InspectMember("map<unsigned int,std::pair<double,double> >", (void*)&sobj->fMinosErrors, "fMinosErrors.", false);
01153       R__insp.Inspect(R__cl, R__insp.GetParent(), "fMinimType", (void*)&sobj->fMinimType);
01154       R__insp.InspectMember("string", (void*)&sobj->fMinimType, "fMinimType.", false);
01155       R__insp.Inspect(R__cl, R__insp.GetParent(), "fParNames", (void*)&sobj->fParNames);
01156       R__insp.InspectMember("vector<std::string>", (void*)&sobj->fParNames, "fParNames.", false);
01157    }
01158 
01159 }
01160 
01161 namespace ROOT {
01162    // Wrappers around operator new
01163    static void *new_ROOTcLcLFitcLcLFitResult(void *p) {
01164       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Fit::FitResult : new ::ROOT::Fit::FitResult;
01165    }
01166    static void *newArray_ROOTcLcLFitcLcLFitResult(Long_t nElements, void *p) {
01167       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Fit::FitResult[nElements] : new ::ROOT::Fit::FitResult[nElements];
01168    }
01169    // Wrapper around operator delete
01170    static void delete_ROOTcLcLFitcLcLFitResult(void *p) {
01171       delete ((::ROOT::Fit::FitResult*)p);
01172    }
01173    static void deleteArray_ROOTcLcLFitcLcLFitResult(void *p) {
01174       delete [] ((::ROOT::Fit::FitResult*)p);
01175    }
01176    static void destruct_ROOTcLcLFitcLcLFitResult(void *p) {
01177       typedef ::ROOT::Fit::FitResult current_t;
01178       ((current_t*)p)->~current_t();
01179    }
01180 } // end of namespace ROOT for class ::ROOT::Fit::FitResult
01181 
01182 //______________________________________________________________________________
01183 namespace ROOT {
01184    void ROOTcLcLFitcLcLParameterSettings_ShowMembers(void *obj, TMemberInspector &R__insp)
01185    {
01186       // Inspect the data members of an object of class ROOT::Fit::ParameterSettings.
01187       typedef ::ROOT::Shadow::ROOT::Fit::ParameterSettings ShadowClass;
01188       ShadowClass *sobj = (ShadowClass*)obj;
01189       if (sobj) { } // Dummy usage just in case there is no datamember.
01190 
01191       TClass *R__cl  = ::ROOT::GenerateInitInstanceLocal((const ::ROOT::Fit::ParameterSettings*)0x0)->GetClass();
01192       if (R__cl || R__insp.IsA()) { }
01193       R__insp.Inspect(R__cl, R__insp.GetParent(), "fValue", &sobj->fValue);
01194       R__insp.Inspect(R__cl, R__insp.GetParent(), "fStepSize", &sobj->fStepSize);
01195       R__insp.Inspect(R__cl, R__insp.GetParent(), "fFix", &sobj->fFix);
01196       R__insp.Inspect(R__cl, R__insp.GetParent(), "fLowerLimit", &sobj->fLowerLimit);
01197       R__insp.Inspect(R__cl, R__insp.GetParent(), "fUpperLimit", &sobj->fUpperLimit);
01198       R__insp.Inspect(R__cl, R__insp.GetParent(), "fHasLowerLimit", &sobj->fHasLowerLimit);
01199       R__insp.Inspect(R__cl, R__insp.GetParent(), "fHasUpperLimit", &sobj->fHasUpperLimit);
01200       R__insp.Inspect(R__cl, R__insp.GetParent(), "fName", (void*)&sobj->fName);
01201       R__insp.InspectMember("string", (void*)&sobj->fName, "fName.", false);
01202    }
01203 
01204 }
01205 
01206 namespace ROOT {
01207    // Wrappers around operator new
01208    static void *new_ROOTcLcLFitcLcLParameterSettings(void *p) {
01209       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Fit::ParameterSettings : new ::ROOT::Fit::ParameterSettings;
01210    }
01211    static void *newArray_ROOTcLcLFitcLcLParameterSettings(Long_t nElements, void *p) {
01212       return p ? ::new((::ROOT::TOperatorNewHelper*)p) ::ROOT::Fit::ParameterSettings[nElements] : new ::ROOT::Fit::ParameterSettings[nElements];
01213    }
01214    // Wrapper around operator delete
01215    static void delete_ROOTcLcLFitcLcLParameterSettings(void *p) {
01216       delete ((::ROOT::Fit::ParameterSettings*)p);
01217    }
01218    static void deleteArray_ROOTcLcLFitcLcLParameterSettings(void *p) {
01219       delete [] ((::ROOT::Fit::ParameterSettings*)p);
01220    }
01221    static void destruct_ROOTcLcLFitcLcLParameterSettings(void *p) {
01222       typedef ::ROOT::Fit::ParameterSettings current_t;
01223       ((current_t*)p)->~current_t();
01224    }
01225 } // end of namespace ROOT for class ::ROOT::Fit::ParameterSettings
01226 
01227 namespace ROOT {
01228    // Wrapper around operator delete
01229    static void delete_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void *p) {
01230       delete ((::ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>*)p);
01231    }
01232    static void deleteArray_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void *p) {
01233       delete [] ((::ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>*)p);
01234    }
01235    static void destruct_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void *p) {
01236       typedef ::ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim> current_t;
01237       ((current_t*)p)->~current_t();
01238    }
01239 } // end of namespace ROOT for class ::ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>
01240 
01241 namespace ROOT {
01242    // Wrapper around operator delete
01243    static void delete_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void *p) {
01244       delete ((::ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>*)p);
01245    }
01246    static void deleteArray_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void *p) {
01247       delete [] ((::ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>*)p);
01248    }
01249    static void destruct_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void *p) {
01250       typedef ::ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim> current_t;
01251       ((current_t*)p)->~current_t();
01252    }
01253 } // end of namespace ROOT for class ::ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>
01254 
01255 namespace ROOT {
01256    // Wrapper around operator delete
01257    static void delete_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void *p) {
01258       delete ((::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*)p);
01259    }
01260    static void deleteArray_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void *p) {
01261       delete [] ((::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*)p);
01262    }
01263    static void destruct_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void *p) {
01264       typedef ::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim> current_t;
01265       ((current_t*)p)->~current_t();
01266    }
01267 } // end of namespace ROOT for class ::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>
01268 
01269 namespace ROOT {
01270    // Wrapper around operator delete
01271    static void delete_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void *p) {
01272       delete ((::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*)p);
01273    }
01274    static void deleteArray_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void *p) {
01275       delete [] ((::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*)p);
01276    }
01277    static void destruct_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void *p) {
01278       typedef ::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim> current_t;
01279       ((current_t*)p)->~current_t();
01280    }
01281 } // end of namespace ROOT for class ::ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>
01282 
01283 namespace ROOT {
01284    // Wrapper around operator delete
01285    static void delete_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void *p) {
01286       delete ((::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*)p);
01287    }
01288    static void deleteArray_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void *p) {
01289       delete [] ((::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*)p);
01290    }
01291    static void destruct_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void *p) {
01292       typedef ::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim> current_t;
01293       ((current_t*)p)->~current_t();
01294    }
01295 } // end of namespace ROOT for class ::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>
01296 
01297 namespace ROOT {
01298    // Wrapper around operator delete
01299    static void delete_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void *p) {
01300       delete ((::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*)p);
01301    }
01302    static void deleteArray_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void *p) {
01303       delete [] ((::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*)p);
01304    }
01305    static void destruct_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void *p) {
01306       typedef ::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim> current_t;
01307       ((current_t*)p)->~current_t();
01308    }
01309 } // end of namespace ROOT for class ::ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>
01310 
01311 namespace ROOT {
01312    void maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR_ShowMembers(void *obj, TMemberInspector &R__insp);
01313    static void maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR_Dictionary();
01314    static void *new_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR(void *p = 0);
01315    static void *newArray_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR(Long_t size, void *p);
01316    static void delete_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR(void *p);
01317    static void deleteArray_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR(void *p);
01318    static void destruct_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR(void *p);
01319 
01320    // Function generating the singleton type initializer
01321    static TGenericClassInfo *GenerateInitInstanceLocal(const map<unsigned int,pair<double,double> >*)
01322    {
01323       map<unsigned int,pair<double,double> > *ptr = 0;
01324       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(map<unsigned int,pair<double,double> >),0);
01325       static ::ROOT::TGenericClassInfo 
01326          instance("map<unsigned int,pair<double,double> >", -2, "prec_stl/map", 63,
01327                   typeid(map<unsigned int,pair<double,double> >), DefineBehavior(ptr, ptr),
01328                   0, &maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR_Dictionary, isa_proxy, 0,
01329                   sizeof(map<unsigned int,pair<double,double> >) );
01330       instance.SetNew(&new_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR);
01331       instance.SetNewArray(&newArray_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR);
01332       instance.SetDelete(&delete_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR);
01333       instance.SetDeleteArray(&deleteArray_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR);
01334       instance.SetDestructor(&destruct_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR);
01335       instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::MapInsert< map<unsigned int,pair<double,double> > >()));
01336       return &instance;
01337    }
01338    // Static variable to force the class initialization
01339    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const map<unsigned int,pair<double,double> >*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01340 
01341    // Dictionary for non-ClassDef classes
01342    static void maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR_Dictionary() {
01343       ::ROOT::GenerateInitInstanceLocal((const map<unsigned int,pair<double,double> >*)0x0)->GetClass();
01344    }
01345 
01346 } // end of namespace ROOT
01347 
01348 namespace ROOT {
01349    // Wrappers around operator new
01350    static void *new_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR(void *p) {
01351       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) map<unsigned int,pair<double,double> > : new map<unsigned int,pair<double,double> >;
01352    }
01353    static void *newArray_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR(Long_t nElements, void *p) {
01354       return p ? ::new((::ROOT::TOperatorNewHelper*)p) map<unsigned int,pair<double,double> >[nElements] : new map<unsigned int,pair<double,double> >[nElements];
01355    }
01356    // Wrapper around operator delete
01357    static void delete_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR(void *p) {
01358       delete ((map<unsigned int,pair<double,double> >*)p);
01359    }
01360    static void deleteArray_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR(void *p) {
01361       delete [] ((map<unsigned int,pair<double,double> >*)p);
01362    }
01363    static void destruct_maplEunsignedsPintcOpairlEdoublecOdoublegRsPgR(void *p) {
01364       typedef map<unsigned int,pair<double,double> > current_t;
01365       ((current_t*)p)->~current_t();
01366    }
01367 } // end of namespace ROOT for class map<unsigned int,pair<double,double> >
01368 
01369 namespace ROOT {
01370    void vectorlEROOTcLcLFitcLcLParameterSettingsgR_ShowMembers(void *obj, TMemberInspector &R__insp);
01371    static void vectorlEROOTcLcLFitcLcLParameterSettingsgR_Dictionary();
01372    static void *new_vectorlEROOTcLcLFitcLcLParameterSettingsgR(void *p = 0);
01373    static void *newArray_vectorlEROOTcLcLFitcLcLParameterSettingsgR(Long_t size, void *p);
01374    static void delete_vectorlEROOTcLcLFitcLcLParameterSettingsgR(void *p);
01375    static void deleteArray_vectorlEROOTcLcLFitcLcLParameterSettingsgR(void *p);
01376    static void destruct_vectorlEROOTcLcLFitcLcLParameterSettingsgR(void *p);
01377 
01378    // Function generating the singleton type initializer
01379    static TGenericClassInfo *GenerateInitInstanceLocal(const vector<ROOT::Fit::ParameterSettings>*)
01380    {
01381       vector<ROOT::Fit::ParameterSettings> *ptr = 0;
01382       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<ROOT::Fit::ParameterSettings>),0);
01383       static ::ROOT::TGenericClassInfo 
01384          instance("vector<ROOT::Fit::ParameterSettings>", -2, "prec_stl/vector", 49,
01385                   typeid(vector<ROOT::Fit::ParameterSettings>), DefineBehavior(ptr, ptr),
01386                   0, &vectorlEROOTcLcLFitcLcLParameterSettingsgR_Dictionary, isa_proxy, 0,
01387                   sizeof(vector<ROOT::Fit::ParameterSettings>) );
01388       instance.SetNew(&new_vectorlEROOTcLcLFitcLcLParameterSettingsgR);
01389       instance.SetNewArray(&newArray_vectorlEROOTcLcLFitcLcLParameterSettingsgR);
01390       instance.SetDelete(&delete_vectorlEROOTcLcLFitcLcLParameterSettingsgR);
01391       instance.SetDeleteArray(&deleteArray_vectorlEROOTcLcLFitcLcLParameterSettingsgR);
01392       instance.SetDestructor(&destruct_vectorlEROOTcLcLFitcLcLParameterSettingsgR);
01393       instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<ROOT::Fit::ParameterSettings> >()));
01394       return &instance;
01395    }
01396    // Static variable to force the class initialization
01397    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<ROOT::Fit::ParameterSettings>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01398 
01399    // Dictionary for non-ClassDef classes
01400    static void vectorlEROOTcLcLFitcLcLParameterSettingsgR_Dictionary() {
01401       ::ROOT::GenerateInitInstanceLocal((const vector<ROOT::Fit::ParameterSettings>*)0x0)->GetClass();
01402    }
01403 
01404 } // end of namespace ROOT
01405 
01406 namespace ROOT {
01407    // Wrappers around operator new
01408    static void *new_vectorlEROOTcLcLFitcLcLParameterSettingsgR(void *p) {
01409       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<ROOT::Fit::ParameterSettings> : new vector<ROOT::Fit::ParameterSettings>;
01410    }
01411    static void *newArray_vectorlEROOTcLcLFitcLcLParameterSettingsgR(Long_t nElements, void *p) {
01412       return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<ROOT::Fit::ParameterSettings>[nElements] : new vector<ROOT::Fit::ParameterSettings>[nElements];
01413    }
01414    // Wrapper around operator delete
01415    static void delete_vectorlEROOTcLcLFitcLcLParameterSettingsgR(void *p) {
01416       delete ((vector<ROOT::Fit::ParameterSettings>*)p);
01417    }
01418    static void deleteArray_vectorlEROOTcLcLFitcLcLParameterSettingsgR(void *p) {
01419       delete [] ((vector<ROOT::Fit::ParameterSettings>*)p);
01420    }
01421    static void destruct_vectorlEROOTcLcLFitcLcLParameterSettingsgR(void *p) {
01422       typedef vector<ROOT::Fit::ParameterSettings> current_t;
01423       ((current_t*)p)->~current_t();
01424    }
01425 } // end of namespace ROOT for class vector<ROOT::Fit::ParameterSettings>
01426 
01427 namespace ROOT {
01428    void vectorlEdoublegR_ShowMembers(void *obj, TMemberInspector &R__insp);
01429    static void vectorlEdoublegR_Dictionary();
01430    static void *new_vectorlEdoublegR(void *p = 0);
01431    static void *newArray_vectorlEdoublegR(Long_t size, void *p);
01432    static void delete_vectorlEdoublegR(void *p);
01433    static void deleteArray_vectorlEdoublegR(void *p);
01434    static void destruct_vectorlEdoublegR(void *p);
01435 
01436    // Function generating the singleton type initializer
01437    static TGenericClassInfo *GenerateInitInstanceLocal(const vector<double>*)
01438    {
01439       vector<double> *ptr = 0;
01440       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<double>),0);
01441       static ::ROOT::TGenericClassInfo 
01442          instance("vector<double>", -2, "prec_stl/vector", 49,
01443                   typeid(vector<double>), DefineBehavior(ptr, ptr),
01444                   0, &vectorlEdoublegR_Dictionary, isa_proxy, 0,
01445                   sizeof(vector<double>) );
01446       instance.SetNew(&new_vectorlEdoublegR);
01447       instance.SetNewArray(&newArray_vectorlEdoublegR);
01448       instance.SetDelete(&delete_vectorlEdoublegR);
01449       instance.SetDeleteArray(&deleteArray_vectorlEdoublegR);
01450       instance.SetDestructor(&destruct_vectorlEdoublegR);
01451       instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<double> >()));
01452       return &instance;
01453    }
01454    // Static variable to force the class initialization
01455    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<double>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01456 
01457    // Dictionary for non-ClassDef classes
01458    static void vectorlEdoublegR_Dictionary() {
01459       ::ROOT::GenerateInitInstanceLocal((const vector<double>*)0x0)->GetClass();
01460    }
01461 
01462 } // end of namespace ROOT
01463 
01464 namespace ROOT {
01465    // Wrappers around operator new
01466    static void *new_vectorlEdoublegR(void *p) {
01467       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double> : new vector<double>;
01468    }
01469    static void *newArray_vectorlEdoublegR(Long_t nElements, void *p) {
01470       return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<double>[nElements] : new vector<double>[nElements];
01471    }
01472    // Wrapper around operator delete
01473    static void delete_vectorlEdoublegR(void *p) {
01474       delete ((vector<double>*)p);
01475    }
01476    static void deleteArray_vectorlEdoublegR(void *p) {
01477       delete [] ((vector<double>*)p);
01478    }
01479    static void destruct_vectorlEdoublegR(void *p) {
01480       typedef vector<double> current_t;
01481       ((current_t*)p)->~current_t();
01482    }
01483 } // end of namespace ROOT for class vector<double>
01484 
01485 namespace ROOT {
01486    void vectorlEstringgR_ShowMembers(void *obj, TMemberInspector &R__insp);
01487    static void vectorlEstringgR_Dictionary();
01488    static void *new_vectorlEstringgR(void *p = 0);
01489    static void *newArray_vectorlEstringgR(Long_t size, void *p);
01490    static void delete_vectorlEstringgR(void *p);
01491    static void deleteArray_vectorlEstringgR(void *p);
01492    static void destruct_vectorlEstringgR(void *p);
01493 
01494    // Function generating the singleton type initializer
01495    static TGenericClassInfo *GenerateInitInstanceLocal(const vector<string>*)
01496    {
01497       vector<string> *ptr = 0;
01498       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<string>),0);
01499       static ::ROOT::TGenericClassInfo 
01500          instance("vector<string>", -2, "prec_stl/vector", 49,
01501                   typeid(vector<string>), DefineBehavior(ptr, ptr),
01502                   0, &vectorlEstringgR_Dictionary, isa_proxy, 0,
01503                   sizeof(vector<string>) );
01504       instance.SetNew(&new_vectorlEstringgR);
01505       instance.SetNewArray(&newArray_vectorlEstringgR);
01506       instance.SetDelete(&delete_vectorlEstringgR);
01507       instance.SetDeleteArray(&deleteArray_vectorlEstringgR);
01508       instance.SetDestructor(&destruct_vectorlEstringgR);
01509       instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<string> >()));
01510       return &instance;
01511    }
01512    // Static variable to force the class initialization
01513    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<string>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01514 
01515    // Dictionary for non-ClassDef classes
01516    static void vectorlEstringgR_Dictionary() {
01517       ::ROOT::GenerateInitInstanceLocal((const vector<string>*)0x0)->GetClass();
01518    }
01519 
01520 } // end of namespace ROOT
01521 
01522 namespace ROOT {
01523    // Wrappers around operator new
01524    static void *new_vectorlEstringgR(void *p) {
01525       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<string> : new vector<string>;
01526    }
01527    static void *newArray_vectorlEstringgR(Long_t nElements, void *p) {
01528       return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<string>[nElements] : new vector<string>[nElements];
01529    }
01530    // Wrapper around operator delete
01531    static void delete_vectorlEstringgR(void *p) {
01532       delete ((vector<string>*)p);
01533    }
01534    static void deleteArray_vectorlEstringgR(void *p) {
01535       delete [] ((vector<string>*)p);
01536    }
01537    static void destruct_vectorlEstringgR(void *p) {
01538       typedef vector<string> current_t;
01539       ((current_t*)p)->~current_t();
01540    }
01541 } // end of namespace ROOT for class vector<string>
01542 
01543 namespace ROOT {
01544    void vectorlEunsignedsPintgR_ShowMembers(void *obj, TMemberInspector &R__insp);
01545    static void vectorlEunsignedsPintgR_Dictionary();
01546    static void *new_vectorlEunsignedsPintgR(void *p = 0);
01547    static void *newArray_vectorlEunsignedsPintgR(Long_t size, void *p);
01548    static void delete_vectorlEunsignedsPintgR(void *p);
01549    static void deleteArray_vectorlEunsignedsPintgR(void *p);
01550    static void destruct_vectorlEunsignedsPintgR(void *p);
01551 
01552    // Function generating the singleton type initializer
01553    static TGenericClassInfo *GenerateInitInstanceLocal(const vector<unsigned int>*)
01554    {
01555       vector<unsigned int> *ptr = 0;
01556       static ::TVirtualIsAProxy* isa_proxy = new ::TIsAProxy(typeid(vector<unsigned int>),0);
01557       static ::ROOT::TGenericClassInfo 
01558          instance("vector<unsigned int>", -2, "prec_stl/vector", 49,
01559                   typeid(vector<unsigned int>), DefineBehavior(ptr, ptr),
01560                   0, &vectorlEunsignedsPintgR_Dictionary, isa_proxy, 0,
01561                   sizeof(vector<unsigned int>) );
01562       instance.SetNew(&new_vectorlEunsignedsPintgR);
01563       instance.SetNewArray(&newArray_vectorlEunsignedsPintgR);
01564       instance.SetDelete(&delete_vectorlEunsignedsPintgR);
01565       instance.SetDeleteArray(&deleteArray_vectorlEunsignedsPintgR);
01566       instance.SetDestructor(&destruct_vectorlEunsignedsPintgR);
01567       instance.AdoptCollectionProxyInfo(TCollectionProxyInfo::Generate(TCollectionProxyInfo::Pushback< vector<unsigned int> >()));
01568       return &instance;
01569    }
01570    // Static variable to force the class initialization
01571    static ::ROOT::TGenericClassInfo *_R__UNIQUE_(Init) = GenerateInitInstanceLocal((const vector<unsigned int>*)0x0); R__UseDummy(_R__UNIQUE_(Init));
01572 
01573    // Dictionary for non-ClassDef classes
01574    static void vectorlEunsignedsPintgR_Dictionary() {
01575       ::ROOT::GenerateInitInstanceLocal((const vector<unsigned int>*)0x0)->GetClass();
01576    }
01577 
01578 } // end of namespace ROOT
01579 
01580 namespace ROOT {
01581    // Wrappers around operator new
01582    static void *new_vectorlEunsignedsPintgR(void *p) {
01583       return  p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<unsigned int> : new vector<unsigned int>;
01584    }
01585    static void *newArray_vectorlEunsignedsPintgR(Long_t nElements, void *p) {
01586       return p ? ::new((::ROOT::TOperatorNewHelper*)p) vector<unsigned int>[nElements] : new vector<unsigned int>[nElements];
01587    }
01588    // Wrapper around operator delete
01589    static void delete_vectorlEunsignedsPintgR(void *p) {
01590       delete ((vector<unsigned int>*)p);
01591    }
01592    static void deleteArray_vectorlEunsignedsPintgR(void *p) {
01593       delete [] ((vector<unsigned int>*)p);
01594    }
01595    static void destruct_vectorlEunsignedsPintgR(void *p) {
01596       typedef vector<unsigned int> current_t;
01597       ((current_t*)p)->~current_t();
01598    }
01599 } // end of namespace ROOT for class vector<unsigned int>
01600 
01601 /********************************************************
01602 * math/mathcore/src/G__MathFit.cxx
01603 * CAUTION: DON'T CHANGE THIS FILE. THIS FILE IS AUTOMATICALLY GENERATED
01604 *          FROM HEADER FILES LISTED IN G__setup_cpp_environmentXXX().
01605 *          CHANGE THOSE HEADER FILES AND REGENERATE THIS FILE.
01606 ********************************************************/
01607 
01608 #ifdef G__MEMTEST
01609 #undef malloc
01610 #undef free
01611 #endif
01612 
01613 #if defined(__GNUC__) && __GNUC__ >= 4 && ((__GNUC_MINOR__ == 2 && __GNUC_PATCHLEVEL__ >= 1) || (__GNUC_MINOR__ >= 3))
01614 #pragma GCC diagnostic ignored "-Wstrict-aliasing"
01615 #endif
01616 
01617 extern "C" void G__cpp_reset_tagtableG__MathFit();
01618 
01619 extern "C" void G__set_cpp_environmentG__MathFit() {
01620   G__add_compiledheader("TObject.h");
01621   G__add_compiledheader("TMemberInspector.h");
01622   G__add_compiledheader("Fit/BinData.h");
01623   G__add_compiledheader("Fit/BinPoint.h");
01624   G__add_compiledheader("Fit/Chi2FCN.h");
01625   G__add_compiledheader("Fit/DataOptions.h");
01626   G__add_compiledheader("Fit/DataRange.h");
01627   G__add_compiledheader("Fit/DataVectorfwd.h");
01628   G__add_compiledheader("Fit/DataVector.h");
01629   G__add_compiledheader("Fit/FcnAdapter.h");
01630   G__add_compiledheader("Fit/FitConfig.h");
01631   G__add_compiledheader("Fit/FitResult.h");
01632   G__add_compiledheader("Fit/Fitter.h");
01633   G__add_compiledheader("Fit/FitUtil.h");
01634   G__add_compiledheader("Fit/FitUtilParallel.h");
01635   G__add_compiledheader("Fit/LogLikelihoodFCN.h");
01636   G__add_compiledheader("Fit/ParameterSettings.h");
01637   G__add_compiledheader("Fit/PoissonLikelihoodFCN.h");
01638   G__add_compiledheader("Fit/SparseData.h");
01639   G__add_compiledheader("Fit/UnBinData.h");
01640   G__cpp_reset_tagtableG__MathFit();
01641 }
01642 #include <new>
01643 extern "C" int G__cpp_dllrevG__MathFit() { return(30051515); }
01644 
01645 /*********************************************************
01646 * Member function Interface Method
01647 *********************************************************/
01648 
01649 /* ROOT::Fit */
01650 
01651 /* ROOT::Fit::DataOptions */
01652 static int G__G__MathFit_100_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01653 {
01654    ROOT::Fit::DataOptions* p = NULL;
01655    char* gvp = (char*) G__getgvp();
01656    int n = G__getaryconstruct();
01657    if (n) {
01658      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
01659        p = new ROOT::Fit::DataOptions[n];
01660      } else {
01661        p = new((void*) gvp) ROOT::Fit::DataOptions[n];
01662      }
01663    } else {
01664      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
01665        p = new ROOT::Fit::DataOptions;
01666      } else {
01667        p = new((void*) gvp) ROOT::Fit::DataOptions;
01668      }
01669    }
01670    result7->obj.i = (long) p;
01671    result7->ref = (long) p;
01672    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataOptions));
01673    return(1 || funcname || hash || result7 || libp) ;
01674 }
01675 
01676 // automatic copy constructor
01677 static int G__G__MathFit_100_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01678 
01679 {
01680    ROOT::Fit::DataOptions* p;
01681    void* tmp = (void*) G__int(libp->para[0]);
01682    p = new ROOT::Fit::DataOptions(*(ROOT::Fit::DataOptions*) tmp);
01683    result7->obj.i = (long) p;
01684    result7->ref = (long) p;
01685    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataOptions));
01686    return(1 || funcname || hash || result7 || libp) ;
01687 }
01688 
01689 // automatic destructor
01690 typedef ROOT::Fit::DataOptions G__TROOTcLcLFitcLcLDataOptions;
01691 static int G__G__MathFit_100_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01692 {
01693    char* gvp = (char*) G__getgvp();
01694    long soff = G__getstructoffset();
01695    int n = G__getaryconstruct();
01696    //
01697    //has_a_delete: 0
01698    //has_own_delete1arg: 0
01699    //has_own_delete2arg: 0
01700    //
01701    if (!soff) {
01702      return(1);
01703    }
01704    if (n) {
01705      if (gvp == (char*)G__PVOID) {
01706        delete[] (ROOT::Fit::DataOptions*) soff;
01707      } else {
01708        G__setgvp((long) G__PVOID);
01709        for (int i = n - 1; i >= 0; --i) {
01710          ((ROOT::Fit::DataOptions*) (soff+(sizeof(ROOT::Fit::DataOptions)*i)))->~G__TROOTcLcLFitcLcLDataOptions();
01711        }
01712        G__setgvp((long)gvp);
01713      }
01714    } else {
01715      if (gvp == (char*)G__PVOID) {
01716        delete (ROOT::Fit::DataOptions*) soff;
01717      } else {
01718        G__setgvp((long) G__PVOID);
01719        ((ROOT::Fit::DataOptions*) (soff))->~G__TROOTcLcLFitcLcLDataOptions();
01720        G__setgvp((long)gvp);
01721      }
01722    }
01723    G__setnull(result7);
01724    return(1 || funcname || hash || result7 || libp) ;
01725 }
01726 
01727 // automatic assignment operator
01728 static int G__G__MathFit_100_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01729 {
01730    ROOT::Fit::DataOptions* dest = (ROOT::Fit::DataOptions*) G__getstructoffset();
01731    *dest = *(ROOT::Fit::DataOptions*) libp->para[0].ref;
01732    const ROOT::Fit::DataOptions& obj = *dest;
01733    result7->ref = (long) (&obj);
01734    result7->obj.i = (long) (&obj);
01735    return(1 || funcname || hash || result7 || libp) ;
01736 }
01737 
01738 
01739 /* ROOT::Fit::DataRange */
01740 static int G__G__MathFit_101_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01741 {
01742    ROOT::Fit::DataRange* p = NULL;
01743    char* gvp = (char*) G__getgvp();
01744    switch (libp->paran) {
01745    case 1:
01746      //m: 1
01747      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
01748        p = new ROOT::Fit::DataRange((unsigned int) G__int(libp->para[0]));
01749      } else {
01750        p = new((void*) gvp) ROOT::Fit::DataRange((unsigned int) G__int(libp->para[0]));
01751      }
01752      break;
01753    case 0:
01754      int n = G__getaryconstruct();
01755      if (n) {
01756        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
01757          p = new ROOT::Fit::DataRange[n];
01758        } else {
01759          p = new((void*) gvp) ROOT::Fit::DataRange[n];
01760        }
01761      } else {
01762        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
01763          p = new ROOT::Fit::DataRange;
01764        } else {
01765          p = new((void*) gvp) ROOT::Fit::DataRange;
01766        }
01767      }
01768      break;
01769    }
01770    result7->obj.i = (long) p;
01771    result7->ref = (long) p;
01772    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataRange));
01773    return(1 || funcname || hash || result7 || libp) ;
01774 }
01775 
01776 static int G__G__MathFit_101_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01777 {
01778    ROOT::Fit::DataRange* p = NULL;
01779    char* gvp = (char*) G__getgvp();
01780    //m: 2
01781    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
01782      p = new ROOT::Fit::DataRange((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
01783    } else {
01784      p = new((void*) gvp) ROOT::Fit::DataRange((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
01785    }
01786    result7->obj.i = (long) p;
01787    result7->ref = (long) p;
01788    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataRange));
01789    return(1 || funcname || hash || result7 || libp) ;
01790 }
01791 
01792 static int G__G__MathFit_101_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01793 {
01794    ROOT::Fit::DataRange* p = NULL;
01795    char* gvp = (char*) G__getgvp();
01796    //m: 4
01797    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
01798      p = new ROOT::Fit::DataRange(
01799 (double) G__double(libp->para[0]), (double) G__double(libp->para[1])
01800 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
01801    } else {
01802      p = new((void*) gvp) ROOT::Fit::DataRange(
01803 (double) G__double(libp->para[0]), (double) G__double(libp->para[1])
01804 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
01805    }
01806    result7->obj.i = (long) p;
01807    result7->ref = (long) p;
01808    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataRange));
01809    return(1 || funcname || hash || result7 || libp) ;
01810 }
01811 
01812 static int G__G__MathFit_101_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01813 {
01814    ROOT::Fit::DataRange* p = NULL;
01815    char* gvp = (char*) G__getgvp();
01816    //m: 6
01817    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
01818      p = new ROOT::Fit::DataRange(
01819 (double) G__double(libp->para[0]), (double) G__double(libp->para[1])
01820 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
01821 , (double) G__double(libp->para[4]), (double) G__double(libp->para[5]));
01822    } else {
01823      p = new((void*) gvp) ROOT::Fit::DataRange(
01824 (double) G__double(libp->para[0]), (double) G__double(libp->para[1])
01825 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
01826 , (double) G__double(libp->para[4]), (double) G__double(libp->para[5]));
01827    }
01828    result7->obj.i = (long) p;
01829    result7->ref = (long) p;
01830    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataRange));
01831    return(1 || funcname || hash || result7 || libp) ;
01832 }
01833 
01834 static int G__G__MathFit_101_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01835 {
01836       G__letint(result7, 104, (long) ((const ROOT::Fit::DataRange*) G__getstructoffset())->NDim());
01837    return(1 || funcname || hash || result7 || libp) ;
01838 }
01839 
01840 static int G__G__MathFit_101_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01841 {
01842    switch (libp->paran) {
01843    case 1:
01844       G__letint(result7, 104, (long) ((const ROOT::Fit::DataRange*) G__getstructoffset())->Size((unsigned int) G__int(libp->para[0])));
01845       break;
01846    case 0:
01847       G__letint(result7, 104, (long) ((const ROOT::Fit::DataRange*) G__getstructoffset())->Size());
01848       break;
01849    }
01850    return(1 || funcname || hash || result7 || libp) ;
01851 }
01852 
01853 static int G__G__MathFit_101_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01854 {
01855       G__letint(result7, 103, (long) ((const ROOT::Fit::DataRange*) G__getstructoffset())->IsSet());
01856    return(1 || funcname || hash || result7 || libp) ;
01857 }
01858 
01859 static int G__G__MathFit_101_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01860 {
01861    switch (libp->paran) {
01862    case 1:
01863       {
01864          const ROOT::Fit::DataRange::RangeSet& obj = ((const ROOT::Fit::DataRange*) G__getstructoffset())->Ranges((unsigned int) G__int(libp->para[0]));
01865          result7->ref = (long) (&obj);
01866          result7->obj.i = (long) (&obj);
01867       }
01868       break;
01869    case 0:
01870       {
01871          const ROOT::Fit::DataRange::RangeSet& obj = ((const ROOT::Fit::DataRange*) G__getstructoffset())->Ranges();
01872          result7->ref = (long) (&obj);
01873          result7->obj.i = (long) (&obj);
01874       }
01875       break;
01876    }
01877    return(1 || funcname || hash || result7 || libp) ;
01878 }
01879 
01880 static int G__G__MathFit_101_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01881 {
01882    switch (libp->paran) {
01883    case 2:
01884       {
01885          const pair<double,double>* pobj;
01886          const pair<double,double> xobj = ((const ROOT::Fit::DataRange*) G__getstructoffset())->operator()((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
01887          pobj = new pair<double,double>(xobj);
01888          result7->obj.i = (long) ((void*) pobj);
01889          result7->ref = result7->obj.i;
01890          G__store_tempobject(*result7);
01891       }
01892       break;
01893    case 1:
01894       {
01895          const pair<double,double>* pobj;
01896          const pair<double,double> xobj = ((const ROOT::Fit::DataRange*) G__getstructoffset())->operator()((unsigned int) G__int(libp->para[0]));
01897          pobj = new pair<double,double>(xobj);
01898          result7->obj.i = (long) ((void*) pobj);
01899          result7->ref = result7->obj.i;
01900          G__store_tempobject(*result7);
01901       }
01902       break;
01903    case 0:
01904       {
01905          const pair<double,double>* pobj;
01906          const pair<double,double> xobj = ((const ROOT::Fit::DataRange*) G__getstructoffset())->operator()();
01907          pobj = new pair<double,double>(xobj);
01908          result7->obj.i = (long) ((void*) pobj);
01909          result7->ref = result7->obj.i;
01910          G__store_tempobject(*result7);
01911       }
01912       break;
01913    }
01914    return(1 || funcname || hash || result7 || libp) ;
01915 }
01916 
01917 static int G__G__MathFit_101_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01918 {
01919       ((const ROOT::Fit::DataRange*) G__getstructoffset())->GetRange((unsigned int) G__int(libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
01920 , *(double*) G__Doubleref(&libp->para[2]));
01921       G__setnull(result7);
01922    return(1 || funcname || hash || result7 || libp) ;
01923 }
01924 
01925 static int G__G__MathFit_101_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01926 {
01927       ((const ROOT::Fit::DataRange*) G__getstructoffset())->GetRange(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1]));
01928       G__setnull(result7);
01929    return(1 || funcname || hash || result7 || libp) ;
01930 }
01931 
01932 static int G__G__MathFit_101_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01933 {
01934       ((const ROOT::Fit::DataRange*) G__getstructoffset())->GetRange(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
01935 , *(double*) G__Doubleref(&libp->para[2]), *(double*) G__Doubleref(&libp->para[3]));
01936       G__setnull(result7);
01937    return(1 || funcname || hash || result7 || libp) ;
01938 }
01939 
01940 static int G__G__MathFit_101_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01941 {
01942       ((const ROOT::Fit::DataRange*) G__getstructoffset())->GetRange(*(double*) G__Doubleref(&libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
01943 , *(double*) G__Doubleref(&libp->para[2]), *(double*) G__Doubleref(&libp->para[3])
01944 , *(double*) G__Doubleref(&libp->para[4]), *(double*) G__Doubleref(&libp->para[5]));
01945       G__setnull(result7);
01946    return(1 || funcname || hash || result7 || libp) ;
01947 }
01948 
01949 static int G__G__MathFit_101_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01950 {
01951       ((const ROOT::Fit::DataRange*) G__getstructoffset())->GetRange((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
01952       G__setnull(result7);
01953    return(1 || funcname || hash || result7 || libp) ;
01954 }
01955 
01956 static int G__G__MathFit_101_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01957 {
01958       ((ROOT::Fit::DataRange*) G__getstructoffset())->AddRange((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])
01959 , (double) G__double(libp->para[2]));
01960       G__setnull(result7);
01961    return(1 || funcname || hash || result7 || libp) ;
01962 }
01963 
01964 static int G__G__MathFit_101_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01965 {
01966       ((ROOT::Fit::DataRange*) G__getstructoffset())->AddRange((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
01967       G__setnull(result7);
01968    return(1 || funcname || hash || result7 || libp) ;
01969 }
01970 
01971 static int G__G__MathFit_101_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01972 {
01973       ((ROOT::Fit::DataRange*) G__getstructoffset())->AddRange((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
01974 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
01975       G__setnull(result7);
01976    return(1 || funcname || hash || result7 || libp) ;
01977 }
01978 
01979 static int G__G__MathFit_101_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01980 {
01981       ((ROOT::Fit::DataRange*) G__getstructoffset())->AddRange((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
01982 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
01983 , (double) G__double(libp->para[4]), (double) G__double(libp->para[5]));
01984       G__setnull(result7);
01985    return(1 || funcname || hash || result7 || libp) ;
01986 }
01987 
01988 static int G__G__MathFit_101_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01989 {
01990       ((ROOT::Fit::DataRange*) G__getstructoffset())->SetRange((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])
01991 , (double) G__double(libp->para[2]));
01992       G__setnull(result7);
01993    return(1 || funcname || hash || result7 || libp) ;
01994 }
01995 
01996 static int G__G__MathFit_101_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
01997 {
01998       ((ROOT::Fit::DataRange*) G__getstructoffset())->SetRange((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
01999       G__setnull(result7);
02000    return(1 || funcname || hash || result7 || libp) ;
02001 }
02002 
02003 static int G__G__MathFit_101_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02004 {
02005       ((ROOT::Fit::DataRange*) G__getstructoffset())->SetRange((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
02006 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
02007       G__setnull(result7);
02008    return(1 || funcname || hash || result7 || libp) ;
02009 }
02010 
02011 static int G__G__MathFit_101_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02012 {
02013       ((ROOT::Fit::DataRange*) G__getstructoffset())->SetRange((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
02014 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
02015 , (double) G__double(libp->para[4]), (double) G__double(libp->para[5]));
02016       G__setnull(result7);
02017    return(1 || funcname || hash || result7 || libp) ;
02018 }
02019 
02020 static int G__G__MathFit_101_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02021 {
02022    switch (libp->paran) {
02023    case 1:
02024       ((ROOT::Fit::DataRange*) G__getstructoffset())->Clear((unsigned int) G__int(libp->para[0]));
02025       G__setnull(result7);
02026       break;
02027    case 0:
02028       ((ROOT::Fit::DataRange*) G__getstructoffset())->Clear();
02029       G__setnull(result7);
02030       break;
02031    }
02032    return(1 || funcname || hash || result7 || libp) ;
02033 }
02034 
02035 static int G__G__MathFit_101_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02036 {
02037    switch (libp->paran) {
02038    case 2:
02039       G__letint(result7, 103, (long) ((const ROOT::Fit::DataRange*) G__getstructoffset())->IsInside((double) G__double(libp->para[0]), (unsigned int) G__int(libp->para[1])));
02040       break;
02041    case 1:
02042       G__letint(result7, 103, (long) ((const ROOT::Fit::DataRange*) G__getstructoffset())->IsInside((double) G__double(libp->para[0])));
02043       break;
02044    }
02045    return(1 || funcname || hash || result7 || libp) ;
02046 }
02047 
02048 // automatic copy constructor
02049 static int G__G__MathFit_101_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02050 
02051 {
02052    ROOT::Fit::DataRange* p;
02053    void* tmp = (void*) G__int(libp->para[0]);
02054    p = new ROOT::Fit::DataRange(*(ROOT::Fit::DataRange*) tmp);
02055    result7->obj.i = (long) p;
02056    result7->ref = (long) p;
02057    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataRange));
02058    return(1 || funcname || hash || result7 || libp) ;
02059 }
02060 
02061 // automatic destructor
02062 typedef ROOT::Fit::DataRange G__TROOTcLcLFitcLcLDataRange;
02063 static int G__G__MathFit_101_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02064 {
02065    char* gvp = (char*) G__getgvp();
02066    long soff = G__getstructoffset();
02067    int n = G__getaryconstruct();
02068    //
02069    //has_a_delete: 0
02070    //has_own_delete1arg: 0
02071    //has_own_delete2arg: 0
02072    //
02073    if (!soff) {
02074      return(1);
02075    }
02076    if (n) {
02077      if (gvp == (char*)G__PVOID) {
02078        delete[] (ROOT::Fit::DataRange*) soff;
02079      } else {
02080        G__setgvp((long) G__PVOID);
02081        for (int i = n - 1; i >= 0; --i) {
02082          ((ROOT::Fit::DataRange*) (soff+(sizeof(ROOT::Fit::DataRange)*i)))->~G__TROOTcLcLFitcLcLDataRange();
02083        }
02084        G__setgvp((long)gvp);
02085      }
02086    } else {
02087      if (gvp == (char*)G__PVOID) {
02088        delete (ROOT::Fit::DataRange*) soff;
02089      } else {
02090        G__setgvp((long) G__PVOID);
02091        ((ROOT::Fit::DataRange*) (soff))->~G__TROOTcLcLFitcLcLDataRange();
02092        G__setgvp((long)gvp);
02093      }
02094    }
02095    G__setnull(result7);
02096    return(1 || funcname || hash || result7 || libp) ;
02097 }
02098 
02099 // automatic assignment operator
02100 static int G__G__MathFit_101_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02101 {
02102    ROOT::Fit::DataRange* dest = (ROOT::Fit::DataRange*) G__getstructoffset();
02103    *dest = *(ROOT::Fit::DataRange*) libp->para[0].ref;
02104    const ROOT::Fit::DataRange& obj = *dest;
02105    result7->ref = (long) (&obj);
02106    result7->obj.i = (long) (&obj);
02107    return(1 || funcname || hash || result7 || libp) ;
02108 }
02109 
02110 
02111 /* ROOT::Fit::FitData */
02112 static int G__G__MathFit_111_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02113 {
02114    ROOT::Fit::FitData* p = NULL;
02115    char* gvp = (char*) G__getgvp();
02116    int n = G__getaryconstruct();
02117    if (n) {
02118      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02119        p = new ROOT::Fit::FitData[n];
02120      } else {
02121        p = new((void*) gvp) ROOT::Fit::FitData[n];
02122      }
02123    } else {
02124      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02125        p = new ROOT::Fit::FitData;
02126      } else {
02127        p = new((void*) gvp) ROOT::Fit::FitData;
02128      }
02129    }
02130    result7->obj.i = (long) p;
02131    result7->ref = (long) p;
02132    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitData));
02133    return(1 || funcname || hash || result7 || libp) ;
02134 }
02135 
02136 static int G__G__MathFit_111_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02137 {
02138    ROOT::Fit::FitData* p = NULL;
02139    char* gvp = (char*) G__getgvp();
02140    //m: 1
02141    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02142      p = new ROOT::Fit::FitData(*(ROOT::Fit::DataOptions*) libp->para[0].ref);
02143    } else {
02144      p = new((void*) gvp) ROOT::Fit::FitData(*(ROOT::Fit::DataOptions*) libp->para[0].ref);
02145    }
02146    result7->obj.i = (long) p;
02147    result7->ref = (long) p;
02148    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitData));
02149    return(1 || funcname || hash || result7 || libp) ;
02150 }
02151 
02152 static int G__G__MathFit_111_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02153 {
02154    ROOT::Fit::FitData* p = NULL;
02155    char* gvp = (char*) G__getgvp();
02156    //m: 1
02157    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02158      p = new ROOT::Fit::FitData(*(ROOT::Fit::DataRange*) libp->para[0].ref);
02159    } else {
02160      p = new((void*) gvp) ROOT::Fit::FitData(*(ROOT::Fit::DataRange*) libp->para[0].ref);
02161    }
02162    result7->obj.i = (long) p;
02163    result7->ref = (long) p;
02164    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitData));
02165    return(1 || funcname || hash || result7 || libp) ;
02166 }
02167 
02168 static int G__G__MathFit_111_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02169 {
02170    ROOT::Fit::FitData* p = NULL;
02171    char* gvp = (char*) G__getgvp();
02172    //m: 2
02173    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02174      p = new ROOT::Fit::FitData(*(ROOT::Fit::DataOptions*) libp->para[0].ref, *(ROOT::Fit::DataRange*) libp->para[1].ref);
02175    } else {
02176      p = new((void*) gvp) ROOT::Fit::FitData(*(ROOT::Fit::DataOptions*) libp->para[0].ref, *(ROOT::Fit::DataRange*) libp->para[1].ref);
02177    }
02178    result7->obj.i = (long) p;
02179    result7->ref = (long) p;
02180    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitData));
02181    return(1 || funcname || hash || result7 || libp) ;
02182 }
02183 
02184 static int G__G__MathFit_111_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02185 {
02186       {
02187          const ROOT::Fit::DataOptions& obj = ((const ROOT::Fit::FitData*) G__getstructoffset())->Opt();
02188          result7->ref = (long) (&obj);
02189          result7->obj.i = (long) (&obj);
02190       }
02191    return(1 || funcname || hash || result7 || libp) ;
02192 }
02193 
02194 static int G__G__MathFit_111_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02195 {
02196       {
02197          const ROOT::Fit::DataOptions& obj = ((ROOT::Fit::FitData*) G__getstructoffset())->Opt();
02198          result7->ref = (long) (&obj);
02199          result7->obj.i = (long) (&obj);
02200       }
02201    return(1 || funcname || hash || result7 || libp) ;
02202 }
02203 
02204 static int G__G__MathFit_111_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02205 {
02206       {
02207          const ROOT::Fit::DataRange& obj = ((const ROOT::Fit::FitData*) G__getstructoffset())->Range();
02208          result7->ref = (long) (&obj);
02209          result7->obj.i = (long) (&obj);
02210       }
02211    return(1 || funcname || hash || result7 || libp) ;
02212 }
02213 
02214 static int G__G__MathFit_111_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02215 {
02216       G__letint(result7, 104, (long) ROOT::Fit::FitData::MaxSize());
02217    return(1 || funcname || hash || result7 || libp) ;
02218 }
02219 
02220 // automatic copy constructor
02221 static int G__G__MathFit_111_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02222 
02223 {
02224    ROOT::Fit::FitData* p;
02225    void* tmp = (void*) G__int(libp->para[0]);
02226    p = new ROOT::Fit::FitData(*(ROOT::Fit::FitData*) tmp);
02227    result7->obj.i = (long) p;
02228    result7->ref = (long) p;
02229    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitData));
02230    return(1 || funcname || hash || result7 || libp) ;
02231 }
02232 
02233 // automatic destructor
02234 typedef ROOT::Fit::FitData G__TROOTcLcLFitcLcLFitData;
02235 static int G__G__MathFit_111_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02236 {
02237    char* gvp = (char*) G__getgvp();
02238    long soff = G__getstructoffset();
02239    int n = G__getaryconstruct();
02240    //
02241    //has_a_delete: 0
02242    //has_own_delete1arg: 0
02243    //has_own_delete2arg: 0
02244    //
02245    if (!soff) {
02246      return(1);
02247    }
02248    if (n) {
02249      if (gvp == (char*)G__PVOID) {
02250        delete[] (ROOT::Fit::FitData*) soff;
02251      } else {
02252        G__setgvp((long) G__PVOID);
02253        for (int i = n - 1; i >= 0; --i) {
02254          ((ROOT::Fit::FitData*) (soff+(sizeof(ROOT::Fit::FitData)*i)))->~G__TROOTcLcLFitcLcLFitData();
02255        }
02256        G__setgvp((long)gvp);
02257      }
02258    } else {
02259      if (gvp == (char*)G__PVOID) {
02260        delete (ROOT::Fit::FitData*) soff;
02261      } else {
02262        G__setgvp((long) G__PVOID);
02263        ((ROOT::Fit::FitData*) (soff))->~G__TROOTcLcLFitcLcLFitData();
02264        G__setgvp((long)gvp);
02265      }
02266    }
02267    G__setnull(result7);
02268    return(1 || funcname || hash || result7 || libp) ;
02269 }
02270 
02271 // automatic assignment operator
02272 static int G__G__MathFit_111_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02273 {
02274    ROOT::Fit::FitData* dest = (ROOT::Fit::FitData*) G__getstructoffset();
02275    *dest = *(ROOT::Fit::FitData*) libp->para[0].ref;
02276    const ROOT::Fit::FitData& obj = *dest;
02277    result7->ref = (long) (&obj);
02278    result7->obj.i = (long) (&obj);
02279    return(1 || funcname || hash || result7 || libp) ;
02280 }
02281 
02282 
02283 /* ROOT::Fit::BinData */
02284 static int G__G__MathFit_122_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02285 {
02286       G__letint(result7, 104, (long) ROOT::Fit::BinData::GetPointSize((ROOT::Fit::BinData::ErrorType) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])));
02287    return(1 || funcname || hash || result7 || libp) ;
02288 }
02289 
02290 static int G__G__MathFit_122_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02291 {
02292       G__letint(result7, 105, (long) ((const ROOT::Fit::BinData*) G__getstructoffset())->GetErrorType());
02293    return(1 || funcname || hash || result7 || libp) ;
02294 }
02295 
02296 static int G__G__MathFit_122_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02297 {
02298    ROOT::Fit::BinData* p = NULL;
02299    char* gvp = (char*) G__getgvp();
02300    switch (libp->paran) {
02301    case 3:
02302      //m: 3
02303      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02304        p = new ROOT::Fit::BinData(
02305 (unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
02306 , (ROOT::Fit::BinData::ErrorType) G__int(libp->para[2]));
02307      } else {
02308        p = new((void*) gvp) ROOT::Fit::BinData(
02309 (unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
02310 , (ROOT::Fit::BinData::ErrorType) G__int(libp->para[2]));
02311      }
02312      break;
02313    case 2:
02314      //m: 2
02315      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02316        p = new ROOT::Fit::BinData((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
02317      } else {
02318        p = new((void*) gvp) ROOT::Fit::BinData((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
02319      }
02320      break;
02321    case 1:
02322      //m: 1
02323      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02324        p = new ROOT::Fit::BinData((unsigned int) G__int(libp->para[0]));
02325      } else {
02326        p = new((void*) gvp) ROOT::Fit::BinData((unsigned int) G__int(libp->para[0]));
02327      }
02328      break;
02329    case 0:
02330      int n = G__getaryconstruct();
02331      if (n) {
02332        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02333          p = new ROOT::Fit::BinData[n];
02334        } else {
02335          p = new((void*) gvp) ROOT::Fit::BinData[n];
02336        }
02337      } else {
02338        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02339          p = new ROOT::Fit::BinData;
02340        } else {
02341          p = new((void*) gvp) ROOT::Fit::BinData;
02342        }
02343      }
02344      break;
02345    }
02346    result7->obj.i = (long) p;
02347    result7->ref = (long) p;
02348    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData));
02349    return(1 || funcname || hash || result7 || libp) ;
02350 }
02351 
02352 static int G__G__MathFit_122_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02353 {
02354    ROOT::Fit::BinData* p = NULL;
02355    char* gvp = (char*) G__getgvp();
02356    switch (libp->paran) {
02357    case 4:
02358      //m: 4
02359      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02360        p = new ROOT::Fit::BinData(
02361 *(ROOT::Fit::DataOptions*) libp->para[0].ref, (unsigned int) G__int(libp->para[1])
02362 , (unsigned int) G__int(libp->para[2]), (ROOT::Fit::BinData::ErrorType) G__int(libp->para[3]));
02363      } else {
02364        p = new((void*) gvp) ROOT::Fit::BinData(
02365 *(ROOT::Fit::DataOptions*) libp->para[0].ref, (unsigned int) G__int(libp->para[1])
02366 , (unsigned int) G__int(libp->para[2]), (ROOT::Fit::BinData::ErrorType) G__int(libp->para[3]));
02367      }
02368      break;
02369    case 3:
02370      //m: 3
02371      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02372        p = new ROOT::Fit::BinData(
02373 *(ROOT::Fit::DataOptions*) libp->para[0].ref, (unsigned int) G__int(libp->para[1])
02374 , (unsigned int) G__int(libp->para[2]));
02375      } else {
02376        p = new((void*) gvp) ROOT::Fit::BinData(
02377 *(ROOT::Fit::DataOptions*) libp->para[0].ref, (unsigned int) G__int(libp->para[1])
02378 , (unsigned int) G__int(libp->para[2]));
02379      }
02380      break;
02381    case 2:
02382      //m: 2
02383      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02384        p = new ROOT::Fit::BinData(*(ROOT::Fit::DataOptions*) libp->para[0].ref, (unsigned int) G__int(libp->para[1]));
02385      } else {
02386        p = new((void*) gvp) ROOT::Fit::BinData(*(ROOT::Fit::DataOptions*) libp->para[0].ref, (unsigned int) G__int(libp->para[1]));
02387      }
02388      break;
02389    case 1:
02390      //m: 1
02391      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02392        p = new ROOT::Fit::BinData(*(ROOT::Fit::DataOptions*) libp->para[0].ref);
02393      } else {
02394        p = new((void*) gvp) ROOT::Fit::BinData(*(ROOT::Fit::DataOptions*) libp->para[0].ref);
02395      }
02396      break;
02397    }
02398    result7->obj.i = (long) p;
02399    result7->ref = (long) p;
02400    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData));
02401    return(1 || funcname || hash || result7 || libp) ;
02402 }
02403 
02404 static int G__G__MathFit_122_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02405 {
02406    ROOT::Fit::BinData* p = NULL;
02407    char* gvp = (char*) G__getgvp();
02408    switch (libp->paran) {
02409    case 5:
02410      //m: 5
02411      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02412        p = new ROOT::Fit::BinData(
02413 *(ROOT::Fit::DataOptions*) libp->para[0].ref, *(ROOT::Fit::DataRange*) libp->para[1].ref
02414 , (unsigned int) G__int(libp->para[2]), (unsigned int) G__int(libp->para[3])
02415 , (ROOT::Fit::BinData::ErrorType) G__int(libp->para[4]));
02416      } else {
02417        p = new((void*) gvp) ROOT::Fit::BinData(
02418 *(ROOT::Fit::DataOptions*) libp->para[0].ref, *(ROOT::Fit::DataRange*) libp->para[1].ref
02419 , (unsigned int) G__int(libp->para[2]), (unsigned int) G__int(libp->para[3])
02420 , (ROOT::Fit::BinData::ErrorType) G__int(libp->para[4]));
02421      }
02422      break;
02423    case 4:
02424      //m: 4
02425      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02426        p = new ROOT::Fit::BinData(
02427 *(ROOT::Fit::DataOptions*) libp->para[0].ref, *(ROOT::Fit::DataRange*) libp->para[1].ref
02428 , (unsigned int) G__int(libp->para[2]), (unsigned int) G__int(libp->para[3]));
02429      } else {
02430        p = new((void*) gvp) ROOT::Fit::BinData(
02431 *(ROOT::Fit::DataOptions*) libp->para[0].ref, *(ROOT::Fit::DataRange*) libp->para[1].ref
02432 , (unsigned int) G__int(libp->para[2]), (unsigned int) G__int(libp->para[3]));
02433      }
02434      break;
02435    case 3:
02436      //m: 3
02437      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02438        p = new ROOT::Fit::BinData(
02439 *(ROOT::Fit::DataOptions*) libp->para[0].ref, *(ROOT::Fit::DataRange*) libp->para[1].ref
02440 , (unsigned int) G__int(libp->para[2]));
02441      } else {
02442        p = new((void*) gvp) ROOT::Fit::BinData(
02443 *(ROOT::Fit::DataOptions*) libp->para[0].ref, *(ROOT::Fit::DataRange*) libp->para[1].ref
02444 , (unsigned int) G__int(libp->para[2]));
02445      }
02446      break;
02447    case 2:
02448      //m: 2
02449      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02450        p = new ROOT::Fit::BinData(*(ROOT::Fit::DataOptions*) libp->para[0].ref, *(ROOT::Fit::DataRange*) libp->para[1].ref);
02451      } else {
02452        p = new((void*) gvp) ROOT::Fit::BinData(*(ROOT::Fit::DataOptions*) libp->para[0].ref, *(ROOT::Fit::DataRange*) libp->para[1].ref);
02453      }
02454      break;
02455    }
02456    result7->obj.i = (long) p;
02457    result7->ref = (long) p;
02458    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData));
02459    return(1 || funcname || hash || result7 || libp) ;
02460 }
02461 
02462 static int G__G__MathFit_122_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02463 {
02464    ROOT::Fit::BinData* p = NULL;
02465    char* gvp = (char*) G__getgvp();
02466    //m: 5
02467    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02468      p = new ROOT::Fit::BinData(
02469 (unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
02470 , (double*) G__int(libp->para[2]), (double*) G__int(libp->para[3])
02471 , (double*) G__int(libp->para[4]));
02472    } else {
02473      p = new((void*) gvp) ROOT::Fit::BinData(
02474 (unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
02475 , (double*) G__int(libp->para[2]), (double*) G__int(libp->para[3])
02476 , (double*) G__int(libp->para[4]));
02477    }
02478    result7->obj.i = (long) p;
02479    result7->ref = (long) p;
02480    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData));
02481    return(1 || funcname || hash || result7 || libp) ;
02482 }
02483 
02484 static int G__G__MathFit_122_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02485 {
02486    ROOT::Fit::BinData* p = NULL;
02487    char* gvp = (char*) G__getgvp();
02488    //m: 7
02489    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02490      p = new ROOT::Fit::BinData(
02491 (unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
02492 , (double*) G__int(libp->para[2]), (double*) G__int(libp->para[3])
02493 , (double*) G__int(libp->para[4]), (double*) G__int(libp->para[5])
02494 , (double*) G__int(libp->para[6]));
02495    } else {
02496      p = new((void*) gvp) ROOT::Fit::BinData(
02497 (unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
02498 , (double*) G__int(libp->para[2]), (double*) G__int(libp->para[3])
02499 , (double*) G__int(libp->para[4]), (double*) G__int(libp->para[5])
02500 , (double*) G__int(libp->para[6]));
02501    }
02502    result7->obj.i = (long) p;
02503    result7->ref = (long) p;
02504    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData));
02505    return(1 || funcname || hash || result7 || libp) ;
02506 }
02507 
02508 static int G__G__MathFit_122_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02509 {
02510    ROOT::Fit::BinData* p = NULL;
02511    char* gvp = (char*) G__getgvp();
02512    //m: 9
02513    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02514      p = new ROOT::Fit::BinData(
02515 (unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
02516 , (double*) G__int(libp->para[2]), (double*) G__int(libp->para[3])
02517 , (double*) G__int(libp->para[4]), (double*) G__int(libp->para[5])
02518 , (double*) G__int(libp->para[6]), (double*) G__int(libp->para[7])
02519 , (double*) G__int(libp->para[8]));
02520    } else {
02521      p = new((void*) gvp) ROOT::Fit::BinData(
02522 (unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
02523 , (double*) G__int(libp->para[2]), (double*) G__int(libp->para[3])
02524 , (double*) G__int(libp->para[4]), (double*) G__int(libp->para[5])
02525 , (double*) G__int(libp->para[6]), (double*) G__int(libp->para[7])
02526 , (double*) G__int(libp->para[8]));
02527    }
02528    result7->obj.i = (long) p;
02529    result7->ref = (long) p;
02530    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData));
02531    return(1 || funcname || hash || result7 || libp) ;
02532 }
02533 
02534 static int G__G__MathFit_122_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02535 {
02536    ROOT::Fit::BinData* p = NULL;
02537    char* gvp = (char*) G__getgvp();
02538    //m: 1
02539    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02540      p = new ROOT::Fit::BinData(*(ROOT::Fit::BinData*) libp->para[0].ref);
02541    } else {
02542      p = new((void*) gvp) ROOT::Fit::BinData(*(ROOT::Fit::BinData*) libp->para[0].ref);
02543    }
02544    result7->obj.i = (long) p;
02545    result7->ref = (long) p;
02546    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData));
02547    return(1 || funcname || hash || result7 || libp) ;
02548 }
02549 
02550 static int G__G__MathFit_122_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02551 {
02552       {
02553          const ROOT::Fit::BinData& obj = ((ROOT::Fit::BinData*) G__getstructoffset())->operator=(*(ROOT::Fit::BinData*) libp->para[0].ref);
02554          result7->ref = (long) (&obj);
02555          result7->obj.i = (long) (&obj);
02556       }
02557    return(1 || funcname || hash || result7 || libp) ;
02558 }
02559 
02560 static int G__G__MathFit_122_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02561 {
02562    switch (libp->paran) {
02563    case 3:
02564       ((ROOT::Fit::BinData*) G__getstructoffset())->Initialize((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
02565 , (ROOT::Fit::BinData::ErrorType) G__int(libp->para[2]));
02566       G__setnull(result7);
02567       break;
02568    case 2:
02569       ((ROOT::Fit::BinData*) G__getstructoffset())->Initialize((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
02570       G__setnull(result7);
02571       break;
02572    case 1:
02573       ((ROOT::Fit::BinData*) G__getstructoffset())->Initialize((unsigned int) G__int(libp->para[0]));
02574       G__setnull(result7);
02575       break;
02576    }
02577    return(1 || funcname || hash || result7 || libp) ;
02578 }
02579 
02580 static int G__G__MathFit_122_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02581 {
02582       G__letint(result7, 104, (long) ((const ROOT::Fit::BinData*) G__getstructoffset())->PointSize());
02583    return(1 || funcname || hash || result7 || libp) ;
02584 }
02585 
02586 static int G__G__MathFit_122_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02587 {
02588       G__letint(result7, 104, (long) ((const ROOT::Fit::BinData*) G__getstructoffset())->DataSize());
02589    return(1 || funcname || hash || result7 || libp) ;
02590 }
02591 
02592 static int G__G__MathFit_122_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02593 {
02594       G__letint(result7, 103, (long) ((const ROOT::Fit::BinData*) G__getstructoffset())->HaveCoordErrors());
02595    return(1 || funcname || hash || result7 || libp) ;
02596 }
02597 
02598 static int G__G__MathFit_122_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02599 {
02600       G__letint(result7, 103, (long) ((const ROOT::Fit::BinData*) G__getstructoffset())->HaveAsymErrors());
02601    return(1 || funcname || hash || result7 || libp) ;
02602 }
02603 
02604 static int G__G__MathFit_122_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02605 {
02606       ((ROOT::Fit::BinData*) G__getstructoffset())->Add((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
02607       G__setnull(result7);
02608    return(1 || funcname || hash || result7 || libp) ;
02609 }
02610 
02611 static int G__G__MathFit_122_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02612 {
02613       ((ROOT::Fit::BinData*) G__getstructoffset())->Add((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
02614 , (double) G__double(libp->para[2]));
02615       G__setnull(result7);
02616    return(1 || funcname || hash || result7 || libp) ;
02617 }
02618 
02619 static int G__G__MathFit_122_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02620 {
02621       ((ROOT::Fit::BinData*) G__getstructoffset())->Add((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
02622 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3]));
02623       G__setnull(result7);
02624    return(1 || funcname || hash || result7 || libp) ;
02625 }
02626 
02627 static int G__G__MathFit_122_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02628 {
02629       ((ROOT::Fit::BinData*) G__getstructoffset())->Add((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
02630 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
02631 , (double) G__double(libp->para[4]));
02632       G__setnull(result7);
02633    return(1 || funcname || hash || result7 || libp) ;
02634 }
02635 
02636 static int G__G__MathFit_122_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02637 {
02638       ((ROOT::Fit::BinData*) G__getstructoffset())->Add((double*) G__int(libp->para[0]), (double) G__double(libp->para[1]));
02639       G__setnull(result7);
02640    return(1 || funcname || hash || result7 || libp) ;
02641 }
02642 
02643 static int G__G__MathFit_122_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02644 {
02645       ((ROOT::Fit::BinData*) G__getstructoffset())->Add((double*) G__int(libp->para[0]), (double) G__double(libp->para[1])
02646 , (double) G__double(libp->para[2]));
02647       G__setnull(result7);
02648    return(1 || funcname || hash || result7 || libp) ;
02649 }
02650 
02651 static int G__G__MathFit_122_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02652 {
02653       ((ROOT::Fit::BinData*) G__getstructoffset())->Add((double*) G__int(libp->para[0]), (double) G__double(libp->para[1])
02654 , (double*) G__int(libp->para[2]), (double) G__double(libp->para[3]));
02655       G__setnull(result7);
02656    return(1 || funcname || hash || result7 || libp) ;
02657 }
02658 
02659 static int G__G__MathFit_122_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02660 {
02661       ((ROOT::Fit::BinData*) G__getstructoffset())->Add((double*) G__int(libp->para[0]), (double) G__double(libp->para[1])
02662 , (double*) G__int(libp->para[2]), (double) G__double(libp->para[3])
02663 , (double) G__double(libp->para[4]));
02664       G__setnull(result7);
02665    return(1 || funcname || hash || result7 || libp) ;
02666 }
02667 
02668 static int G__G__MathFit_122_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02669 {
02670       G__letint(result7, 68, (long) ((const ROOT::Fit::BinData*) G__getstructoffset())->Coords((unsigned int) G__int(libp->para[0])));
02671    return(1 || funcname || hash || result7 || libp) ;
02672 }
02673 
02674 static int G__G__MathFit_122_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02675 {
02676       G__letdouble(result7, 100, (double) ((const ROOT::Fit::BinData*) G__getstructoffset())->Value((unsigned int) G__int(libp->para[0])));
02677    return(1 || funcname || hash || result7 || libp) ;
02678 }
02679 
02680 static int G__G__MathFit_122_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02681 {
02682       G__letdouble(result7, 100, (double) ((const ROOT::Fit::BinData*) G__getstructoffset())->Error((unsigned int) G__int(libp->para[0])));
02683    return(1 || funcname || hash || result7 || libp) ;
02684 }
02685 
02686 static int G__G__MathFit_122_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02687 {
02688       G__letdouble(result7, 100, (double) ((const ROOT::Fit::BinData*) G__getstructoffset())->InvError((unsigned int) G__int(libp->para[0])));
02689    return(1 || funcname || hash || result7 || libp) ;
02690 }
02691 
02692 static int G__G__MathFit_122_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02693 {
02694       G__letint(result7, 68, (long) ((const ROOT::Fit::BinData*) G__getstructoffset())->CoordErrors((unsigned int) G__int(libp->para[0])));
02695    return(1 || funcname || hash || result7 || libp) ;
02696 }
02697 
02698 static int G__G__MathFit_122_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02699 {
02700       G__letint(result7, 68, (long) ((const ROOT::Fit::BinData*) G__getstructoffset())->GetPoint((unsigned int) G__int(libp->para[0]), *(double*) G__Doubleref(&libp->para[1])));
02701    return(1 || funcname || hash || result7 || libp) ;
02702 }
02703 
02704 static int G__G__MathFit_122_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02705 {
02706       G__letint(result7, 68, (long) ((const ROOT::Fit::BinData*) G__getstructoffset())->GetPoint((unsigned int) G__int(libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
02707 , *(double*) G__Doubleref(&libp->para[2])));
02708    return(1 || funcname || hash || result7 || libp) ;
02709 }
02710 
02711 static int G__G__MathFit_122_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02712 {
02713       G__letint(result7, 68, (long) ((const ROOT::Fit::BinData*) G__getstructoffset())->GetPointError((unsigned int) G__int(libp->para[0]), *(double*) G__Doubleref(&libp->para[1])));
02714    return(1 || funcname || hash || result7 || libp) ;
02715 }
02716 
02717 static int G__G__MathFit_122_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02718 {
02719       G__letint(result7, 68, (long) ((const ROOT::Fit::BinData*) G__getstructoffset())->GetPointError((unsigned int) G__int(libp->para[0]), *(double*) G__Doubleref(&libp->para[1])
02720 , *(double*) G__Doubleref(&libp->para[2])));
02721    return(1 || funcname || hash || result7 || libp) ;
02722 }
02723 
02724 static int G__G__MathFit_122_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02725 {
02726       ((ROOT::Fit::BinData*) G__getstructoffset())->Resize((unsigned int) G__int(libp->para[0]));
02727       G__setnull(result7);
02728    return(1 || funcname || hash || result7 || libp) ;
02729 }
02730 
02731 static int G__G__MathFit_122_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02732 {
02733       G__letint(result7, 104, (long) ((const ROOT::Fit::BinData*) G__getstructoffset())->NPoints());
02734    return(1 || funcname || hash || result7 || libp) ;
02735 }
02736 
02737 static int G__G__MathFit_122_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02738 {
02739       G__letint(result7, 104, (long) ((const ROOT::Fit::BinData*) G__getstructoffset())->Size());
02740    return(1 || funcname || hash || result7 || libp) ;
02741 }
02742 
02743 static int G__G__MathFit_122_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02744 {
02745       G__letint(result7, 104, (long) ((const ROOT::Fit::BinData*) G__getstructoffset())->NDim());
02746    return(1 || funcname || hash || result7 || libp) ;
02747 }
02748 
02749 static int G__G__MathFit_122_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02750 {
02751       {
02752          const ROOT::Fit::BinData& obj = ((ROOT::Fit::BinData*) G__getstructoffset())->LogTransform();
02753          result7->ref = (long) (&obj);
02754          result7->obj.i = (long) (&obj);
02755       }
02756    return(1 || funcname || hash || result7 || libp) ;
02757 }
02758 
02759 static int G__G__MathFit_122_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02760 {
02761       G__letint(result7, 68, (long) ((const ROOT::Fit::BinData*) G__getstructoffset())->BinUpEdge((unsigned int) G__int(libp->para[0])));
02762    return(1 || funcname || hash || result7 || libp) ;
02763 }
02764 
02765 static int G__G__MathFit_122_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02766 {
02767       G__letint(result7, 103, (long) ((const ROOT::Fit::BinData*) G__getstructoffset())->HasBinEdges());
02768    return(1 || funcname || hash || result7 || libp) ;
02769 }
02770 
02771 static int G__G__MathFit_122_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02772 {
02773       ((ROOT::Fit::BinData*) G__getstructoffset())->AddBinUpEdge((double*) G__int(libp->para[0]));
02774       G__setnull(result7);
02775    return(1 || funcname || hash || result7 || libp) ;
02776 }
02777 
02778 static int G__G__MathFit_122_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02779 {
02780       G__letdouble(result7, 100, (double) ((const ROOT::Fit::BinData*) G__getstructoffset())->RefVolume());
02781    return(1 || funcname || hash || result7 || libp) ;
02782 }
02783 
02784 static int G__G__MathFit_122_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02785 {
02786       ((ROOT::Fit::BinData*) G__getstructoffset())->SetRefVolume((double) G__double(libp->para[0]));
02787       G__setnull(result7);
02788    return(1 || funcname || hash || result7 || libp) ;
02789 }
02790 
02791 // automatic destructor
02792 typedef ROOT::Fit::BinData G__TROOTcLcLFitcLcLBinData;
02793 static int G__G__MathFit_122_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02794 {
02795    char* gvp = (char*) G__getgvp();
02796    long soff = G__getstructoffset();
02797    int n = G__getaryconstruct();
02798    //
02799    //has_a_delete: 0
02800    //has_own_delete1arg: 0
02801    //has_own_delete2arg: 0
02802    //
02803    if (!soff) {
02804      return(1);
02805    }
02806    if (n) {
02807      if (gvp == (char*)G__PVOID) {
02808        delete[] (ROOT::Fit::BinData*) soff;
02809      } else {
02810        G__setgvp((long) G__PVOID);
02811        for (int i = n - 1; i >= 0; --i) {
02812          ((ROOT::Fit::BinData*) (soff+(sizeof(ROOT::Fit::BinData)*i)))->~G__TROOTcLcLFitcLcLBinData();
02813        }
02814        G__setgvp((long)gvp);
02815      }
02816    } else {
02817      if (gvp == (char*)G__PVOID) {
02818        delete (ROOT::Fit::BinData*) soff;
02819      } else {
02820        G__setgvp((long) G__PVOID);
02821        ((ROOT::Fit::BinData*) (soff))->~G__TROOTcLcLFitcLcLBinData();
02822        G__setgvp((long)gvp);
02823      }
02824    }
02825    G__setnull(result7);
02826    return(1 || funcname || hash || result7 || libp) ;
02827 }
02828 
02829 
02830 /* ROOT::Fit::UnBinData */
02831 static int G__G__MathFit_142_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02832 {
02833    ROOT::Fit::UnBinData* p = NULL;
02834    char* gvp = (char*) G__getgvp();
02835    switch (libp->paran) {
02836    case 2:
02837      //m: 2
02838      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02839        p = new ROOT::Fit::UnBinData((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
02840      } else {
02841        p = new((void*) gvp) ROOT::Fit::UnBinData((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
02842      }
02843      break;
02844    case 1:
02845      //m: 1
02846      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02847        p = new ROOT::Fit::UnBinData((unsigned int) G__int(libp->para[0]));
02848      } else {
02849        p = new((void*) gvp) ROOT::Fit::UnBinData((unsigned int) G__int(libp->para[0]));
02850      }
02851      break;
02852    case 0:
02853      int n = G__getaryconstruct();
02854      if (n) {
02855        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02856          p = new ROOT::Fit::UnBinData[n];
02857        } else {
02858          p = new((void*) gvp) ROOT::Fit::UnBinData[n];
02859        }
02860      } else {
02861        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02862          p = new ROOT::Fit::UnBinData;
02863        } else {
02864          p = new((void*) gvp) ROOT::Fit::UnBinData;
02865        }
02866      }
02867      break;
02868    }
02869    result7->obj.i = (long) p;
02870    result7->ref = (long) p;
02871    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData));
02872    return(1 || funcname || hash || result7 || libp) ;
02873 }
02874 
02875 static int G__G__MathFit_142_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02876 {
02877    ROOT::Fit::UnBinData* p = NULL;
02878    char* gvp = (char*) G__getgvp();
02879    switch (libp->paran) {
02880    case 3:
02881      //m: 3
02882      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02883        p = new ROOT::Fit::UnBinData(
02884 *(ROOT::Fit::DataRange*) libp->para[0].ref, (unsigned int) G__int(libp->para[1])
02885 , (unsigned int) G__int(libp->para[2]));
02886      } else {
02887        p = new((void*) gvp) ROOT::Fit::UnBinData(
02888 *(ROOT::Fit::DataRange*) libp->para[0].ref, (unsigned int) G__int(libp->para[1])
02889 , (unsigned int) G__int(libp->para[2]));
02890      }
02891      break;
02892    case 2:
02893      //m: 2
02894      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02895        p = new ROOT::Fit::UnBinData(*(ROOT::Fit::DataRange*) libp->para[0].ref, (unsigned int) G__int(libp->para[1]));
02896      } else {
02897        p = new((void*) gvp) ROOT::Fit::UnBinData(*(ROOT::Fit::DataRange*) libp->para[0].ref, (unsigned int) G__int(libp->para[1]));
02898      }
02899      break;
02900    case 1:
02901      //m: 1
02902      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02903        p = new ROOT::Fit::UnBinData(*(ROOT::Fit::DataRange*) libp->para[0].ref);
02904      } else {
02905        p = new((void*) gvp) ROOT::Fit::UnBinData(*(ROOT::Fit::DataRange*) libp->para[0].ref);
02906      }
02907      break;
02908    }
02909    result7->obj.i = (long) p;
02910    result7->ref = (long) p;
02911    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData));
02912    return(1 || funcname || hash || result7 || libp) ;
02913 }
02914 
02915 static int G__G__MathFit_142_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02916 {
02917    ROOT::Fit::UnBinData* p = NULL;
02918    char* gvp = (char*) G__getgvp();
02919    switch (libp->paran) {
02920    case 4:
02921      //m: 4
02922      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02923        p = new ROOT::Fit::UnBinData(
02924 *(ROOT::Fit::DataOptions*) libp->para[0].ref, *(ROOT::Fit::DataRange*) libp->para[1].ref
02925 , (unsigned int) G__int(libp->para[2]), (unsigned int) G__int(libp->para[3]));
02926      } else {
02927        p = new((void*) gvp) ROOT::Fit::UnBinData(
02928 *(ROOT::Fit::DataOptions*) libp->para[0].ref, *(ROOT::Fit::DataRange*) libp->para[1].ref
02929 , (unsigned int) G__int(libp->para[2]), (unsigned int) G__int(libp->para[3]));
02930      }
02931      break;
02932    case 3:
02933      //m: 3
02934      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02935        p = new ROOT::Fit::UnBinData(
02936 *(ROOT::Fit::DataOptions*) libp->para[0].ref, *(ROOT::Fit::DataRange*) libp->para[1].ref
02937 , (unsigned int) G__int(libp->para[2]));
02938      } else {
02939        p = new((void*) gvp) ROOT::Fit::UnBinData(
02940 *(ROOT::Fit::DataOptions*) libp->para[0].ref, *(ROOT::Fit::DataRange*) libp->para[1].ref
02941 , (unsigned int) G__int(libp->para[2]));
02942      }
02943      break;
02944    case 2:
02945      //m: 2
02946      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02947        p = new ROOT::Fit::UnBinData(*(ROOT::Fit::DataOptions*) libp->para[0].ref, *(ROOT::Fit::DataRange*) libp->para[1].ref);
02948      } else {
02949        p = new((void*) gvp) ROOT::Fit::UnBinData(*(ROOT::Fit::DataOptions*) libp->para[0].ref, *(ROOT::Fit::DataRange*) libp->para[1].ref);
02950      }
02951      break;
02952    }
02953    result7->obj.i = (long) p;
02954    result7->ref = (long) p;
02955    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData));
02956    return(1 || funcname || hash || result7 || libp) ;
02957 }
02958 
02959 static int G__G__MathFit_142_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02960 {
02961    ROOT::Fit::UnBinData* p = NULL;
02962    char* gvp = (char*) G__getgvp();
02963    //m: 2
02964    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02965      p = new ROOT::Fit::UnBinData((unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
02966    } else {
02967      p = new((void*) gvp) ROOT::Fit::UnBinData((unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
02968    }
02969    result7->obj.i = (long) p;
02970    result7->ref = (long) p;
02971    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData));
02972    return(1 || funcname || hash || result7 || libp) ;
02973 }
02974 
02975 static int G__G__MathFit_142_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02976 {
02977    ROOT::Fit::UnBinData* p = NULL;
02978    char* gvp = (char*) G__getgvp();
02979    //m: 3
02980    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
02981      p = new ROOT::Fit::UnBinData(
02982 (unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
02983 , (double*) G__int(libp->para[2]));
02984    } else {
02985      p = new((void*) gvp) ROOT::Fit::UnBinData(
02986 (unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
02987 , (double*) G__int(libp->para[2]));
02988    }
02989    result7->obj.i = (long) p;
02990    result7->ref = (long) p;
02991    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData));
02992    return(1 || funcname || hash || result7 || libp) ;
02993 }
02994 
02995 static int G__G__MathFit_142_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
02996 {
02997    ROOT::Fit::UnBinData* p = NULL;
02998    char* gvp = (char*) G__getgvp();
02999    //m: 4
03000    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03001      p = new ROOT::Fit::UnBinData(
03002 (unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
03003 , (double*) G__int(libp->para[2]), (double*) G__int(libp->para[3]));
03004    } else {
03005      p = new((void*) gvp) ROOT::Fit::UnBinData(
03006 (unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
03007 , (double*) G__int(libp->para[2]), (double*) G__int(libp->para[3]));
03008    }
03009    result7->obj.i = (long) p;
03010    result7->ref = (long) p;
03011    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData));
03012    return(1 || funcname || hash || result7 || libp) ;
03013 }
03014 
03015 static int G__G__MathFit_142_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03016 {
03017    ROOT::Fit::UnBinData* p = NULL;
03018    char* gvp = (char*) G__getgvp();
03019    //m: 3
03020    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03021      p = new ROOT::Fit::UnBinData(
03022 (unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
03023 , *(ROOT::Fit::DataRange*) libp->para[2].ref);
03024    } else {
03025      p = new((void*) gvp) ROOT::Fit::UnBinData(
03026 (unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
03027 , *(ROOT::Fit::DataRange*) libp->para[2].ref);
03028    }
03029    result7->obj.i = (long) p;
03030    result7->ref = (long) p;
03031    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData));
03032    return(1 || funcname || hash || result7 || libp) ;
03033 }
03034 
03035 static int G__G__MathFit_142_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03036 {
03037    ROOT::Fit::UnBinData* p = NULL;
03038    char* gvp = (char*) G__getgvp();
03039    //m: 4
03040    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03041      p = new ROOT::Fit::UnBinData(
03042 (unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
03043 , (double*) G__int(libp->para[2]), *(ROOT::Fit::DataRange*) libp->para[3].ref);
03044    } else {
03045      p = new((void*) gvp) ROOT::Fit::UnBinData(
03046 (unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
03047 , (double*) G__int(libp->para[2]), *(ROOT::Fit::DataRange*) libp->para[3].ref);
03048    }
03049    result7->obj.i = (long) p;
03050    result7->ref = (long) p;
03051    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData));
03052    return(1 || funcname || hash || result7 || libp) ;
03053 }
03054 
03055 static int G__G__MathFit_142_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03056 {
03057    ROOT::Fit::UnBinData* p = NULL;
03058    char* gvp = (char*) G__getgvp();
03059    //m: 5
03060    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03061      p = new ROOT::Fit::UnBinData(
03062 (unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
03063 , (double*) G__int(libp->para[2]), (double*) G__int(libp->para[3])
03064 , *(ROOT::Fit::DataRange*) libp->para[4].ref);
03065    } else {
03066      p = new((void*) gvp) ROOT::Fit::UnBinData(
03067 (unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
03068 , (double*) G__int(libp->para[2]), (double*) G__int(libp->para[3])
03069 , *(ROOT::Fit::DataRange*) libp->para[4].ref);
03070    }
03071    result7->obj.i = (long) p;
03072    result7->ref = (long) p;
03073    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData));
03074    return(1 || funcname || hash || result7 || libp) ;
03075 }
03076 
03077 static int G__G__MathFit_142_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03078 {
03079    switch (libp->paran) {
03080    case 2:
03081       ((ROOT::Fit::UnBinData*) G__getstructoffset())->Initialize((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1]));
03082       G__setnull(result7);
03083       break;
03084    case 1:
03085       ((ROOT::Fit::UnBinData*) G__getstructoffset())->Initialize((unsigned int) G__int(libp->para[0]));
03086       G__setnull(result7);
03087       break;
03088    }
03089    return(1 || funcname || hash || result7 || libp) ;
03090 }
03091 
03092 static int G__G__MathFit_142_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03093 {
03094       G__letint(result7, 104, (long) ((const ROOT::Fit::UnBinData*) G__getstructoffset())->PointSize());
03095    return(1 || funcname || hash || result7 || libp) ;
03096 }
03097 
03098 static int G__G__MathFit_142_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03099 {
03100       G__letint(result7, 104, (long) ((const ROOT::Fit::UnBinData*) G__getstructoffset())->DataSize());
03101    return(1 || funcname || hash || result7 || libp) ;
03102 }
03103 
03104 static int G__G__MathFit_142_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03105 {
03106       ((ROOT::Fit::UnBinData*) G__getstructoffset())->Add((double) G__double(libp->para[0]));
03107       G__setnull(result7);
03108    return(1 || funcname || hash || result7 || libp) ;
03109 }
03110 
03111 static int G__G__MathFit_142_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03112 {
03113       ((ROOT::Fit::UnBinData*) G__getstructoffset())->Add((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
03114       G__setnull(result7);
03115    return(1 || funcname || hash || result7 || libp) ;
03116 }
03117 
03118 static int G__G__MathFit_142_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03119 {
03120       ((ROOT::Fit::UnBinData*) G__getstructoffset())->Add((double) G__double(libp->para[0]), (double) G__double(libp->para[1])
03121 , (double) G__double(libp->para[2]));
03122       G__setnull(result7);
03123    return(1 || funcname || hash || result7 || libp) ;
03124 }
03125 
03126 static int G__G__MathFit_142_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03127 {
03128       ((ROOT::Fit::UnBinData*) G__getstructoffset())->Add((double*) G__int(libp->para[0]));
03129       G__setnull(result7);
03130    return(1 || funcname || hash || result7 || libp) ;
03131 }
03132 
03133 static int G__G__MathFit_142_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03134 {
03135       G__letint(result7, 68, (long) ((const ROOT::Fit::UnBinData*) G__getstructoffset())->Coords((unsigned int) G__int(libp->para[0])));
03136    return(1 || funcname || hash || result7 || libp) ;
03137 }
03138 
03139 static int G__G__MathFit_142_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03140 {
03141       ((ROOT::Fit::UnBinData*) G__getstructoffset())->Resize((unsigned int) G__int(libp->para[0]));
03142       G__setnull(result7);
03143    return(1 || funcname || hash || result7 || libp) ;
03144 }
03145 
03146 static int G__G__MathFit_142_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03147 {
03148       G__letint(result7, 104, (long) ((const ROOT::Fit::UnBinData*) G__getstructoffset())->NPoints());
03149    return(1 || funcname || hash || result7 || libp) ;
03150 }
03151 
03152 static int G__G__MathFit_142_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03153 {
03154       G__letint(result7, 104, (long) ((const ROOT::Fit::UnBinData*) G__getstructoffset())->Size());
03155    return(1 || funcname || hash || result7 || libp) ;
03156 }
03157 
03158 static int G__G__MathFit_142_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03159 {
03160       G__letint(result7, 104, (long) ((const ROOT::Fit::UnBinData*) G__getstructoffset())->NDim());
03161    return(1 || funcname || hash || result7 || libp) ;
03162 }
03163 
03164 // automatic destructor
03165 typedef ROOT::Fit::UnBinData G__TROOTcLcLFitcLcLUnBinData;
03166 static int G__G__MathFit_142_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03167 {
03168    char* gvp = (char*) G__getgvp();
03169    long soff = G__getstructoffset();
03170    int n = G__getaryconstruct();
03171    //
03172    //has_a_delete: 0
03173    //has_own_delete1arg: 0
03174    //has_own_delete2arg: 0
03175    //
03176    if (!soff) {
03177      return(1);
03178    }
03179    if (n) {
03180      if (gvp == (char*)G__PVOID) {
03181        delete[] (ROOT::Fit::UnBinData*) soff;
03182      } else {
03183        G__setgvp((long) G__PVOID);
03184        for (int i = n - 1; i >= 0; --i) {
03185          ((ROOT::Fit::UnBinData*) (soff+(sizeof(ROOT::Fit::UnBinData)*i)))->~G__TROOTcLcLFitcLcLUnBinData();
03186        }
03187        G__setgvp((long)gvp);
03188      }
03189    } else {
03190      if (gvp == (char*)G__PVOID) {
03191        delete (ROOT::Fit::UnBinData*) soff;
03192      } else {
03193        G__setgvp((long) G__PVOID);
03194        ((ROOT::Fit::UnBinData*) (soff))->~G__TROOTcLcLFitcLcLUnBinData();
03195        G__setgvp((long)gvp);
03196      }
03197    }
03198    G__setnull(result7);
03199    return(1 || funcname || hash || result7 || libp) ;
03200 }
03201 
03202 
03203 /* ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim> */
03204 static int G__G__MathFit_145_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03205 {
03206    ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>* p = NULL;
03207    char* gvp = (char*) G__getgvp();
03208    //m: 2
03209    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03210      p = new ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>(*(ROOT::Fit::BinData*) libp->para[0].ref, *(ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>::IModelFunction*) libp->para[1].ref);
03211    } else {
03212      p = new((void*) gvp) ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>(*(ROOT::Fit::BinData*) libp->para[0].ref, *(ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>::IModelFunction*) libp->para[1].ref);
03213    }
03214    result7->obj.i = (long) p;
03215    result7->ref = (long) p;
03216    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR));
03217    return(1 || funcname || hash || result7 || libp) ;
03218 }
03219 
03220 static int G__G__MathFit_145_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03221 {
03222       G__letint(result7, 104, (long) ((const ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>*) G__getstructoffset())->NFitPoints());
03223    return(1 || funcname || hash || result7 || libp) ;
03224 }
03225 
03226 static int G__G__MathFit_145_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03227 {
03228       ((const ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>*) G__getstructoffset())->Gradient((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
03229       G__setnull(result7);
03230    return(1 || funcname || hash || result7 || libp) ;
03231 }
03232 
03233 static int G__G__MathFit_145_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03234 {
03235       {
03236          const ROOT::Fit::BinData& obj = ((const ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>*) G__getstructoffset())->Data();
03237          result7->ref = (long) (&obj);
03238          result7->obj.i = (long) (&obj);
03239       }
03240    return(1 || funcname || hash || result7 || libp) ;
03241 }
03242 
03243 static int G__G__MathFit_145_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03244 {
03245       {
03246          const ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>::IModelFunction& obj = ((const ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>*) G__getstructoffset())->ModelFunction();
03247          result7->ref = (long) (&obj);
03248          result7->obj.i = (long) (&obj);
03249       }
03250    return(1 || funcname || hash || result7 || libp) ;
03251 }
03252 
03253 // automatic copy constructor
03254 static int G__G__MathFit_145_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03255 
03256 {
03257    ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>* p;
03258    void* tmp = (void*) G__int(libp->para[0]);
03259    p = new ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>(*(ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>*) tmp);
03260    result7->obj.i = (long) p;
03261    result7->ref = (long) p;
03262    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR));
03263    return(1 || funcname || hash || result7 || libp) ;
03264 }
03265 
03266 // automatic destructor
03267 typedef ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim> G__TROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR;
03268 static int G__G__MathFit_145_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03269 {
03270    char* gvp = (char*) G__getgvp();
03271    long soff = G__getstructoffset();
03272    int n = G__getaryconstruct();
03273    //
03274    //has_a_delete: 0
03275    //has_own_delete1arg: 0
03276    //has_own_delete2arg: 0
03277    //
03278    if (!soff) {
03279      return(1);
03280    }
03281    if (n) {
03282      if (gvp == (char*)G__PVOID) {
03283        delete[] (ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>*) soff;
03284      } else {
03285        G__setgvp((long) G__PVOID);
03286        for (int i = n - 1; i >= 0; --i) {
03287          ((ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>*) (soff+(sizeof(ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>)*i)))->~G__TROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR();
03288        }
03289        G__setgvp((long)gvp);
03290      }
03291    } else {
03292      if (gvp == (char*)G__PVOID) {
03293        delete (ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>*) soff;
03294      } else {
03295        G__setgvp((long) G__PVOID);
03296        ((ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>*) (soff))->~G__TROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR();
03297        G__setgvp((long)gvp);
03298      }
03299    }
03300    G__setnull(result7);
03301    return(1 || funcname || hash || result7 || libp) ;
03302 }
03303 
03304 
03305 /* ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim> */
03306 static int G__G__MathFit_147_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03307 {
03308    ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>* p = NULL;
03309    char* gvp = (char*) G__getgvp();
03310    //m: 2
03311    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03312      p = new ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>(*(ROOT::Fit::BinData*) libp->para[0].ref, *(ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>::IModelFunction*) libp->para[1].ref);
03313    } else {
03314      p = new((void*) gvp) ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>(*(ROOT::Fit::BinData*) libp->para[0].ref, *(ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>::IModelFunction*) libp->para[1].ref);
03315    }
03316    result7->obj.i = (long) p;
03317    result7->ref = (long) p;
03318    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR));
03319    return(1 || funcname || hash || result7 || libp) ;
03320 }
03321 
03322 static int G__G__MathFit_147_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03323 {
03324       G__letint(result7, 104, (long) ((const ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>*) G__getstructoffset())->NFitPoints());
03325    return(1 || funcname || hash || result7 || libp) ;
03326 }
03327 
03328 static int G__G__MathFit_147_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03329 {
03330       {
03331          const ROOT::Fit::BinData& obj = ((const ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>*) G__getstructoffset())->Data();
03332          result7->ref = (long) (&obj);
03333          result7->obj.i = (long) (&obj);
03334       }
03335    return(1 || funcname || hash || result7 || libp) ;
03336 }
03337 
03338 static int G__G__MathFit_147_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03339 {
03340       {
03341          const ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>::IModelFunction& obj = ((const ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>*) G__getstructoffset())->ModelFunction();
03342          result7->ref = (long) (&obj);
03343          result7->obj.i = (long) (&obj);
03344       }
03345    return(1 || funcname || hash || result7 || libp) ;
03346 }
03347 
03348 // automatic copy constructor
03349 static int G__G__MathFit_147_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03350 
03351 {
03352    ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>* p;
03353    void* tmp = (void*) G__int(libp->para[0]);
03354    p = new ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>(*(ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>*) tmp);
03355    result7->obj.i = (long) p;
03356    result7->ref = (long) p;
03357    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR));
03358    return(1 || funcname || hash || result7 || libp) ;
03359 }
03360 
03361 // automatic destructor
03362 typedef ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim> G__TROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR;
03363 static int G__G__MathFit_147_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03364 {
03365    char* gvp = (char*) G__getgvp();
03366    long soff = G__getstructoffset();
03367    int n = G__getaryconstruct();
03368    //
03369    //has_a_delete: 0
03370    //has_own_delete1arg: 0
03371    //has_own_delete2arg: 0
03372    //
03373    if (!soff) {
03374      return(1);
03375    }
03376    if (n) {
03377      if (gvp == (char*)G__PVOID) {
03378        delete[] (ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>*) soff;
03379      } else {
03380        G__setgvp((long) G__PVOID);
03381        for (int i = n - 1; i >= 0; --i) {
03382          ((ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>*) (soff+(sizeof(ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>)*i)))->~G__TROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR();
03383        }
03384        G__setgvp((long)gvp);
03385      }
03386    } else {
03387      if (gvp == (char*)G__PVOID) {
03388        delete (ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>*) soff;
03389      } else {
03390        G__setgvp((long) G__PVOID);
03391        ((ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>*) (soff))->~G__TROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR();
03392        G__setgvp((long)gvp);
03393      }
03394    }
03395    G__setnull(result7);
03396    return(1 || funcname || hash || result7 || libp) ;
03397 }
03398 
03399 
03400 /* ROOT::Fit::ParameterSettings */
03401 static int G__G__MathFit_150_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03402 {
03403    ROOT::Fit::ParameterSettings* p = NULL;
03404    char* gvp = (char*) G__getgvp();
03405    int n = G__getaryconstruct();
03406    if (n) {
03407      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03408        p = new ROOT::Fit::ParameterSettings[n];
03409      } else {
03410        p = new((void*) gvp) ROOT::Fit::ParameterSettings[n];
03411      }
03412    } else {
03413      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03414        p = new ROOT::Fit::ParameterSettings;
03415      } else {
03416        p = new((void*) gvp) ROOT::Fit::ParameterSettings;
03417      }
03418    }
03419    result7->obj.i = (long) p;
03420    result7->ref = (long) p;
03421    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings));
03422    return(1 || funcname || hash || result7 || libp) ;
03423 }
03424 
03425 static int G__G__MathFit_150_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03426 {
03427    ROOT::Fit::ParameterSettings* p = NULL;
03428    char* gvp = (char*) G__getgvp();
03429    //m: 3
03430    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03431      p = new ROOT::Fit::ParameterSettings(
03432 *(string*) libp->para[0].ref, (double) G__double(libp->para[1])
03433 , (double) G__double(libp->para[2]));
03434    } else {
03435      p = new((void*) gvp) ROOT::Fit::ParameterSettings(
03436 *(string*) libp->para[0].ref, (double) G__double(libp->para[1])
03437 , (double) G__double(libp->para[2]));
03438    }
03439    result7->obj.i = (long) p;
03440    result7->ref = (long) p;
03441    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings));
03442    return(1 || funcname || hash || result7 || libp) ;
03443 }
03444 
03445 static int G__G__MathFit_150_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03446 {
03447    ROOT::Fit::ParameterSettings* p = NULL;
03448    char* gvp = (char*) G__getgvp();
03449    //m: 5
03450    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03451      p = new ROOT::Fit::ParameterSettings(
03452 *(string*) libp->para[0].ref, (double) G__double(libp->para[1])
03453 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
03454 , (double) G__double(libp->para[4]));
03455    } else {
03456      p = new((void*) gvp) ROOT::Fit::ParameterSettings(
03457 *(string*) libp->para[0].ref, (double) G__double(libp->para[1])
03458 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
03459 , (double) G__double(libp->para[4]));
03460    }
03461    result7->obj.i = (long) p;
03462    result7->ref = (long) p;
03463    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings));
03464    return(1 || funcname || hash || result7 || libp) ;
03465 }
03466 
03467 static int G__G__MathFit_150_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03468 {
03469    ROOT::Fit::ParameterSettings* p = NULL;
03470    char* gvp = (char*) G__getgvp();
03471    //m: 2
03472    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03473      p = new ROOT::Fit::ParameterSettings(*(string*) libp->para[0].ref, (double) G__double(libp->para[1]));
03474    } else {
03475      p = new((void*) gvp) ROOT::Fit::ParameterSettings(*(string*) libp->para[0].ref, (double) G__double(libp->para[1]));
03476    }
03477    result7->obj.i = (long) p;
03478    result7->ref = (long) p;
03479    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings));
03480    return(1 || funcname || hash || result7 || libp) ;
03481 }
03482 
03483 static int G__G__MathFit_150_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03484 {
03485       ((ROOT::Fit::ParameterSettings*) G__getstructoffset())->Set(*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
03486 , (double) G__double(libp->para[2]));
03487       G__setnull(result7);
03488    return(1 || funcname || hash || result7 || libp) ;
03489 }
03490 
03491 static int G__G__MathFit_150_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03492 {
03493       ((ROOT::Fit::ParameterSettings*) G__getstructoffset())->Set(*(string*) libp->para[0].ref, (double) G__double(libp->para[1])
03494 , (double) G__double(libp->para[2]), (double) G__double(libp->para[3])
03495 , (double) G__double(libp->para[4]));
03496       G__setnull(result7);
03497    return(1 || funcname || hash || result7 || libp) ;
03498 }
03499 
03500 static int G__G__MathFit_150_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03501 {
03502       ((ROOT::Fit::ParameterSettings*) G__getstructoffset())->Set(*(string*) libp->para[0].ref, (double) G__double(libp->para[1]));
03503       G__setnull(result7);
03504    return(1 || funcname || hash || result7 || libp) ;
03505 }
03506 
03507 static int G__G__MathFit_150_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03508 {
03509       G__letdouble(result7, 100, (double) ((const ROOT::Fit::ParameterSettings*) G__getstructoffset())->Value());
03510    return(1 || funcname || hash || result7 || libp) ;
03511 }
03512 
03513 static int G__G__MathFit_150_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03514 {
03515       G__letdouble(result7, 100, (double) ((const ROOT::Fit::ParameterSettings*) G__getstructoffset())->StepSize());
03516    return(1 || funcname || hash || result7 || libp) ;
03517 }
03518 
03519 static int G__G__MathFit_150_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03520 {
03521       G__letdouble(result7, 100, (double) ((const ROOT::Fit::ParameterSettings*) G__getstructoffset())->LowerLimit());
03522    return(1 || funcname || hash || result7 || libp) ;
03523 }
03524 
03525 static int G__G__MathFit_150_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03526 {
03527       G__letdouble(result7, 100, (double) ((const ROOT::Fit::ParameterSettings*) G__getstructoffset())->UpperLimit());
03528    return(1 || funcname || hash || result7 || libp) ;
03529 }
03530 
03531 static int G__G__MathFit_150_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03532 {
03533       G__letint(result7, 103, (long) ((const ROOT::Fit::ParameterSettings*) G__getstructoffset())->IsFixed());
03534    return(1 || funcname || hash || result7 || libp) ;
03535 }
03536 
03537 static int G__G__MathFit_150_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03538 {
03539       G__letint(result7, 103, (long) ((const ROOT::Fit::ParameterSettings*) G__getstructoffset())->HasLowerLimit());
03540    return(1 || funcname || hash || result7 || libp) ;
03541 }
03542 
03543 static int G__G__MathFit_150_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03544 {
03545       G__letint(result7, 103, (long) ((const ROOT::Fit::ParameterSettings*) G__getstructoffset())->HasUpperLimit());
03546    return(1 || funcname || hash || result7 || libp) ;
03547 }
03548 
03549 static int G__G__MathFit_150_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03550 {
03551       G__letint(result7, 103, (long) ((const ROOT::Fit::ParameterSettings*) G__getstructoffset())->IsBound());
03552    return(1 || funcname || hash || result7 || libp) ;
03553 }
03554 
03555 static int G__G__MathFit_150_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03556 {
03557       G__letint(result7, 103, (long) ((const ROOT::Fit::ParameterSettings*) G__getstructoffset())->IsDoubleBound());
03558    return(1 || funcname || hash || result7 || libp) ;
03559 }
03560 
03561 static int G__G__MathFit_150_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03562 {
03563       {
03564          const string& obj = ((const ROOT::Fit::ParameterSettings*) G__getstructoffset())->Name();
03565          result7->ref = (long) (&obj);
03566          result7->obj.i = (long) (&obj);
03567       }
03568    return(1 || funcname || hash || result7 || libp) ;
03569 }
03570 
03571 static int G__G__MathFit_150_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03572 {
03573       ((ROOT::Fit::ParameterSettings*) G__getstructoffset())->SetName(*(string*) libp->para[0].ref);
03574       G__setnull(result7);
03575    return(1 || funcname || hash || result7 || libp) ;
03576 }
03577 
03578 static int G__G__MathFit_150_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03579 {
03580       ((ROOT::Fit::ParameterSettings*) G__getstructoffset())->Fix();
03581       G__setnull(result7);
03582    return(1 || funcname || hash || result7 || libp) ;
03583 }
03584 
03585 static int G__G__MathFit_150_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03586 {
03587       ((ROOT::Fit::ParameterSettings*) G__getstructoffset())->Release();
03588       G__setnull(result7);
03589    return(1 || funcname || hash || result7 || libp) ;
03590 }
03591 
03592 static int G__G__MathFit_150_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03593 {
03594       ((ROOT::Fit::ParameterSettings*) G__getstructoffset())->SetValue((double) G__double(libp->para[0]));
03595       G__setnull(result7);
03596    return(1 || funcname || hash || result7 || libp) ;
03597 }
03598 
03599 static int G__G__MathFit_150_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03600 {
03601       ((ROOT::Fit::ParameterSettings*) G__getstructoffset())->SetStepSize((double) G__double(libp->para[0]));
03602       G__setnull(result7);
03603    return(1 || funcname || hash || result7 || libp) ;
03604 }
03605 
03606 static int G__G__MathFit_150_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03607 {
03608       ((ROOT::Fit::ParameterSettings*) G__getstructoffset())->SetLimits((double) G__double(libp->para[0]), (double) G__double(libp->para[1]));
03609       G__setnull(result7);
03610    return(1 || funcname || hash || result7 || libp) ;
03611 }
03612 
03613 static int G__G__MathFit_150_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03614 {
03615       ((ROOT::Fit::ParameterSettings*) G__getstructoffset())->SetUpperLimit((double) G__double(libp->para[0]));
03616       G__setnull(result7);
03617    return(1 || funcname || hash || result7 || libp) ;
03618 }
03619 
03620 static int G__G__MathFit_150_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03621 {
03622       ((ROOT::Fit::ParameterSettings*) G__getstructoffset())->SetLowerLimit((double) G__double(libp->para[0]));
03623       G__setnull(result7);
03624    return(1 || funcname || hash || result7 || libp) ;
03625 }
03626 
03627 static int G__G__MathFit_150_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03628 {
03629       ((ROOT::Fit::ParameterSettings*) G__getstructoffset())->RemoveLimits();
03630       G__setnull(result7);
03631    return(1 || funcname || hash || result7 || libp) ;
03632 }
03633 
03634 // automatic copy constructor
03635 static int G__G__MathFit_150_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03636 
03637 {
03638    ROOT::Fit::ParameterSettings* p;
03639    void* tmp = (void*) G__int(libp->para[0]);
03640    p = new ROOT::Fit::ParameterSettings(*(ROOT::Fit::ParameterSettings*) tmp);
03641    result7->obj.i = (long) p;
03642    result7->ref = (long) p;
03643    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings));
03644    return(1 || funcname || hash || result7 || libp) ;
03645 }
03646 
03647 // automatic destructor
03648 typedef ROOT::Fit::ParameterSettings G__TROOTcLcLFitcLcLParameterSettings;
03649 static int G__G__MathFit_150_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03650 {
03651    char* gvp = (char*) G__getgvp();
03652    long soff = G__getstructoffset();
03653    int n = G__getaryconstruct();
03654    //
03655    //has_a_delete: 0
03656    //has_own_delete1arg: 0
03657    //has_own_delete2arg: 0
03658    //
03659    if (!soff) {
03660      return(1);
03661    }
03662    if (n) {
03663      if (gvp == (char*)G__PVOID) {
03664        delete[] (ROOT::Fit::ParameterSettings*) soff;
03665      } else {
03666        G__setgvp((long) G__PVOID);
03667        for (int i = n - 1; i >= 0; --i) {
03668          ((ROOT::Fit::ParameterSettings*) (soff+(sizeof(ROOT::Fit::ParameterSettings)*i)))->~G__TROOTcLcLFitcLcLParameterSettings();
03669        }
03670        G__setgvp((long)gvp);
03671      }
03672    } else {
03673      if (gvp == (char*)G__PVOID) {
03674        delete (ROOT::Fit::ParameterSettings*) soff;
03675      } else {
03676        G__setgvp((long) G__PVOID);
03677        ((ROOT::Fit::ParameterSettings*) (soff))->~G__TROOTcLcLFitcLcLParameterSettings();
03678        G__setgvp((long)gvp);
03679      }
03680    }
03681    G__setnull(result7);
03682    return(1 || funcname || hash || result7 || libp) ;
03683 }
03684 
03685 // automatic assignment operator
03686 static int G__G__MathFit_150_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03687 {
03688    ROOT::Fit::ParameterSettings* dest = (ROOT::Fit::ParameterSettings*) G__getstructoffset();
03689    *dest = *(ROOT::Fit::ParameterSettings*) libp->para[0].ref;
03690    const ROOT::Fit::ParameterSettings& obj = *dest;
03691    result7->ref = (long) (&obj);
03692    result7->obj.i = (long) (&obj);
03693    return(1 || funcname || hash || result7 || libp) ;
03694 }
03695 
03696 
03697 /* ROOT::Fit::FitConfig */
03698 static int G__G__MathFit_154_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03699 {
03700    ROOT::Fit::FitConfig* p = NULL;
03701    char* gvp = (char*) G__getgvp();
03702    switch (libp->paran) {
03703    case 1:
03704      //m: 1
03705      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03706        p = new ROOT::Fit::FitConfig((unsigned int) G__int(libp->para[0]));
03707      } else {
03708        p = new((void*) gvp) ROOT::Fit::FitConfig((unsigned int) G__int(libp->para[0]));
03709      }
03710      break;
03711    case 0:
03712      int n = G__getaryconstruct();
03713      if (n) {
03714        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03715          p = new ROOT::Fit::FitConfig[n];
03716        } else {
03717          p = new((void*) gvp) ROOT::Fit::FitConfig[n];
03718        }
03719      } else {
03720        if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03721          p = new ROOT::Fit::FitConfig;
03722        } else {
03723          p = new((void*) gvp) ROOT::Fit::FitConfig;
03724        }
03725      }
03726      break;
03727    }
03728    result7->obj.i = (long) p;
03729    result7->ref = (long) p;
03730    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitConfig));
03731    return(1 || funcname || hash || result7 || libp) ;
03732 }
03733 
03734 static int G__G__MathFit_154_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03735 {
03736    ROOT::Fit::FitConfig* p = NULL;
03737    char* gvp = (char*) G__getgvp();
03738    //m: 1
03739    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
03740      p = new ROOT::Fit::FitConfig(*(ROOT::Fit::FitConfig*) libp->para[0].ref);
03741    } else {
03742      p = new((void*) gvp) ROOT::Fit::FitConfig(*(ROOT::Fit::FitConfig*) libp->para[0].ref);
03743    }
03744    result7->obj.i = (long) p;
03745    result7->ref = (long) p;
03746    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitConfig));
03747    return(1 || funcname || hash || result7 || libp) ;
03748 }
03749 
03750 static int G__G__MathFit_154_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03751 {
03752       {
03753          const ROOT::Fit::FitConfig& obj = ((ROOT::Fit::FitConfig*) G__getstructoffset())->operator=(*(ROOT::Fit::FitConfig*) libp->para[0].ref);
03754          result7->ref = (long) (&obj);
03755          result7->obj.i = (long) (&obj);
03756       }
03757    return(1 || funcname || hash || result7 || libp) ;
03758 }
03759 
03760 static int G__G__MathFit_154_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03761 {
03762       {
03763          const ROOT::Fit::ParameterSettings& obj = ((const ROOT::Fit::FitConfig*) G__getstructoffset())->ParSettings((unsigned int) G__int(libp->para[0]));
03764          result7->ref = (long) (&obj);
03765          result7->obj.i = (long) (&obj);
03766       }
03767    return(1 || funcname || hash || result7 || libp) ;
03768 }
03769 
03770 static int G__G__MathFit_154_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03771 {
03772       {
03773          const ROOT::Fit::ParameterSettings& obj = ((ROOT::Fit::FitConfig*) G__getstructoffset())->ParSettings((unsigned int) G__int(libp->para[0]));
03774          result7->ref = (long) (&obj);
03775          result7->obj.i = (long) (&obj);
03776       }
03777    return(1 || funcname || hash || result7 || libp) ;
03778 }
03779 
03780 static int G__G__MathFit_154_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03781 {
03782       {
03783          const vector<ROOT::Fit::ParameterSettings>& obj = ((const ROOT::Fit::FitConfig*) G__getstructoffset())->ParamsSettings();
03784          result7->ref = (long) (&obj);
03785          result7->obj.i = (long) (&obj);
03786       }
03787    return(1 || funcname || hash || result7 || libp) ;
03788 }
03789 
03790 static int G__G__MathFit_154_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03791 {
03792       {
03793          const vector<ROOT::Fit::ParameterSettings>& obj = ((ROOT::Fit::FitConfig*) G__getstructoffset())->ParamsSettings();
03794          result7->ref = (long) (&obj);
03795          result7->obj.i = (long) (&obj);
03796       }
03797    return(1 || funcname || hash || result7 || libp) ;
03798 }
03799 
03800 static int G__G__MathFit_154_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03801 {
03802       ((ROOT::Fit::FitConfig*) G__getstructoffset())->CreateParamsSettings(*(ROOT::Math::IParamMultiFunction*) libp->para[0].ref);
03803       G__setnull(result7);
03804    return(1 || funcname || hash || result7 || libp) ;
03805 }
03806 
03807 static int G__G__MathFit_154_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03808 {
03809    switch (libp->paran) {
03810    case 3:
03811       ((ROOT::Fit::FitConfig*) G__getstructoffset())->SetParamsSettings((unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
03812 , (double*) G__int(libp->para[2]));
03813       G__setnull(result7);
03814       break;
03815    case 2:
03816       ((ROOT::Fit::FitConfig*) G__getstructoffset())->SetParamsSettings((unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
03817       G__setnull(result7);
03818       break;
03819    }
03820    return(1 || funcname || hash || result7 || libp) ;
03821 }
03822 
03823 static int G__G__MathFit_154_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03824 {
03825       G__letint(result7, 85, (long) ((ROOT::Fit::FitConfig*) G__getstructoffset())->CreateMinimizer());
03826    return(1 || funcname || hash || result7 || libp) ;
03827 }
03828 
03829 static int G__G__MathFit_154_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03830 {
03831       {
03832          const ROOT::Math::MinimizerOptions& obj = ((ROOT::Fit::FitConfig*) G__getstructoffset())->MinimizerOptions();
03833          result7->ref = (long) (&obj);
03834          result7->obj.i = (long) (&obj);
03835       }
03836    return(1 || funcname || hash || result7 || libp) ;
03837 }
03838 
03839 static int G__G__MathFit_154_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03840 {
03841    switch (libp->paran) {
03842    case 2:
03843       ((ROOT::Fit::FitConfig*) G__getstructoffset())->SetMinimizer((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
03844       G__setnull(result7);
03845       break;
03846    case 1:
03847       ((ROOT::Fit::FitConfig*) G__getstructoffset())->SetMinimizer((const char*) G__int(libp->para[0]));
03848       G__setnull(result7);
03849       break;
03850    }
03851    return(1 || funcname || hash || result7 || libp) ;
03852 }
03853 
03854 static int G__G__MathFit_154_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03855 {
03856       {
03857          const string& obj = ((const ROOT::Fit::FitConfig*) G__getstructoffset())->MinimizerType();
03858          result7->ref = (long) (&obj);
03859          result7->obj.i = (long) (&obj);
03860       }
03861    return(1 || funcname || hash || result7 || libp) ;
03862 }
03863 
03864 static int G__G__MathFit_154_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03865 {
03866       {
03867          const string& obj = ((const ROOT::Fit::FitConfig*) G__getstructoffset())->MinimizerAlgoType();
03868          result7->ref = (long) (&obj);
03869          result7->obj.i = (long) (&obj);
03870       }
03871    return(1 || funcname || hash || result7 || libp) ;
03872 }
03873 
03874 static int G__G__MathFit_154_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03875 {
03876       G__letint(result7, 103, (long) ((const ROOT::Fit::FitConfig*) G__getstructoffset())->NormalizeErrors());
03877    return(1 || funcname || hash || result7 || libp) ;
03878 }
03879 
03880 static int G__G__MathFit_154_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03881 {
03882       G__letint(result7, 103, (long) ((const ROOT::Fit::FitConfig*) G__getstructoffset())->ParabErrors());
03883    return(1 || funcname || hash || result7 || libp) ;
03884 }
03885 
03886 static int G__G__MathFit_154_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03887 {
03888       G__letint(result7, 103, (long) ((const ROOT::Fit::FitConfig*) G__getstructoffset())->MinosErrors());
03889    return(1 || funcname || hash || result7 || libp) ;
03890 }
03891 
03892 static int G__G__MathFit_154_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03893 {
03894       {
03895          const vector<unsigned int>& obj = ((const ROOT::Fit::FitConfig*) G__getstructoffset())->MinosParams();
03896          result7->ref = (long) (&obj);
03897          result7->obj.i = (long) (&obj);
03898       }
03899    return(1 || funcname || hash || result7 || libp) ;
03900 }
03901 
03902 static int G__G__MathFit_154_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03903 {
03904    switch (libp->paran) {
03905    case 1:
03906       ((ROOT::Fit::FitConfig*) G__getstructoffset())->SetNormErrors((bool) G__int(libp->para[0]));
03907       G__setnull(result7);
03908       break;
03909    case 0:
03910       ((ROOT::Fit::FitConfig*) G__getstructoffset())->SetNormErrors();
03911       G__setnull(result7);
03912       break;
03913    }
03914    return(1 || funcname || hash || result7 || libp) ;
03915 }
03916 
03917 static int G__G__MathFit_154_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03918 {
03919    switch (libp->paran) {
03920    case 1:
03921       ((ROOT::Fit::FitConfig*) G__getstructoffset())->SetParabErrors((bool) G__int(libp->para[0]));
03922       G__setnull(result7);
03923       break;
03924    case 0:
03925       ((ROOT::Fit::FitConfig*) G__getstructoffset())->SetParabErrors();
03926       G__setnull(result7);
03927       break;
03928    }
03929    return(1 || funcname || hash || result7 || libp) ;
03930 }
03931 
03932 static int G__G__MathFit_154_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03933 {
03934    switch (libp->paran) {
03935    case 1:
03936       ((ROOT::Fit::FitConfig*) G__getstructoffset())->SetMinosErrors((bool) G__int(libp->para[0]));
03937       G__setnull(result7);
03938       break;
03939    case 0:
03940       ((ROOT::Fit::FitConfig*) G__getstructoffset())->SetMinosErrors();
03941       G__setnull(result7);
03942       break;
03943    }
03944    return(1 || funcname || hash || result7 || libp) ;
03945 }
03946 
03947 static int G__G__MathFit_154_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03948 {
03949       ((ROOT::Fit::FitConfig*) G__getstructoffset())->SetMinosErrors(*(vector<unsigned int>*) libp->para[0].ref);
03950       G__setnull(result7);
03951    return(1 || funcname || hash || result7 || libp) ;
03952 }
03953 
03954 static int G__G__MathFit_154_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03955 {
03956    switch (libp->paran) {
03957    case 2:
03958       ROOT::Fit::FitConfig::SetDefaultMinimizer((const char*) G__int(libp->para[0]), (const char*) G__int(libp->para[1]));
03959       G__setnull(result7);
03960       break;
03961    case 1:
03962       ROOT::Fit::FitConfig::SetDefaultMinimizer((const char*) G__int(libp->para[0]));
03963       G__setnull(result7);
03964       break;
03965    }
03966    return(1 || funcname || hash || result7 || libp) ;
03967 }
03968 
03969 // automatic destructor
03970 typedef ROOT::Fit::FitConfig G__TROOTcLcLFitcLcLFitConfig;
03971 static int G__G__MathFit_154_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
03972 {
03973    char* gvp = (char*) G__getgvp();
03974    long soff = G__getstructoffset();
03975    int n = G__getaryconstruct();
03976    //
03977    //has_a_delete: 0
03978    //has_own_delete1arg: 0
03979    //has_own_delete2arg: 0
03980    //
03981    if (!soff) {
03982      return(1);
03983    }
03984    if (n) {
03985      if (gvp == (char*)G__PVOID) {
03986        delete[] (ROOT::Fit::FitConfig*) soff;
03987      } else {
03988        G__setgvp((long) G__PVOID);
03989        for (int i = n - 1; i >= 0; --i) {
03990          ((ROOT::Fit::FitConfig*) (soff+(sizeof(ROOT::Fit::FitConfig)*i)))->~G__TROOTcLcLFitcLcLFitConfig();
03991        }
03992        G__setgvp((long)gvp);
03993      }
03994    } else {
03995      if (gvp == (char*)G__PVOID) {
03996        delete (ROOT::Fit::FitConfig*) soff;
03997      } else {
03998        G__setgvp((long) G__PVOID);
03999        ((ROOT::Fit::FitConfig*) (soff))->~G__TROOTcLcLFitcLcLFitConfig();
04000        G__setgvp((long)gvp);
04001      }
04002    }
04003    G__setnull(result7);
04004    return(1 || funcname || hash || result7 || libp) ;
04005 }
04006 
04007 
04008 /* vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> > */
04009 static int G__G__MathFit_156_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04010 {
04011       {
04012          const ROOT::Fit::ParameterSettings& obj = ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->at((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::size_type) G__int(libp->para[0]));
04013          result7->ref = (long) (&obj);
04014          result7->obj.i = (long) (&obj);
04015       }
04016    return(1 || funcname || hash || result7 || libp) ;
04017 }
04018 
04019 static int G__G__MathFit_156_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04020 {
04021       {
04022          vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator* pobj;
04023          vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator xobj = ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->begin();
04024          pobj = new vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator(xobj);
04025          result7->obj.i = (long) ((void*) pobj);
04026          result7->ref = result7->obj.i;
04027          G__store_tempobject(*result7);
04028       }
04029    return(1 || funcname || hash || result7 || libp) ;
04030 }
04031 
04032 static int G__G__MathFit_156_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04033 {
04034       {
04035          vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator* pobj;
04036          vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator xobj = ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->end();
04037          pobj = new vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator(xobj);
04038          result7->obj.i = (long) ((void*) pobj);
04039          result7->ref = result7->obj.i;
04040          G__store_tempobject(*result7);
04041       }
04042    return(1 || funcname || hash || result7 || libp) ;
04043 }
04044 
04045 static int G__G__MathFit_156_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04046 {
04047       {
04048          vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::reverse_iterator* pobj;
04049          vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::reverse_iterator xobj = ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->rbegin();
04050          pobj = new vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::reverse_iterator(xobj);
04051          result7->obj.i = (long) ((void*) pobj);
04052          result7->ref = result7->obj.i;
04053          G__store_tempobject(*result7);
04054       }
04055    return(1 || funcname || hash || result7 || libp) ;
04056 }
04057 
04058 static int G__G__MathFit_156_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04059 {
04060       {
04061          vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::reverse_iterator* pobj;
04062          vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::reverse_iterator xobj = ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->rend();
04063          pobj = new vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::reverse_iterator(xobj);
04064          result7->obj.i = (long) ((void*) pobj);
04065          result7->ref = result7->obj.i;
04066          G__store_tempobject(*result7);
04067       }
04068    return(1 || funcname || hash || result7 || libp) ;
04069 }
04070 
04071 static int G__G__MathFit_156_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04072 {
04073       G__letint(result7, 104, (long) ((const vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->size());
04074    return(1 || funcname || hash || result7 || libp) ;
04075 }
04076 
04077 static int G__G__MathFit_156_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04078 {
04079       G__letint(result7, 104, (long) ((const vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->max_size());
04080    return(1 || funcname || hash || result7 || libp) ;
04081 }
04082 
04083 static int G__G__MathFit_156_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04084 {
04085       ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->resize((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::size_type) G__int(libp->para[0]));
04086       G__setnull(result7);
04087    return(1 || funcname || hash || result7 || libp) ;
04088 }
04089 
04090 static int G__G__MathFit_156_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04091 {
04092       ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->resize((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::size_type) G__int(libp->para[0]), *((ROOT::Fit::ParameterSettings*) G__int(libp->para[1])));
04093       G__setnull(result7);
04094    return(1 || funcname || hash || result7 || libp) ;
04095 }
04096 
04097 static int G__G__MathFit_156_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04098 {
04099       G__letint(result7, 104, (long) ((const vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->capacity());
04100    return(1 || funcname || hash || result7 || libp) ;
04101 }
04102 
04103 static int G__G__MathFit_156_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04104 {
04105       G__letint(result7, 103, (long) ((const vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->empty());
04106    return(1 || funcname || hash || result7 || libp) ;
04107 }
04108 
04109 static int G__G__MathFit_156_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04110 {
04111       {
04112          const ROOT::Fit::ParameterSettings& obj = ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->operator[]((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::size_type) G__int(libp->para[0]));
04113          result7->ref = (long) (&obj);
04114          result7->obj.i = (long) (&obj);
04115       }
04116    return(1 || funcname || hash || result7 || libp) ;
04117 }
04118 
04119 static int G__G__MathFit_156_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04120 {
04121    vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >* p = NULL;
04122    char* gvp = (char*) G__getgvp();
04123    int n = G__getaryconstruct();
04124    if (n) {
04125      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04126        p = new vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >[n];
04127      } else {
04128        p = new((void*) gvp) vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >[n];
04129      }
04130    } else {
04131      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04132        p = new vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >;
04133      } else {
04134        p = new((void*) gvp) vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >;
04135      }
04136    }
04137    result7->obj.i = (long) p;
04138    result7->ref = (long) p;
04139    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
04140    return(1 || funcname || hash || result7 || libp) ;
04141 }
04142 
04143 static int G__G__MathFit_156_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04144 {
04145    vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >* p = NULL;
04146    char* gvp = (char*) G__getgvp();
04147    switch (libp->paran) {
04148    case 2:
04149      //m: 2
04150      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04151        p = new vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::size_type) G__int(libp->para[0]), *(ROOT::Fit::ParameterSettings*) libp->para[1].ref);
04152      } else {
04153        p = new((void*) gvp) vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::size_type) G__int(libp->para[0]), *(ROOT::Fit::ParameterSettings*) libp->para[1].ref);
04154      }
04155      break;
04156    case 1:
04157      //m: 1
04158      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04159        p = new vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::size_type) G__int(libp->para[0]));
04160      } else {
04161        p = new((void*) gvp) vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::size_type) G__int(libp->para[0]));
04162      }
04163      break;
04164    }
04165    result7->obj.i = (long) p;
04166    result7->ref = (long) p;
04167    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
04168    return(1 || funcname || hash || result7 || libp) ;
04169 }
04170 
04171 static int G__G__MathFit_156_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04172 {
04173    vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >* p = NULL;
04174    char* gvp = (char*) G__getgvp();
04175    //m: 1
04176    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04177      p = new vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >(*(vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) libp->para[0].ref);
04178    } else {
04179      p = new((void*) gvp) vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >(*(vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) libp->para[0].ref);
04180    }
04181    result7->obj.i = (long) p;
04182    result7->ref = (long) p;
04183    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
04184    return(1 || funcname || hash || result7 || libp) ;
04185 }
04186 
04187 static int G__G__MathFit_156_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04188 {
04189    vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >* p = NULL;
04190    char* gvp = (char*) G__getgvp();
04191    //m: 2
04192    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04193      p = new vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >(*((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::const_iterator*) G__int(libp->para[0])), *((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::const_iterator*) G__int(libp->para[1])));
04194    } else {
04195      p = new((void*) gvp) vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >(*((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::const_iterator*) G__int(libp->para[0])), *((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::const_iterator*) G__int(libp->para[1])));
04196    }
04197    result7->obj.i = (long) p;
04198    result7->ref = (long) p;
04199    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
04200    return(1 || funcname || hash || result7 || libp) ;
04201 }
04202 
04203 static int G__G__MathFit_156_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04204 {
04205       {
04206          const vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >& obj = ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->operator=(*(vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) libp->para[0].ref);
04207          result7->ref = (long) (&obj);
04208          result7->obj.i = (long) (&obj);
04209       }
04210    return(1 || funcname || hash || result7 || libp) ;
04211 }
04212 
04213 static int G__G__MathFit_156_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04214 {
04215       ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->reserve((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::size_type) G__int(libp->para[0]));
04216       G__setnull(result7);
04217    return(1 || funcname || hash || result7 || libp) ;
04218 }
04219 
04220 static int G__G__MathFit_156_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04221 {
04222       {
04223          const ROOT::Fit::ParameterSettings& obj = ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->front();
04224          result7->ref = (long) (&obj);
04225          result7->obj.i = (long) (&obj);
04226       }
04227    return(1 || funcname || hash || result7 || libp) ;
04228 }
04229 
04230 static int G__G__MathFit_156_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04231 {
04232       {
04233          const ROOT::Fit::ParameterSettings& obj = ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->back();
04234          result7->ref = (long) (&obj);
04235          result7->obj.i = (long) (&obj);
04236       }
04237    return(1 || funcname || hash || result7 || libp) ;
04238 }
04239 
04240 static int G__G__MathFit_156_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04241 {
04242       ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->push_back(*(ROOT::Fit::ParameterSettings*) libp->para[0].ref);
04243       G__setnull(result7);
04244    return(1 || funcname || hash || result7 || libp) ;
04245 }
04246 
04247 static int G__G__MathFit_156_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04248 {
04249       ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->swap(*(vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) libp->para[0].ref);
04250       G__setnull(result7);
04251    return(1 || funcname || hash || result7 || libp) ;
04252 }
04253 
04254 static int G__G__MathFit_156_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04255 {
04256       {
04257          vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator* pobj;
04258          vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator xobj = ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->insert(*((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator*) G__int(libp->para[0])), *(ROOT::Fit::ParameterSettings*) libp->para[1].ref);
04259          pobj = new vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator(xobj);
04260          result7->obj.i = (long) ((void*) pobj);
04261          result7->ref = result7->obj.i;
04262          G__store_tempobject(*result7);
04263       }
04264    return(1 || funcname || hash || result7 || libp) ;
04265 }
04266 
04267 static int G__G__MathFit_156_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04268 {
04269       ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->insert(*((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator*) G__int(libp->para[0])), *((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::const_iterator*) G__int(libp->para[1]))
04270 , *((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::const_iterator*) G__int(libp->para[2])));
04271       G__setnull(result7);
04272    return(1 || funcname || hash || result7 || libp) ;
04273 }
04274 
04275 static int G__G__MathFit_156_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04276 {
04277       ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->insert(*((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator*) G__int(libp->para[0])), (vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::size_type) G__int(libp->para[1])
04278 , *(ROOT::Fit::ParameterSettings*) libp->para[2].ref);
04279       G__setnull(result7);
04280    return(1 || funcname || hash || result7 || libp) ;
04281 }
04282 
04283 static int G__G__MathFit_156_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04284 {
04285       ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->pop_back();
04286       G__setnull(result7);
04287    return(1 || funcname || hash || result7 || libp) ;
04288 }
04289 
04290 static int G__G__MathFit_156_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04291 {
04292       ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->erase(*((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator*) G__int(libp->para[0])));
04293       G__setnull(result7);
04294    return(1 || funcname || hash || result7 || libp) ;
04295 }
04296 
04297 static int G__G__MathFit_156_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04298 {
04299       ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->erase(*((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator*) G__int(libp->para[0])), *((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator*) G__int(libp->para[1])));
04300       G__setnull(result7);
04301    return(1 || funcname || hash || result7 || libp) ;
04302 }
04303 
04304 static int G__G__MathFit_156_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04305 {
04306       ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) G__getstructoffset())->clear();
04307       G__setnull(result7);
04308    return(1 || funcname || hash || result7 || libp) ;
04309 }
04310 
04311 // automatic destructor
04312 typedef vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> > G__TvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR;
04313 static int G__G__MathFit_156_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04314 {
04315    char* gvp = (char*) G__getgvp();
04316    long soff = G__getstructoffset();
04317    int n = G__getaryconstruct();
04318    //
04319    //has_a_delete: 0
04320    //has_own_delete1arg: 0
04321    //has_own_delete2arg: 0
04322    //
04323    if (!soff) {
04324      return(1);
04325    }
04326    if (n) {
04327      if (gvp == (char*)G__PVOID) {
04328        delete[] (vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) soff;
04329      } else {
04330        G__setgvp((long) G__PVOID);
04331        for (int i = n - 1; i >= 0; --i) {
04332          ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) (soff+(sizeof(vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >)*i)))->~G__TvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR();
04333        }
04334        G__setgvp((long)gvp);
04335      }
04336    } else {
04337      if (gvp == (char*)G__PVOID) {
04338        delete (vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) soff;
04339      } else {
04340        G__setgvp((long) G__PVOID);
04341        ((vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*) (soff))->~G__TvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR();
04342        G__setgvp((long)gvp);
04343      }
04344    }
04345    G__setnull(result7);
04346    return(1 || funcname || hash || result7 || libp) ;
04347 }
04348 
04349 
04350 /* ROOT::Fit::FitResult */
04351 static int G__G__MathFit_163_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04352 {
04353    ROOT::Fit::FitResult* p = NULL;
04354    char* gvp = (char*) G__getgvp();
04355    int n = G__getaryconstruct();
04356    if (n) {
04357      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04358        p = new ROOT::Fit::FitResult[n];
04359      } else {
04360        p = new((void*) gvp) ROOT::Fit::FitResult[n];
04361      }
04362    } else {
04363      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04364        p = new ROOT::Fit::FitResult;
04365      } else {
04366        p = new((void*) gvp) ROOT::Fit::FitResult;
04367      }
04368    }
04369    result7->obj.i = (long) p;
04370    result7->ref = (long) p;
04371    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitResult));
04372    return(1 || funcname || hash || result7 || libp) ;
04373 }
04374 
04375 static int G__G__MathFit_163_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04376 {
04377    ROOT::Fit::FitResult* p = NULL;
04378    char* gvp = (char*) G__getgvp();
04379    switch (libp->paran) {
04380    case 8:
04381      //m: 8
04382      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04383        p = new ROOT::Fit::FitResult(
04384 *(ROOT::Math::Minimizer*) libp->para[0].ref, *(ROOT::Fit::FitConfig*) libp->para[1].ref
04385 , (ROOT::Fit::FitResult::IModelFunction*) G__int(libp->para[2]), (bool) G__int(libp->para[3])
04386 , (unsigned int) G__int(libp->para[4]), (bool) G__int(libp->para[5])
04387 , (ROOT::Math::IMultiGenFunction*) G__int(libp->para[6]), (unsigned int) G__int(libp->para[7]));
04388      } else {
04389        p = new((void*) gvp) ROOT::Fit::FitResult(
04390 *(ROOT::Math::Minimizer*) libp->para[0].ref, *(ROOT::Fit::FitConfig*) libp->para[1].ref
04391 , (ROOT::Fit::FitResult::IModelFunction*) G__int(libp->para[2]), (bool) G__int(libp->para[3])
04392 , (unsigned int) G__int(libp->para[4]), (bool) G__int(libp->para[5])
04393 , (ROOT::Math::IMultiGenFunction*) G__int(libp->para[6]), (unsigned int) G__int(libp->para[7]));
04394      }
04395      break;
04396    case 7:
04397      //m: 7
04398      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04399        p = new ROOT::Fit::FitResult(
04400 *(ROOT::Math::Minimizer*) libp->para[0].ref, *(ROOT::Fit::FitConfig*) libp->para[1].ref
04401 , (ROOT::Fit::FitResult::IModelFunction*) G__int(libp->para[2]), (bool) G__int(libp->para[3])
04402 , (unsigned int) G__int(libp->para[4]), (bool) G__int(libp->para[5])
04403 , (ROOT::Math::IMultiGenFunction*) G__int(libp->para[6]));
04404      } else {
04405        p = new((void*) gvp) ROOT::Fit::FitResult(
04406 *(ROOT::Math::Minimizer*) libp->para[0].ref, *(ROOT::Fit::FitConfig*) libp->para[1].ref
04407 , (ROOT::Fit::FitResult::IModelFunction*) G__int(libp->para[2]), (bool) G__int(libp->para[3])
04408 , (unsigned int) G__int(libp->para[4]), (bool) G__int(libp->para[5])
04409 , (ROOT::Math::IMultiGenFunction*) G__int(libp->para[6]));
04410      }
04411      break;
04412    case 6:
04413      //m: 6
04414      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04415        p = new ROOT::Fit::FitResult(
04416 *(ROOT::Math::Minimizer*) libp->para[0].ref, *(ROOT::Fit::FitConfig*) libp->para[1].ref
04417 , (ROOT::Fit::FitResult::IModelFunction*) G__int(libp->para[2]), (bool) G__int(libp->para[3])
04418 , (unsigned int) G__int(libp->para[4]), (bool) G__int(libp->para[5]));
04419      } else {
04420        p = new((void*) gvp) ROOT::Fit::FitResult(
04421 *(ROOT::Math::Minimizer*) libp->para[0].ref, *(ROOT::Fit::FitConfig*) libp->para[1].ref
04422 , (ROOT::Fit::FitResult::IModelFunction*) G__int(libp->para[2]), (bool) G__int(libp->para[3])
04423 , (unsigned int) G__int(libp->para[4]), (bool) G__int(libp->para[5]));
04424      }
04425      break;
04426    case 5:
04427      //m: 5
04428      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04429        p = new ROOT::Fit::FitResult(
04430 *(ROOT::Math::Minimizer*) libp->para[0].ref, *(ROOT::Fit::FitConfig*) libp->para[1].ref
04431 , (ROOT::Fit::FitResult::IModelFunction*) G__int(libp->para[2]), (bool) G__int(libp->para[3])
04432 , (unsigned int) G__int(libp->para[4]));
04433      } else {
04434        p = new((void*) gvp) ROOT::Fit::FitResult(
04435 *(ROOT::Math::Minimizer*) libp->para[0].ref, *(ROOT::Fit::FitConfig*) libp->para[1].ref
04436 , (ROOT::Fit::FitResult::IModelFunction*) G__int(libp->para[2]), (bool) G__int(libp->para[3])
04437 , (unsigned int) G__int(libp->para[4]));
04438      }
04439      break;
04440    case 4:
04441      //m: 4
04442      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04443        p = new ROOT::Fit::FitResult(
04444 *(ROOT::Math::Minimizer*) libp->para[0].ref, *(ROOT::Fit::FitConfig*) libp->para[1].ref
04445 , (ROOT::Fit::FitResult::IModelFunction*) G__int(libp->para[2]), (bool) G__int(libp->para[3]));
04446      } else {
04447        p = new((void*) gvp) ROOT::Fit::FitResult(
04448 *(ROOT::Math::Minimizer*) libp->para[0].ref, *(ROOT::Fit::FitConfig*) libp->para[1].ref
04449 , (ROOT::Fit::FitResult::IModelFunction*) G__int(libp->para[2]), (bool) G__int(libp->para[3]));
04450      }
04451      break;
04452    }
04453    result7->obj.i = (long) p;
04454    result7->ref = (long) p;
04455    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitResult));
04456    return(1 || funcname || hash || result7 || libp) ;
04457 }
04458 
04459 static int G__G__MathFit_163_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04460 {
04461    ROOT::Fit::FitResult* p = NULL;
04462    char* gvp = (char*) G__getgvp();
04463    //m: 1
04464    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04465      p = new ROOT::Fit::FitResult(*(ROOT::Fit::FitResult*) libp->para[0].ref);
04466    } else {
04467      p = new((void*) gvp) ROOT::Fit::FitResult(*(ROOT::Fit::FitResult*) libp->para[0].ref);
04468    }
04469    result7->obj.i = (long) p;
04470    result7->ref = (long) p;
04471    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitResult));
04472    return(1 || funcname || hash || result7 || libp) ;
04473 }
04474 
04475 static int G__G__MathFit_163_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04476 {
04477       {
04478          const ROOT::Fit::FitResult& obj = ((ROOT::Fit::FitResult*) G__getstructoffset())->operator=(*(ROOT::Fit::FitResult*) libp->para[0].ref);
04479          result7->ref = (long) (&obj);
04480          result7->obj.i = (long) (&obj);
04481       }
04482    return(1 || funcname || hash || result7 || libp) ;
04483 }
04484 
04485 static int G__G__MathFit_163_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04486 {
04487    switch (libp->paran) {
04488    case 3:
04489       G__letint(result7, 103, (long) ((ROOT::Fit::FitResult*) G__getstructoffset())->Update(*(ROOT::Math::Minimizer*) libp->para[0].ref, (bool) G__int(libp->para[1])
04490 , (unsigned int) G__int(libp->para[2])));
04491       break;
04492    case 2:
04493       G__letint(result7, 103, (long) ((ROOT::Fit::FitResult*) G__getstructoffset())->Update(*(ROOT::Math::Minimizer*) libp->para[0].ref, (bool) G__int(libp->para[1])));
04494       break;
04495    }
04496    return(1 || funcname || hash || result7 || libp) ;
04497 }
04498 
04499 static int G__G__MathFit_163_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04500 {
04501       {
04502          const string& obj = ((const ROOT::Fit::FitResult*) G__getstructoffset())->MinimizerType();
04503          result7->ref = (long) (&obj);
04504          result7->obj.i = (long) (&obj);
04505       }
04506    return(1 || funcname || hash || result7 || libp) ;
04507 }
04508 
04509 static int G__G__MathFit_163_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04510 {
04511       G__letint(result7, 103, (long) ((const ROOT::Fit::FitResult*) G__getstructoffset())->IsValid());
04512    return(1 || funcname || hash || result7 || libp) ;
04513 }
04514 
04515 static int G__G__MathFit_163_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04516 {
04517       G__letint(result7, 103, (long) ((const ROOT::Fit::FitResult*) G__getstructoffset())->IsEmpty());
04518    return(1 || funcname || hash || result7 || libp) ;
04519 }
04520 
04521 static int G__G__MathFit_163_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04522 {
04523       G__letdouble(result7, 100, (double) ((const ROOT::Fit::FitResult*) G__getstructoffset())->MinFcnValue());
04524    return(1 || funcname || hash || result7 || libp) ;
04525 }
04526 
04527 static int G__G__MathFit_163_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04528 {
04529       G__letint(result7, 104, (long) ((const ROOT::Fit::FitResult*) G__getstructoffset())->NCalls());
04530    return(1 || funcname || hash || result7 || libp) ;
04531 }
04532 
04533 static int G__G__MathFit_163_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04534 {
04535       G__letdouble(result7, 100, (double) ((const ROOT::Fit::FitResult*) G__getstructoffset())->Edm());
04536    return(1 || funcname || hash || result7 || libp) ;
04537 }
04538 
04539 static int G__G__MathFit_163_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04540 {
04541       G__letint(result7, 104, (long) ((const ROOT::Fit::FitResult*) G__getstructoffset())->NTotalParameters());
04542    return(1 || funcname || hash || result7 || libp) ;
04543 }
04544 
04545 static int G__G__MathFit_163_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04546 {
04547       G__letint(result7, 104, (long) ((const ROOT::Fit::FitResult*) G__getstructoffset())->NPar());
04548    return(1 || funcname || hash || result7 || libp) ;
04549 }
04550 
04551 static int G__G__MathFit_163_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04552 {
04553       G__letint(result7, 104, (long) ((const ROOT::Fit::FitResult*) G__getstructoffset())->NFreeParameters());
04554    return(1 || funcname || hash || result7 || libp) ;
04555 }
04556 
04557 static int G__G__MathFit_163_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04558 {
04559       G__letint(result7, 105, (long) ((const ROOT::Fit::FitResult*) G__getstructoffset())->Status());
04560    return(1 || funcname || hash || result7 || libp) ;
04561 }
04562 
04563 static int G__G__MathFit_163_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04564 {
04565       G__letint(result7, 105, (long) ((const ROOT::Fit::FitResult*) G__getstructoffset())->CovMatrixStatus());
04566    return(1 || funcname || hash || result7 || libp) ;
04567 }
04568 
04569 static int G__G__MathFit_163_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04570 {
04571       G__letint(result7, 85, (long) ((const ROOT::Fit::FitResult*) G__getstructoffset())->FittedFunction());
04572    return(1 || funcname || hash || result7 || libp) ;
04573 }
04574 
04575 static int G__G__MathFit_163_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04576 {
04577       G__letdouble(result7, 100, (double) ((const ROOT::Fit::FitResult*) G__getstructoffset())->Chi2());
04578    return(1 || funcname || hash || result7 || libp) ;
04579 }
04580 
04581 static int G__G__MathFit_163_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04582 {
04583       G__letint(result7, 104, (long) ((const ROOT::Fit::FitResult*) G__getstructoffset())->Ndf());
04584    return(1 || funcname || hash || result7 || libp) ;
04585 }
04586 
04587 static int G__G__MathFit_163_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04588 {
04589       G__letdouble(result7, 100, (double) ((const ROOT::Fit::FitResult*) G__getstructoffset())->Prob());
04590    return(1 || funcname || hash || result7 || libp) ;
04591 }
04592 
04593 static int G__G__MathFit_163_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04594 {
04595       {
04596          const vector<double>& obj = ((const ROOT::Fit::FitResult*) G__getstructoffset())->Errors();
04597          result7->ref = (long) (&obj);
04598          result7->obj.i = (long) (&obj);
04599       }
04600    return(1 || funcname || hash || result7 || libp) ;
04601 }
04602 
04603 static int G__G__MathFit_163_0_22(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04604 {
04605       G__letint(result7, 68, (long) ((const ROOT::Fit::FitResult*) G__getstructoffset())->GetErrors());
04606    return(1 || funcname || hash || result7 || libp) ;
04607 }
04608 
04609 static int G__G__MathFit_163_0_23(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04610 {
04611       {
04612          const vector<double>& obj = ((const ROOT::Fit::FitResult*) G__getstructoffset())->Parameters();
04613          result7->ref = (long) (&obj);
04614          result7->obj.i = (long) (&obj);
04615       }
04616    return(1 || funcname || hash || result7 || libp) ;
04617 }
04618 
04619 static int G__G__MathFit_163_0_24(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04620 {
04621       G__letint(result7, 68, (long) ((const ROOT::Fit::FitResult*) G__getstructoffset())->GetParams());
04622    return(1 || funcname || hash || result7 || libp) ;
04623 }
04624 
04625 static int G__G__MathFit_163_0_25(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04626 {
04627       G__letdouble(result7, 100, (double) ((const ROOT::Fit::FitResult*) G__getstructoffset())->Value((unsigned int) G__int(libp->para[0])));
04628    return(1 || funcname || hash || result7 || libp) ;
04629 }
04630 
04631 static int G__G__MathFit_163_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04632 {
04633       G__letdouble(result7, 100, (double) ((const ROOT::Fit::FitResult*) G__getstructoffset())->Parameter((unsigned int) G__int(libp->para[0])));
04634    return(1 || funcname || hash || result7 || libp) ;
04635 }
04636 
04637 static int G__G__MathFit_163_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04638 {
04639       G__letdouble(result7, 100, (double) ((const ROOT::Fit::FitResult*) G__getstructoffset())->Error((unsigned int) G__int(libp->para[0])));
04640    return(1 || funcname || hash || result7 || libp) ;
04641 }
04642 
04643 static int G__G__MathFit_163_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04644 {
04645       G__letdouble(result7, 100, (double) ((const ROOT::Fit::FitResult*) G__getstructoffset())->ParError((unsigned int) G__int(libp->para[0])));
04646    return(1 || funcname || hash || result7 || libp) ;
04647 }
04648 
04649 static int G__G__MathFit_163_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04650 {
04651       {
04652          const string* pobj;
04653          const string xobj = ((const ROOT::Fit::FitResult*) G__getstructoffset())->ParName((unsigned int) G__int(libp->para[0]));
04654          pobj = new string(xobj);
04655          result7->obj.i = (long) ((void*) pobj);
04656          result7->ref = result7->obj.i;
04657          G__store_tempobject(*result7);
04658       }
04659    return(1 || funcname || hash || result7 || libp) ;
04660 }
04661 
04662 static int G__G__MathFit_163_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04663 {
04664       ((ROOT::Fit::FitResult*) G__getstructoffset())->SetMinosError((unsigned int) G__int(libp->para[0]), (double) G__double(libp->para[1])
04665 , (double) G__double(libp->para[2]));
04666       G__setnull(result7);
04667    return(1 || funcname || hash || result7 || libp) ;
04668 }
04669 
04670 static int G__G__MathFit_163_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04671 {
04672       G__letdouble(result7, 100, (double) ((const ROOT::Fit::FitResult*) G__getstructoffset())->LowerError((unsigned int) G__int(libp->para[0])));
04673    return(1 || funcname || hash || result7 || libp) ;
04674 }
04675 
04676 static int G__G__MathFit_163_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04677 {
04678       G__letdouble(result7, 100, (double) ((const ROOT::Fit::FitResult*) G__getstructoffset())->UpperError((unsigned int) G__int(libp->para[0])));
04679    return(1 || funcname || hash || result7 || libp) ;
04680 }
04681 
04682 static int G__G__MathFit_163_0_33(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04683 {
04684       G__letdouble(result7, 100, (double) ((const ROOT::Fit::FitResult*) G__getstructoffset())->GlobalCC((unsigned int) G__int(libp->para[0])));
04685    return(1 || funcname || hash || result7 || libp) ;
04686 }
04687 
04688 static int G__G__MathFit_163_0_34(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04689 {
04690       G__letdouble(result7, 100, (double) ((const ROOT::Fit::FitResult*) G__getstructoffset())->CovMatrix((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])));
04691    return(1 || funcname || hash || result7 || libp) ;
04692 }
04693 
04694 static int G__G__MathFit_163_0_35(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04695 {
04696       G__letdouble(result7, 100, (double) ((const ROOT::Fit::FitResult*) G__getstructoffset())->Correlation((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])));
04697    return(1 || funcname || hash || result7 || libp) ;
04698 }
04699 
04700 static int G__G__MathFit_163_0_36(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04701 {
04702    switch (libp->paran) {
04703    case 7:
04704       ((const ROOT::Fit::FitResult*) G__getstructoffset())->GetConfidenceIntervals(
04705 (unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
04706 , (unsigned int) G__int(libp->para[2]), (double*) G__int(libp->para[3])
04707 , (double*) G__int(libp->para[4]), (double) G__double(libp->para[5])
04708 , (bool) G__int(libp->para[6]));
04709       G__setnull(result7);
04710       break;
04711    case 6:
04712       ((const ROOT::Fit::FitResult*) G__getstructoffset())->GetConfidenceIntervals((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
04713 , (unsigned int) G__int(libp->para[2]), (double*) G__int(libp->para[3])
04714 , (double*) G__int(libp->para[4]), (double) G__double(libp->para[5]));
04715       G__setnull(result7);
04716       break;
04717    case 5:
04718       ((const ROOT::Fit::FitResult*) G__getstructoffset())->GetConfidenceIntervals((unsigned int) G__int(libp->para[0]), (unsigned int) G__int(libp->para[1])
04719 , (unsigned int) G__int(libp->para[2]), (double*) G__int(libp->para[3])
04720 , (double*) G__int(libp->para[4]));
04721       G__setnull(result7);
04722       break;
04723    }
04724    return(1 || funcname || hash || result7 || libp) ;
04725 }
04726 
04727 static int G__G__MathFit_163_0_37(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04728 {
04729    switch (libp->paran) {
04730    case 4:
04731       ((const ROOT::Fit::FitResult*) G__getstructoffset())->GetConfidenceIntervals(*(ROOT::Fit::BinData*) libp->para[0].ref, (double*) G__int(libp->para[1])
04732 , (double) G__double(libp->para[2]), (bool) G__int(libp->para[3]));
04733       G__setnull(result7);
04734       break;
04735    case 3:
04736       ((const ROOT::Fit::FitResult*) G__getstructoffset())->GetConfidenceIntervals(*(ROOT::Fit::BinData*) libp->para[0].ref, (double*) G__int(libp->para[1])
04737 , (double) G__double(libp->para[2]));
04738       G__setnull(result7);
04739       break;
04740    case 2:
04741       ((const ROOT::Fit::FitResult*) G__getstructoffset())->GetConfidenceIntervals(*(ROOT::Fit::BinData*) libp->para[0].ref, (double*) G__int(libp->para[1]));
04742       G__setnull(result7);
04743       break;
04744    }
04745    return(1 || funcname || hash || result7 || libp) ;
04746 }
04747 
04748 static int G__G__MathFit_163_0_38(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04749 {
04750       G__letint(result7, 105, (long) ((const ROOT::Fit::FitResult*) G__getstructoffset())->Index(*(string*) libp->para[0].ref));
04751    return(1 || funcname || hash || result7 || libp) ;
04752 }
04753 
04754 static int G__G__MathFit_163_0_39(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04755 {
04756       ((ROOT::Fit::FitResult*) G__getstructoffset())->NormalizeErrors();
04757       G__setnull(result7);
04758    return(1 || funcname || hash || result7 || libp) ;
04759 }
04760 
04761 static int G__G__MathFit_163_0_40(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04762 {
04763       G__letint(result7, 103, (long) ((ROOT::Fit::FitResult*) G__getstructoffset())->NormalizedErrors());
04764    return(1 || funcname || hash || result7 || libp) ;
04765 }
04766 
04767 static int G__G__MathFit_163_0_41(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04768 {
04769    switch (libp->paran) {
04770    case 2:
04771       ((const ROOT::Fit::FitResult*) G__getstructoffset())->Print(*(ostream*) libp->para[0].ref, (bool) G__int(libp->para[1]));
04772       G__setnull(result7);
04773       break;
04774    case 1:
04775       ((const ROOT::Fit::FitResult*) G__getstructoffset())->Print(*(ostream*) libp->para[0].ref);
04776       G__setnull(result7);
04777       break;
04778    }
04779    return(1 || funcname || hash || result7 || libp) ;
04780 }
04781 
04782 static int G__G__MathFit_163_0_42(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04783 {
04784       ((const ROOT::Fit::FitResult*) G__getstructoffset())->PrintCovMatrix(*(ostream*) libp->para[0].ref);
04785       G__setnull(result7);
04786    return(1 || funcname || hash || result7 || libp) ;
04787 }
04788 
04789 static int G__G__MathFit_163_0_43(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04790 {
04791       G__letint(result7, 103, (long) ((const ROOT::Fit::FitResult*) G__getstructoffset())->IsParameterBound((unsigned int) G__int(libp->para[0])));
04792    return(1 || funcname || hash || result7 || libp) ;
04793 }
04794 
04795 static int G__G__MathFit_163_0_44(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04796 {
04797       G__letint(result7, 103, (long) ((const ROOT::Fit::FitResult*) G__getstructoffset())->IsParameterFixed((unsigned int) G__int(libp->para[0])));
04798    return(1 || funcname || hash || result7 || libp) ;
04799 }
04800 
04801 static int G__G__MathFit_163_0_45(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04802 {
04803       {
04804          const string* pobj;
04805          const string xobj = ((const ROOT::Fit::FitResult*) G__getstructoffset())->GetParameterName((unsigned int) G__int(libp->para[0]));
04806          pobj = new string(xobj);
04807          result7->obj.i = (long) ((void*) pobj);
04808          result7->ref = result7->obj.i;
04809          G__store_tempobject(*result7);
04810       }
04811    return(1 || funcname || hash || result7 || libp) ;
04812 }
04813 
04814 // automatic destructor
04815 typedef ROOT::Fit::FitResult G__TROOTcLcLFitcLcLFitResult;
04816 static int G__G__MathFit_163_0_48(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04817 {
04818    char* gvp = (char*) G__getgvp();
04819    long soff = G__getstructoffset();
04820    int n = G__getaryconstruct();
04821    //
04822    //has_a_delete: 0
04823    //has_own_delete1arg: 0
04824    //has_own_delete2arg: 0
04825    //
04826    if (!soff) {
04827      return(1);
04828    }
04829    if (n) {
04830      if (gvp == (char*)G__PVOID) {
04831        delete[] (ROOT::Fit::FitResult*) soff;
04832      } else {
04833        G__setgvp((long) G__PVOID);
04834        for (int i = n - 1; i >= 0; --i) {
04835          ((ROOT::Fit::FitResult*) (soff+(sizeof(ROOT::Fit::FitResult)*i)))->~G__TROOTcLcLFitcLcLFitResult();
04836        }
04837        G__setgvp((long)gvp);
04838      }
04839    } else {
04840      if (gvp == (char*)G__PVOID) {
04841        delete (ROOT::Fit::FitResult*) soff;
04842      } else {
04843        G__setgvp((long) G__PVOID);
04844        ((ROOT::Fit::FitResult*) (soff))->~G__TROOTcLcLFitcLcLFitResult();
04845        G__setgvp((long)gvp);
04846      }
04847    }
04848    G__setnull(result7);
04849    return(1 || funcname || hash || result7 || libp) ;
04850 }
04851 
04852 
04853 /* ROOT::Fit::Fitter */
04854 static int G__G__MathFit_178_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04855 {
04856    ROOT::Fit::Fitter* p = NULL;
04857    char* gvp = (char*) G__getgvp();
04858    int n = G__getaryconstruct();
04859    if (n) {
04860      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04861        p = new ROOT::Fit::Fitter[n];
04862      } else {
04863        p = new((void*) gvp) ROOT::Fit::Fitter[n];
04864      }
04865    } else {
04866      if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
04867        p = new ROOT::Fit::Fitter;
04868      } else {
04869        p = new((void*) gvp) ROOT::Fit::Fitter;
04870      }
04871    }
04872    result7->obj.i = (long) p;
04873    result7->ref = (long) p;
04874    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitter));
04875    return(1 || funcname || hash || result7 || libp) ;
04876 }
04877 
04878 static int G__G__MathFit_178_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04879 {
04880       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->Fit(*(ROOT::Fit::BinData*) libp->para[0].ref));
04881    return(1 || funcname || hash || result7 || libp) ;
04882 }
04883 
04884 static int G__G__MathFit_178_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04885 {
04886       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->Fit(*(ROOT::Fit::UnBinData*) libp->para[0].ref));
04887    return(1 || funcname || hash || result7 || libp) ;
04888 }
04889 
04890 static int G__G__MathFit_178_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04891 {
04892    switch (libp->paran) {
04893    case 4:
04894       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->FitFCN(*(ROOT::Math::IMultiGenFunction*) libp->para[0].ref, (double*) G__int(libp->para[1])
04895 , (unsigned int) G__int(libp->para[2]), (bool) G__int(libp->para[3])));
04896       break;
04897    case 3:
04898       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->FitFCN(*(ROOT::Math::IMultiGenFunction*) libp->para[0].ref, (double*) G__int(libp->para[1])
04899 , (unsigned int) G__int(libp->para[2])));
04900       break;
04901    case 2:
04902       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->FitFCN(*(ROOT::Math::IMultiGenFunction*) libp->para[0].ref, (double*) G__int(libp->para[1])));
04903       break;
04904    case 1:
04905       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->FitFCN(*(ROOT::Math::IMultiGenFunction*) libp->para[0].ref));
04906       break;
04907    }
04908    return(1 || funcname || hash || result7 || libp) ;
04909 }
04910 
04911 static int G__G__MathFit_178_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04912 {
04913    switch (libp->paran) {
04914    case 4:
04915       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->FitFCN(*(ROOT::Math::IMultiGradFunction*) libp->para[0].ref, (double*) G__int(libp->para[1])
04916 , (unsigned int) G__int(libp->para[2]), (bool) G__int(libp->para[3])));
04917       break;
04918    case 3:
04919       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->FitFCN(*(ROOT::Math::IMultiGradFunction*) libp->para[0].ref, (double*) G__int(libp->para[1])
04920 , (unsigned int) G__int(libp->para[2])));
04921       break;
04922    case 2:
04923       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->FitFCN(*(ROOT::Math::IMultiGradFunction*) libp->para[0].ref, (double*) G__int(libp->para[1])));
04924       break;
04925    case 1:
04926       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->FitFCN(*(ROOT::Math::IMultiGradFunction*) libp->para[0].ref));
04927       break;
04928    }
04929    return(1 || funcname || hash || result7 || libp) ;
04930 }
04931 
04932 static int G__G__MathFit_178_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04933 {
04934    switch (libp->paran) {
04935    case 5:
04936       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->FitFCN((ROOT::Fit::Fitter::MinuitFCN_t) G__int(libp->para[0]), (int) G__int(libp->para[1])
04937 , (double*) G__int(libp->para[2]), (unsigned int) G__int(libp->para[3])
04938 , (bool) G__int(libp->para[4])));
04939       break;
04940    case 4:
04941       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->FitFCN((ROOT::Fit::Fitter::MinuitFCN_t) G__int(libp->para[0]), (int) G__int(libp->para[1])
04942 , (double*) G__int(libp->para[2]), (unsigned int) G__int(libp->para[3])));
04943       break;
04944    case 3:
04945       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->FitFCN((ROOT::Fit::Fitter::MinuitFCN_t) G__int(libp->para[0]), (int) G__int(libp->para[1])
04946 , (double*) G__int(libp->para[2])));
04947       break;
04948    case 2:
04949       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->FitFCN((ROOT::Fit::Fitter::MinuitFCN_t) G__int(libp->para[0]), (int) G__int(libp->para[1])));
04950       break;
04951    case 1:
04952       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->FitFCN((ROOT::Fit::Fitter::MinuitFCN_t) G__int(libp->para[0])));
04953       break;
04954    }
04955    return(1 || funcname || hash || result7 || libp) ;
04956 }
04957 
04958 static int G__G__MathFit_178_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04959 {
04960       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->LinearFit(*(ROOT::Fit::BinData*) libp->para[0].ref));
04961    return(1 || funcname || hash || result7 || libp) ;
04962 }
04963 
04964 static int G__G__MathFit_178_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04965 {
04966       ((ROOT::Fit::Fitter*) G__getstructoffset())->SetFunction(*(ROOT::Fit::Fitter::IModelFunction*) libp->para[0].ref);
04967       G__setnull(result7);
04968    return(1 || funcname || hash || result7 || libp) ;
04969 }
04970 
04971 static int G__G__MathFit_178_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04972 {
04973       ((ROOT::Fit::Fitter*) G__getstructoffset())->SetFunction(*(ROOT::Fit::Fitter::IModel1DFunction*) libp->para[0].ref);
04974       G__setnull(result7);
04975    return(1 || funcname || hash || result7 || libp) ;
04976 }
04977 
04978 static int G__G__MathFit_178_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04979 {
04980       ((ROOT::Fit::Fitter*) G__getstructoffset())->SetFunction(*(ROOT::Fit::Fitter::IGradModelFunction*) libp->para[0].ref);
04981       G__setnull(result7);
04982    return(1 || funcname || hash || result7 || libp) ;
04983 }
04984 
04985 static int G__G__MathFit_178_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04986 {
04987       ((ROOT::Fit::Fitter*) G__getstructoffset())->SetFunction(*(ROOT::Fit::Fitter::IGradModel1DFunction*) libp->para[0].ref);
04988       G__setnull(result7);
04989    return(1 || funcname || hash || result7 || libp) ;
04990 }
04991 
04992 static int G__G__MathFit_178_0_14(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
04993 {
04994       {
04995          const ROOT::Fit::FitResult& obj = ((const ROOT::Fit::Fitter*) G__getstructoffset())->Result();
04996          result7->ref = (long) (&obj);
04997          result7->obj.i = (long) (&obj);
04998       }
04999    return(1 || funcname || hash || result7 || libp) ;
05000 }
05001 
05002 static int G__G__MathFit_178_0_15(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05003 {
05004       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->CalculateHessErrors());
05005    return(1 || funcname || hash || result7 || libp) ;
05006 }
05007 
05008 static int G__G__MathFit_178_0_16(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05009 {
05010       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->CalculateMinosErrors());
05011    return(1 || funcname || hash || result7 || libp) ;
05012 }
05013 
05014 static int G__G__MathFit_178_0_17(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05015 {
05016       {
05017          const ROOT::Fit::FitConfig& obj = ((const ROOT::Fit::Fitter*) G__getstructoffset())->Config();
05018          result7->ref = (long) (&obj);
05019          result7->obj.i = (long) (&obj);
05020       }
05021    return(1 || funcname || hash || result7 || libp) ;
05022 }
05023 
05024 static int G__G__MathFit_178_0_18(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05025 {
05026       {
05027          const ROOT::Fit::FitConfig& obj = ((ROOT::Fit::Fitter*) G__getstructoffset())->Config();
05028          result7->ref = (long) (&obj);
05029          result7->obj.i = (long) (&obj);
05030       }
05031    return(1 || funcname || hash || result7 || libp) ;
05032 }
05033 
05034 static int G__G__MathFit_178_0_19(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05035 {
05036       G__letint(result7, 103, (long) ((const ROOT::Fit::Fitter*) G__getstructoffset())->IsBinFit());
05037    return(1 || funcname || hash || result7 || libp) ;
05038 }
05039 
05040 static int G__G__MathFit_178_0_20(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05041 {
05042       G__letint(result7, 85, (long) ((const ROOT::Fit::Fitter*) G__getstructoffset())->GetMinimizer());
05043    return(1 || funcname || hash || result7 || libp) ;
05044 }
05045 
05046 static int G__G__MathFit_178_0_21(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05047 {
05048       G__letint(result7, 85, (long) ((const ROOT::Fit::Fitter*) G__getstructoffset())->GetFCN());
05049    return(1 || funcname || hash || result7 || libp) ;
05050 }
05051 
05052 static int G__G__MathFit_178_0_26(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05053 {
05054       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->Fit(*(ROOT::Fit::BinData*) libp->para[0].ref, *(ROOT::Math::IParametricFunctionMultiDim*) libp->para[1].ref));
05055    return(1 || funcname || hash || result7 || libp) ;
05056 }
05057 
05058 static int G__G__MathFit_178_0_27(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05059 {
05060       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->Fit(*(ROOT::Fit::UnBinData*) libp->para[0].ref, *(ROOT::Math::IParametricFunctionMultiDim*) libp->para[1].ref));
05061    return(1 || funcname || hash || result7 || libp) ;
05062 }
05063 
05064 static int G__G__MathFit_178_0_28(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05065 {
05066       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->LikelihoodFit(*(ROOT::Fit::BinData*) libp->para[0].ref, *(ROOT::Math::IParametricFunctionMultiDim*) libp->para[1].ref));
05067    return(1 || funcname || hash || result7 || libp) ;
05068 }
05069 
05070 static int G__G__MathFit_178_0_29(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05071 {
05072       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->LikelihoodFit(*(ROOT::Fit::UnBinData*) libp->para[0].ref, *(ROOT::Math::IParametricFunctionMultiDim*) libp->para[1].ref));
05073    return(1 || funcname || hash || result7 || libp) ;
05074 }
05075 
05076 static int G__G__MathFit_178_0_30(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05077 {
05078       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->LikelihoodFit(*(ROOT::Fit::BinData*) libp->para[0].ref));
05079    return(1 || funcname || hash || result7 || libp) ;
05080 }
05081 
05082 static int G__G__MathFit_178_0_31(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05083 {
05084       G__letint(result7, 103, (long) ((ROOT::Fit::Fitter*) G__getstructoffset())->LikelihoodFit(*(ROOT::Fit::UnBinData*) libp->para[0].ref));
05085    return(1 || funcname || hash || result7 || libp) ;
05086 }
05087 
05088 // automatic destructor
05089 typedef ROOT::Fit::Fitter G__TROOTcLcLFitcLcLFitter;
05090 static int G__G__MathFit_178_0_32(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05091 {
05092    char* gvp = (char*) G__getgvp();
05093    long soff = G__getstructoffset();
05094    int n = G__getaryconstruct();
05095    //
05096    //has_a_delete: 0
05097    //has_own_delete1arg: 0
05098    //has_own_delete2arg: 0
05099    //
05100    if (!soff) {
05101      return(1);
05102    }
05103    if (n) {
05104      if (gvp == (char*)G__PVOID) {
05105        delete[] (ROOT::Fit::Fitter*) soff;
05106      } else {
05107        G__setgvp((long) G__PVOID);
05108        for (int i = n - 1; i >= 0; --i) {
05109          ((ROOT::Fit::Fitter*) (soff+(sizeof(ROOT::Fit::Fitter)*i)))->~G__TROOTcLcLFitcLcLFitter();
05110        }
05111        G__setgvp((long)gvp);
05112      }
05113    } else {
05114      if (gvp == (char*)G__PVOID) {
05115        delete (ROOT::Fit::Fitter*) soff;
05116      } else {
05117        G__setgvp((long) G__PVOID);
05118        ((ROOT::Fit::Fitter*) (soff))->~G__TROOTcLcLFitcLcLFitter();
05119        G__setgvp((long)gvp);
05120      }
05121    }
05122    G__setnull(result7);
05123    return(1 || funcname || hash || result7 || libp) ;
05124 }
05125 
05126 
05127 /* ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim> */
05128 static int G__G__MathFit_182_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05129 {
05130    ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>* p = NULL;
05131    char* gvp = (char*) G__getgvp();
05132    //m: 2
05133    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05134      p = new ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>(*(ROOT::Fit::UnBinData*) libp->para[0].ref, *(ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>::IModelFunction*) libp->para[1].ref);
05135    } else {
05136      p = new((void*) gvp) ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>(*(ROOT::Fit::UnBinData*) libp->para[0].ref, *(ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>::IModelFunction*) libp->para[1].ref);
05137    }
05138    result7->obj.i = (long) p;
05139    result7->ref = (long) p;
05140    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR));
05141    return(1 || funcname || hash || result7 || libp) ;
05142 }
05143 
05144 static int G__G__MathFit_182_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05145 {
05146       G__letint(result7, 104, (long) ((const ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*) G__getstructoffset())->NFitPoints());
05147    return(1 || funcname || hash || result7 || libp) ;
05148 }
05149 
05150 static int G__G__MathFit_182_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05151 {
05152       ((const ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*) G__getstructoffset())->Gradient((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
05153       G__setnull(result7);
05154    return(1 || funcname || hash || result7 || libp) ;
05155 }
05156 
05157 static int G__G__MathFit_182_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05158 {
05159       {
05160          const ROOT::Fit::UnBinData& obj = ((const ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*) G__getstructoffset())->Data();
05161          result7->ref = (long) (&obj);
05162          result7->obj.i = (long) (&obj);
05163       }
05164    return(1 || funcname || hash || result7 || libp) ;
05165 }
05166 
05167 static int G__G__MathFit_182_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05168 {
05169       {
05170          const ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>::IModelFunction& obj = ((const ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*) G__getstructoffset())->ModelFunction();
05171          result7->ref = (long) (&obj);
05172          result7->obj.i = (long) (&obj);
05173       }
05174    return(1 || funcname || hash || result7 || libp) ;
05175 }
05176 
05177 // automatic destructor
05178 typedef ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim> G__TROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR;
05179 static int G__G__MathFit_182_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05180 {
05181    char* gvp = (char*) G__getgvp();
05182    long soff = G__getstructoffset();
05183    int n = G__getaryconstruct();
05184    //
05185    //has_a_delete: 0
05186    //has_own_delete1arg: 0
05187    //has_own_delete2arg: 0
05188    //
05189    if (!soff) {
05190      return(1);
05191    }
05192    if (n) {
05193      if (gvp == (char*)G__PVOID) {
05194        delete[] (ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*) soff;
05195      } else {
05196        G__setgvp((long) G__PVOID);
05197        for (int i = n - 1; i >= 0; --i) {
05198          ((ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*) (soff+(sizeof(ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>)*i)))->~G__TROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR();
05199        }
05200        G__setgvp((long)gvp);
05201      }
05202    } else {
05203      if (gvp == (char*)G__PVOID) {
05204        delete (ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*) soff;
05205      } else {
05206        G__setgvp((long) G__PVOID);
05207        ((ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*) (soff))->~G__TROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR();
05208        G__setgvp((long)gvp);
05209      }
05210    }
05211    G__setnull(result7);
05212    return(1 || funcname || hash || result7 || libp) ;
05213 }
05214 
05215 
05216 /* ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim> */
05217 static int G__G__MathFit_183_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05218 {
05219    ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>* p = NULL;
05220    char* gvp = (char*) G__getgvp();
05221    //m: 2
05222    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05223      p = new ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>(*(ROOT::Fit::UnBinData*) libp->para[0].ref, *(ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>::IModelFunction*) libp->para[1].ref);
05224    } else {
05225      p = new((void*) gvp) ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>(*(ROOT::Fit::UnBinData*) libp->para[0].ref, *(ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>::IModelFunction*) libp->para[1].ref);
05226    }
05227    result7->obj.i = (long) p;
05228    result7->ref = (long) p;
05229    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR));
05230    return(1 || funcname || hash || result7 || libp) ;
05231 }
05232 
05233 static int G__G__MathFit_183_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05234 {
05235       G__letint(result7, 104, (long) ((const ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*) G__getstructoffset())->NFitPoints());
05236    return(1 || funcname || hash || result7 || libp) ;
05237 }
05238 
05239 static int G__G__MathFit_183_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05240 {
05241       {
05242          const ROOT::Fit::UnBinData& obj = ((const ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*) G__getstructoffset())->Data();
05243          result7->ref = (long) (&obj);
05244          result7->obj.i = (long) (&obj);
05245       }
05246    return(1 || funcname || hash || result7 || libp) ;
05247 }
05248 
05249 static int G__G__MathFit_183_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05250 {
05251       {
05252          const ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>::IModelFunction& obj = ((const ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*) G__getstructoffset())->ModelFunction();
05253          result7->ref = (long) (&obj);
05254          result7->obj.i = (long) (&obj);
05255       }
05256    return(1 || funcname || hash || result7 || libp) ;
05257 }
05258 
05259 // automatic destructor
05260 typedef ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim> G__TROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR;
05261 static int G__G__MathFit_183_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05262 {
05263    char* gvp = (char*) G__getgvp();
05264    long soff = G__getstructoffset();
05265    int n = G__getaryconstruct();
05266    //
05267    //has_a_delete: 0
05268    //has_own_delete1arg: 0
05269    //has_own_delete2arg: 0
05270    //
05271    if (!soff) {
05272      return(1);
05273    }
05274    if (n) {
05275      if (gvp == (char*)G__PVOID) {
05276        delete[] (ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*) soff;
05277      } else {
05278        G__setgvp((long) G__PVOID);
05279        for (int i = n - 1; i >= 0; --i) {
05280          ((ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*) (soff+(sizeof(ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>)*i)))->~G__TROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR();
05281        }
05282        G__setgvp((long)gvp);
05283      }
05284    } else {
05285      if (gvp == (char*)G__PVOID) {
05286        delete (ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*) soff;
05287      } else {
05288        G__setgvp((long) G__PVOID);
05289        ((ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*) (soff))->~G__TROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR();
05290        G__setgvp((long)gvp);
05291      }
05292    }
05293    G__setnull(result7);
05294    return(1 || funcname || hash || result7 || libp) ;
05295 }
05296 
05297 
05298 /* ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim> */
05299 static int G__G__MathFit_184_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05300 {
05301    ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>* p = NULL;
05302    char* gvp = (char*) G__getgvp();
05303    //m: 2
05304    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05305      p = new ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>(*(ROOT::Fit::BinData*) libp->para[0].ref, *(ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>::IModelFunction*) libp->para[1].ref);
05306    } else {
05307      p = new((void*) gvp) ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>(*(ROOT::Fit::BinData*) libp->para[0].ref, *(ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>::IModelFunction*) libp->para[1].ref);
05308    }
05309    result7->obj.i = (long) p;
05310    result7->ref = (long) p;
05311    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR));
05312    return(1 || funcname || hash || result7 || libp) ;
05313 }
05314 
05315 static int G__G__MathFit_184_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05316 {
05317       G__letint(result7, 104, (long) ((const ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*) G__getstructoffset())->NFitPoints());
05318    return(1 || funcname || hash || result7 || libp) ;
05319 }
05320 
05321 static int G__G__MathFit_184_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05322 {
05323       ((const ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*) G__getstructoffset())->Gradient((double*) G__int(libp->para[0]), (double*) G__int(libp->para[1]));
05324       G__setnull(result7);
05325    return(1 || funcname || hash || result7 || libp) ;
05326 }
05327 
05328 static int G__G__MathFit_184_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05329 {
05330       {
05331          const ROOT::Fit::BinData& obj = ((const ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*) G__getstructoffset())->Data();
05332          result7->ref = (long) (&obj);
05333          result7->obj.i = (long) (&obj);
05334       }
05335    return(1 || funcname || hash || result7 || libp) ;
05336 }
05337 
05338 static int G__G__MathFit_184_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05339 {
05340       {
05341          const ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>::IModelFunction& obj = ((const ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*) G__getstructoffset())->ModelFunction();
05342          result7->ref = (long) (&obj);
05343          result7->obj.i = (long) (&obj);
05344       }
05345    return(1 || funcname || hash || result7 || libp) ;
05346 }
05347 
05348 // automatic destructor
05349 typedef ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim> G__TROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR;
05350 static int G__G__MathFit_184_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05351 {
05352    char* gvp = (char*) G__getgvp();
05353    long soff = G__getstructoffset();
05354    int n = G__getaryconstruct();
05355    //
05356    //has_a_delete: 0
05357    //has_own_delete1arg: 0
05358    //has_own_delete2arg: 0
05359    //
05360    if (!soff) {
05361      return(1);
05362    }
05363    if (n) {
05364      if (gvp == (char*)G__PVOID) {
05365        delete[] (ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*) soff;
05366      } else {
05367        G__setgvp((long) G__PVOID);
05368        for (int i = n - 1; i >= 0; --i) {
05369          ((ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*) (soff+(sizeof(ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>)*i)))->~G__TROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR();
05370        }
05371        G__setgvp((long)gvp);
05372      }
05373    } else {
05374      if (gvp == (char*)G__PVOID) {
05375        delete (ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*) soff;
05376      } else {
05377        G__setgvp((long) G__PVOID);
05378        ((ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*) (soff))->~G__TROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR();
05379        G__setgvp((long)gvp);
05380      }
05381    }
05382    G__setnull(result7);
05383    return(1 || funcname || hash || result7 || libp) ;
05384 }
05385 
05386 
05387 /* ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim> */
05388 static int G__G__MathFit_185_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05389 {
05390    ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>* p = NULL;
05391    char* gvp = (char*) G__getgvp();
05392    //m: 2
05393    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05394      p = new ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>(*(ROOT::Fit::BinData*) libp->para[0].ref, *(ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>::IModelFunction*) libp->para[1].ref);
05395    } else {
05396      p = new((void*) gvp) ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>(*(ROOT::Fit::BinData*) libp->para[0].ref, *(ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>::IModelFunction*) libp->para[1].ref);
05397    }
05398    result7->obj.i = (long) p;
05399    result7->ref = (long) p;
05400    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR));
05401    return(1 || funcname || hash || result7 || libp) ;
05402 }
05403 
05404 static int G__G__MathFit_185_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05405 {
05406       G__letint(result7, 104, (long) ((const ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*) G__getstructoffset())->NFitPoints());
05407    return(1 || funcname || hash || result7 || libp) ;
05408 }
05409 
05410 static int G__G__MathFit_185_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05411 {
05412       {
05413          const ROOT::Fit::BinData& obj = ((const ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*) G__getstructoffset())->Data();
05414          result7->ref = (long) (&obj);
05415          result7->obj.i = (long) (&obj);
05416       }
05417    return(1 || funcname || hash || result7 || libp) ;
05418 }
05419 
05420 static int G__G__MathFit_185_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05421 {
05422       {
05423          const ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>::IModelFunction& obj = ((const ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*) G__getstructoffset())->ModelFunction();
05424          result7->ref = (long) (&obj);
05425          result7->obj.i = (long) (&obj);
05426       }
05427    return(1 || funcname || hash || result7 || libp) ;
05428 }
05429 
05430 // automatic destructor
05431 typedef ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim> G__TROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR;
05432 static int G__G__MathFit_185_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05433 {
05434    char* gvp = (char*) G__getgvp();
05435    long soff = G__getstructoffset();
05436    int n = G__getaryconstruct();
05437    //
05438    //has_a_delete: 0
05439    //has_own_delete1arg: 0
05440    //has_own_delete2arg: 0
05441    //
05442    if (!soff) {
05443      return(1);
05444    }
05445    if (n) {
05446      if (gvp == (char*)G__PVOID) {
05447        delete[] (ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*) soff;
05448      } else {
05449        G__setgvp((long) G__PVOID);
05450        for (int i = n - 1; i >= 0; --i) {
05451          ((ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*) (soff+(sizeof(ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>)*i)))->~G__TROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR();
05452        }
05453        G__setgvp((long)gvp);
05454      }
05455    } else {
05456      if (gvp == (char*)G__PVOID) {
05457        delete (ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*) soff;
05458      } else {
05459        G__setgvp((long) G__PVOID);
05460        ((ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*) (soff))->~G__TROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR();
05461        G__setgvp((long)gvp);
05462      }
05463    }
05464    G__setnull(result7);
05465    return(1 || funcname || hash || result7 || libp) ;
05466 }
05467 
05468 
05469 /* ROOT::Fit::SparseData */
05470 static int G__G__MathFit_187_0_1(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05471 {
05472    ROOT::Fit::SparseData* p = NULL;
05473    char* gvp = (char*) G__getgvp();
05474    //m: 2
05475    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05476      p = new ROOT::Fit::SparseData(*(vector<double>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref);
05477    } else {
05478      p = new((void*) gvp) ROOT::Fit::SparseData(*(vector<double>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref);
05479    }
05480    result7->obj.i = (long) p;
05481    result7->ref = (long) p;
05482    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLSparseData));
05483    return(1 || funcname || hash || result7 || libp) ;
05484 }
05485 
05486 static int G__G__MathFit_187_0_2(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05487 {
05488    ROOT::Fit::SparseData* p = NULL;
05489    char* gvp = (char*) G__getgvp();
05490    //m: 3
05491    if ((gvp == (char*)G__PVOID) || (gvp == 0)) {
05492      p = new ROOT::Fit::SparseData(
05493 (const unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
05494 , (double*) G__int(libp->para[2]));
05495    } else {
05496      p = new((void*) gvp) ROOT::Fit::SparseData(
05497 (const unsigned int) G__int(libp->para[0]), (double*) G__int(libp->para[1])
05498 , (double*) G__int(libp->para[2]));
05499    }
05500    result7->obj.i = (long) p;
05501    result7->ref = (long) p;
05502    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLSparseData));
05503    return(1 || funcname || hash || result7 || libp) ;
05504 }
05505 
05506 static int G__G__MathFit_187_0_3(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05507 {
05508       G__letint(result7, 104, (long) ((const ROOT::Fit::SparseData*) G__getstructoffset())->NPoints());
05509    return(1 || funcname || hash || result7 || libp) ;
05510 }
05511 
05512 static int G__G__MathFit_187_0_4(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05513 {
05514       G__letint(result7, 104, (long) ((const ROOT::Fit::SparseData*) G__getstructoffset())->NDim());
05515    return(1 || funcname || hash || result7 || libp) ;
05516 }
05517 
05518 static int G__G__MathFit_187_0_5(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05519 {
05520    switch (libp->paran) {
05521    case 4:
05522       ((ROOT::Fit::SparseData*) G__getstructoffset())->Add(*(vector<double>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
05523 , (const double) G__double(libp->para[2]), (const double) G__double(libp->para[3]));
05524       G__setnull(result7);
05525       break;
05526    case 3:
05527       ((ROOT::Fit::SparseData*) G__getstructoffset())->Add(*(vector<double>*) libp->para[0].ref, *(vector<double>*) libp->para[1].ref
05528 , (const double) G__double(libp->para[2]));
05529       G__setnull(result7);
05530       break;
05531    }
05532    return(1 || funcname || hash || result7 || libp) ;
05533 }
05534 
05535 static int G__G__MathFit_187_0_6(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05536 {
05537       ((ROOT::Fit::SparseData*) G__getstructoffset())->GetPoint((const unsigned int) G__int(libp->para[0]), *(vector<double>*) libp->para[1].ref
05538 , *(vector<double>*) libp->para[2].ref, *(double*) G__Doubleref(&libp->para[3])
05539 , *(double*) G__Doubleref(&libp->para[4]));
05540       G__setnull(result7);
05541    return(1 || funcname || hash || result7 || libp) ;
05542 }
05543 
05544 static int G__G__MathFit_187_0_7(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05545 {
05546       ((const ROOT::Fit::SparseData*) G__getstructoffset())->PrintList();
05547       G__setnull(result7);
05548    return(1 || funcname || hash || result7 || libp) ;
05549 }
05550 
05551 static int G__G__MathFit_187_0_8(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05552 {
05553       ((const ROOT::Fit::SparseData*) G__getstructoffset())->GetBinData(*(ROOT::Fit::BinData*) libp->para[0].ref);
05554       G__setnull(result7);
05555    return(1 || funcname || hash || result7 || libp) ;
05556 }
05557 
05558 static int G__G__MathFit_187_0_9(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05559 {
05560       ((const ROOT::Fit::SparseData*) G__getstructoffset())->GetBinDataIntegral(*(ROOT::Fit::BinData*) libp->para[0].ref);
05561       G__setnull(result7);
05562    return(1 || funcname || hash || result7 || libp) ;
05563 }
05564 
05565 static int G__G__MathFit_187_0_10(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05566 {
05567       ((const ROOT::Fit::SparseData*) G__getstructoffset())->GetBinDataNoZeros(*(ROOT::Fit::BinData*) libp->para[0].ref);
05568       G__setnull(result7);
05569    return(1 || funcname || hash || result7 || libp) ;
05570 }
05571 
05572 // automatic copy constructor
05573 static int G__G__MathFit_187_0_11(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05574 
05575 {
05576    ROOT::Fit::SparseData* p;
05577    void* tmp = (void*) G__int(libp->para[0]);
05578    p = new ROOT::Fit::SparseData(*(ROOT::Fit::SparseData*) tmp);
05579    result7->obj.i = (long) p;
05580    result7->ref = (long) p;
05581    G__set_tagnum(result7,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLSparseData));
05582    return(1 || funcname || hash || result7 || libp) ;
05583 }
05584 
05585 // automatic destructor
05586 typedef ROOT::Fit::SparseData G__TROOTcLcLFitcLcLSparseData;
05587 static int G__G__MathFit_187_0_12(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05588 {
05589    char* gvp = (char*) G__getgvp();
05590    long soff = G__getstructoffset();
05591    int n = G__getaryconstruct();
05592    //
05593    //has_a_delete: 0
05594    //has_own_delete1arg: 0
05595    //has_own_delete2arg: 0
05596    //
05597    if (!soff) {
05598      return(1);
05599    }
05600    if (n) {
05601      if (gvp == (char*)G__PVOID) {
05602        delete[] (ROOT::Fit::SparseData*) soff;
05603      } else {
05604        G__setgvp((long) G__PVOID);
05605        for (int i = n - 1; i >= 0; --i) {
05606          ((ROOT::Fit::SparseData*) (soff+(sizeof(ROOT::Fit::SparseData)*i)))->~G__TROOTcLcLFitcLcLSparseData();
05607        }
05608        G__setgvp((long)gvp);
05609      }
05610    } else {
05611      if (gvp == (char*)G__PVOID) {
05612        delete (ROOT::Fit::SparseData*) soff;
05613      } else {
05614        G__setgvp((long) G__PVOID);
05615        ((ROOT::Fit::SparseData*) (soff))->~G__TROOTcLcLFitcLcLSparseData();
05616        G__setgvp((long)gvp);
05617      }
05618    }
05619    G__setnull(result7);
05620    return(1 || funcname || hash || result7 || libp) ;
05621 }
05622 
05623 // automatic assignment operator
05624 static int G__G__MathFit_187_0_13(G__value* result7, G__CONST char* funcname, struct G__param* libp, int hash)
05625 {
05626    ROOT::Fit::SparseData* dest = (ROOT::Fit::SparseData*) G__getstructoffset();
05627    *dest = *(ROOT::Fit::SparseData*) libp->para[0].ref;
05628    const ROOT::Fit::SparseData& obj = *dest;
05629    result7->ref = (long) (&obj);
05630    result7->obj.i = (long) (&obj);
05631    return(1 || funcname || hash || result7 || libp) ;
05632 }
05633 
05634 
05635 /* Setting up global function */
05636 
05637 /*********************************************************
05638 * Member function Stub
05639 *********************************************************/
05640 
05641 /* ROOT::Fit */
05642 
05643 /* ROOT::Fit::DataOptions */
05644 
05645 /* ROOT::Fit::DataRange */
05646 
05647 /* ROOT::Fit::FitData */
05648 
05649 /* ROOT::Fit::BinData */
05650 
05651 /* ROOT::Fit::UnBinData */
05652 
05653 /* ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim> */
05654 
05655 /* ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim> */
05656 
05657 /* ROOT::Fit::ParameterSettings */
05658 
05659 /* ROOT::Fit::FitConfig */
05660 
05661 /* vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> > */
05662 
05663 /* ROOT::Fit::FitResult */
05664 
05665 /* ROOT::Fit::Fitter */
05666 
05667 /* ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim> */
05668 
05669 /* ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim> */
05670 
05671 /* ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim> */
05672 
05673 /* ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim> */
05674 
05675 /* ROOT::Fit::SparseData */
05676 
05677 /*********************************************************
05678 * Global function Stub
05679 *********************************************************/
05680 
05681 /*********************************************************
05682 * Get size of pointer to member function
05683 *********************************************************/
05684 class G__Sizep2memfuncG__MathFit {
05685  public:
05686   G__Sizep2memfuncG__MathFit(): p(&G__Sizep2memfuncG__MathFit::sizep2memfunc) {}
05687     size_t sizep2memfunc() { return(sizeof(p)); }
05688   private:
05689     size_t (G__Sizep2memfuncG__MathFit::*p)();
05690 };
05691 
05692 size_t G__get_sizep2memfuncG__MathFit()
05693 {
05694   G__Sizep2memfuncG__MathFit a;
05695   G__setsizep2memfunc((int)a.sizep2memfunc());
05696   return((size_t)a.sizep2memfunc());
05697 }
05698 
05699 
05700 /*********************************************************
05701 * virtual base class offset calculation interface
05702 *********************************************************/
05703 
05704    /* Setting up class inheritance */
05705 static long G__2vbo_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR_ROOTcLcLMathcLcLIBaseFunctionMultiDim_2(long pobject) {
05706   ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim> *G__Lderived=(ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>*)pobject;
05707   ROOT::Math::IBaseFunctionMultiDim *G__Lbase=G__Lderived;
05708   return((long)G__Lbase-(long)G__Lderived);
05709 }
05710 
05711 static long G__2vbo_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR_ROOTcLcLMathcLcLIBaseFunctionMultiDim_2(long pobject) {
05712   ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim> *G__Lderived=(ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*)pobject;
05713   ROOT::Math::IBaseFunctionMultiDim *G__Lbase=G__Lderived;
05714   return((long)G__Lbase-(long)G__Lderived);
05715 }
05716 
05717 static long G__2vbo_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR_ROOTcLcLMathcLcLIBaseFunctionMultiDim_2(long pobject) {
05718   ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim> *G__Lderived=(ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*)pobject;
05719   ROOT::Math::IBaseFunctionMultiDim *G__Lbase=G__Lderived;
05720   return((long)G__Lbase-(long)G__Lderived);
05721 }
05722 
05723 
05724 /*********************************************************
05725 * Inheritance information setup/
05726 *********************************************************/
05727 extern "C" void G__cpp_setup_inheritanceG__MathFit() {
05728 
05729    /* Setting up class inheritance */
05730    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData))) {
05731      ROOT::Fit::BinData *G__Lderived;
05732      G__Lderived=(ROOT::Fit::BinData*)0x1000;
05733      {
05734        ROOT::Fit::FitData *G__Lpbase=(ROOT::Fit::FitData*)G__Lderived;
05735        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitData),(long)G__Lpbase-(long)G__Lderived,1,1);
05736      }
05737    }
05738    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData))) {
05739      ROOT::Fit::UnBinData *G__Lderived;
05740      G__Lderived=(ROOT::Fit::UnBinData*)0x1000;
05741      {
05742        ROOT::Fit::FitData *G__Lpbase=(ROOT::Fit::FitData*)G__Lderived;
05743        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitData),(long)G__Lpbase-(long)G__Lderived,1,1);
05744      }
05745    }
05746    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR))) {
05747      ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim> *G__Lderived;
05748      G__Lderived=(ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>*)0x1000;
05749      {
05750        ROOT::Math::BasicFitMethodFunction<ROOT::Math::IBaseFunctionMultiDim> *G__Lpbase=(ROOT::Math::BasicFitMethodFunction<ROOT::Math::IBaseFunctionMultiDim>*)G__Lderived;
05751        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),(long)G__Lpbase-(long)G__Lderived,1,1);
05752      }
05753      {
05754        ROOT::Math::IBaseFunctionMultiDim *G__Lpbase=(ROOT::Math::IBaseFunctionMultiDim*)G__Lderived;
05755        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),(long)G__Lpbase-(long)G__Lderived,1,0);
05756      }
05757    }
05758    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR))) {
05759      ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim> *G__Lderived;
05760      G__Lderived=(ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>*)0x1000;
05761      {
05762        ROOT::Math::BasicFitMethodFunction<ROOT::Math::IGradientFunctionMultiDim> *G__Lpbase=(ROOT::Math::BasicFitMethodFunction<ROOT::Math::IGradientFunctionMultiDim>*)G__Lderived;
05763        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),(long)G__Lpbase-(long)G__Lderived,1,1);
05764      }
05765      {
05766        ROOT::Math::IGradientFunctionMultiDim *G__Lpbase=(ROOT::Math::IGradientFunctionMultiDim*)G__Lderived;
05767        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIGradientFunctionMultiDim),(long)G__Lpbase-(long)G__Lderived,1,0);
05768      }
05769      {
05770        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),(long)G__2vbo_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR_ROOTcLcLMathcLcLIBaseFunctionMultiDim_2,1,2);
05771      }
05772      {
05773        ROOT::Math::IGradientMultiDim *G__Lpbase=(ROOT::Math::IGradientMultiDim*)G__Lderived;
05774        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIGradientMultiDim),(long)G__Lpbase-(long)G__Lderived,1,0);
05775      }
05776    }
05777    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR))) {
05778      ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim> *G__Lderived;
05779      G__Lderived=(ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*)0x1000;
05780      {
05781        ROOT::Math::BasicFitMethodFunction<ROOT::Math::IBaseFunctionMultiDim> *G__Lpbase=(ROOT::Math::BasicFitMethodFunction<ROOT::Math::IBaseFunctionMultiDim>*)G__Lderived;
05782        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),(long)G__Lpbase-(long)G__Lderived,1,1);
05783      }
05784      {
05785        ROOT::Math::IBaseFunctionMultiDim *G__Lpbase=(ROOT::Math::IBaseFunctionMultiDim*)G__Lderived;
05786        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),(long)G__Lpbase-(long)G__Lderived,1,0);
05787      }
05788    }
05789    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR))) {
05790      ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim> *G__Lderived;
05791      G__Lderived=(ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*)0x1000;
05792      {
05793        ROOT::Math::BasicFitMethodFunction<ROOT::Math::IGradientFunctionMultiDim> *G__Lpbase=(ROOT::Math::BasicFitMethodFunction<ROOT::Math::IGradientFunctionMultiDim>*)G__Lderived;
05794        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),(long)G__Lpbase-(long)G__Lderived,1,1);
05795      }
05796      {
05797        ROOT::Math::IGradientFunctionMultiDim *G__Lpbase=(ROOT::Math::IGradientFunctionMultiDim*)G__Lderived;
05798        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIGradientFunctionMultiDim),(long)G__Lpbase-(long)G__Lderived,1,0);
05799      }
05800      {
05801        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),(long)G__2vbo_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR_ROOTcLcLMathcLcLIBaseFunctionMultiDim_2,1,2);
05802      }
05803      {
05804        ROOT::Math::IGradientMultiDim *G__Lpbase=(ROOT::Math::IGradientMultiDim*)G__Lderived;
05805        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIGradientMultiDim),(long)G__Lpbase-(long)G__Lderived,1,0);
05806      }
05807    }
05808    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR))) {
05809      ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim> *G__Lderived;
05810      G__Lderived=(ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*)0x1000;
05811      {
05812        ROOT::Math::BasicFitMethodFunction<ROOT::Math::IBaseFunctionMultiDim> *G__Lpbase=(ROOT::Math::BasicFitMethodFunction<ROOT::Math::IBaseFunctionMultiDim>*)G__Lderived;
05813        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),(long)G__Lpbase-(long)G__Lderived,1,1);
05814      }
05815      {
05816        ROOT::Math::IBaseFunctionMultiDim *G__Lpbase=(ROOT::Math::IBaseFunctionMultiDim*)G__Lderived;
05817        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),(long)G__Lpbase-(long)G__Lderived,1,0);
05818      }
05819    }
05820    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR))) {
05821      ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim> *G__Lderived;
05822      G__Lderived=(ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*)0x1000;
05823      {
05824        ROOT::Math::BasicFitMethodFunction<ROOT::Math::IGradientFunctionMultiDim> *G__Lpbase=(ROOT::Math::BasicFitMethodFunction<ROOT::Math::IGradientFunctionMultiDim>*)G__Lderived;
05825        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),(long)G__Lpbase-(long)G__Lderived,1,1);
05826      }
05827      {
05828        ROOT::Math::IGradientFunctionMultiDim *G__Lpbase=(ROOT::Math::IGradientFunctionMultiDim*)G__Lderived;
05829        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIGradientFunctionMultiDim),(long)G__Lpbase-(long)G__Lderived,1,0);
05830      }
05831      {
05832        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),(long)G__2vbo_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR_ROOTcLcLMathcLcLIBaseFunctionMultiDim_2,1,2);
05833      }
05834      {
05835        ROOT::Math::IGradientMultiDim *G__Lpbase=(ROOT::Math::IGradientMultiDim*)G__Lderived;
05836        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIGradientMultiDim),(long)G__Lpbase-(long)G__Lderived,1,0);
05837      }
05838    }
05839    if(0==G__getnumbaseclass(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLSparseData))) {
05840      ROOT::Fit::SparseData *G__Lderived;
05841      G__Lderived=(ROOT::Fit::SparseData*)0x1000;
05842      {
05843        ROOT::Fit::FitData *G__Lpbase=(ROOT::Fit::FitData*)G__Lderived;
05844        G__inheritance_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLSparseData),G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitData),(long)G__Lpbase-(long)G__Lderived,1,1);
05845      }
05846    }
05847 }
05848 
05849 /*********************************************************
05850 * typedef information setup/
05851 *********************************************************/
05852 extern "C" void G__cpp_setup_typetableG__MathFit() {
05853 
05854    /* Setting up typedef entry */
05855    G__search_typename2("vector<ROOT::TSchemaHelper>",117,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR),0,-1);
05856    G__setnewtype(-1,NULL,0);
05857    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
05858    G__setnewtype(-1,NULL,0);
05859    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR));
05860    G__setnewtype(-1,NULL,0);
05861    G__search_typename2("vector<TVirtualArray*>",117,G__get_linked_tagnum(&G__G__MathFitLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR),0,-1);
05862    G__setnewtype(-1,NULL,0);
05863    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
05864    G__setnewtype(-1,NULL,0);
05865    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR));
05866    G__setnewtype(-1,NULL,0);
05867    G__search_typename2("vector<std::pair<double,double> >",117,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),0,-1);
05868    G__setnewtype(-1,NULL,0);
05869    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR));
05870    G__setnewtype(-1,NULL,0);
05871    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR));
05872    G__setnewtype(-1,NULL,0);
05873    G__search_typename2("vector<pair<double,double> >",117,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),0,-1);
05874    G__setnewtype(-1,NULL,0);
05875    G__search_typename2("RangeSet",117,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataRange));
05876    G__setnewtype(-1,NULL,0);
05877    G__search_typename2("vector<RangeSet>",117,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgR),0,-1);
05878    G__setnewtype(-1,NULL,0);
05879    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgR));
05880    G__setnewtype(-1,NULL,0);
05881    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgR));
05882    G__setnewtype(-1,NULL,0);
05883    G__search_typename2("vector<vector<pair<double,double>,allocator<pair<double,double> > > >",117,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgR),0,-1);
05884    G__setnewtype(-1,NULL,0);
05885    G__search_typename2("RangeIntervals",117,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataRange));
05886    G__setnewtype(-1,NULL,0);
05887    G__search_typename2("vector<double>",117,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEdoublecOallocatorlEdoublegRsPgR),0,-1);
05888    G__setnewtype(-1,NULL,0);
05889    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEdoublecOallocatorlEdoublegRsPgR));
05890    G__setnewtype(-1,NULL,0);
05891    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEdoublecOallocatorlEdoublegRsPgR));
05892    G__setnewtype(-1,NULL,0);
05893    G__search_typename2("vector<const double*>",117,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgR),0,-1);
05894    G__setnewtype(-1,NULL,0);
05895    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgR));
05896    G__setnewtype(-1,NULL,0);
05897    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgR));
05898    G__setnewtype(-1,NULL,0);
05899    G__search_typename2("IMultiGenFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMath));
05900    G__setnewtype(-1,NULL,0);
05901    G__search_typename2("IMultiGradFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIGradientFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMath));
05902    G__setnewtype(-1,NULL,0);
05903    G__search_typename2("BasicFitMethodFunction<ROOT::Math::IMultiGenFunction>",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMath));
05904    G__setnewtype(-1,NULL,0);
05905    G__search_typename2("BasicFitMethodFunction<ROOT::Math::IMultiGradFunction>",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMath));
05906    G__setnewtype(-1,NULL,0);
05907    G__search_typename2("IParamMultiFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMath));
05908    G__setnewtype(-1,NULL,0);
05909    G__search_typename2("Chi2FCN<ROOT::Math::IMultiGenFunction>",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFit));
05910    G__setnewtype(-1,NULL,0);
05911    G__search_typename2("BaseObjFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR));
05912    G__setnewtype(-1,NULL,0);
05913    G__search_typename2("BaseFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR));
05914    G__setnewtype(-1,NULL,0);
05915    G__search_typename2("IModelFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR));
05916    G__setnewtype(-1,NULL,0);
05917    G__search_typename2("Type_t",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgRcLcLType_t),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR));
05918    G__setnewtype(-1,NULL,0);
05919    G__search_typename2("Chi2Function",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFit));
05920    G__setnewtype(-1,NULL,0);
05921    G__search_typename2("Chi2FCN<ROOT::Math::IMultiGradFunction>",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFit));
05922    G__setnewtype(-1,NULL,0);
05923    G__search_typename2("BaseObjFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR));
05924    G__setnewtype(-1,NULL,0);
05925    G__search_typename2("BaseFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR));
05926    G__setnewtype(-1,NULL,0);
05927    G__search_typename2("IModelFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR));
05928    G__setnewtype(-1,NULL,0);
05929    G__search_typename2("Type_t",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgRcLcLType_t),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR));
05930    G__setnewtype(-1,NULL,0);
05931    G__search_typename2("Chi2GradFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFit));
05932    G__setnewtype(-1,NULL,0);
05933    G__search_typename2("vector<ROOT::Fit::ParameterSettings>",117,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR),0,-1);
05934    G__setnewtype(-1,NULL,0);
05935    G__search_typename2("value_type",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
05936    G__setnewtype(-1,NULL,0);
05937    G__search_typename2("pointer",85,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
05938    G__setnewtype(-1,NULL,0);
05939    G__search_typename2("const_pointer",85,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings),256,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
05940    G__setnewtype(-1,NULL,0);
05941    G__search_typename2("reference",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings),1,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
05942    G__setnewtype(-1,NULL,0);
05943    G__search_typename2("const_reference",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings),257,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
05944    G__setnewtype(-1,NULL,0);
05945    G__search_typename2("size_type",104,-1,0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
05946    G__setnewtype(-1,NULL,0);
05947    G__search_typename2("difference_type",108,-1,0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
05948    G__setnewtype(-1,NULL,0);
05949    G__search_typename2("const_iterator",117,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiterator),256,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
05950    G__setnewtype(-1,NULL,0);
05951    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
05952    G__setnewtype(-1,NULL,0);
05953    G__search_typename2("const_reverse_iterator",117,G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
05954    G__setnewtype(-1,NULL,0);
05955    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
05956    G__setnewtype(-1,NULL,0);
05957    G__search_typename2("reverse_iterator",117,G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
05958    G__setnewtype(-1,NULL,0);
05959    G__search_typename2("vector<unsigned int>",117,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),0,-1);
05960    G__setnewtype(-1,NULL,0);
05961    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
05962    G__setnewtype(-1,NULL,0);
05963    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR));
05964    G__setnewtype(-1,NULL,0);
05965    G__search_typename2("IModelFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitResult));
05966    G__setnewtype(-1,NULL,0);
05967    G__search_typename2("map<unsigned int,std::pair<double,double> >",117,G__get_linked_tagnum(&G__G__MathFitLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
05968    G__setnewtype(-1,NULL,0);
05969    G__search_typename2("map<unsigned int,pair<double,double> >",117,G__get_linked_tagnum(&G__G__MathFitLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
05970    G__setnewtype(-1,NULL,0);
05971    G__search_typename2("map<unsigned int,pair<double,double>,less<unsigned int> >",117,G__get_linked_tagnum(&G__G__MathFitLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),0,-1);
05972    G__setnewtype(-1,NULL,0);
05973    G__search_typename2("vector<std::string>",117,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
05974    G__setnewtype(-1,NULL,0);
05975    G__search_typename2("reverse_iterator<const_iterator>",117,G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEstringcOallocatorlEstringgRsPgR));
05976    G__setnewtype(-1,NULL,0);
05977    G__search_typename2("reverse_iterator<iterator>",117,G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR),0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEstringcOallocatorlEstringgRsPgR));
05978    G__setnewtype(-1,NULL,0);
05979    G__search_typename2("vector<string>",117,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEstringcOallocatorlEstringgRsPgR),0,-1);
05980    G__setnewtype(-1,NULL,0);
05981    G__search_typename2("IModelFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitter));
05982    G__setnewtype(-1,NULL,0);
05983    G__search_typename2("IGradModelFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricGradFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitter));
05984    G__setnewtype(-1,NULL,0);
05985    G__search_typename2("IModel1DFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionOneDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitter));
05986    G__setnewtype(-1,NULL,0);
05987    G__search_typename2("IGradModel1DFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricGradFunctionOneDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitter));
05988    G__setnewtype(-1,NULL,0);
05989    G__search_typename2("BaseFunc",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitter));
05990    G__setnewtype(-1,NULL,0);
05991    G__search_typename2("BaseGradFunc",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIGradientFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitter));
05992    G__setnewtype(-1,NULL,0);
05993    G__search_typename2("MinuitFCN_t",89,-1,0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitter));
05994    G__setnewtype(-1," void (* MinuitFCN_t )(int &npar, double *gin, double &f, double *u, int flag);",0);
05995    G__search_typename2("auto_ptr<ROOT::Math::IMultiGenFunction>",117,G__get_linked_tagnum(&G__G__MathFitLN_auto_ptrlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),0,-1);
05996    G__setnewtype(-1,NULL,0);
05997    G__search_typename2("LogLikelihoodFCN<ROOT::Math::IMultiGenFunction>",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFit));
05998    G__setnewtype(-1,NULL,0);
05999    G__search_typename2("BaseObjFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR));
06000    G__setnewtype(-1,NULL,0);
06001    G__search_typename2("BaseFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR));
06002    G__setnewtype(-1,NULL,0);
06003    G__search_typename2("IModelFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR));
06004    G__setnewtype(-1,NULL,0);
06005    G__search_typename2("LogLikelihoodFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFit));
06006    G__setnewtype(-1,NULL,0);
06007    G__search_typename2("LogLikelihoodFCN<ROOT::Math::IMultiGradFunction>",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFit));
06008    G__setnewtype(-1,NULL,0);
06009    G__search_typename2("BaseObjFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR));
06010    G__setnewtype(-1,NULL,0);
06011    G__search_typename2("BaseFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR));
06012    G__setnewtype(-1,NULL,0);
06013    G__search_typename2("IModelFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR));
06014    G__setnewtype(-1,NULL,0);
06015    G__search_typename2("LogLikelihoodGradFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFit));
06016    G__setnewtype(-1,NULL,0);
06017    G__search_typename2("PoissonLikelihoodFCN<ROOT::Math::IMultiGenFunction>",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFit));
06018    G__setnewtype(-1,NULL,0);
06019    G__search_typename2("BaseObjFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR));
06020    G__setnewtype(-1,NULL,0);
06021    G__search_typename2("BaseFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR));
06022    G__setnewtype(-1,NULL,0);
06023    G__search_typename2("IModelFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR));
06024    G__setnewtype(-1,NULL,0);
06025    G__search_typename2("PoissonLLFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFit));
06026    G__setnewtype(-1,NULL,0);
06027    G__search_typename2("PoissonLikelihoodFCN<ROOT::Math::IMultiGradFunction>",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFit));
06028    G__setnewtype(-1,NULL,0);
06029    G__search_typename2("BaseObjFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR));
06030    G__setnewtype(-1,NULL,0);
06031    G__search_typename2("BaseFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR));
06032    G__setnewtype(-1,NULL,0);
06033    G__search_typename2("IModelFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR));
06034    G__setnewtype(-1,NULL,0);
06035    G__search_typename2("PoissonLLGradFunction",117,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFit));
06036    G__setnewtype(-1,NULL,0);
06037 }
06038 
06039 /*********************************************************
06040 * Data Member information setup/
06041 *********************************************************/
06042 
06043    /* Setting up class,struct,union tag member variable */
06044 
06045    /* ROOT::Fit */
06046 static void G__setup_memvarROOTcLcLFit(void) {
06047    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFit));
06048    {
06049    }
06050    G__tag_memvar_reset();
06051 }
06052 
06053 
06054    /* ROOT::Fit::DataOptions */
06055 static void G__setup_memvarROOTcLcLFitcLcLDataOptions(void) {
06056    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataOptions));
06057    { ROOT::Fit::DataOptions *p; p=(ROOT::Fit::DataOptions*)0x1000; if (p) { }
06058    G__memvar_setup((void*)((long)(&p->fIntegral)-(long)(p)),103,0,0,-1,-1,-1,1,"fIntegral=",0,"use integral of bin content instead of bin center (default is false)");
06059    G__memvar_setup((void*)((long)(&p->fBinVolume)-(long)(p)),103,0,0,-1,-1,-1,1,"fBinVolume=",0,"normalize data by the bin volume (it is used in the Poisson likelihood fits)");
06060    G__memvar_setup((void*)((long)(&p->fUseEmpty)-(long)(p)),103,0,0,-1,-1,-1,1,"fUseEmpty=",0,"use empty bins (default is false) with a fixed error of 1");
06061    G__memvar_setup((void*)((long)(&p->fUseRange)-(long)(p)),103,0,0,-1,-1,-1,1,"fUseRange=",0,"use the function range when creating the fit data (default is false)");
06062    G__memvar_setup((void*)((long)(&p->fErrors1)-(long)(p)),103,0,0,-1,-1,-1,1,"fErrors1=",0,"use all errors equal to 1, i.e. fit without errors (default is false) ");
06063    G__memvar_setup((void*)((long)(&p->fCoordErrors)-(long)(p)),103,0,0,-1,-1,-1,1,"fCoordErrors=",0,"use errors on the x coordinates when available (default is true)");
06064    G__memvar_setup((void*)((long)(&p->fAsymErrors)-(long)(p)),103,0,0,-1,-1,-1,1,"fAsymErrors=",0,"use asymmetric errors in the value when available, selecting them according to the on sign of residual (default is true)");
06065    }
06066    G__tag_memvar_reset();
06067 }
06068 
06069 
06070    /* ROOT::Fit::DataRange */
06071 static void G__setup_memvarROOTcLcLFitcLcLDataRange(void) {
06072    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataRange));
06073    { ROOT::Fit::DataRange *p; p=(ROOT::Fit::DataRange*)0x1000; if (p) { }
06074    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgR),G__defined_typename("RangeIntervals"),-1,4,"fRanges=",0,"list of all ranges");
06075    }
06076    G__tag_memvar_reset();
06077 }
06078 
06079 
06080    /* ROOT::Fit::FitData */
06081 static void G__setup_memvarROOTcLcLFitcLcLFitData(void) {
06082    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitData));
06083    { ROOT::Fit::FitData *p; p=(ROOT::Fit::FitData*)0x1000; if (p) { }
06084    G__memvar_setup((void*)0,108,0,0,-1,-1,-1,4,"G__virtualinfo=",0,(char*)NULL);
06085    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataOptions),-1,-1,4,"fOptions=",0,(char*)NULL);
06086    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataRange),-1,-1,4,"fRange=",0,(char*)NULL);
06087    }
06088    G__tag_memvar_reset();
06089 }
06090 
06091 
06092    /* ROOT::Fit::BinData */
06093 static void G__setup_memvarROOTcLcLFitcLcLBinData(void) {
06094    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData));
06095    { ROOT::Fit::BinData *p; p=(ROOT::Fit::BinData*)0x1000; if (p) { }
06096    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinDatacLcLErrorType),-1,-2,1,G__FastAllocString(2048).Format("kNoError=%lldLL",(long long)ROOT::Fit::BinData::kNoError).data(),0,(char*)NULL);
06097    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinDatacLcLErrorType),-1,-2,1,G__FastAllocString(2048).Format("kValueError=%lldLL",(long long)ROOT::Fit::BinData::kValueError).data(),0,(char*)NULL);
06098    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinDatacLcLErrorType),-1,-2,1,G__FastAllocString(2048).Format("kCoordError=%lldLL",(long long)ROOT::Fit::BinData::kCoordError).data(),0,(char*)NULL);
06099    G__memvar_setup((void*)G__PVOID,105,0,1,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinDatacLcLErrorType),-1,-2,1,G__FastAllocString(2048).Format("kAsymError=%lldLL",(long long)ROOT::Fit::BinData::kAsymError).data(),0,(char*)NULL);
06100    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fDim=",0,"coordinate dimension");
06101    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fPointSize=",0,"total point size including value and errors (= fDim + 2 for error in only Y ) ");
06102    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fNPoints=",0,"number of contained points in the data set (can be different than size of vector)");
06103    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fRefVolume=",0,"reference bin volume - used to normalize the bins in case of variable bins data");
06104    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataVector),-1,-1,4,"fDataVector=",0,"pointer to the copied in data vector");
06105    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataWrapper),-1,-1,4,"fDataWrapper=",0,"pointer to the external data wrapper structure");
06106    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fBinEdge=",0,"vector containing the bin upper edge (coordinate will contain low edge) ");
06107    }
06108    G__tag_memvar_reset();
06109 }
06110 
06111 
06112    /* ROOT::Fit::UnBinData */
06113 static void G__setup_memvarROOTcLcLFitcLcLUnBinData(void) {
06114    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData));
06115    { ROOT::Fit::UnBinData *p; p=(ROOT::Fit::UnBinData*)0x1000; if (p) { }
06116    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fDim=",0,"coordinate data dimension");
06117    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fNPoints=",0,"numer of fit points");
06118    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataVector),-1,-1,4,"fDataVector=",0,"pointer to internal data vector (null for external data)");
06119    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataWrapper),-1,-1,4,"fDataWrapper=",0,"pointer to structure wrapping external data (null when data are copied in)");
06120    }
06121    G__tag_memvar_reset();
06122 }
06123 
06124 
06125    /* ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim> */
06126 static void G__setup_memvarROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void) {
06127    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR));
06128    { ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim> *p; p=(ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>*)0x1000; if (p) { }
06129    G__memvar_setup((void*)0,117,1,1,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData),-1,-1,4,"fData=",0,(char*)NULL);
06130    G__memvar_setup((void*)0,117,1,1,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim),G__defined_typename("IModelFunction"),-1,4,"fFunc=",0,(char*)NULL);
06131    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fNEffPoints=",0,"number of effective points used in the fit ");
06132    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fGrad=",0,"for derivatives");
06133    }
06134    G__tag_memvar_reset();
06135 }
06136 
06137 
06138    /* ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim> */
06139 static void G__setup_memvarROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void) {
06140    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR));
06141    { ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim> *p; p=(ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>*)0x1000; if (p) { }
06142    G__memvar_setup((void*)0,117,1,1,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData),-1,-1,4,"fData=",0,(char*)NULL);
06143    G__memvar_setup((void*)0,117,1,1,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim),G__defined_typename("IModelFunction"),-1,4,"fFunc=",0,(char*)NULL);
06144    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fNEffPoints=",0,"number of effective points used in the fit ");
06145    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fGrad=",0,"for derivatives");
06146    }
06147    G__tag_memvar_reset();
06148 }
06149 
06150 
06151    /* ROOT::Fit::ParameterSettings */
06152 static void G__setup_memvarROOTcLcLFitcLcLParameterSettings(void) {
06153    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings));
06154    { ROOT::Fit::ParameterSettings *p; p=(ROOT::Fit::ParameterSettings*)0x1000; if (p) { }
06155    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fValue=",0,"parameter value");
06156    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fStepSize=",0,"parameter step size (used by minimizer)");
06157    G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fFix=",0,"flag to control if parameter is fixed ");
06158    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fLowerLimit=",0,"lower parameter limit");
06159    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,4,"fUpperLimit=",0,"upper parameter limit");
06160    G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fHasLowerLimit=",0,"flag to control lower parameter limit");
06161    G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fHasUpperLimit=",0,"flag to control upper parameter limit");
06162    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_string),-1,-1,4,"fName=",0,"parameter name");
06163    }
06164    G__tag_memvar_reset();
06165 }
06166 
06167 
06168    /* ROOT::Fit::FitConfig */
06169 static void G__setup_memvarROOTcLcLFitcLcLFitConfig(void) {
06170    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitConfig));
06171    { ROOT::Fit::FitConfig *p; p=(ROOT::Fit::FitConfig*)0x1000; if (p) { }
06172    G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fNormErrors=",0,"flag for error normalization");
06173    G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fParabErrors=",0,"get correct parabolic errors estimate (call Hesse after minimizing)  ");
06174    G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fMinosErrors=",0,"do full error analysis using Minos");
06175    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR),G__defined_typename("vector<ROOT::Fit::ParameterSettings>"),-1,4,"fSettings=",0,"vector with the parameter settings");
06176    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),G__defined_typename("vector<unsigned int>"),-1,4,"fMinosParams=",0,"vector with the parameter indeces for running Minos");
06177    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLMinimizerOptions),-1,-1,4,"fMinimizerOpts=",0,"minimizer control parameters including name and algo type");
06178    }
06179    G__tag_memvar_reset();
06180 }
06181 
06182 
06183    /* vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> > */
06184 static void G__setup_memvarvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR(void) {
06185    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
06186    { vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> > *p; p=(vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >*)0x1000; if (p) { }
06187    }
06188    G__tag_memvar_reset();
06189 }
06190 
06191 
06192    /* ROOT::Fit::FitResult */
06193 static void G__setup_memvarROOTcLcLFitcLcLFitResult(void) {
06194    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitResult));
06195    { ROOT::Fit::FitResult *p; p=(ROOT::Fit::FitResult*)0x1000; if (p) { }
06196    G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fValid=",0,"flag for indicating valid fit");
06197    G__memvar_setup((void*)0,103,0,0,-1,-1,-1,2,"fNormalized=",0,"flag for indicating is errors are normalized");
06198    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fNFree=",0,"number of fit free parameters (total parameters are in size of parameter vector)  ");
06199    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fNdf=",0,"number of degree of freedom");
06200    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,2,"fNCalls=",0,"number of function calls");
06201    G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fStatus=",0,"minimizer status code");
06202    G__memvar_setup((void*)0,105,0,0,-1,-1,-1,2,"fCovStatus=",0,"covariance matrix status code");
06203    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fVal=",0,"minimum function value");
06204    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fEdm=",0,"expected distance from mimimum");
06205    G__memvar_setup((void*)0,100,0,0,-1,-1,-1,2,"fChi2=",0,"fit chi2 value (different than fval in case of chi2 fits)");
06206    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim),G__defined_typename("IModelFunction"),-1,2,"fFitFunc=",0,"! model function resulting  from the fit. It is given by Fitter but it is managed by FitResult");
06207    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),G__defined_typename("vector<unsigned int>"),-1,2,"fFixedParams=",0,"list of fixed parameters");
06208    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR),G__defined_typename("vector<unsigned int>"),-1,2,"fBoundParams=",0,"list of limited parameters");
06209    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,2,"fParams=",0,"parameter values. Size is total number of parameters");
06210    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,2,"fErrors=",0,"errors ");
06211    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,2,"fCovMatrix=",0,"covariance matrix (size is npar*(npar+1)/2) where npar is total parameters");
06212    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,2,"fGlobalCC=",0,"global Correlation coefficient");
06213    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR),G__defined_typename("map<unsigned int,std::pair<double,double> >"),-1,2,"fMinosErrors=",0,"map contains the two Minos errors");
06214    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_string),-1,-1,2,"fMinimType=",0,"string indicating type of minimizer");
06215    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEstringcOallocatorlEstringgRsPgR),G__defined_typename("vector<std::string>"),-1,2,"fParNames=",0,"parameter names (only with FCN only fits, when fFitFunc=0)");
06216    }
06217    G__tag_memvar_reset();
06218 }
06219 
06220 
06221    /* ROOT::Fit::Fitter */
06222 static void G__setup_memvarROOTcLcLFitcLcLFitter(void) {
06223    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitter));
06224    { ROOT::Fit::Fitter *p; p=(ROOT::Fit::Fitter*)0x1000; if (p) { }
06225    G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fUseGradient=",0,"flag to indicate if using gradient or not");
06226    G__memvar_setup((void*)0,103,0,0,-1,-1,-1,4,"fBinFit=",0,"flag to indicate if fit is binned (in case of false the fit is unbinned or undefined)");
06227    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim),G__defined_typename("IModelFunction"),-1,4,"fFunc=",0,"copy of the fitted  function containing on output the fit result (managed by FitResult)");
06228    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitConfig),-1,-1,4,"fConfig=",0,"fitter configuration (options and parameter settings)");
06229    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_auto_ptrlEROOTcLcLFitcLcLFitResultgR),-1,-1,4,"fResult=",0,"! pointer to the object containing the result of the fit");
06230    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_auto_ptrlEROOTcLcLMathcLcLMinimizergR),-1,-1,4,"fMinimizer=",0,"! pointer to used minimizer");
06231    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_auto_ptrlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),G__defined_typename("auto_ptr<ROOT::Math::IMultiGenFunction>"),-1,4,"fObjFunction=",0,"! pointer to used objective function");
06232    }
06233    G__tag_memvar_reset();
06234 }
06235 
06236 
06237    /* ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim> */
06238 static void G__setup_memvarROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void) {
06239    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR));
06240    { ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim> *p; p=(ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*)0x1000; if (p) { }
06241    G__memvar_setup((void*)0,117,1,1,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData),-1,-1,4,"fData=",0,(char*)NULL);
06242    G__memvar_setup((void*)0,117,1,1,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim),G__defined_typename("IModelFunction"),-1,4,"fFunc=",0,(char*)NULL);
06243    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fNEffPoints=",0,"number of effective points used in the fit ");
06244    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fGrad=",0,"for derivatives");
06245    }
06246    G__tag_memvar_reset();
06247 }
06248 
06249 
06250    /* ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim> */
06251 static void G__setup_memvarROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void) {
06252    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR));
06253    { ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim> *p; p=(ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*)0x1000; if (p) { }
06254    G__memvar_setup((void*)0,117,1,1,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData),-1,-1,4,"fData=",0,(char*)NULL);
06255    G__memvar_setup((void*)0,117,1,1,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim),G__defined_typename("IModelFunction"),-1,4,"fFunc=",0,(char*)NULL);
06256    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fNEffPoints=",0,"number of effective points used in the fit ");
06257    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fGrad=",0,"for derivatives");
06258    }
06259    G__tag_memvar_reset();
06260 }
06261 
06262 
06263    /* ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim> */
06264 static void G__setup_memvarROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void) {
06265    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR));
06266    { ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim> *p; p=(ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>*)0x1000; if (p) { }
06267    G__memvar_setup((void*)0,117,1,1,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData),-1,-1,4,"fData=",0,(char*)NULL);
06268    G__memvar_setup((void*)0,117,1,1,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim),G__defined_typename("IModelFunction"),-1,4,"fFunc=",0,(char*)NULL);
06269    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fNEffPoints=",0,"number of effective points used in the fit");
06270    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fGrad=",0,"for derivatives");
06271    }
06272    G__tag_memvar_reset();
06273 }
06274 
06275 
06276    /* ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim> */
06277 static void G__setup_memvarROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void) {
06278    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR));
06279    { ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim> *p; p=(ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>*)0x1000; if (p) { }
06280    G__memvar_setup((void*)0,117,1,1,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData),-1,-1,4,"fData=",0,(char*)NULL);
06281    G__memvar_setup((void*)0,117,1,1,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim),G__defined_typename("IModelFunction"),-1,4,"fFunc=",0,(char*)NULL);
06282    G__memvar_setup((void*)0,104,0,0,-1,-1,-1,4,"fNEffPoints=",0,"number of effective points used in the fit");
06283    G__memvar_setup((void*)0,117,0,0,G__get_linked_tagnum(&G__G__MathFitLN_vectorlEdoublecOallocatorlEdoublegRsPgR),G__defined_typename("vector<double>"),-1,4,"fGrad=",0,"for derivatives");
06284    }
06285    G__tag_memvar_reset();
06286 }
06287 
06288 
06289    /* ROOT::Fit::SparseData */
06290 static void G__setup_memvarROOTcLcLFitcLcLSparseData(void) {
06291    G__tag_memvar_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLSparseData));
06292    { ROOT::Fit::SparseData *p; p=(ROOT::Fit::SparseData*)0x1000; if (p) { }
06293    G__memvar_setup((void*)0,85,0,0,G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLProxyListBox),-1,-1,4,"fList=",0,(char*)NULL);
06294    }
06295    G__tag_memvar_reset();
06296 }
06297 
06298 extern "C" void G__cpp_setup_memvarG__MathFit() {
06299 }
06300 /***********************************************************
06301 ************************************************************
06302 ************************************************************
06303 ************************************************************
06304 ************************************************************
06305 ************************************************************
06306 ************************************************************
06307 ***********************************************************/
06308 
06309 /*********************************************************
06310 * Member function information setup for each class
06311 *********************************************************/
06312 static void G__setup_memfuncROOTcLcLFit(void) {
06313    /* ROOT::Fit */
06314    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFit));
06315    G__tag_memfunc_reset();
06316 }
06317 
06318 static void G__setup_memfuncROOTcLcLFitcLcLDataOptions(void) {
06319    /* ROOT::Fit::DataOptions */
06320    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataOptions));
06321    G__memfunc_setup("DataOptions",1126,G__G__MathFit_100_0_1, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataOptions), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06322    // automatic copy constructor
06323    G__memfunc_setup("DataOptions", 1126, G__G__MathFit_100_0_2, (int) ('i'), G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataOptions), -1, 0, 1, 1, 1, 0, "u 'ROOT::Fit::DataOptions' - 11 - -", (char*) NULL, (void*) NULL, 0);
06324    // automatic destructor
06325    G__memfunc_setup("~DataOptions", 1252, G__G__MathFit_100_0_3, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
06326    // automatic assignment operator
06327    G__memfunc_setup("operator=", 937, G__G__MathFit_100_0_4, (int) ('u'), G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataOptions), -1, 1, 1, 1, 1, 0, "u 'ROOT::Fit::DataOptions' - 11 - -", (char*) NULL, (void*) NULL, 0);
06328    G__tag_memfunc_reset();
06329 }
06330 
06331 static void G__setup_memfuncROOTcLcLFitcLcLDataRange(void) {
06332    /* ROOT::Fit::DataRange */
06333    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataRange));
06334    G__memfunc_setup("DataRange",871,G__G__MathFit_101_0_1, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataRange), -1, 0, 1, 5, 1, 0, "h - - 0 '1' dim", (char*)NULL, (void*) NULL, 0);
06335    G__memfunc_setup("DataRange",871,G__G__MathFit_101_0_2, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataRange), -1, 0, 2, 1, 1, 0, 
06336 "d - - 0 - xmin d - - 0 - xmax", (char*)NULL, (void*) NULL, 0);
06337    G__memfunc_setup("DataRange",871,G__G__MathFit_101_0_3, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataRange), -1, 0, 4, 1, 1, 0, 
06338 "d - - 0 - xmin d - - 0 - xmax "
06339 "d - - 0 - ymin d - - 0 - ymax", (char*)NULL, (void*) NULL, 0);
06340    G__memfunc_setup("DataRange",871,G__G__MathFit_101_0_4, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataRange), -1, 0, 6, 1, 1, 0, 
06341 "d - - 0 - xmin d - - 0 - xmax "
06342 "d - - 0 - ymin d - - 0 - ymax "
06343 "d - - 0 - zmin d - - 0 - zmax", (char*)NULL, (void*) NULL, 0);
06344    G__memfunc_setup("NDim",360,G__G__MathFit_101_0_5, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06345    G__memfunc_setup("Size",411,G__G__MathFit_101_0_6, 104, -1, -1, 0, 1, 1, 1, 8, "h - - 0 '0' icoord", (char*)NULL, (void*) NULL, 0);
06346    G__memfunc_setup("IsSet",488,G__G__MathFit_101_0_7, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06347    G__memfunc_setup("Ranges",608,G__G__MathFit_101_0_8, 117, G__get_linked_tagnum(&G__G__MathFitLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR), G__defined_typename("ROOT::Fit::DataRange::RangeSet"), 1, 1, 1, 1, 9, "h - - 0 '0' icoord", (char*)NULL, (void*) NULL, 0);
06348    G__memfunc_setup("operator()",957,G__G__MathFit_101_0_9, 117, G__get_linked_tagnum(&G__G__MathFitLN_pairlEdoublecOdoublegR), -1, 0, 2, 1, 1, 8, 
06349 "h - - 0 '0' icoord h - - 0 '0' irange", (char*)NULL, (void*) NULL, 0);
06350    G__memfunc_setup("GetRange",781,G__G__MathFit_101_0_10, 121, -1, -1, 0, 3, 1, 1, 8, 
06351 "h - - 0 - icoord d - - 1 - xmin "
06352 "d - - 1 - xmax", (char*)NULL, (void*) NULL, 0);
06353    G__memfunc_setup("GetRange",781,G__G__MathFit_101_0_11, 121, -1, -1, 0, 2, 1, 1, 8, 
06354 "d - - 1 - xmin d - - 1 - xmax", (char*)NULL, (void*) NULL, 0);
06355    G__memfunc_setup("GetRange",781,G__G__MathFit_101_0_12, 121, -1, -1, 0, 4, 1, 1, 8, 
06356 "d - - 1 - xmin d - - 1 - xmax "
06357 "d - - 1 - ymin d - - 1 - ymax", (char*)NULL, (void*) NULL, 0);
06358    G__memfunc_setup("GetRange",781,G__G__MathFit_101_0_13, 121, -1, -1, 0, 6, 1, 1, 8, 
06359 "d - - 1 - xmin d - - 1 - xmax "
06360 "d - - 1 - ymin d - - 1 - ymax "
06361 "d - - 1 - zmin d - - 1 - zmax", (char*)NULL, (void*) NULL, 0);
06362    G__memfunc_setup("GetRange",781,G__G__MathFit_101_0_14, 121, -1, -1, 0, 2, 1, 1, 8, 
06363 "D - - 0 - xmin D - - 0 - xmax", (char*)NULL, (void*) NULL, 0);
06364    G__memfunc_setup("AddRange",758,G__G__MathFit_101_0_15, 121, -1, -1, 0, 3, 1, 1, 0, 
06365 "h - - 0 - icoord d - - 0 - xmin "
06366 "d - - 0 - xmax", (char*)NULL, (void*) NULL, 0);
06367    G__memfunc_setup("AddRange",758,G__G__MathFit_101_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
06368 "d - - 0 - xmin d - - 0 - xmax", (char*)NULL, (void*) NULL, 0);
06369    G__memfunc_setup("AddRange",758,G__G__MathFit_101_0_17, 121, -1, -1, 0, 4, 1, 1, 0, 
06370 "d - - 0 - xmin d - - 0 - xmax "
06371 "d - - 0 - ymin d - - 0 - ymax", (char*)NULL, (void*) NULL, 0);
06372    G__memfunc_setup("AddRange",758,G__G__MathFit_101_0_18, 121, -1, -1, 0, 6, 1, 1, 0, 
06373 "d - - 0 - xmin d - - 0 - xmax "
06374 "d - - 0 - ymin d - - 0 - ymax "
06375 "d - - 0 - zmin d - - 0 - zmax", (char*)NULL, (void*) NULL, 0);
06376    G__memfunc_setup("SetRange",793,G__G__MathFit_101_0_19, 121, -1, -1, 0, 3, 1, 1, 0, 
06377 "h - - 0 - icoord d - - 0 - xmin "
06378 "d - - 0 - xmax", (char*)NULL, (void*) NULL, 0);
06379    G__memfunc_setup("SetRange",793,G__G__MathFit_101_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
06380 "d - - 0 - xmin d - - 0 - xmax", (char*)NULL, (void*) NULL, 0);
06381    G__memfunc_setup("SetRange",793,G__G__MathFit_101_0_21, 121, -1, -1, 0, 4, 1, 1, 0, 
06382 "d - - 0 - xmin d - - 0 - xmax "
06383 "d - - 0 - ymin d - - 0 - ymax", (char*)NULL, (void*) NULL, 0);
06384    G__memfunc_setup("SetRange",793,G__G__MathFit_101_0_22, 121, -1, -1, 0, 6, 1, 1, 0, 
06385 "d - - 0 - xmin d - - 0 - xmax "
06386 "d - - 0 - ymin d - - 0 - ymax "
06387 "d - - 0 - zmin d - - 0 - zmax", (char*)NULL, (void*) NULL, 0);
06388    G__memfunc_setup("Clear",487,G__G__MathFit_101_0_23, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 '0' icoord", (char*)NULL, (void*) NULL, 0);
06389    G__memfunc_setup("IsInside",792,G__G__MathFit_101_0_24, 103, -1, -1, 0, 2, 1, 1, 8, 
06390 "d - - 0 - x h - - 0 '0' icoord", (char*)NULL, (void*) NULL, 0);
06391    G__memfunc_setup("CleanRangeSet",1276,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 3, 1, 2, 0, 
06392 "h - - 0 - icoord d - - 0 - xmin "
06393 "d - - 0 - xmax", (char*)NULL, (void*) NULL, 0);
06394    G__memfunc_setup("GetInfRange",1066,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 2, 3, 2, 0, 
06395 "d - - 1 - x1 d - - 1 - x2", (char*)NULL, (void*) NULL, 0);
06396    // automatic copy constructor
06397    G__memfunc_setup("DataRange", 871, G__G__MathFit_101_0_27, (int) ('i'), G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataRange), -1, 0, 1, 1, 1, 0, "u 'ROOT::Fit::DataRange' - 11 - -", (char*) NULL, (void*) NULL, 0);
06398    // automatic destructor
06399    G__memfunc_setup("~DataRange", 997, G__G__MathFit_101_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
06400    // automatic assignment operator
06401    G__memfunc_setup("operator=", 937, G__G__MathFit_101_0_29, (int) ('u'), G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataRange), -1, 1, 1, 1, 1, 0, "u 'ROOT::Fit::DataRange' - 11 - -", (char*) NULL, (void*) NULL, 0);
06402    G__tag_memfunc_reset();
06403 }
06404 
06405 static void G__setup_memfuncROOTcLcLFitcLcLFitData(void) {
06406    /* ROOT::Fit::FitData */
06407    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitData));
06408    G__memfunc_setup("FitData",669,G__G__MathFit_111_0_1, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitData), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06409    G__memfunc_setup("FitData",669,G__G__MathFit_111_0_2, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitData), -1, 0, 1, 1, 1, 0, "u 'ROOT::Fit::DataOptions' - 11 - opt", (char*)NULL, (void*) NULL, 0);
06410    G__memfunc_setup("FitData",669,G__G__MathFit_111_0_3, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitData), -1, 0, 1, 1, 1, 0, "u 'ROOT::Fit::DataRange' - 11 - range", (char*)NULL, (void*) NULL, 0);
06411    G__memfunc_setup("FitData",669,G__G__MathFit_111_0_4, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitData), -1, 0, 2, 1, 1, 0, 
06412 "u 'ROOT::Fit::DataOptions' - 11 - opt u 'ROOT::Fit::DataRange' - 11 - range", (char*)NULL, (void*) NULL, 0);
06413    G__memfunc_setup("Opt",307,G__G__MathFit_111_0_5, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataOptions), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
06414    G__memfunc_setup("Opt",307,G__G__MathFit_111_0_6, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataOptions), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06415    G__memfunc_setup("Range",493,G__G__MathFit_111_0_7, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLDataRange), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
06416    G__memfunc_setup("MaxSize",705,G__G__MathFit_111_0_8, 104, -1, -1, 0, 0, 3, 1, 0, "", (char*)NULL, (void*) G__func2void( (unsigned int (*)())(&ROOT::Fit::FitData::MaxSize) ), 0);
06417    // automatic copy constructor
06418    G__memfunc_setup("FitData", 669, G__G__MathFit_111_0_9, (int) ('i'), G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitData), -1, 0, 1, 1, 1, 0, "u 'ROOT::Fit::FitData' - 11 - -", (char*) NULL, (void*) NULL, 0);
06419    // automatic destructor
06420    G__memfunc_setup("~FitData", 795, G__G__MathFit_111_0_10, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
06421    // automatic assignment operator
06422    G__memfunc_setup("operator=", 937, G__G__MathFit_111_0_11, (int) ('u'), G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitData), -1, 1, 1, 1, 1, 0, "u 'ROOT::Fit::FitData' - 11 - -", (char*) NULL, (void*) NULL, 0);
06423    G__tag_memfunc_reset();
06424 }
06425 
06426 static void G__setup_memfuncROOTcLcLFitcLcLBinData(void) {
06427    /* ROOT::Fit::BinData */
06428    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData));
06429    G__memfunc_setup("GetPointSize",1221,G__G__MathFit_122_0_1, 104, -1, -1, 0, 2, 3, 1, 0, 
06430 "i 'ROOT::Fit::BinData::ErrorType' - 0 - err h - - 0 - dim", (char*)NULL, (void*) G__func2void( (unsigned int (*)(ROOT::Fit::BinData::ErrorType, unsigned int))(&ROOT::Fit::BinData::GetPointSize) ), 0);
06431    G__memfunc_setup("GetErrorType",1228,G__G__MathFit_122_0_2, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinDatacLcLErrorType), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06432    G__memfunc_setup("BinData",659,G__G__MathFit_122_0_3, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData), -1, 0, 3, 5, 1, 0, 
06433 "h - - 0 '0' maxpoints h - - 0 '1' dim "
06434 "i 'ROOT::Fit::BinData::ErrorType' - 0 'kValueError' err", (char*)NULL, (void*) NULL, 0);
06435    G__memfunc_setup("BinData",659,G__G__MathFit_122_0_4, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData), -1, 0, 4, 5, 1, 0, 
06436 "u 'ROOT::Fit::DataOptions' - 11 - opt h - - 0 '0' maxpoints "
06437 "h - - 0 '1' dim i 'ROOT::Fit::BinData::ErrorType' - 0 'kValueError' err", (char*)NULL, (void*) NULL, 0);
06438    G__memfunc_setup("BinData",659,G__G__MathFit_122_0_5, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData), -1, 0, 5, 1, 1, 0, 
06439 "u 'ROOT::Fit::DataOptions' - 11 - opt u 'ROOT::Fit::DataRange' - 11 - range "
06440 "h - - 0 '0' maxpoints h - - 0 '1' dim "
06441 "i 'ROOT::Fit::BinData::ErrorType' - 0 'kValueError' err", (char*)NULL, (void*) NULL, 0);
06442    G__memfunc_setup("BinData",659,G__G__MathFit_122_0_6, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData), -1, 0, 5, 1, 1, 0, 
06443 "h - - 0 - n D - - 10 - dataX "
06444 "D - - 10 - val D - - 10 - ex "
06445 "D - - 10 - eval", (char*)NULL, (void*) NULL, 0);
06446    G__memfunc_setup("BinData",659,G__G__MathFit_122_0_7, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData), -1, 0, 7, 1, 1, 0, 
06447 "h - - 0 - n D - - 10 - dataX "
06448 "D - - 10 - dataY D - - 10 - val "
06449 "D - - 10 - ex D - - 10 - ey "
06450 "D - - 10 - eval", (char*)NULL, (void*) NULL, 0);
06451    G__memfunc_setup("BinData",659,G__G__MathFit_122_0_8, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData), -1, 0, 9, 1, 1, 0, 
06452 "h - - 0 - n D - - 10 - dataX "
06453 "D - - 10 - dataY D - - 10 - dataZ "
06454 "D - - 10 - val D - - 10 - ex "
06455 "D - - 10 - ey D - - 10 - ez "
06456 "D - - 10 - eval", (char*)NULL, (void*) NULL, 0);
06457    G__memfunc_setup("BinData",659,G__G__MathFit_122_0_9, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData), -1, 0, 1, 1, 1, 0, "u 'ROOT::Fit::BinData' - 11 - -", (char*)NULL, (void*) NULL, 0);
06458    G__memfunc_setup("operator=",937,G__G__MathFit_122_0_10, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData), -1, 1, 1, 1, 1, 0, "u 'ROOT::Fit::BinData' - 11 - -", (char*)NULL, (void*) NULL, 0);
06459    G__memfunc_setup("Initialize",1042,G__G__MathFit_122_0_11, 121, -1, -1, 0, 3, 1, 1, 0, 
06460 "h - - 0 - maxpoints h - - 0 '1' dim "
06461 "i 'ROOT::Fit::BinData::ErrorType' - 0 'kValueError' err", (char*)NULL, (void*) NULL, 0);
06462    G__memfunc_setup("PointSize",933,G__G__MathFit_122_0_12, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06463    G__memfunc_setup("DataSize",789,G__G__MathFit_122_0_13, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06464    G__memfunc_setup("HaveCoordErrors",1528,G__G__MathFit_122_0_14, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06465    G__memfunc_setup("HaveAsymErrors",1435,G__G__MathFit_122_0_15, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06466    G__memfunc_setup("Add",265,G__G__MathFit_122_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
06467 "d - - 0 - x d - - 0 - y", (char*)NULL, (void*) NULL, 0);
06468    G__memfunc_setup("Add",265,G__G__MathFit_122_0_17, 121, -1, -1, 0, 3, 1, 1, 0, 
06469 "d - - 0 - x d - - 0 - y "
06470 "d - - 0 - ey", (char*)NULL, (void*) NULL, 0);
06471    G__memfunc_setup("Add",265,G__G__MathFit_122_0_18, 121, -1, -1, 0, 4, 1, 1, 0, 
06472 "d - - 0 - x d - - 0 - y "
06473 "d - - 0 - ex d - - 0 - ey", (char*)NULL, (void*) NULL, 0);
06474    G__memfunc_setup("Add",265,G__G__MathFit_122_0_19, 121, -1, -1, 0, 5, 1, 1, 0, 
06475 "d - - 0 - x d - - 0 - y "
06476 "d - - 0 - ex d - - 0 - eyl "
06477 "d - - 0 - eyh", (char*)NULL, (void*) NULL, 0);
06478    G__memfunc_setup("Add",265,G__G__MathFit_122_0_20, 121, -1, -1, 0, 2, 1, 1, 0, 
06479 "D - - 10 - x d - - 0 - val", (char*)NULL, (void*) NULL, 0);
06480    G__memfunc_setup("Add",265,G__G__MathFit_122_0_21, 121, -1, -1, 0, 3, 1, 1, 0, 
06481 "D - - 10 - x d - - 0 - val "
06482 "d - - 0 - eval", (char*)NULL, (void*) NULL, 0);
06483    G__memfunc_setup("Add",265,G__G__MathFit_122_0_22, 121, -1, -1, 0, 4, 1, 1, 0, 
06484 "D - - 10 - x d - - 0 - val "
06485 "D - - 10 - ex d - - 0 - eval", (char*)NULL, (void*) NULL, 0);
06486    G__memfunc_setup("Add",265,G__G__MathFit_122_0_23, 121, -1, -1, 0, 5, 1, 1, 0, 
06487 "D - - 10 - x d - - 0 - val "
06488 "D - - 10 - ex d - - 0 - elval "
06489 "d - - 0 - ehval", (char*)NULL, (void*) NULL, 0);
06490    G__memfunc_setup("Coords",618,G__G__MathFit_122_0_24, 68, -1, -1, 0, 1, 1, 1, 9, "h - - 0 - ipoint", (char*)NULL, (void*) NULL, 0);
06491    G__memfunc_setup("Value",509,G__G__MathFit_122_0_25, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - ipoint", (char*)NULL, (void*) NULL, 0);
06492    G__memfunc_setup("Error",522,G__G__MathFit_122_0_26, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - ipoint", (char*)NULL, (void*) NULL, 0);
06493    G__memfunc_setup("InvError",823,G__G__MathFit_122_0_27, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - ipoint", (char*)NULL, (void*) NULL, 0);
06494    G__memfunc_setup("CoordErrors",1140,G__G__MathFit_122_0_28, 68, -1, -1, 0, 1, 1, 1, 9, "h - - 0 - ipoint", (char*)NULL, (void*) NULL, 0);
06495    G__memfunc_setup("GetPoint",810,G__G__MathFit_122_0_29, 68, -1, -1, 0, 2, 1, 1, 9, 
06496 "h - - 0 - ipoint d - - 1 - value", (char*)NULL, (void*) NULL, 0);
06497    G__memfunc_setup("GetPoint",810,G__G__MathFit_122_0_30, 68, -1, -1, 0, 3, 1, 1, 9, 
06498 "h - - 0 - ipoint d - - 1 - value "
06499 "d - - 1 - invError", (char*)NULL, (void*) NULL, 0);
06500    G__memfunc_setup("GetPointError",1332,G__G__MathFit_122_0_31, 68, -1, -1, 0, 2, 1, 1, 9, 
06501 "h - - 0 - ipoint d - - 1 - errvalue", (char*)NULL, (void*) NULL, 0);
06502    G__memfunc_setup("GetPointError",1332,G__G__MathFit_122_0_32, 68, -1, -1, 0, 3, 1, 1, 9, 
06503 "h - - 0 - ipoint d - - 1 - errlow "
06504 "d - - 1 - errhigh", (char*)NULL, (void*) NULL, 0);
06505    G__memfunc_setup("Resize",626,G__G__MathFit_122_0_33, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - npoints", (char*)NULL, (void*) NULL, 0);
06506    G__memfunc_setup("NPoints",715,G__G__MathFit_122_0_34, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06507    G__memfunc_setup("Size",411,G__G__MathFit_122_0_35, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06508    G__memfunc_setup("NDim",360,G__G__MathFit_122_0_36, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06509    G__memfunc_setup("LogTransform",1246,G__G__MathFit_122_0_37, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06510    G__memfunc_setup("BinUpEdge",851,G__G__MathFit_122_0_38, 68, -1, -1, 0, 1, 1, 1, 9, "h - - 0 - icoord", (char*)NULL, (void*) NULL, 0);
06511    G__memfunc_setup("HasBinEdges",1053,G__G__MathFit_122_0_39, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06512    G__memfunc_setup("AddBinUpEdge",1116,G__G__MathFit_122_0_40, 121, -1, -1, 0, 1, 1, 1, 0, "D - - 10 - xup", (char*)NULL, (void*) NULL, 0);
06513    G__memfunc_setup("RefVolume",917,G__G__MathFit_122_0_41, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06514    G__memfunc_setup("SetRefVolume",1217,G__G__MathFit_122_0_42, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - value", (char*)NULL, (void*) NULL, 0);
06515    G__memfunc_setup("SetNPoints",1015,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "h - - 0 - n", (char*)NULL, (void*) NULL, 0);
06516    // automatic destructor
06517    G__memfunc_setup("~BinData", 785, G__G__MathFit_122_0_44, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
06518    G__tag_memfunc_reset();
06519 }
06520 
06521 static void G__setup_memfuncROOTcLcLFitcLcLUnBinData(void) {
06522    /* ROOT::Fit::UnBinData */
06523    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData));
06524    G__memfunc_setup("UnBinData",854,G__G__MathFit_142_0_1, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData), -1, 0, 2, 5, 1, 0, 
06525 "h - - 0 '0' maxpoints h - - 0 '1' dim", (char*)NULL, (void*) NULL, 0);
06526    G__memfunc_setup("UnBinData",854,G__G__MathFit_142_0_2, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData), -1, 0, 3, 5, 1, 0, 
06527 "u 'ROOT::Fit::DataRange' - 11 - range h - - 0 '0' maxpoints "
06528 "h - - 0 '1' dim", (char*)NULL, (void*) NULL, 0);
06529    G__memfunc_setup("UnBinData",854,G__G__MathFit_142_0_3, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData), -1, 0, 4, 1, 1, 0, 
06530 "u 'ROOT::Fit::DataOptions' - 11 - opt u 'ROOT::Fit::DataRange' - 11 - range "
06531 "h - - 0 '0' maxpoints h - - 0 '1' dim", (char*)NULL, (void*) NULL, 0);
06532    G__memfunc_setup("UnBinData",854,G__G__MathFit_142_0_4, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData), -1, 0, 2, 1, 1, 0, 
06533 "h - - 0 - n D - - 10 - dataX", (char*)NULL, (void*) NULL, 0);
06534    G__memfunc_setup("UnBinData",854,G__G__MathFit_142_0_5, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData), -1, 0, 3, 1, 1, 0, 
06535 "h - - 0 - n D - - 10 - dataX "
06536 "D - - 10 - dataY", (char*)NULL, (void*) NULL, 0);
06537    G__memfunc_setup("UnBinData",854,G__G__MathFit_142_0_6, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData), -1, 0, 4, 1, 1, 0, 
06538 "h - - 0 - n D - - 10 - dataX "
06539 "D - - 10 - dataY D - - 10 - dataZ", (char*)NULL, (void*) NULL, 0);
06540    G__memfunc_setup("UnBinData",854,G__G__MathFit_142_0_7, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData), -1, 0, 3, 1, 1, 0, 
06541 "h - - 0 - maxpoints D - - 10 - dataX "
06542 "u 'ROOT::Fit::DataRange' - 11 - range", (char*)NULL, (void*) NULL, 0);
06543    G__memfunc_setup("UnBinData",854,G__G__MathFit_142_0_8, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData), -1, 0, 4, 1, 1, 0, 
06544 "h - - 0 - maxpoints D - - 10 - dataX "
06545 "D - - 10 - dataY u 'ROOT::Fit::DataRange' - 11 - range", (char*)NULL, (void*) NULL, 0);
06546    G__memfunc_setup("UnBinData",854,G__G__MathFit_142_0_9, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData), -1, 0, 5, 1, 1, 0, 
06547 "h - - 0 - maxpoints D - - 10 - dataX "
06548 "D - - 10 - dataY D - - 10 - dataZ "
06549 "u 'ROOT::Fit::DataRange' - 11 - range", (char*)NULL, (void*) NULL, 0);
06550    G__memfunc_setup("UnBinData",854,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData), -1, 0, 1, 1, 4, 0, "u 'ROOT::Fit::UnBinData' - 11 - -", (char*)NULL, (void*) NULL, 0);
06551    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData), -1, 1, 1, 1, 4, 0, "u 'ROOT::Fit::UnBinData' - 11 - -", (char*)NULL, (void*) NULL, 0);
06552    G__memfunc_setup("Initialize",1042,G__G__MathFit_142_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
06553 "h - - 0 - maxpoints h - - 0 '1' dim", (char*)NULL, (void*) NULL, 0);
06554    G__memfunc_setup("PointSize",933,G__G__MathFit_142_0_13, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06555    G__memfunc_setup("DataSize",789,G__G__MathFit_142_0_14, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06556    G__memfunc_setup("Add",265,G__G__MathFit_142_0_15, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - x", (char*)NULL, (void*) NULL, 0);
06557    G__memfunc_setup("Add",265,G__G__MathFit_142_0_16, 121, -1, -1, 0, 2, 1, 1, 0, 
06558 "d - - 0 - x d - - 0 - y", (char*)NULL, (void*) NULL, 0);
06559    G__memfunc_setup("Add",265,G__G__MathFit_142_0_17, 121, -1, -1, 0, 3, 1, 1, 0, 
06560 "d - - 0 - x d - - 0 - y "
06561 "d - - 0 - z", (char*)NULL, (void*) NULL, 0);
06562    G__memfunc_setup("Add",265,G__G__MathFit_142_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "D - - 10 - x", (char*)NULL, (void*) NULL, 0);
06563    G__memfunc_setup("Coords",618,G__G__MathFit_142_0_19, 68, -1, -1, 0, 1, 1, 1, 9, "h - - 0 - ipoint", (char*)NULL, (void*) NULL, 0);
06564    G__memfunc_setup("Resize",626,G__G__MathFit_142_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "h - - 0 - npoints", (char*)NULL, (void*) NULL, 0);
06565    G__memfunc_setup("NPoints",715,G__G__MathFit_142_0_21, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06566    G__memfunc_setup("Size",411,G__G__MathFit_142_0_22, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06567    G__memfunc_setup("NDim",360,G__G__MathFit_142_0_23, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06568    G__memfunc_setup("SetNPoints",1015,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "h - - 0 - n", (char*)NULL, (void*) NULL, 0);
06569    // automatic destructor
06570    G__memfunc_setup("~UnBinData", 980, G__G__MathFit_142_0_25, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
06571    G__tag_memfunc_reset();
06572 }
06573 
06574 static void G__setup_memfuncROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void) {
06575    /* ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim> */
06576    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR));
06577    G__memfunc_setup("Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>",3708,G__G__MathFit_145_0_1, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR), -1, 0, 2, 1, 1, 0, 
06578 "u 'ROOT::Fit::BinData' - 11 - data u 'ROOT::Math::IParametricFunctionMultiDim' 'ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>::IModelFunction' 11 - func", (char*)NULL, (void*) NULL, 0);
06579    G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim), G__defined_typename("ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>::BaseFunction"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06580    G__memfunc_setup("NFitPoints",1006,G__G__MathFit_145_0_3, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06581    G__memfunc_setup("DataElement",1092,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 8, 
06582 "D - - 10 - x h - - 0 - i "
06583 "D - - 0 - g", (char*)NULL, (void*) NULL, 1);
06584    G__memfunc_setup("Gradient",814,G__G__MathFit_145_0_5, 121, -1, -1, 0, 2, 1, 1, 8, 
06585 "D - - 10 - x D - - 0 - g", (char*)NULL, (void*) NULL, 1);
06586    G__memfunc_setup("Type",418,(G__InterfaceMethod) NULL,105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgRcLcLType_t), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06587    G__memfunc_setup("Data",378,G__G__MathFit_145_0_7, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
06588    G__memfunc_setup("ModelFunction",1335,G__G__MathFit_145_0_8, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim), G__defined_typename("ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>::IModelFunction"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
06589    G__memfunc_setup("SetNFitPoints",1306,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "h - - 0 - n", (char*)NULL, (void*) NULL, 1);
06590    G__memfunc_setup("DoEval",571,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 1, 1, 4, 8, "D - - 10 - x", (char*)NULL, (void*) NULL, 1);
06591    G__memfunc_setup("DoDerivative",1222,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 2, 1, 4, 8, 
06592 "D - - 10 - x h - - 0 - icoord", (char*)NULL, (void*) NULL, 1);
06593    // automatic copy constructor
06594    G__memfunc_setup("Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>", 3708, G__G__MathFit_145_0_12, (int) ('i'), 
06595 G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR), -1, 0, 1, 1, 1, 0, "u 'ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>' - 11 - -", (char*) NULL, (void*) NULL, 0);
06596    // automatic destructor
06597    G__memfunc_setup("~Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>", 3834, G__G__MathFit_145_0_13, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
06598    G__tag_memfunc_reset();
06599 }
06600 
06601 static void G__setup_memfuncROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void) {
06602    /* ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim> */
06603    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR));
06604    G__memfunc_setup("Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>",4143,G__G__MathFit_147_0_1, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR), -1, 0, 2, 1, 1, 0, 
06605 "u 'ROOT::Fit::BinData' - 11 - data u 'ROOT::Math::IParametricFunctionMultiDim' 'ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>::IModelFunction' 11 - func", (char*)NULL, (void*) NULL, 0);
06606    G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim), G__defined_typename("ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>::BaseFunction"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06607    G__memfunc_setup("NFitPoints",1006,G__G__MathFit_147_0_3, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06608    G__memfunc_setup("DataElement",1092,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 8, 
06609 "D - - 10 - x h - - 0 - i "
06610 "D - - 0 - g", (char*)NULL, (void*) NULL, 1);
06611    G__memfunc_setup("Gradient",814,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
06612 "D - - 10 - x D - - 0 - g", (char*)NULL, (void*) NULL, 1);
06613    G__memfunc_setup("Type",418,(G__InterfaceMethod) NULL,105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgRcLcLType_t), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06614    G__memfunc_setup("Data",378,G__G__MathFit_147_0_7, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
06615    G__memfunc_setup("ModelFunction",1335,G__G__MathFit_147_0_8, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim), G__defined_typename("ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>::IModelFunction"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
06616    G__memfunc_setup("SetNFitPoints",1306,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 8, "h - - 0 - n", (char*)NULL, (void*) NULL, 1);
06617    G__memfunc_setup("DoEval",571,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 1, 1, 4, 8, "D - - 10 - x", (char*)NULL, (void*) NULL, 1);
06618    G__memfunc_setup("DoDerivative",1222,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 2, 1, 4, 8, 
06619 "D - - 10 - x h - - 0 - icoord", (char*)NULL, (void*) NULL, 1);
06620    // automatic copy constructor
06621    G__memfunc_setup("Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>", 4143, G__G__MathFit_147_0_12, (int) ('i'), 
06622 G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR), -1, 0, 1, 1, 1, 0, "u 'ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>' - 11 - -", (char*) NULL, (void*) NULL, 0);
06623    // automatic destructor
06624    G__memfunc_setup("~Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>", 4269, G__G__MathFit_147_0_13, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
06625    G__tag_memfunc_reset();
06626 }
06627 
06628 static void G__setup_memfuncROOTcLcLFitcLcLParameterSettings(void) {
06629    /* ROOT::Fit::ParameterSettings */
06630    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings));
06631    G__memfunc_setup("ParameterSettings",1778,G__G__MathFit_150_0_1, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06632    G__memfunc_setup("ParameterSettings",1778,G__G__MathFit_150_0_2, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings), -1, 0, 3, 1, 1, 0, 
06633 "u 'string' - 11 - name d - - 0 - val "
06634 "d - - 0 - err", (char*)NULL, (void*) NULL, 0);
06635    G__memfunc_setup("ParameterSettings",1778,G__G__MathFit_150_0_3, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings), -1, 0, 5, 1, 1, 0, 
06636 "u 'string' - 11 - name d - - 0 - val "
06637 "d - - 0 - err d - - 0 - min "
06638 "d - - 0 - max", (char*)NULL, (void*) NULL, 0);
06639    G__memfunc_setup("ParameterSettings",1778,G__G__MathFit_150_0_4, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings), -1, 0, 2, 1, 1, 0, 
06640 "u 'string' - 11 - name d - - 0 - val", (char*)NULL, (void*) NULL, 0);
06641    G__memfunc_setup("Set",300,G__G__MathFit_150_0_5, 121, -1, -1, 0, 3, 1, 1, 0, 
06642 "u 'string' - 11 - name d - - 0 - value "
06643 "d - - 0 - step", (char*)NULL, (void*) NULL, 0);
06644    G__memfunc_setup("Set",300,G__G__MathFit_150_0_6, 121, -1, -1, 0, 5, 1, 1, 0, 
06645 "u 'string' - 11 - name d - - 0 - value "
06646 "d - - 0 - step d - - 0 - lower "
06647 "d - - 0 - upper", (char*)NULL, (void*) NULL, 0);
06648    G__memfunc_setup("Set",300,G__G__MathFit_150_0_7, 121, -1, -1, 0, 2, 1, 1, 0, 
06649 "u 'string' - 11 - name d - - 0 - value", (char*)NULL, (void*) NULL, 0);
06650    G__memfunc_setup("Value",509,G__G__MathFit_150_0_8, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06651    G__memfunc_setup("StepSize",823,G__G__MathFit_150_0_9, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06652    G__memfunc_setup("LowerLimit",1032,G__G__MathFit_150_0_10, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06653    G__memfunc_setup("UpperLimit",1035,G__G__MathFit_150_0_11, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06654    G__memfunc_setup("IsFixed",684,G__G__MathFit_150_0_12, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06655    G__memfunc_setup("HasLowerLimit",1316,G__G__MathFit_150_0_13, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06656    G__memfunc_setup("HasUpperLimit",1319,G__G__MathFit_150_0_14, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06657    G__memfunc_setup("IsBound",692,G__G__MathFit_150_0_15, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06658    G__memfunc_setup("IsDoubleBound",1295,G__G__MathFit_150_0_16, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06659    G__memfunc_setup("Name",385,G__G__MathFit_150_0_17, 117, G__get_linked_tagnum(&G__G__MathFitLN_string), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
06660    G__memfunc_setup("SetName",685,G__G__MathFit_150_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
06661    G__memfunc_setup("Fix",295,G__G__MathFit_150_0_19, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06662    G__memfunc_setup("Release",705,G__G__MathFit_150_0_20, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06663    G__memfunc_setup("SetValue",809,G__G__MathFit_150_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - val", (char*)NULL, (void*) NULL, 0);
06664    G__memfunc_setup("SetStepSize",1123,G__G__MathFit_150_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - err", (char*)NULL, (void*) NULL, 0);
06665    G__memfunc_setup("SetLimits",926,G__G__MathFit_150_0_23, 121, -1, -1, 0, 2, 1, 1, 0, 
06666 "d - - 0 - low d - - 0 - up", (char*)NULL, (void*) NULL, 0);
06667    G__memfunc_setup("SetUpperLimit",1335,G__G__MathFit_150_0_24, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - up", (char*)NULL, (void*) NULL, 0);
06668    G__memfunc_setup("SetLowerLimit",1332,G__G__MathFit_150_0_25, 121, -1, -1, 0, 1, 1, 1, 0, "d - - 0 - low", (char*)NULL, (void*) NULL, 0);
06669    G__memfunc_setup("RemoveLimits",1248,G__G__MathFit_150_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06670    // automatic copy constructor
06671    G__memfunc_setup("ParameterSettings", 1778, G__G__MathFit_150_0_27, (int) ('i'), G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings), -1, 0, 1, 1, 1, 0, "u 'ROOT::Fit::ParameterSettings' - 11 - -", (char*) NULL, (void*) NULL, 0);
06672    // automatic destructor
06673    G__memfunc_setup("~ParameterSettings", 1904, G__G__MathFit_150_0_28, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
06674    // automatic assignment operator
06675    G__memfunc_setup("operator=", 937, G__G__MathFit_150_0_29, (int) ('u'), G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings), -1, 1, 1, 1, 1, 0, "u 'ROOT::Fit::ParameterSettings' - 11 - -", (char*) NULL, (void*) NULL, 0);
06676    G__tag_memfunc_reset();
06677 }
06678 
06679 static void G__setup_memfuncROOTcLcLFitcLcLFitConfig(void) {
06680    /* ROOT::Fit::FitConfig */
06681    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitConfig));
06682    G__memfunc_setup("FitConfig",889,G__G__MathFit_154_0_1, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitConfig), -1, 0, 1, 1, 1, 0, "h - - 0 '0' npar", (char*)NULL, (void*) NULL, 0);
06683    G__memfunc_setup("FitConfig",889,G__G__MathFit_154_0_2, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitConfig), -1, 0, 1, 1, 1, 0, "u 'ROOT::Fit::FitConfig' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
06684    G__memfunc_setup("operator=",937,G__G__MathFit_154_0_3, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitConfig), -1, 1, 1, 1, 1, 0, "u 'ROOT::Fit::FitConfig' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
06685    G__memfunc_setup("ParSettings",1140,G__G__MathFit_154_0_4, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings), -1, 1, 1, 1, 1, 9, "h - - 0 - i", (char*)NULL, (void*) NULL, 0);
06686    G__memfunc_setup("ParSettings",1140,G__G__MathFit_154_0_5, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings), -1, 1, 1, 1, 1, 0, "h - - 0 - i", (char*)NULL, (void*) NULL, 0);
06687    G__memfunc_setup("ParamsSettings",1461,G__G__MathFit_154_0_6, 117, G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR), G__defined_typename("vector<ROOT::Fit::ParameterSettings>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
06688    G__memfunc_setup("ParamsSettings",1461,G__G__MathFit_154_0_7, 117, G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR), G__defined_typename("vector<ROOT::Fit::ParameterSettings>"), 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06689    G__memfunc_setup("CreateParamsSettings",2057,G__G__MathFit_154_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::IParametricFunctionMultiDim' 'ROOT::Math::IParamMultiFunction' 11 - func", (char*)NULL, (void*) NULL, 0);
06690    G__memfunc_setup("SetParamsSettings",1761,G__G__MathFit_154_0_9, 121, -1, -1, 0, 3, 1, 1, 0, 
06691 "h - - 0 - npar D - - 10 - params "
06692 "D - - 10 '0' vstep", (char*)NULL, (void*) NULL, 0);
06693    G__memfunc_setup("CreateMinimizer",1544,G__G__MathFit_154_0_10, 85, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLMinimizer), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06694    G__memfunc_setup("MinimizerOptions",1696,G__G__MathFit_154_0_11, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLMinimizerOptions), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06695    G__memfunc_setup("SetMinimizer",1248,G__G__MathFit_154_0_12, 121, -1, -1, 0, 2, 1, 1, 0, 
06696 "C - - 10 - type C - - 10 '0' algo", (char*)NULL, (void*) NULL, 0);
06697    G__memfunc_setup("MinimizerType",1366,G__G__MathFit_154_0_13, 117, G__get_linked_tagnum(&G__G__MathFitLN_string), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
06698    G__memfunc_setup("MinimizerAlgoType",1753,G__G__MathFit_154_0_14, 117, G__get_linked_tagnum(&G__G__MathFitLN_string), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
06699    G__memfunc_setup("NormalizeErrors",1582,G__G__MathFit_154_0_15, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06700    G__memfunc_setup("ParabErrors",1123,G__G__MathFit_154_0_16, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06701    G__memfunc_setup("MinosErrors",1155,G__G__MathFit_154_0_17, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06702    G__memfunc_setup("MinosParams",1130,G__G__MathFit_154_0_18, 117, G__get_linked_tagnum(&G__G__MathFitLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR), G__defined_typename("vector<unsigned int>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
06703    G__memfunc_setup("SetNormErrors",1349,G__G__MathFit_154_0_19, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' on", (char*)NULL, (void*) NULL, 0);
06704    G__memfunc_setup("SetParabErrors",1423,G__G__MathFit_154_0_20, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' on", (char*)NULL, (void*) NULL, 0);
06705    G__memfunc_setup("SetMinosErrors",1455,G__G__MathFit_154_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "g - - 0 'true' on", (char*)NULL, (void*) NULL, 0);
06706    G__memfunc_setup("SetMinosErrors",1455,G__G__MathFit_154_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<unsigned int,allocator<unsigned int> >' 'vector<unsigned int>' 11 - paramInd", (char*)NULL, (void*) NULL, 0);
06707    G__memfunc_setup("SetDefaultMinimizer",1957,G__G__MathFit_154_0_23, 121, -1, -1, 0, 2, 3, 1, 0, 
06708 "C - - 10 - type C - - 10 '0' algo", (char*)NULL, (void*) G__func2void( (void (*)(const char*, const char*))(&ROOT::Fit::FitConfig::SetDefaultMinimizer) ), 0);
06709    // automatic destructor
06710    G__memfunc_setup("~FitConfig", 1015, G__G__MathFit_154_0_24, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
06711    G__tag_memfunc_reset();
06712 }
06713 
06714 static void G__setup_memfuncvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR(void) {
06715    /* vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> > */
06716    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR));
06717    G__memfunc_setup("at",213,G__G__MathFit_156_0_1, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings), -1, 1, 1, 1, 1, 0, "h - 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
06718    G__memfunc_setup("begin",517,G__G__MathFit_156_0_2, 117, G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06719    G__memfunc_setup("end",311,G__G__MathFit_156_0_3, 117, G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiterator), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06720    G__memfunc_setup("rbegin",631,G__G__MathFit_156_0_4, 117, G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiteratorgR), G__defined_typename("vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06721    G__memfunc_setup("rend",425,G__G__MathFit_156_0_5, 117, G__get_linked_tagnum(&G__G__MathFitLN_reverse_iteratorlEvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiteratorgR), G__defined_typename("vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::reverse_iterator"), 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06722    G__memfunc_setup("size",443,G__G__MathFit_156_0_6, 104, -1, G__defined_typename("vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06723    G__memfunc_setup("max_size",864,G__G__MathFit_156_0_7, 104, -1, G__defined_typename("vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06724    G__memfunc_setup("resize",658,G__G__MathFit_156_0_8, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::size_type' 0 - sz", (char*)NULL, (void*) NULL, 0);
06725    G__memfunc_setup("resize",658,G__G__MathFit_156_0_9, 121, -1, -1, 0, 2, 1, 1, 0, 
06726 "h - 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::size_type' 0 - sz u 'ROOT::Fit::ParameterSettings' - 0 - c", (char*)NULL, (void*) NULL, 0);
06727    G__memfunc_setup("capacity",846,G__G__MathFit_156_0_10, 104, -1, G__defined_typename("vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::size_type"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06728    G__memfunc_setup("empty",559,G__G__MathFit_156_0_11, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06729    G__memfunc_setup("operator[]",1060,G__G__MathFit_156_0_12, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings), -1, 1, 1, 1, 1, 0, "h - 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
06730    G__memfunc_setup("vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >",7190,G__G__MathFit_156_0_13, 105, G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06731    G__memfunc_setup("vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >",7190,G__G__MathFit_156_0_14, 105, G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR), -1, 0, 2, 1, 1, 0, 
06732 "h - 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::size_type' 0 - n u 'ROOT::Fit::ParameterSettings' - 11 'ROOT::Fit::ParameterSettings()' value", (char*)NULL, (void*) NULL, 0);
06733    G__memfunc_setup("vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >",7190,G__G__MathFit_156_0_15, 105, G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR), -1, 0, 1, 1, 1, 0, "u 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
06734    G__memfunc_setup("vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >",7190,G__G__MathFit_156_0_16, 105, G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR), -1, 0, 2, 1, 1, 0, 
06735 "u 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator' 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::const_iterator' 10 - first u 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator' 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
06736    G__memfunc_setup("operator=",937,G__G__MathFit_156_0_17, 117, G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR), -1, 1, 1, 1, 1, 0, "u 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >' - 11 - x", (char*)NULL, (void*) NULL, 0);
06737    G__memfunc_setup("reserve",764,G__G__MathFit_156_0_18, 121, -1, -1, 0, 1, 1, 1, 0, "h - 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::size_type' 0 - n", (char*)NULL, (void*) NULL, 0);
06738    G__memfunc_setup("front",553,G__G__MathFit_156_0_19, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06739    G__memfunc_setup("back",401,G__G__MathFit_156_0_20, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06740    G__memfunc_setup("push_back",944,G__G__MathFit_156_0_21, 121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Fit::ParameterSettings' - 11 - x", (char*)NULL, (void*) NULL, 0);
06741    G__memfunc_setup("swap",443,G__G__MathFit_156_0_22, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >' - 1 - x", (char*)NULL, (void*) NULL, 0);
06742    G__memfunc_setup("insert",661,G__G__MathFit_156_0_23, 117, G__get_linked_tagnum(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiterator), -1, 0, 2, 1, 1, 0, 
06743 "u 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator' - 0 - position u 'ROOT::Fit::ParameterSettings' - 11 - x", (char*)NULL, (void*) NULL, 0);
06744    G__memfunc_setup("insert",661,G__G__MathFit_156_0_24, 121, -1, -1, 0, 3, 1, 1, 0, 
06745 "u 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator' - 0 - position u 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator' 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::const_iterator' 10 - first "
06746 "u 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator' 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::const_iterator' 10 - last", (char*)NULL, (void*) NULL, 0);
06747    G__memfunc_setup("insert",661,G__G__MathFit_156_0_25, 121, -1, -1, 0, 3, 1, 1, 0, 
06748 "u 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator' - 0 - position h - 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::size_type' 0 - n "
06749 "u 'ROOT::Fit::ParameterSettings' - 11 - x", (char*)NULL, (void*) NULL, 0);
06750    G__memfunc_setup("pop_back",831,G__G__MathFit_156_0_26, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06751    G__memfunc_setup("erase",528,G__G__MathFit_156_0_27, 121, -1, -1, 0, 1, 1, 1, 0, "u 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator' - 0 - position", (char*)NULL, (void*) NULL, 0);
06752    G__memfunc_setup("erase",528,G__G__MathFit_156_0_28, 121, -1, -1, 0, 2, 1, 1, 0, 
06753 "u 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator' - 0 - first u 'vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator' - 0 - last", (char*)NULL, (void*) NULL, 0);
06754    G__memfunc_setup("clear",519,G__G__MathFit_156_0_29, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06755    // automatic destructor
06756    G__memfunc_setup("~vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >", 7316, G__G__MathFit_156_0_30, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
06757    G__tag_memfunc_reset();
06758 }
06759 
06760 static void G__setup_memfuncROOTcLcLFitcLcLFitResult(void) {
06761    /* ROOT::Fit::FitResult */
06762    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitResult));
06763    G__memfunc_setup("FitResult",930,G__G__MathFit_163_0_1, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitResult), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06764    G__memfunc_setup("FitResult",930,G__G__MathFit_163_0_2, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitResult), -1, 0, 8, 1, 1, 0, 
06765 "u 'ROOT::Math::Minimizer' - 1 - min u 'ROOT::Fit::FitConfig' - 11 - fconfig "
06766 "U 'ROOT::Math::IParametricFunctionMultiDim' 'ROOT::Fit::FitResult::IModelFunction' 10 - f g - - 0 - isValid "
06767 "h - - 0 '0' sizeOfData g - - 0 'true' binFit "
06768 "U 'ROOT::Math::IBaseFunctionMultiDim' 'ROOT::Math::IMultiGenFunction' 10 '0' chi2func h - - 0 '0' ncalls", (char*)NULL, (void*) NULL, 0);
06769    G__memfunc_setup("FitResult",930,G__G__MathFit_163_0_3, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitResult), -1, 0, 1, 1, 1, 0, "u 'ROOT::Fit::FitResult' - 11 - -", (char*)NULL, (void*) NULL, 0);
06770    G__memfunc_setup("operator=",937,G__G__MathFit_163_0_4, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitResult), -1, 1, 1, 1, 1, 0, "u 'ROOT::Fit::FitResult' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
06771    G__memfunc_setup("Update",611,G__G__MathFit_163_0_5, 103, -1, -1, 0, 3, 1, 1, 0, 
06772 "u 'ROOT::Math::Minimizer' - 11 - min g - - 0 - isValid "
06773 "h - - 0 '0' ncalls", (char*)NULL, (void*) NULL, 0);
06774    G__memfunc_setup("MinimizerType",1366,G__G__MathFit_163_0_6, 117, G__get_linked_tagnum(&G__G__MathFitLN_string), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
06775    G__memfunc_setup("IsValid",684,G__G__MathFit_163_0_7, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06776    G__memfunc_setup("IsEmpty",715,G__G__MathFit_163_0_8, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06777    G__memfunc_setup("MinFcnValue",1080,G__G__MathFit_163_0_9, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06778    G__memfunc_setup("NCalls",573,G__G__MathFit_163_0_10, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06779    G__memfunc_setup("Edm",278,G__G__MathFit_163_0_11, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06780    G__memfunc_setup("NTotalParameters",1638,G__G__MathFit_163_0_12, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06781    G__memfunc_setup("NPar",369,G__G__MathFit_163_0_13, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06782    G__memfunc_setup("NFreeParameters",1508,G__G__MathFit_163_0_14, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06783    G__memfunc_setup("Status",644,G__G__MathFit_163_0_15, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06784    G__memfunc_setup("CovMatrixStatus",1569,G__G__MathFit_163_0_16, 105, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06785    G__memfunc_setup("FittedFunction",1446,G__G__MathFit_163_0_17, 85, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim), G__defined_typename("ROOT::Fit::FitResult::IModelFunction"), 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
06786    G__memfunc_setup("Chi2",326,G__G__MathFit_163_0_18, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06787    G__memfunc_setup("Ndf",280,G__G__MathFit_163_0_19, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06788    G__memfunc_setup("Prob",403,G__G__MathFit_163_0_20, 100, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06789    G__memfunc_setup("Errors",637,G__G__MathFit_163_0_21, 117, G__get_linked_tagnum(&G__G__MathFitLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
06790    G__memfunc_setup("GetErrors",925,G__G__MathFit_163_0_22, 68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
06791    G__memfunc_setup("Parameters",1044,G__G__MathFit_163_0_23, 117, G__get_linked_tagnum(&G__G__MathFitLN_vectorlEdoublecOallocatorlEdoublegRsPgR), G__defined_typename("vector<double>"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
06792    G__memfunc_setup("GetParams",900,G__G__MathFit_163_0_24, 68, -1, -1, 0, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
06793    G__memfunc_setup("Value",509,G__G__MathFit_163_0_25, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - i", (char*)NULL, (void*) NULL, 0);
06794    G__memfunc_setup("Parameter",929,G__G__MathFit_163_0_26, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - i", (char*)NULL, (void*) NULL, 0);
06795    G__memfunc_setup("Error",522,G__G__MathFit_163_0_27, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - i", (char*)NULL, (void*) NULL, 0);
06796    G__memfunc_setup("ParError",813,G__G__MathFit_163_0_28, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - i", (char*)NULL, (void*) NULL, 0);
06797    G__memfunc_setup("ParName",676,G__G__MathFit_163_0_29, 117, G__get_linked_tagnum(&G__G__MathFitLN_string), -1, 0, 1, 1, 1, 8, "h - - 0 - i", (char*)NULL, (void*) NULL, 0);
06798    G__memfunc_setup("SetMinosError",1340,G__G__MathFit_163_0_30, 121, -1, -1, 0, 3, 1, 1, 0, 
06799 "h - - 0 - i d - - 0 - elow "
06800 "d - - 0 - eup", (char*)NULL, (void*) NULL, 0);
06801    G__memfunc_setup("LowerError",1043,G__G__MathFit_163_0_31, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - i", (char*)NULL, (void*) NULL, 0);
06802    G__memfunc_setup("UpperError",1046,G__G__MathFit_163_0_32, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - i", (char*)NULL, (void*) NULL, 0);
06803    G__memfunc_setup("GlobalCC",727,G__G__MathFit_163_0_33, 100, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - i", (char*)NULL, (void*) NULL, 0);
06804    G__memfunc_setup("CovMatrix",925,G__G__MathFit_163_0_34, 100, -1, -1, 0, 2, 1, 1, 8, 
06805 "h - - 0 - i h - - 0 - j", (char*)NULL, (void*) NULL, 0);
06806    G__memfunc_setup("Correlation",1154,G__G__MathFit_163_0_35, 100, -1, -1, 0, 2, 1, 1, 8, 
06807 "h - - 0 - i h - - 0 - j", (char*)NULL, (void*) NULL, 0);
06808    G__memfunc_setup("GetConfidenceIntervals",2246,G__G__MathFit_163_0_36, 121, -1, -1, 0, 7, 1, 1, 8, 
06809 "h - - 0 - n h - - 0 - stride1 "
06810 "h - - 0 - stride2 D - - 10 - x "
06811 "D - - 0 - ci d - - 0 '0.95' cl "
06812 "g - - 0 'true' norm", (char*)NULL, (void*) NULL, 0);
06813    G__memfunc_setup("GetConfidenceIntervals",2246,G__G__MathFit_163_0_37, 121, -1, -1, 0, 4, 1, 1, 8, 
06814 "u 'ROOT::Fit::BinData' - 11 - data D - - 0 - ci "
06815 "d - - 0 '0.95' cl g - - 0 'true' norm", (char*)NULL, (void*) NULL, 0);
06816    G__memfunc_setup("Index",504,G__G__MathFit_163_0_38, 105, -1, -1, 0, 1, 1, 1, 8, "u 'string' - 11 - name", (char*)NULL, (void*) NULL, 0);
06817    G__memfunc_setup("NormalizeErrors",1582,G__G__MathFit_163_0_39, 121, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06818    G__memfunc_setup("NormalizedErrors",1682,G__G__MathFit_163_0_40, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06819    G__memfunc_setup("Print",525,G__G__MathFit_163_0_41, 121, -1, -1, 0, 2, 1, 1, 8, 
06820 "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os g - - 0 'false' covmat", (char*)NULL, (void*) NULL, 0);
06821    G__memfunc_setup("PrintCovMatrix",1450,G__G__MathFit_163_0_42, 121, -1, -1, 0, 1, 1, 1, 8, "u 'basic_ostream<char,char_traits<char> >' 'ostream' 1 - os", (char*)NULL, (void*) NULL, 0);
06822    G__memfunc_setup("IsParameterBound",1621,G__G__MathFit_163_0_43, 103, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - ipar", (char*)NULL, (void*) NULL, 0);
06823    G__memfunc_setup("IsParameterFixed",1613,G__G__MathFit_163_0_44, 103, -1, -1, 0, 1, 1, 1, 8, "h - - 0 - ipar", (char*)NULL, (void*) NULL, 0);
06824    G__memfunc_setup("GetParameterName",1602,G__G__MathFit_163_0_45, 117, G__get_linked_tagnum(&G__G__MathFitLN_string), -1, 0, 1, 1, 1, 8, "h - - 0 - ipar", (char*)NULL, (void*) NULL, 0);
06825    G__memfunc_setup("ModelFunction",1335,(G__InterfaceMethod) NULL, 85, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim), G__defined_typename("ROOT::Fit::FitResult::IModelFunction"), 0, 0, 1, 2, 0, "", (char*)NULL, (void*) NULL, 0);
06826    G__memfunc_setup("SetModelFunction",1635,(G__InterfaceMethod) NULL, 121, -1, -1, 0, 1, 1, 2, 0, "U 'ROOT::Math::IParametricFunctionMultiDim' 'ROOT::Fit::FitResult::IModelFunction' 0 - func", (char*)NULL, (void*) NULL, 0);
06827    // automatic destructor
06828    G__memfunc_setup("~FitResult", 1056, G__G__MathFit_163_0_48, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
06829    G__tag_memfunc_reset();
06830 }
06831 
06832 static void G__setup_memfuncROOTcLcLFitcLcLFitter(void) {
06833    /* ROOT::Fit::Fitter */
06834    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitter));
06835    G__memfunc_setup("Fitter",622,G__G__MathFit_178_0_1, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitter), -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06836    G__memfunc_setup("Fitter",622,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitter), -1, 0, 1, 1, 4, 0, "u 'ROOT::Fit::Fitter' - 11 - -", (char*)NULL, (void*) NULL, 0);
06837    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitter), -1, 1, 1, 1, 4, 0, "u 'ROOT::Fit::Fitter' - 11 - rhs", (char*)NULL, (void*) NULL, 0);
06838    G__memfunc_setup("Fit",291,G__G__MathFit_178_0_4, 103, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Fit::BinData' - 11 - data", (char*)NULL, (void*) NULL, 0);
06839    G__memfunc_setup("Fit",291,G__G__MathFit_178_0_5, 103, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Fit::UnBinData' - 11 - data", (char*)NULL, (void*) NULL, 0);
06840    G__memfunc_setup("FitFCN",506,G__G__MathFit_178_0_6, 103, -1, -1, 0, 4, 1, 1, 0, 
06841 "u 'ROOT::Math::IBaseFunctionMultiDim' 'ROOT::Math::IMultiGenFunction' 11 - fcn D - - 10 '0' params "
06842 "h - - 0 '0' dataSize g - - 0 'false' chi2fit", (char*)NULL, (void*) NULL, 0);
06843    G__memfunc_setup("FitFCN",506,G__G__MathFit_178_0_7, 103, -1, -1, 0, 4, 1, 1, 0, 
06844 "u 'ROOT::Math::IGradientFunctionMultiDim' 'ROOT::Math::IMultiGradFunction' 11 - fcn D - - 10 '0' params "
06845 "h - - 0 '0' dataSize g - - 0 'false' chi2fit", (char*)NULL, (void*) NULL, 0);
06846    G__memfunc_setup("FitFCN",506,G__G__MathFit_178_0_8, 103, -1, -1, 0, 5, 1, 1, 0, 
06847 "Y - 'ROOT::Fit::Fitter::MinuitFCN_t' 0 - fcn i - - 0 '0' npar "
06848 "D - - 10 '0' params h - - 0 '0' dataSize "
06849 "g - - 0 'false' chi2fit", (char*)NULL, (void*) NULL, 0);
06850    G__memfunc_setup("LinearFit",894,G__G__MathFit_178_0_9, 103, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Fit::BinData' - 11 - data", (char*)NULL, (void*) NULL, 0);
06851    G__memfunc_setup("SetFunction",1138,G__G__MathFit_178_0_10, 121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::IParametricFunctionMultiDim' 'ROOT::Fit::Fitter::IModelFunction' 11 - func", (char*)NULL, (void*) NULL, 0);
06852    G__memfunc_setup("SetFunction",1138,G__G__MathFit_178_0_11, 121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::IParametricFunctionOneDim' 'ROOT::Fit::Fitter::IModel1DFunction' 11 - func", (char*)NULL, (void*) NULL, 0);
06853    G__memfunc_setup("SetFunction",1138,G__G__MathFit_178_0_12, 121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::IParametricGradFunctionMultiDim' 'ROOT::Fit::Fitter::IGradModelFunction' 11 - func", (char*)NULL, (void*) NULL, 0);
06854    G__memfunc_setup("SetFunction",1138,G__G__MathFit_178_0_13, 121, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Math::IParametricGradFunctionOneDim' 'ROOT::Fit::Fitter::IGradModel1DFunction' 11 - func", (char*)NULL, (void*) NULL, 0);
06855    G__memfunc_setup("Result",639,G__G__MathFit_178_0_14, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitResult), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
06856    G__memfunc_setup("CalculateHessErrors",1950,G__G__MathFit_178_0_15, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06857    G__memfunc_setup("CalculateMinosErrors",2065,G__G__MathFit_178_0_16, 103, -1, -1, 0, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06858    G__memfunc_setup("Config",598,G__G__MathFit_178_0_17, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitConfig), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 0);
06859    G__memfunc_setup("Config",598,G__G__MathFit_178_0_18, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLFitConfig), -1, 1, 0, 1, 1, 0, "", (char*)NULL, (void*) NULL, 0);
06860    G__memfunc_setup("IsBinFit",760,G__G__MathFit_178_0_19, 103, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06861    G__memfunc_setup("GetMinimizer",1236,G__G__MathFit_178_0_20, 85, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLMinimizer), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06862    G__memfunc_setup("GetFCN",503,G__G__MathFit_178_0_21, 85, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim), G__defined_typename("ROOT::Math::IMultiGenFunction"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06863    G__memfunc_setup("DoLeastSquareFit",1600,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 1, 1, 2, 0, "u 'ROOT::Fit::BinData' - 11 - data", (char*)NULL, (void*) NULL, 0);
06864    G__memfunc_setup("DoLikelihoodFit",1498,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 1, 1, 2, 0, "u 'ROOT::Fit::BinData' - 11 - data", (char*)NULL, (void*) NULL, 0);
06865    G__memfunc_setup("DoLikelihoodFit",1498,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 1, 1, 2, 0, "u 'ROOT::Fit::UnBinData' - 11 - data", (char*)NULL, (void*) NULL, 0);
06866    G__memfunc_setup("DoLinearFit",1073,(G__InterfaceMethod) NULL, 103, -1, -1, 0, 1, 1, 2, 0, "u 'ROOT::Fit::BinData' - 11 - data", (char*)NULL, (void*) NULL, 0);
06867    G__memfunc_setup("Fit",291,G__G__MathFit_178_0_26, 103, -1, -1, 0, 2, 1, 1, 0, 
06868 "u 'ROOT::Fit::BinData' - 11 - data u 'ROOT::Math::IParametricFunctionMultiDim' - 11 - func", (char*)NULL, (void*) NULL, 0);
06869    G__memfunc_setup("Fit",291,G__G__MathFit_178_0_27, 103, -1, -1, 0, 2, 1, 1, 0, 
06870 "u 'ROOT::Fit::UnBinData' - 11 - data u 'ROOT::Math::IParametricFunctionMultiDim' - 11 - func", (char*)NULL, (void*) NULL, 0);
06871    G__memfunc_setup("LikelihoodFit",1319,G__G__MathFit_178_0_28, 103, -1, -1, 0, 2, 1, 1, 0, 
06872 "u 'ROOT::Fit::BinData' - 11 - data u 'ROOT::Math::IParametricFunctionMultiDim' - 11 - func", (char*)NULL, (void*) NULL, 0);
06873    G__memfunc_setup("LikelihoodFit",1319,G__G__MathFit_178_0_29, 103, -1, -1, 0, 2, 1, 1, 0, 
06874 "u 'ROOT::Fit::UnBinData' - 11 - data u 'ROOT::Math::IParametricFunctionMultiDim' - 11 - func", (char*)NULL, (void*) NULL, 0);
06875    G__memfunc_setup("LikelihoodFit",1319,G__G__MathFit_178_0_30, 103, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Fit::BinData' - 11 - data", (char*)NULL, (void*) NULL, 0);
06876    G__memfunc_setup("LikelihoodFit",1319,G__G__MathFit_178_0_31, 103, -1, -1, 0, 1, 1, 1, 0, "u 'ROOT::Fit::UnBinData' - 11 - data", (char*)NULL, (void*) NULL, 0);
06877    // automatic destructor
06878    G__memfunc_setup("~Fitter", 748, G__G__MathFit_178_0_32, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 0);
06879    G__tag_memfunc_reset();
06880 }
06881 
06882 static void G__setup_memfuncROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void) {
06883    /* ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim> */
06884    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR));
06885    G__memfunc_setup("LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>",4700,G__G__MathFit_182_0_1, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR), -1, 0, 2, 1, 1, 0, 
06886 "u 'ROOT::Fit::UnBinData' - 11 - data u 'ROOT::Math::IParametricFunctionMultiDim' 'ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>::IModelFunction' 11 - func", (char*)NULL, (void*) NULL, 0);
06887    G__memfunc_setup("LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>",4700,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR), -1, 0, 1, 1, 4, 0, "u 'ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>' - 11 - -", (char*)NULL, (void*) NULL, 0);
06888    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR), -1, 1, 1, 1, 4, 0, "u 'ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>' - 11 - -", (char*)NULL, (void*) NULL, 0);
06889    G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim), G__defined_typename("ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>::BaseFunction"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06890    G__memfunc_setup("NFitPoints",1006,G__G__MathFit_182_0_5, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06891    G__memfunc_setup("DataElement",1092,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 8, 
06892 "D - - 10 - x h - - 0 - i "
06893 "D - - 0 - g", (char*)NULL, (void*) NULL, 1);
06894    G__memfunc_setup("Gradient",814,G__G__MathFit_182_0_7, 121, -1, -1, 0, 2, 1, 1, 8, 
06895 "D - - 10 - x D - - 0 - g", (char*)NULL, (void*) NULL, 1);
06896    G__memfunc_setup("Type",418,(G__InterfaceMethod) NULL,105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgRcLcLType_t), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06897    G__memfunc_setup("Data",378,G__G__MathFit_182_0_9, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
06898    G__memfunc_setup("ModelFunction",1335,G__G__MathFit_182_0_10, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim), G__defined_typename("ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>::IModelFunction"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
06899    G__memfunc_setup("DoEval",571,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 1, 1, 4, 8, "D - - 10 - x", (char*)NULL, (void*) NULL, 1);
06900    G__memfunc_setup("DoDerivative",1222,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 2, 1, 4, 8, 
06901 "D - - 10 - x h - - 0 - icoord", (char*)NULL, (void*) NULL, 1);
06902    // automatic destructor
06903    G__memfunc_setup("~LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>", 4826, G__G__MathFit_182_0_13, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
06904    G__tag_memfunc_reset();
06905 }
06906 
06907 static void G__setup_memfuncROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void) {
06908    /* ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim> */
06909    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR));
06910    G__memfunc_setup("LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>",5135,G__G__MathFit_183_0_1, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR), -1, 0, 2, 1, 1, 0, 
06911 "u 'ROOT::Fit::UnBinData' - 11 - data u 'ROOT::Math::IParametricFunctionMultiDim' 'ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>::IModelFunction' 11 - func", (char*)NULL, (void*) NULL, 0);
06912    G__memfunc_setup("LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>",5135,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR), -1, 0, 1, 1, 4, 0, "u 'ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>' - 11 - -", (char*)NULL, (void*) NULL, 0);
06913    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR), -1, 1, 1, 1, 4, 0, "u 'ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>' - 11 - -", (char*)NULL, (void*) NULL, 0);
06914    G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim), G__defined_typename("ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>::BaseFunction"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06915    G__memfunc_setup("NFitPoints",1006,G__G__MathFit_183_0_5, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06916    G__memfunc_setup("DataElement",1092,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 8, 
06917 "D - - 10 - x h - - 0 - i "
06918 "D - - 0 - g", (char*)NULL, (void*) NULL, 1);
06919    G__memfunc_setup("Gradient",814,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
06920 "D - - 10 - x D - - 0 - g", (char*)NULL, (void*) NULL, 1);
06921    G__memfunc_setup("Type",418,(G__InterfaceMethod) NULL,105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgRcLcLType_t), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06922    G__memfunc_setup("Data",378,G__G__MathFit_183_0_9, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
06923    G__memfunc_setup("ModelFunction",1335,G__G__MathFit_183_0_10, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim), G__defined_typename("ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>::IModelFunction"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
06924    G__memfunc_setup("DoEval",571,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 1, 1, 4, 8, "D - - 10 - x", (char*)NULL, (void*) NULL, 1);
06925    G__memfunc_setup("DoDerivative",1222,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 2, 1, 4, 8, 
06926 "D - - 10 - x h - - 0 - icoord", (char*)NULL, (void*) NULL, 1);
06927    // automatic destructor
06928    G__memfunc_setup("~LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>", 5261, G__G__MathFit_183_0_13, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
06929    G__tag_memfunc_reset();
06930 }
06931 
06932 static void G__setup_memfuncROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR(void) {
06933    /* ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim> */
06934    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR));
06935    G__memfunc_setup("PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>",5157,G__G__MathFit_184_0_1, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR), -1, 0, 2, 1, 1, 0, 
06936 "u 'ROOT::Fit::BinData' - 11 - data u 'ROOT::Math::IParametricFunctionMultiDim' 'ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>::IModelFunction' 11 - func", (char*)NULL, (void*) NULL, 0);
06937    G__memfunc_setup("PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>",5157,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR), -1, 0, 1, 1, 4, 0, "u 'ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>' - 11 - -", (char*)NULL, (void*) NULL, 0);
06938    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR), -1, 1, 1, 1, 4, 0, "u 'ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>' - 11 - -", (char*)NULL, (void*) NULL, 0);
06939    G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim), G__defined_typename("ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>::BaseFunction"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06940    G__memfunc_setup("NFitPoints",1006,G__G__MathFit_184_0_5, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06941    G__memfunc_setup("DataElement",1092,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 8, 
06942 "D - - 10 - x h - - 0 - i "
06943 "D - - 0 - g", (char*)NULL, (void*) NULL, 1);
06944    G__memfunc_setup("Gradient",814,G__G__MathFit_184_0_7, 121, -1, -1, 0, 2, 1, 1, 8, 
06945 "D - - 10 - x D - - 0 - g", (char*)NULL, (void*) NULL, 1);
06946    G__memfunc_setup("Type",418,(G__InterfaceMethod) NULL,105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgRcLcLType_t), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06947    G__memfunc_setup("Data",378,G__G__MathFit_184_0_9, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
06948    G__memfunc_setup("ModelFunction",1335,G__G__MathFit_184_0_10, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim), G__defined_typename("ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>::IModelFunction"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
06949    G__memfunc_setup("DoEval",571,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 1, 1, 4, 8, "D - - 10 - x", (char*)NULL, (void*) NULL, 1);
06950    G__memfunc_setup("DoDerivative",1222,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 2, 1, 4, 8, 
06951 "D - - 10 - x h - - 0 - icoord", (char*)NULL, (void*) NULL, 1);
06952    // automatic destructor
06953    G__memfunc_setup("~PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>", 5283, G__G__MathFit_184_0_13, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
06954    G__tag_memfunc_reset();
06955 }
06956 
06957 static void G__setup_memfuncROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR(void) {
06958    /* ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim> */
06959    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR));
06960    G__memfunc_setup("PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>",5592,G__G__MathFit_185_0_1, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR), -1, 0, 2, 1, 1, 0, 
06961 "u 'ROOT::Fit::BinData' - 11 - data u 'ROOT::Math::IParametricFunctionMultiDim' 'ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>::IModelFunction' 11 - func", (char*)NULL, (void*) NULL, 0);
06962    G__memfunc_setup("PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>",5592,(G__InterfaceMethod) NULL, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR), -1, 0, 1, 1, 4, 0, "u 'ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>' - 11 - -", (char*)NULL, (void*) NULL, 0);
06963    G__memfunc_setup("operator=",937,(G__InterfaceMethod) NULL, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR), -1, 1, 1, 1, 4, 0, "u 'ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>' - 11 - -", (char*)NULL, (void*) NULL, 0);
06964    G__memfunc_setup("Clone",497,(G__InterfaceMethod) NULL,85, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim), G__defined_typename("ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>::BaseFunction"), 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06965    G__memfunc_setup("NFitPoints",1006,G__G__MathFit_185_0_5, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06966    G__memfunc_setup("DataElement",1092,(G__InterfaceMethod) NULL,100, -1, -1, 0, 3, 1, 1, 8, 
06967 "D - - 10 - x h - - 0 - i "
06968 "D - - 0 - g", (char*)NULL, (void*) NULL, 1);
06969    G__memfunc_setup("Gradient",814,(G__InterfaceMethod) NULL,121, -1, -1, 0, 2, 1, 1, 8, 
06970 "D - - 10 - x D - - 0 - g", (char*)NULL, (void*) NULL, 1);
06971    G__memfunc_setup("Type",418,(G__InterfaceMethod) NULL,105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgRcLcLType_t), -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 1);
06972    G__memfunc_setup("Data",378,G__G__MathFit_185_0_9, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData), -1, 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
06973    G__memfunc_setup("ModelFunction",1335,G__G__MathFit_185_0_10, 117, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim), G__defined_typename("ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>::IModelFunction"), 1, 0, 1, 1, 9, "", (char*)NULL, (void*) NULL, 1);
06974    G__memfunc_setup("DoEval",571,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 1, 1, 4, 8, "D - - 10 - x", (char*)NULL, (void*) NULL, 1);
06975    G__memfunc_setup("DoDerivative",1222,(G__InterfaceMethod) NULL, 100, -1, -1, 0, 2, 1, 4, 8, 
06976 "D - - 10 - x h - - 0 - icoord", (char*)NULL, (void*) NULL, 1);
06977    // automatic destructor
06978    G__memfunc_setup("~PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>", 5718, G__G__MathFit_185_0_13, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
06979    G__tag_memfunc_reset();
06980 }
06981 
06982 static void G__setup_memfuncROOTcLcLFitcLcLSparseData(void) {
06983    /* ROOT::Fit::SparseData */
06984    G__tag_memfunc_setup(G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLSparseData));
06985    G__memfunc_setup("SparseData",1000,G__G__MathFit_187_0_1, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLSparseData), -1, 0, 2, 1, 1, 0, 
06986 "u 'vector<double,allocator<double> >' 'vector<double>' 1 - min u 'vector<double,allocator<double> >' 'vector<double>' 1 - max", (char*)NULL, (void*) NULL, 0);
06987    G__memfunc_setup("SparseData",1000,G__G__MathFit_187_0_2, 105, G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLSparseData), -1, 0, 3, 1, 1, 0, 
06988 "h - - 10 - dim D - - 0 - min "
06989 "D - - 0 - max", (char*)NULL, (void*) NULL, 0);
06990    G__memfunc_setup("NPoints",715,G__G__MathFit_187_0_3, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06991    G__memfunc_setup("NDim",360,G__G__MathFit_187_0_4, 104, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
06992    G__memfunc_setup("Add",265,G__G__MathFit_187_0_5, 121, -1, -1, 0, 4, 1, 1, 0, 
06993 "u 'vector<double,allocator<double> >' 'vector<double>' 1 - min u 'vector<double,allocator<double> >' 'vector<double>' 1 - max "
06994 "d - - 10 - content d - - 10 '1.0' error", (char*)NULL, (void*) NULL, 0);
06995    G__memfunc_setup("GetPoint",810,G__G__MathFit_187_0_6, 121, -1, -1, 0, 5, 1, 1, 0, 
06996 "h - - 10 - i u 'vector<double,allocator<double> >' 'vector<double>' 1 - min "
06997 "u 'vector<double,allocator<double> >' 'vector<double>' 1 - max d - - 1 - content "
06998 "d - - 1 - error", (char*)NULL, (void*) NULL, 0);
06999    G__memfunc_setup("PrintList",937,G__G__MathFit_187_0_7, 121, -1, -1, 0, 0, 1, 1, 8, "", (char*)NULL, (void*) NULL, 0);
07000    G__memfunc_setup("GetBinData",947,G__G__MathFit_187_0_8, 121, -1, -1, 0, 1, 1, 1, 8, "u 'ROOT::Fit::BinData' - 1 - -", (char*)NULL, (void*) NULL, 0);
07001    G__memfunc_setup("GetBinDataIntegral",1769,G__G__MathFit_187_0_9, 121, -1, -1, 0, 1, 1, 1, 8, "u 'ROOT::Fit::BinData' - 1 - -", (char*)NULL, (void*) NULL, 0);
07002    G__memfunc_setup("GetBinDataNoZeros",1667,G__G__MathFit_187_0_10, 121, -1, -1, 0, 1, 1, 1, 8, "u 'ROOT::Fit::BinData' - 1 - -", (char*)NULL, (void*) NULL, 0);
07003    // automatic copy constructor
07004    G__memfunc_setup("SparseData", 1000, G__G__MathFit_187_0_11, (int) ('i'), G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLSparseData), -1, 0, 1, 1, 1, 0, "u 'ROOT::Fit::SparseData' - 11 - -", (char*) NULL, (void*) NULL, 0);
07005    // automatic destructor
07006    G__memfunc_setup("~SparseData", 1126, G__G__MathFit_187_0_12, (int) ('y'), -1, -1, 0, 0, 1, 1, 0, "", (char*) NULL, (void*) NULL, 1);
07007    // automatic assignment operator
07008    G__memfunc_setup("operator=", 937, G__G__MathFit_187_0_13, (int) ('u'), G__get_linked_tagnum(&G__G__MathFitLN_ROOTcLcLFitcLcLSparseData), -1, 1, 1, 1, 1, 0, "u 'ROOT::Fit::SparseData' - 11 - -", (char*) NULL, (void*) NULL, 0);
07009    G__tag_memfunc_reset();
07010 }
07011 
07012 
07013 /*********************************************************
07014 * Member function information setup
07015 *********************************************************/
07016 extern "C" void G__cpp_setup_memfuncG__MathFit() {
07017 }
07018 
07019 /*********************************************************
07020 * Global variable information setup for each class
07021 *********************************************************/
07022 static void G__cpp_setup_global0() {
07023 
07024    /* Setting up global variables */
07025    G__resetplocal();
07026 
07027 }
07028 
07029 static void G__cpp_setup_global1() {
07030 
07031    G__resetglobalenv();
07032 }
07033 extern "C" void G__cpp_setup_globalG__MathFit() {
07034   G__cpp_setup_global0();
07035   G__cpp_setup_global1();
07036 }
07037 
07038 /*********************************************************
07039 * Global function information setup for each class
07040 *********************************************************/
07041 static void G__cpp_setup_func0() {
07042    G__lastifuncposition();
07043 
07044 }
07045 
07046 static void G__cpp_setup_func1() {
07047 }
07048 
07049 static void G__cpp_setup_func2() {
07050 }
07051 
07052 static void G__cpp_setup_func3() {
07053 }
07054 
07055 static void G__cpp_setup_func4() {
07056 }
07057 
07058 static void G__cpp_setup_func5() {
07059 }
07060 
07061 static void G__cpp_setup_func6() {
07062 }
07063 
07064 static void G__cpp_setup_func7() {
07065 
07066    G__resetifuncposition();
07067 }
07068 
07069 extern "C" void G__cpp_setup_funcG__MathFit() {
07070   G__cpp_setup_func0();
07071   G__cpp_setup_func1();
07072   G__cpp_setup_func2();
07073   G__cpp_setup_func3();
07074   G__cpp_setup_func4();
07075   G__cpp_setup_func5();
07076   G__cpp_setup_func6();
07077   G__cpp_setup_func7();
07078 }
07079 
07080 /*********************************************************
07081 * Class,struct,union,enum tag information setup
07082 *********************************************************/
07083 /* Setup class/struct taginfo */
07084 G__linked_taginfo G__G__MathFitLN_ROOT = { "ROOT" , 110 , -1 };
07085 G__linked_taginfo G__G__MathFitLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR = { "basic_ostream<char,char_traits<char> >" , 99 , -1 };
07086 G__linked_taginfo G__G__MathFitLN_string = { "string" , 99 , -1 };
07087 G__linked_taginfo G__G__MathFitLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR = { "vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >" , 99 , -1 };
07088 G__linked_taginfo G__G__MathFitLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::TSchemaHelper,allocator<ROOT::TSchemaHelper> >::iterator>" , 99 , -1 };
07089 G__linked_taginfo G__G__MathFitLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR = { "vector<TVirtualArray*,allocator<TVirtualArray*> >" , 99 , -1 };
07090 G__linked_taginfo G__G__MathFitLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<TVirtualArray*,allocator<TVirtualArray*> >::iterator>" , 99 , -1 };
07091 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFit = { "ROOT::Fit" , 110 , -1 };
07092 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFitcLcLDataOptions = { "ROOT::Fit::DataOptions" , 115 , -1 };
07093 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFitcLcLDataRange = { "ROOT::Fit::DataRange" , 99 , -1 };
07094 G__linked_taginfo G__G__MathFitLN_pairlEdoublecOdoublegR = { "pair<double,double>" , 115 , -1 };
07095 G__linked_taginfo G__G__MathFitLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR = { "vector<pair<double,double>,allocator<pair<double,double> > >" , 99 , -1 };
07096 G__linked_taginfo G__G__MathFitLN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<pair<double,double>,allocator<pair<double,double> > >::iterator>" , 99 , -1 };
07097 G__linked_taginfo G__G__MathFitLN_vectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgR = { "vector<vector<pair<double,double>,allocator<pair<double,double> > >,allocator<vector<pair<double,double>,allocator<pair<double,double> > > > >" , 99 , -1 };
07098 G__linked_taginfo G__G__MathFitLN_reverse_iteratorlEvectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<vector<pair<double,double>,allocator<pair<double,double> > >,allocator<vector<pair<double,double>,allocator<pair<double,double> > > > >::iterator>" , 99 , -1 };
07099 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFitcLcLFitData = { "ROOT::Fit::FitData" , 99 , -1 };
07100 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFitcLcLDataVector = { "ROOT::Fit::DataVector" , 99 , -1 };
07101 G__linked_taginfo G__G__MathFitLN_vectorlEdoublecOallocatorlEdoublegRsPgR = { "vector<double,allocator<double> >" , 99 , -1 };
07102 G__linked_taginfo G__G__MathFitLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR = { "reverse_iterator<vector<double,allocator<double> >::iterator>" , 99 , -1 };
07103 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFitcLcLDataWrapper = { "ROOT::Fit::DataWrapper" , 99 , -1 };
07104 G__linked_taginfo G__G__MathFitLN_vectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgR = { "vector<const double*,allocator<const double*> >" , 99 , -1 };
07105 G__linked_taginfo G__G__MathFitLN_reverse_iteratorlEvectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<const double*,allocator<const double*> >::iterator>" , 99 , -1 };
07106 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFitcLcLBinData = { "ROOT::Fit::BinData" , 99 , -1 };
07107 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFitcLcLBinDatacLcLErrorType = { "ROOT::Fit::BinData::ErrorType" , 101 , -1 };
07108 G__linked_taginfo G__G__MathFitLN_ROOTcLcLMath = { "ROOT::Math" , 110 , -1 };
07109 G__linked_taginfo G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim = { "ROOT::Math::IBaseFunctionMultiDim" , 99 , -1 };
07110 G__linked_taginfo G__G__MathFitLN_ROOTcLcLMathcLcLIGradientFunctionMultiDim = { "ROOT::Math::IGradientFunctionMultiDim" , 99 , -1 };
07111 G__linked_taginfo G__G__MathFitLN_ROOTcLcLMathcLcLIGradientMultiDim = { "ROOT::Math::IGradientMultiDim" , 99 , -1 };
07112 G__linked_taginfo G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR = { "ROOT::Math::BasicFitMethodFunction<ROOT::Math::IBaseFunctionMultiDim>" , 99 , -1 };
07113 G__linked_taginfo G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgRcLcLType_t = { "ROOT::Math::BasicFitMethodFunction<ROOT::Math::IBaseFunctionMultiDim>::Type_t" , 101 , -1 };
07114 G__linked_taginfo G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR = { "ROOT::Math::BasicFitMethodFunction<ROOT::Math::IGradientFunctionMultiDim>" , 99 , -1 };
07115 G__linked_taginfo G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgRcLcLType_t = { "ROOT::Math::BasicFitMethodFunction<ROOT::Math::IGradientFunctionMultiDim>::Type_t" , 101 , -1 };
07116 G__linked_taginfo G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionOneDim = { "ROOT::Math::IParametricFunctionOneDim" , 99 , -1 };
07117 G__linked_taginfo G__G__MathFitLN_ROOTcLcLMathcLcLIParametricGradFunctionOneDim = { "ROOT::Math::IParametricGradFunctionOneDim" , 99 , -1 };
07118 G__linked_taginfo G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim = { "ROOT::Math::IParametricFunctionMultiDim" , 99 , -1 };
07119 G__linked_taginfo G__G__MathFitLN_ROOTcLcLMathcLcLIParametricGradFunctionMultiDim = { "ROOT::Math::IParametricGradFunctionMultiDim" , 99 , -1 };
07120 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData = { "ROOT::Fit::UnBinData" , 99 , -1 };
07121 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR = { "ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>" , 99 , -1 };
07122 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR = { "ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>" , 99 , -1 };
07123 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings = { "ROOT::Fit::ParameterSettings" , 99 , -1 };
07124 G__linked_taginfo G__G__MathFitLN_ROOTcLcLMathcLcLMinimizerOptions = { "ROOT::Math::MinimizerOptions" , 99 , -1 };
07125 G__linked_taginfo G__G__MathFitLN_ROOTcLcLMathcLcLMinimizer = { "ROOT::Math::Minimizer" , 99 , -1 };
07126 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFitcLcLFitConfig = { "ROOT::Fit::FitConfig" , 99 , -1 };
07127 G__linked_taginfo G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR = { "vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >" , 99 , -1 };
07128 G__linked_taginfo G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiterator = { "vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator" , 99 , -1 };
07129 G__linked_taginfo G__G__MathFitLN_reverse_iteratorlEvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >::iterator>" , 99 , -1 };
07130 G__linked_taginfo G__G__MathFitLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR = { "vector<unsigned int,allocator<unsigned int> >" , 99 , -1 };
07131 G__linked_taginfo G__G__MathFitLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<unsigned int,allocator<unsigned int> >::iterator>" , 99 , -1 };
07132 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFitcLcLFitResult = { "ROOT::Fit::FitResult" , 99 , -1 };
07133 G__linked_taginfo G__G__MathFitLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR = { "map<unsigned int,pair<double,double>,less<unsigned int>,allocator<pair<const unsigned int,pair<double,double> > > >" , 99 , -1 };
07134 G__linked_taginfo G__G__MathFitLN_vectorlEstringcOallocatorlEstringgRsPgR = { "vector<string,allocator<string> >" , 99 , -1 };
07135 G__linked_taginfo G__G__MathFitLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR = { "reverse_iterator<vector<string,allocator<string> >::iterator>" , 99 , -1 };
07136 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFitcLcLFitter = { "ROOT::Fit::Fitter" , 99 , -1 };
07137 G__linked_taginfo G__G__MathFitLN_auto_ptrlEROOTcLcLFitcLcLFitResultgR = { "auto_ptr<ROOT::Fit::FitResult>" , 99 , -1 };
07138 G__linked_taginfo G__G__MathFitLN_auto_ptrlEROOTcLcLMathcLcLMinimizergR = { "auto_ptr<ROOT::Math::Minimizer>" , 99 , -1 };
07139 G__linked_taginfo G__G__MathFitLN_auto_ptrlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR = { "auto_ptr<ROOT::Math::IBaseFunctionMultiDim>" , 99 , -1 };
07140 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR = { "ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>" , 99 , -1 };
07141 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR = { "ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>" , 99 , -1 };
07142 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR = { "ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>" , 99 , -1 };
07143 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR = { "ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>" , 99 , -1 };
07144 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFitcLcLProxyListBox = { "ROOT::Fit::ProxyListBox" , 99 , -1 };
07145 G__linked_taginfo G__G__MathFitLN_ROOTcLcLFitcLcLSparseData = { "ROOT::Fit::SparseData" , 99 , -1 };
07146 
07147 /* Reset class/struct taginfo */
07148 extern "C" void G__cpp_reset_tagtableG__MathFit() {
07149   G__G__MathFitLN_ROOT.tagnum = -1 ;
07150   G__G__MathFitLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR.tagnum = -1 ;
07151   G__G__MathFitLN_string.tagnum = -1 ;
07152   G__G__MathFitLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR.tagnum = -1 ;
07153   G__G__MathFitLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR.tagnum = -1 ;
07154   G__G__MathFitLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR.tagnum = -1 ;
07155   G__G__MathFitLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR.tagnum = -1 ;
07156   G__G__MathFitLN_ROOTcLcLFit.tagnum = -1 ;
07157   G__G__MathFitLN_ROOTcLcLFitcLcLDataOptions.tagnum = -1 ;
07158   G__G__MathFitLN_ROOTcLcLFitcLcLDataRange.tagnum = -1 ;
07159   G__G__MathFitLN_pairlEdoublecOdoublegR.tagnum = -1 ;
07160   G__G__MathFitLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR.tagnum = -1 ;
07161   G__G__MathFitLN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
07162   G__G__MathFitLN_vectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgR.tagnum = -1 ;
07163   G__G__MathFitLN_reverse_iteratorlEvectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgRcLcLiteratorgR.tagnum = -1 ;
07164   G__G__MathFitLN_ROOTcLcLFitcLcLFitData.tagnum = -1 ;
07165   G__G__MathFitLN_ROOTcLcLFitcLcLDataVector.tagnum = -1 ;
07166   G__G__MathFitLN_vectorlEdoublecOallocatorlEdoublegRsPgR.tagnum = -1 ;
07167   G__G__MathFitLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR.tagnum = -1 ;
07168   G__G__MathFitLN_ROOTcLcLFitcLcLDataWrapper.tagnum = -1 ;
07169   G__G__MathFitLN_vectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgR.tagnum = -1 ;
07170   G__G__MathFitLN_reverse_iteratorlEvectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgRcLcLiteratorgR.tagnum = -1 ;
07171   G__G__MathFitLN_ROOTcLcLFitcLcLBinData.tagnum = -1 ;
07172   G__G__MathFitLN_ROOTcLcLFitcLcLBinDatacLcLErrorType.tagnum = -1 ;
07173   G__G__MathFitLN_ROOTcLcLMath.tagnum = -1 ;
07174   G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim.tagnum = -1 ;
07175   G__G__MathFitLN_ROOTcLcLMathcLcLIGradientFunctionMultiDim.tagnum = -1 ;
07176   G__G__MathFitLN_ROOTcLcLMathcLcLIGradientMultiDim.tagnum = -1 ;
07177   G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR.tagnum = -1 ;
07178   G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgRcLcLType_t.tagnum = -1 ;
07179   G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR.tagnum = -1 ;
07180   G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgRcLcLType_t.tagnum = -1 ;
07181   G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionOneDim.tagnum = -1 ;
07182   G__G__MathFitLN_ROOTcLcLMathcLcLIParametricGradFunctionOneDim.tagnum = -1 ;
07183   G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim.tagnum = -1 ;
07184   G__G__MathFitLN_ROOTcLcLMathcLcLIParametricGradFunctionMultiDim.tagnum = -1 ;
07185   G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData.tagnum = -1 ;
07186   G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR.tagnum = -1 ;
07187   G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR.tagnum = -1 ;
07188   G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings.tagnum = -1 ;
07189   G__G__MathFitLN_ROOTcLcLMathcLcLMinimizerOptions.tagnum = -1 ;
07190   G__G__MathFitLN_ROOTcLcLMathcLcLMinimizer.tagnum = -1 ;
07191   G__G__MathFitLN_ROOTcLcLFitcLcLFitConfig.tagnum = -1 ;
07192   G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR.tagnum = -1 ;
07193   G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiterator.tagnum = -1 ;
07194   G__G__MathFitLN_reverse_iteratorlEvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiteratorgR.tagnum = -1 ;
07195   G__G__MathFitLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR.tagnum = -1 ;
07196   G__G__MathFitLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR.tagnum = -1 ;
07197   G__G__MathFitLN_ROOTcLcLFitcLcLFitResult.tagnum = -1 ;
07198   G__G__MathFitLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR.tagnum = -1 ;
07199   G__G__MathFitLN_vectorlEstringcOallocatorlEstringgRsPgR.tagnum = -1 ;
07200   G__G__MathFitLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR.tagnum = -1 ;
07201   G__G__MathFitLN_ROOTcLcLFitcLcLFitter.tagnum = -1 ;
07202   G__G__MathFitLN_auto_ptrlEROOTcLcLFitcLcLFitResultgR.tagnum = -1 ;
07203   G__G__MathFitLN_auto_ptrlEROOTcLcLMathcLcLMinimizergR.tagnum = -1 ;
07204   G__G__MathFitLN_auto_ptrlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR.tagnum = -1 ;
07205   G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR.tagnum = -1 ;
07206   G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR.tagnum = -1 ;
07207   G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR.tagnum = -1 ;
07208   G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR.tagnum = -1 ;
07209   G__G__MathFitLN_ROOTcLcLFitcLcLProxyListBox.tagnum = -1 ;
07210   G__G__MathFitLN_ROOTcLcLFitcLcLSparseData.tagnum = -1 ;
07211 }
07212 
07213 
07214 extern "C" void G__cpp_setup_tagtableG__MathFit() {
07215 
07216    /* Setting up class,struct,union tag entry */
07217    G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOT);
07218    G__get_linked_tagnum_fwd(&G__G__MathFitLN_basic_ostreamlEcharcOchar_traitslEchargRsPgR);
07219    G__get_linked_tagnum_fwd(&G__G__MathFitLN_string);
07220    G__get_linked_tagnum_fwd(&G__G__MathFitLN_vectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgR);
07221    G__get_linked_tagnum_fwd(&G__G__MathFitLN_reverse_iteratorlEvectorlEROOTcLcLTSchemaHelpercOallocatorlEROOTcLcLTSchemaHelpergRsPgRcLcLiteratorgR);
07222    G__get_linked_tagnum_fwd(&G__G__MathFitLN_vectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgR);
07223    G__get_linked_tagnum_fwd(&G__G__MathFitLN_reverse_iteratorlEvectorlETVirtualArraymUcOallocatorlETVirtualArraymUgRsPgRcLcLiteratorgR);
07224    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFit),0,-1,0,(char*)NULL,G__setup_memvarROOTcLcLFit,G__setup_memfuncROOTcLcLFit);
07225    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFitcLcLDataOptions),sizeof(ROOT::Fit::DataOptions),-1,256,(char*)NULL,G__setup_memvarROOTcLcLFitcLcLDataOptions,G__setup_memfuncROOTcLcLFitcLcLDataOptions);
07226    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFitcLcLDataRange),sizeof(ROOT::Fit::DataRange),-1,34048,(char*)NULL,G__setup_memvarROOTcLcLFitcLcLDataRange,G__setup_memfuncROOTcLcLFitcLcLDataRange);
07227    G__get_linked_tagnum_fwd(&G__G__MathFitLN_pairlEdoublecOdoublegR);
07228    G__get_linked_tagnum_fwd(&G__G__MathFitLN_vectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgR);
07229    G__get_linked_tagnum_fwd(&G__G__MathFitLN_reverse_iteratorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcLcLiteratorgR);
07230    G__get_linked_tagnum_fwd(&G__G__MathFitLN_vectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgR);
07231    G__get_linked_tagnum_fwd(&G__G__MathFitLN_reverse_iteratorlEvectorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRcOallocatorlEvectorlEpairlEdoublecOdoublegRcOallocatorlEpairlEdoublecOdoublegRsPgRsPgRsPgRsPgRcLcLiteratorgR);
07232    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFitcLcLFitData),sizeof(ROOT::Fit::FitData),-1,296192,(char*)NULL,G__setup_memvarROOTcLcLFitcLcLFitData,G__setup_memfuncROOTcLcLFitcLcLFitData);
07233    G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFitcLcLDataVector);
07234    G__get_linked_tagnum_fwd(&G__G__MathFitLN_vectorlEdoublecOallocatorlEdoublegRsPgR);
07235    G__get_linked_tagnum_fwd(&G__G__MathFitLN_reverse_iteratorlEvectorlEdoublecOallocatorlEdoublegRsPgRcLcLiteratorgR);
07236    G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFitcLcLDataWrapper);
07237    G__get_linked_tagnum_fwd(&G__G__MathFitLN_vectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgR);
07238    G__get_linked_tagnum_fwd(&G__G__MathFitLN_reverse_iteratorlEvectorlEconstsPdoublemUcOallocatorlEconstsPdoublemUgRsPgRcLcLiteratorgR);
07239    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFitcLcLBinData),sizeof(ROOT::Fit::BinData),-1,298752,(char*)NULL,G__setup_memvarROOTcLcLFitcLcLBinData,G__setup_memfuncROOTcLcLFitcLcLBinData);
07240    G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFitcLcLBinDatacLcLErrorType);
07241    G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLMath);
07242    G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLMathcLcLIBaseFunctionMultiDim);
07243    G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLMathcLcLIGradientFunctionMultiDim);
07244    G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLMathcLcLIGradientMultiDim);
07245    G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR);
07246    G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIBaseFunctionMultiDimgRcLcLType_t);
07247    G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR);
07248    G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLMathcLcLBasicFitMethodFunctionlEROOTcLcLMathcLcLIGradientFunctionMultiDimgRcLcLType_t);
07249    G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionOneDim);
07250    G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricGradFunctionOneDim);
07251    G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricFunctionMultiDim);
07252    G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLMathcLcLIParametricGradFunctionMultiDim);
07253    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFitcLcLUnBinData),sizeof(ROOT::Fit::UnBinData),-1,298752,(char*)NULL,G__setup_memvarROOTcLcLFitcLcLUnBinData,G__setup_memfuncROOTcLcLFitcLcLUnBinData);
07254    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),sizeof(ROOT::Fit::Chi2FCN<ROOT::Math::IBaseFunctionMultiDim>),-1,99328,(char*)NULL,G__setup_memvarROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR,G__setup_memfuncROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR);
07255    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),sizeof(ROOT::Fit::Chi2FCN<ROOT::Math::IGradientFunctionMultiDim>),-1,99328,(char*)NULL,G__setup_memvarROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR,G__setup_memfuncROOTcLcLFitcLcLChi2FCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR);
07256    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFitcLcLParameterSettings),sizeof(ROOT::Fit::ParameterSettings),-1,296192,(char*)NULL,G__setup_memvarROOTcLcLFitcLcLParameterSettings,G__setup_memfuncROOTcLcLFitcLcLParameterSettings);
07257    G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLMathcLcLMinimizerOptions);
07258    G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLMathcLcLMinimizer);
07259    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFitcLcLFitConfig),sizeof(ROOT::Fit::FitConfig),-1,265984,(char*)NULL,G__setup_memvarROOTcLcLFitcLcLFitConfig,G__setup_memfuncROOTcLcLFitcLcLFitConfig);
07260    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR),sizeof(vector<ROOT::Fit::ParameterSettings,allocator<ROOT::Fit::ParameterSettings> >),-1,36608,(char*)NULL,G__setup_memvarvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR,G__setup_memfuncvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgR);
07261    G__get_linked_tagnum_fwd(&G__G__MathFitLN_vectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiterator);
07262    G__get_linked_tagnum_fwd(&G__G__MathFitLN_reverse_iteratorlEvectorlEROOTcLcLFitcLcLParameterSettingscOallocatorlEROOTcLcLFitcLcLParameterSettingsgRsPgRcLcLiteratorgR);
07263    G__get_linked_tagnum_fwd(&G__G__MathFitLN_vectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgR);
07264    G__get_linked_tagnum_fwd(&G__G__MathFitLN_reverse_iteratorlEvectorlEunsignedsPintcOallocatorlEunsignedsPintgRsPgRcLcLiteratorgR);
07265    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFitcLcLFitResult),sizeof(ROOT::Fit::FitResult),-1,298752,(char*)NULL,G__setup_memvarROOTcLcLFitcLcLFitResult,G__setup_memfuncROOTcLcLFitcLcLFitResult);
07266    G__get_linked_tagnum_fwd(&G__G__MathFitLN_maplEunsignedsPintcOpairlEdoublecOdoublegRcOlesslEunsignedsPintgRcOallocatorlEpairlEconstsPunsignedsPintcOpairlEdoublecOdoublegRsPgRsPgRsPgR);
07267    G__get_linked_tagnum_fwd(&G__G__MathFitLN_vectorlEstringcOallocatorlEstringgRsPgR);
07268    G__get_linked_tagnum_fwd(&G__G__MathFitLN_reverse_iteratorlEvectorlEstringcOallocatorlEstringgRsPgRcLcLiteratorgR);
07269    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFitcLcLFitter),sizeof(ROOT::Fit::Fitter),-1,3840,(char*)NULL,G__setup_memvarROOTcLcLFitcLcLFitter,G__setup_memfuncROOTcLcLFitcLcLFitter);
07270    G__get_linked_tagnum_fwd(&G__G__MathFitLN_auto_ptrlEROOTcLcLFitcLcLFitResultgR);
07271    G__get_linked_tagnum_fwd(&G__G__MathFitLN_auto_ptrlEROOTcLcLMathcLcLMinimizergR);
07272    G__get_linked_tagnum_fwd(&G__G__MathFitLN_auto_ptrlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR);
07273    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),sizeof(ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>),-1,101888,(char*)NULL,G__setup_memvarROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR,G__setup_memfuncROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR);
07274    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),sizeof(ROOT::Fit::LogLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>),-1,101888,(char*)NULL,G__setup_memvarROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR,G__setup_memfuncROOTcLcLFitcLcLLogLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR);
07275    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR),sizeof(ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IBaseFunctionMultiDim>),-1,101888,(char*)NULL,G__setup_memvarROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR,G__setup_memfuncROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIBaseFunctionMultiDimgR);
07276    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR),sizeof(ROOT::Fit::PoissonLikelihoodFCN<ROOT::Math::IGradientFunctionMultiDim>),-1,101888,(char*)NULL,G__setup_memvarROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR,G__setup_memfuncROOTcLcLFitcLcLPoissonLikelihoodFCNlEROOTcLcLMathcLcLIGradientFunctionMultiDimgR);
07277    G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFitcLcLProxyListBox);
07278    G__tagtable_setup(G__get_linked_tagnum_fwd(&G__G__MathFitLN_ROOTcLcLFitcLcLSparseData),sizeof(ROOT::Fit::SparseData),-1,295936,(char*)NULL,G__setup_memvarROOTcLcLFitcLcLSparseData,G__setup_memfuncROOTcLcLFitcLcLSparseData);
07279 }
07280 extern "C" void G__cpp_setupG__MathFit(void) {
07281   G__check_setup_version(30051515,"G__cpp_setupG__MathFit()");
07282   G__set_cpp_environmentG__MathFit();
07283   G__cpp_setup_tagtableG__MathFit();
07284 
07285   G__cpp_setup_inheritanceG__MathFit();
07286 
07287   G__cpp_setup_typetableG__MathFit();
07288 
07289   G__cpp_setup_memvarG__MathFit();
07290 
07291   G__cpp_setup_memfuncG__MathFit();
07292   G__cpp_setup_globalG__MathFit();
07293   G__cpp_setup_funcG__MathFit();
07294 
07295    if(0==G__getsizep2memfunc()) G__get_sizep2memfuncG__MathFit();
07296   return;
07297 }
07298 class G__cpp_setup_initG__MathFit {
07299   public:
07300     G__cpp_setup_initG__MathFit() { G__add_setup_func("G__MathFit",(G__incsetup)(&G__cpp_setupG__MathFit)); G__call_setup_funcs(); }
07301    ~G__cpp_setup_initG__MathFit() { G__remove_setup_func("G__MathFit"); }
07302 };
07303 G__cpp_setup_initG__MathFit G__cpp_setup_initializerG__MathFit;
07304